Display a linear combination: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V a = enumerate(x).filter2((i, v) -> v != 0).map2((i, v) -> ‘#.e(#.)’.format(I v == -1 {‘-’} E I v == 1 {‘’} E String(v)‘*’, i + 1))

R (I !a.empty {a} E [String(‘0’)]).join(‘ + ’).replace(‘ + -’, ‘ - ’)

 

L(x) [[1, 2, 3], [0, 1, 2, 3], [1, 0, 3, 4], [1, 2, 0], [0, 0, 0], [0], [1, 1, 1], [-1, -1, -1], [-1, -2, 0, 3], [-1]]

{{out}}

<pre>

 

=={{header|Ada}}==

with Ada.Strings.Unbounded;

with Ada.Strings.Fixed;

Put_Line (Linear_Combination ((-1, -2, 0, -3)));

Put_Line (Linear_Combination ((1 => -1)));

{{out}}

<pre>e(1) + 2*e(2) + 3*e(3)

-e(1) - 2*e(2) - 3*e(4)

-e(1)</pre>

 

=={{header|C}}==

Accepts vector coefficients from the command line, prints usage syntax if invoked with no arguments. This implementation can handle floating point values but displays integer values as integers. All test case results shown with invocation. A multiplication sign is not shown between a coefficient and the unit vector when a vector is written out by hand ( i.e. human readable) and is thus not shown here as well.

 

#include<stdlib.h>

return 0;

}

{{out}}

<pre>

=={{header|C sharp|C#}}==

{{trans|D}}

using System.Collections.Generic;

using System.Text;

}

}

{{out}}

<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

=={{header|C++}}==

{{trans|D}}

#include <iostream>

#include <sstream>

 

return 0;

{{out}}

<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4)

[-1] -> -e(1)</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

import std.conv;

import std.format;

writefln("%-15s -> %s", arr, linearCombo(c));

}

{{out}}

<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4)

[-1] -> -e(1)</pre>

 

=={{header|EchoLisp}}==

;; build an html string from list of coeffs

 

(for/string ((linear linears))

(format "%a -> <span style='color:blue'>%a</span> <br>" linear (linear->html linear)))))

{{out}}

(1 2 3) -> <span style='color:blue'> e₁ + 2*e₂ + 3*e₃ </span> <br>(0 1 2 3) -> <span style='color:blue'> e₂ + 2*e₃ + 3*e₄ </span> <br>(1 0 3 4) -> <span style='color:blue'> e₁ + 3*e₃ + 4*e₄ </span> <br>(1 2 0) -> <span style='color:blue'> e₁ + 2*e₂ </span> <br>(0 0 0) -> <span style='color:blue'>0</span> <br>(0) -> <span style='color:blue'>0</span> <br>(1 1 1) -> <span style='color:blue'> e₁ + e₂ + e₃ </span> <br>(-1 -1 -1) -> <span style='color:blue'>- e₁ - e₂ - e₃ </span> <br>(-1 -2 0 -3) -> <span style='color:blue'>- e₁ - 2*e₂ - 3*e₄ </span> <br>(-1) -> <span style='color:blue'>- e₁ </span> <br>

=={{header|Elixir}}==

{{works with|Elixir|1.3}}

def display(coeff) do

Enum.with_index(coeff)

[-1]

]

 

{{out}}

=={{header|F_Sharp|F#}}==

===The function===

// Display a linear combination. Nigel Galloway: March 28th., 2018

let fN g =

|_ -> printfn "0"

fN 1 g

 

===The Task===

fN [1;2;3]

{{out}}

<pre>

e(1)+2e(2)+3e(3)

</pre>

fN [0;1;2;3]

{{out}}

<pre>

e(2)+2e(3)+3e(4)

</pre>

fN[1;0;3;4]

{{out}}

<pre>

e(1)+3e(3)+4e(4)

</pre>

fN[1;2;0]

{{out}}

<pre>

e(1)+2e(2)

</pre>

fN[0;0;0]

{{out}}

<pre>

0

</pre>

fN[0]

{{out}}

<pre>

0

</pre>

fN[1;1;1]

{{out}}

<pre>

e(1)+e(2)+e(3)

</pre>

fN[-1;-1;-1]

{{out}}

<pre>

-e(1)-e(2)-e(3)

</pre>

fN[-1;-2;0;-3]

{{out}}

<pre>

-e(1)-2e(2)-3e(4)

</pre>

fN[1]

{{out}}

<pre>

 

=={{header|Factor}}==

 

MATCH-VARS: ?a ?b ;

{ { 1 2 3 } { 0 1 2 3 } { 1 0 3 4 } { 1 2 0 } { 0 0 0 } { 0 }

{ 1 1 1 } { -1 -1 -1 } { -1 -2 0 -3 } { -1 } }

{{out}}

{ 0 1 2 3 } -> e(2) + 2*e(3) + 3*e(4)

{ 1 0 3 4 } -> e(1) + 3*e(3) + 4*e(4)

{ -1 -1 -1 } -> -e(1) - e(2) - e(3)

{ -1 -2 0 -3 } -> -e(1) - 2*e(2) - 3*e(4)

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Printf("%-15s -> %s\n", t, linearCombo(c))

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private static String linearCombo(int[] c) {

StringBuilder sb = new StringBuilder()

}

}

{{out}}

<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

 

=={{header|Haskell}}==

 

linearForm :: [Int] -> String

'+':s -> s

"" -> "0"

 

Testing

 

coeffs = [ [1, 2, 3]

, [0, 1, 2, 3]

, [-1, -1, -1]

, [-1, -2, 0, -3]

 

<pre>λ> mapM_ (print . linearForm) coeffs

Implementation:

 

e=. ('e(',')',~])@":&.> 1+i.#y

firstpos=. 0< {.y-.0

case. do. pfx,(":|x),'*',y

end.

 

Example use:

 

e(1)+2*e(2)+3*e(3)

fourbanger 0 1 2 3

-e(1)-2*e(2)-3*e(4)

fourbanger _1

 

=={{header|Java}}==

{{trans|Kotlin}}

 

public class LinearCombination {

}

}

{{out}}

<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

 

=={{header|jq}}==

reduce to_entries[] as {key: $k,value: $v} ("";

if $v == 0 then .

[-1]

| "\(lpad(15)) => \(linearCombo)"

{{out}}

[0,1,2,3] => e1 + 2*e2 + 3*e3

[1,0,3,4] => e0 + 3*e2 + 4*e3

[-1,-1,-1] => -e0 - e1 - e2

[-1,-2,0,-3] => -e0 - 2*e1 - 3*e3

=={{header|Julia}}==

 

linearcombination(coef::Array) = join(collect("$c * e($i)" for (i, c) in enumerate(coef) if c != 0), " + ")

[-1, -1, -1], [-1, -2, 0, -3], [-1]]

@printf("%20s -> %s\n", c, linearcombination(c))

 

{{out}}

 

=={{header|Kotlin}}==

 

fun linearCombo(c: IntArray): String {

println("${c.contentToString().padEnd(15)} -> ${linearCombo(c)}")

}

 

{{out}}

 

=={{header|Lambdatalk}}==

 

{def linearcomb

{linearcomb -1} -> - e(1)

 

 

=={{header|Lua}}==

{{trans|C#}}

local s = "["

for i,v in pairs(t) do

end

 

{{out}}

<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4)

[-1] -> -e(1)</pre>

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Nim}}==

{{trans|Kotlin}}

 

proc linearCombo(c: openArray[int]): string =

 

for c in Combos:

 

{{out}}

[-1, -2, 0, -3] → -e(1) - 2*e(2) - 3*e(4)

[-1] → -e(1)</pre>

 

=={{header|Perl}}==

use warnings;

use feature 'say';

 

say linear_combination($_) for

{{out}}

<pre>e(1) + 2*e(2) + 3*e(3)

=={{header|Phix}}==

{{trans|Tcl}}

{{out}}

<pre>

 

=={{header|PureBasic}}==

Procedure WriteLinear(Array c.i(1))

Define buf$,

Data.i -1

_V10:

{{out}}

<pre>

 

=={{header|Python}}==

def linear(x):

return ' + '.join(['{}e({})'.format('-' if v == -1 else '' if v == 1 else str(v) + '*', i + 1)

list(map(lambda x: print(linear(x)), [[1, 2, 3], [0, 1, 2, 3], [1, 0, 3, 4], [1, 2, 0],

[0, 0, 0], [0], [1, 1, 1], [-1, -1, -1], [-1, -2, 0, 3], [-1]]))

{{out}}

<pre>

 

=={{header|Racket}}==

(require racket/match racket/string)

 

(-1 -2 0 -3)

(-1)))

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

(@coeff Z=> map { "e($_)" }, 1 .. *)

.grep(+*.key)

[-1, -2, 0, -3],

[-1 ]

{{out}}

<pre>e(1) + 2*e(2) + 3*e(3)

 

=={{header|REXX}}==

@.= .; @.1 = ' 1, 2, 3 ' /*define a specific test case for build*/

@.2 = ' 0, 1, 2, 3 ' /* " " " " " " " */

n= n + 1 /*bump the number of elements in vector*/

if n==1 then s= strip(s) /*if the 1st element used, remove blank*/

$= $ s'e('k")" /*construct a liner combination element*/

end /*k*/

if $=='' then $= 0 /*handle special case of no elements. */

say right( space(@.j), 20) ' ──► ' strip($) /*align the output for presentation. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Display a linear combination

 

see str + nl

next

Output:

<pre>

-e1-2*e2-3*e4

-e1

</pre>

 

=={{header|Ruby}}==

{{trans|D}}

sb = ""

c.each_with_index { |n, i|

end

 

{{out}}

<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

 

=={{header|Rust}}==

use std::fmt::{Display, Formatter, Result};

use std::process::exit;

println!("{}", linear_combination(&coefficients));

}

{{out}}

<pre>

 

=={{header|Scala}}==

val combos = Seq(Seq(1, 2, 3), Seq(0, 1, 2, 3),

Seq(1, 0, 3, 4), Seq(1, 2, 0), Seq(0, 0, 0), Seq(0),

println(f"${c.mkString("[", ", ", "]")}%-15s -> ${linearCombo(c)}%s")

}

 

=={{header|Sidef}}==

{{trans|Tcl}}

var res = ""

for e,f in (coeffs.kv) {

tests.each { |t|

printf("%10s -> %-10s\n", t.join(' '), linear_combination(t))

{{out}}

<pre> 1 2 3 -> e(1)+2*e(2)+3*e(3)

This solution strives for legibility rather than golf.

 

set exp 0

set res ""

} {

puts [format "%10s -> %-10s" $test [lincom $test]]

 

{{out}}

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3)

[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4)

[-1] -> -e(1)</pre>

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var linearCombo = Fn.new { |c|

for (c in combos) {

Fmt.print("$-15s -> $s", c.toString, linearCombo.call(c))

 

{{out}}

=={{header|zkl}}==

{{trans|Raku}}

[1..].zipWith(fcn(n,c){ if(c==0) "" else "%s*e(%s)".fmt(c,n) },coeffs)

.filter().concat("+").replace("+-","-").replace("1*","")

or 0

T(-1,-2,0,-3),T(-1),T)

{{out}}

<pre>