Display a linear combination: Difference between revisions
(→{{header|Elixir}}: String.lstrip -> trim_leading) |
(Applesoft BASIC) |
||
(67 intermediate revisions by 32 users not shown) | |||
Line 1: | Line 1: | ||
{{ |
{{task}} |
||
;Task: |
;Task: |
||
Line 35: | Line 35: | ||
</pre> |
</pre> |
||
<br><br> |
<br><br> |
||
=={{header|11l}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang="11l">F linear(x) |
|||
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]] |
|||
print(linear(x))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1) + 2*e(2) + 3*e(3) |
|||
e(2) + 2*e(3) + 3*e(4) |
|||
e(1) + 3*e(3) + 4*e(4) |
|||
e(1) + 2*e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2*e(2) + 3*e(4) |
|||
-e(1) |
|||
</pre> |
|||
=={{header|Ada}}== |
|||
<syntaxhighlight lang="ada">with Ada.Text_Io; |
|||
with Ada.Strings.Unbounded; |
|||
with Ada.Strings.Fixed; |
|||
procedure Display_Linear is |
|||
subtype Position is Positive; |
|||
type Coefficient is new Integer; |
|||
type Combination is array (Position range <>) of Coefficient; |
|||
function Linear_Combination (Comb : Combination) return String is |
|||
use Ada.Strings.Unbounded; |
|||
use Ada.Strings; |
|||
Accu : Unbounded_String; |
|||
begin |
|||
for Pos in Comb'Range loop |
|||
case Comb (Pos) is |
|||
when Coefficient'First .. -1 => |
|||
Append (Accu, (if Accu = "" then "-" else " - ")); |
|||
when 0 => null; |
|||
when 1 .. Coefficient'Last => |
|||
Append (Accu, (if Accu /= "" then " + " else "")); |
|||
end case; |
|||
if Comb (Pos) /= 0 then |
|||
declare |
|||
Abs_Coeff : constant Coefficient := abs Comb (Pos); |
|||
Coeff_Image : constant String := Fixed.Trim (Coefficient'Image (Abs_Coeff), Left); |
|||
Exp_Image : constant String := Fixed.Trim (Position'Image (Pos), Left); |
|||
begin |
|||
if Abs_Coeff /= 1 then |
|||
Append (Accu, Coeff_Image & "*"); |
|||
end if; |
|||
Append (Accu, "e(" & Exp_Image & ")"); |
|||
end; |
|||
end if; |
|||
end loop; |
|||
return (if Accu = "" then "0" else To_String (Accu)); |
|||
end Linear_Combination; |
|||
use Ada.Text_Io; |
|||
begin |
|||
Put_Line (Linear_Combination ((1, 2, 3))); |
|||
Put_Line (Linear_Combination ((0, 1, 2, 3))); |
|||
Put_Line (Linear_Combination ((1, 0, 3, 4))); |
|||
Put_Line (Linear_Combination ((1, 2, 0))); |
|||
Put_Line (Linear_Combination ((0, 0, 0))); |
|||
Put_Line (Linear_Combination ((1 => 0))); |
|||
Put_Line (Linear_Combination ((1, 1, 1))); |
|||
Put_Line (Linear_Combination ((-1, -1, -1))); |
|||
Put_Line (Linear_Combination ((-1, -2, 0, -3))); |
|||
Put_Line (Linear_Combination ((1 => -1))); |
|||
end Display_Linear;</syntaxhighlight> |
|||
{{out}} |
|||
<pre>e(1) + 2*e(2) + 3*e(3) |
|||
e(2) + 2*e(3) + 3*e(4) |
|||
e(1) + 3*e(3) + 4*e(4) |
|||
e(1) + 2*e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2*e(2) - 3*e(4) |
|||
-e(1)</pre> |
|||
=={{header|ALGOL 68}}== |
|||
Using implicit multiplication operators, as in the C and Mathematica samples. |
|||
<syntaxhighlight lang="algol68"> |
|||
BEGIN # display a string representation of some linear combinations # |
|||
# returns a string representing the sum of the terms of a linear combination # |
|||
# whose coefficients are the elements of coeffs # |
|||
PROC linear combination = ( []INT coeffs )STRING: |
|||
BEGIN |
|||
[]INT cf = coeffs[ AT 1 ]; # ensure the lower bound is 1 # |
|||
STRING result := ""; |
|||
BOOL first term := TRUE; |
|||
FOR i FROM LWB cf TO UPB cf DO |
|||
IF INT c = cf[ i ]; |
|||
c /= 0 |
|||
THEN # non-null element # |
|||
IF first term THEN |
|||
# first term - only add the operator if it is "-" # |
|||
IF c < 0 THEN result +:= "-" FI; |
|||
first term := FALSE |
|||
ELSE |
|||
# second or subsequent term - separate from the previous # |
|||
# and always add the operator # |
|||
result +:= " " + IF c < 0 THEN "-" ELSE "+" FI + " " |
|||
FI; |
|||
# add the coefficient, unless it is one # |
|||
IF ABS c /= 1 THEN |
|||
result +:= whole( ABS c, 0 ) |
|||
FI; |
|||
# add the vector # |
|||
result +:= "e(" + whole( i, 0 ) + ")" |
|||
FI |
|||
OD; |
|||
IF result = "" THEN "0" ELSE result FI |
|||
END # linear combination # ; |
|||
# test cases # |
|||
[][]INT tests = ( ( 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 ) |
|||
); |
|||
FOR i FROM LWB tests TO UPB tests DO |
|||
print( ( linear combination( tests[ i ] ), newline ) ) |
|||
OD |
|||
END |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1) + 2e(2) + 3e(3) |
|||
e(2) + 2e(3) + 3e(4) |
|||
e(1) + 3e(3) + 4e(4) |
|||
e(1) + 2e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2e(2) - 3e(4) |
|||
-e(1) |
|||
</pre> |
|||
=={{header|APL}}== |
|||
{{works with|Dyalog APL}} |
|||
<syntaxhighlight lang="apl"> lincomb←{ |
|||
fmtco←{ |
|||
mul←(⍵≠1)/(⍕|⍵),'*' |
|||
mul,'e(',(⍕⍺),')' |
|||
} |
|||
co←⊃¨fmtco/¨(⍵≠0)/(⍳⍴,⍵),¨|⍵ |
|||
sgn←'-+'[1+(×⍵)/×⍵] |
|||
lc←(('+'=⊃)↓⊢)∊sgn,¨co |
|||
0=⍴lc:'0' ⋄ lc |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> ↑lincomb¨(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) |
|||
e(1)+2*e(2)+3*e(3) |
|||
e(2)+2*e(3)+3*e(4) |
|||
e(1)+3*e(3)+4*e(4) |
|||
e(1)+2*e(2) |
|||
0 |
|||
0 |
|||
e(1)+e(2)+e(3) |
|||
-e(1)+e(2)+e(3) |
|||
-e(1)+2*e(2)-3*e(4) |
|||
-e(1) </pre> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="arturo">linearCombination: function [coeffs][ |
|||
combo: new [] |
|||
loop.with:'i coeffs 'x [ |
|||
case [x] |
|||
when? [=0] [] |
|||
when? [=1] -> 'combo ++ ~"e(|i+1|)" |
|||
when? [= neg 1] -> 'combo ++ ~"-e(|i+1|)" |
|||
else -> 'combo ++ ~"|x|*e(|i+1|)" |
|||
] |
|||
join.with: " + " 'combo |
|||
replace 'combo {/\+ -/} "- " |
|||
(empty? combo)? -> "0" -> combo |
|||
] |
|||
loop @[ |
|||
[1 2 3] |
|||
[0 1 2 3] |
|||
[1 0 3 4] |
|||
[1 2 0] |
|||
[0 0 0] |
|||
[0] |
|||
[1 1 1] |
|||
@[neg 1 neg 1 neg 1] |
|||
@[neg 1 neg 2 0 neg 3] |
|||
@[neg 1] |
|||
] => [print linearCombination &] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>e(1) + 2*e(2) + 3*e(3) |
|||
e(2) + 2*e(3) + 3*e(4) |
|||
e(1) + 3*e(3) + 4*e(4) |
|||
e(1) + 2*e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2*e(2) - 3*e(4) |
|||
-e(1)</pre> |
|||
=={{header|BASIC}}== |
|||
==={{header|Applesoft BASIC}}=== |
|||
{{trans|Chipmunk Basic}} The Spanish word "cadena" means "string" in English. |
|||
<syntaxhighlight lang="basic"> 100 READ UX,UY |
|||
110 DIM SCALARS(UX,UY) |
|||
120 FOR N = 1 TO UX |
|||
130 FOR M = 1 TO UY |
|||
140 READ SCALARS(N,M) |
|||
150 NEXT M,N |
|||
160 DATA10,4 |
|||
170 DATA1,2,3,0,0,1,2,3 |
|||
180 DATA1,0,3,4,1,2,0,0 |
|||
190 DATA0,0,0,0,0,0,0,0 |
|||
200 DATA1,1,1,0,-1,-1,-1,0 |
|||
210 DATA-1,-2,0,-3,-1,0,0,0 |
|||
220 FOR N = 1 TO UX |
|||
230 CADENA$ = "" |
|||
240 FOR M = 1 TO UY |
|||
250 SCALAR = SCALARS(N,M) |
|||
260 IF SCALAR THEN CADENA$ = CADENA$ + CHR$ (44 - SGN (SCALAR)) + MID$ ( STR$ ( ABS (SCALAR)) + "*",1,255 * ( ABS (SCALAR) < > 1)) + "E" + STR$ (M) |
|||
270 NEXT M |
|||
280 IF CADENA$ = "" THEN CADENA$ = "0" |
|||
290 IF LEFT$ (CADENA$,1) = "+" THEN CADENA$ = RIGHT$ (CADENA$, LEN (CADENA$) - 1) |
|||
300 PRINT CADENA$ |
|||
310 NEXT N</syntaxhighlight> |
|||
==={{header|Chipmunk Basic}}=== |
|||
{{trans|FreeBASIC}} |
|||
{{works with|Chipmunk Basic|3.6.4}} |
|||
<syntaxhighlight lang="vbnet">100 dim scalars(10,4) |
|||
110 scalars(1,1) = 1 : scalars(1,2) = 2 : scalars(1,3) = 3 |
|||
120 scalars(2,1) = 0 : scalars(2,2) = 1 : scalars(2,3) = 2 : scalars(2,4) = 3 |
|||
130 scalars(3,1) = 1 : scalars(3,2) = 0 : scalars(3,3) = 3 : scalars(3,4) = 4 |
|||
140 scalars(4,1) = 1 : scalars(4,2) = 2 : scalars(4,3) = 0 |
|||
150 scalars(5,1) = 0 : scalars(5,2) = 0 : scalars(5,3) = 0 |
|||
160 scalars(6,1) = 0 |
|||
170 scalars(7,1) = 1 : scalars(7,2) = 1 : scalars(7,3) = 1 |
|||
180 scalars(8,1) = -1 : scalars(8,2) = -1 : scalars(8,3) = -1 |
|||
190 scalars(9,1) = -1 : scalars(9,2) = -2 : scalars(9,3) = 0 : scalars(9,4) = -3 |
|||
200 scalars(10,1) = -1 |
|||
210 cls |
|||
220 for n = 1 to ubound(scalars) |
|||
230 cadena$ = "" |
|||
240 scalar = 0 |
|||
250 for m = 1 to ubound(scalars,2) |
|||
260 scalar = scalars(n,m) |
|||
270 if scalar <> 0 then |
|||
280 if scalar = 1 then |
|||
290 cadena$ = cadena$+"+e"+str$(m) |
|||
300 else |
|||
310 if scalar = -1 then |
|||
320 cadena$ = cadena$+"-e"+str$(m) |
|||
330 else |
|||
340 if scalar > 0 then |
|||
350 cadena$ = cadena$+chr$(43)+str$(scalar)+"*e"+str$(m) |
|||
360 else |
|||
370 cadena$ = cadena$+str$(scalar)+"*e"+str$(m) |
|||
380 endif |
|||
390 endif |
|||
400 endif |
|||
410 endif |
|||
420 next m |
|||
430 if cadena$ = "" then cadena$ = "0" |
|||
440 if left$(cadena$,1) = "+" then cadena$ = right$(cadena$,len(cadena$)-1) |
|||
450 print cadena$ |
|||
460 next n |
|||
470 end</syntaxhighlight> |
|||
==={{header|FreeBASIC}}=== |
|||
{{trans|Ring}} |
|||
<syntaxhighlight lang="freebasic">Dim scalars(1 To 10, 1 To 4) As Integer => {{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}} |
|||
For n As Integer = 1 To Ubound(scalars) |
|||
Dim As String cadena = "" |
|||
Dim As Integer scalar |
|||
For m As Integer = 1 To Ubound(scalars,2) |
|||
scalar = scalars(n, m) |
|||
If scalar <> 0 Then |
|||
If scalar = 1 Then |
|||
cadena &= "+e" & m |
|||
Elseif scalar = -1 Then |
|||
cadena &= "-e" & m |
|||
Else |
|||
If scalar > 0 Then |
|||
cadena &= Chr(43) & scalar & "*e" & m |
|||
Else |
|||
cadena &= scalar & "*e" & m |
|||
End If |
|||
End If |
|||
End If |
|||
Next m |
|||
If cadena = "" Then cadena = "0" |
|||
If Left(cadena, 1) = "+" Then cadena = Right(cadena, Len(cadena)-1) |
|||
Print cadena |
|||
Next n |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Same as Ring entry.</pre> |
|||
==={{header|GW-BASIC}}=== |
|||
{{works with|PC-BASIC|any}} |
|||
{{works with|BASICA}} |
|||
{{works with|Chipmunk Basic}} |
|||
{{works with|QBasic}} |
|||
{{works with|MSX BASIC}} |
|||
<syntaxhighlight lang="qbasic">100 DIM SKLS(10, 4) |
|||
110 SKLS(1, 1) = 1: SKLS(1, 2) = 2: SKLS(1, 3) = 3 |
|||
120 SKLS(2, 1) = 0: SKLS(2, 2) = 1: SKLS(2, 3) = 2: SKLS(2, 4) = 3 |
|||
130 SKLS(3, 1) = 1: SKLS(3, 2) = 0: SKLS(3, 3) = 3: SKLS(3, 4) = 4 |
|||
140 SKLS(4, 1) = 1: SKLS(4, 2) = 2: SKLS(4, 3) = 0 |
|||
150 SKLS(5, 1) = 0: SKLS(5, 2) = 0: SKLS(5, 3) = 0 |
|||
160 SKLS(6, 1) = 0 |
|||
170 SKLS(7, 1) = 1: SKLS(7, 2) = 1: SKLS(7, 3) = 1 |
|||
180 SKLS(8, 1) = -1: SKLS(8, 2) = -1: SKLS(8, 3) = -1 |
|||
190 SKLS(9, 1) = -1: SKLS(9, 2) = -2: SKLS(9, 3) = 0: SKLS(9, 4) = -3 |
|||
200 SKLS(10, 1) = -1 |
|||
210 CLS |
|||
220 FOR N = 1 TO 10 |
|||
230 CAD$ = "" |
|||
240 SCL = 0 |
|||
250 FOR M = 1 TO 4 |
|||
260 SCL = SKLS(N, M) |
|||
270 IF SCL <> 0 THEN IF SCL = 1 THEN CAD$ = CAD$ + "+e" + STR$(M) ELSE IF SCL = -1 THEN CAD$ = CAD$ + "-e" + STR$(M) ELSE IF SCL > 0 THEN CAD$ = CAD$ + CHR$(43) + STR$(SCL) + "*e" + STR$(M) ELSE CAD$ = CAD$ + STR$(SCL) + "*e" + STR$(M) |
|||
280 NEXT M |
|||
290 IF CAD$ = "" THEN CAD$ = "0" |
|||
300 IF LEFT$(CAD$, 1) = "+" THEN CAD$ = RIGHT$(CAD$, LEN(CAD$) - 1) |
|||
310 PRINT CAD$ |
|||
320 NEXT N |
|||
330 END</syntaxhighlight> |
|||
==={{header|MSX Basic}}=== |
|||
{{works with|MSX BASIC|any}} |
|||
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.ht> |
|||
==={{header|QBasic}}=== |
|||
{{trans|FreeBASIC}} |
|||
{{works with|QBasic|1.1}} |
|||
{{works with|QuickBasic|4.5}} |
|||
{{works with|QB64}} |
|||
<syntaxhighlight lang="qbasic">DIM scalars(1 TO 10, 1 TO 4) |
|||
scalars(1, 1) = 1: scalars(1, 2) = 2: scalars(1, 3) = 3 |
|||
scalars(2, 1) = 0: scalars(2, 2) = 1: scalars(2, 3) = 2: scalars(2, 4) = 3 |
|||
scalars(3, 1) = 1: scalars(3, 2) = 0: scalars(3, 3) = 3: scalars(3, 4) = 4 |
|||
scalars(4, 1) = 1: scalars(4, 2) = 2: scalars(4, 3) = 0 |
|||
scalars(5, 1) = 0: scalars(5, 2) = 0: scalars(5, 3) = 0 |
|||
scalars(6, 1) = 0 |
|||
scalars(7, 1) = 1: scalars(7, 2) = 1: scalars(7, 3) = 1 |
|||
scalars(8, 1) = -1: scalars(8, 2) = -1: scalars(8, 3) = -1 |
|||
scalars(9, 1) = -1: scalars(9, 2) = -2: scalars(9, 3) = 0: scalars(9, 4) = -3 |
|||
scalars(10, 1) = -1 |
|||
CLS |
|||
FOR n = 1 TO UBOUND(scalars) |
|||
cadena$ = "" |
|||
scalar = 0 |
|||
FOR m = 1 TO UBOUND(scalars, 2) |
|||
scalar = scalars(n, m) |
|||
IF scalar <> 0 THEN |
|||
IF scalar = 1 THEN |
|||
cadena$ = cadena$ + "+e" + STR$(m) |
|||
ELSEIF scalar = -1 THEN |
|||
cadena$ = cadena$ + "-e" + STR$(m) |
|||
ELSE |
|||
IF scalar > 0 THEN |
|||
cadena$ = cadena$ + CHR$(43) + STR$(scalar) + "*e" + STR$(m) |
|||
ELSE |
|||
cadena$ = cadena$ + STR$(scalar) + "*e" + STR$(m) |
|||
END IF |
|||
END IF |
|||
END IF |
|||
NEXT m |
|||
IF cadena$ = "" THEN cadena$ = "0" |
|||
IF LEFT$(cadena$, 1) = "+" THEN cadena$ = RIGHT$(cadena$, LEN(cadena$) - 1) |
|||
PRINT cadena$ |
|||
NEXT n |
|||
END</syntaxhighlight> |
|||
==={{header|Yabasic}}=== |
|||
{{trans|FreeBASIC}} |
|||
<syntaxhighlight lang="vb">dim scalars(10,4) |
|||
scalars(1,1) = 1: scalars(1,2) = 2: scalars(1,3) = 3 |
|||
scalars(2,1) = 0: scalars(2,2) = 1: scalars(2,3) = 2: scalars(2,4) = 3 |
|||
scalars(3,1) = 1: scalars(3,2) = 0: scalars(3,3) = 3: scalars(3,4) = 4 |
|||
scalars(4,1) = 1: scalars(4,2) = 2: scalars(4,3) = 0 |
|||
scalars(5,1) = 0: scalars(5,2) = 0: scalars(5,3) = 0 |
|||
scalars(6,1) = 0 |
|||
scalars(7,1) = 1: scalars(7,2) = 1: scalars(7,3) = 1 |
|||
scalars(8,1) = -1: scalars(8,2) = -1: scalars(8,3) = -1 |
|||
scalars(9,1) = -1: scalars(9,2) = -2: scalars(9,3) = 0: scalars(9,4) = -3 |
|||
scalars(10,1) = -1 |
|||
for n = 1 to arraysize(scalars(),1) |
|||
cadena$ = "" |
|||
for m = 1 to arraysize(scalars(),2) |
|||
scalar = scalars(n, m) |
|||
if scalar <> 0 then |
|||
if scalar = 1 then |
|||
cadena$ = cadena$ + "+e" + str$(m) |
|||
else |
|||
if scalar = -1 then |
|||
cadena$ = cadena$ + "-e" + str$(m) |
|||
else |
|||
if scalar > 0 then |
|||
cadena$ = cadena$ + chr$(43) + str$(scalar) + "*e" + str$(m) |
|||
else |
|||
cadena$ = cadena$ + str$(scalar) + "*e" + str$(m) |
|||
fi |
|||
fi |
|||
fi |
|||
fi |
|||
next m |
|||
if cadena$ = "" cadena$ = "0" |
|||
if left$(cadena$, 1) = "+" cadena$ = right$(cadena$, len(cadena$)-1) |
|||
print cadena$ |
|||
next n |
|||
end</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="c"> |
|||
#include<stdlib.h> |
|||
#include<stdio.h> |
|||
#include<math.h> /*Optional, but better if included as fabs, labs and abs functions are being used. */ |
|||
int main(int argC, char* argV[]) |
|||
{ |
|||
int i,zeroCount= 0,firstNonZero = -1; |
|||
double* vector; |
|||
if(argC == 1){ |
|||
printf("Usage : %s <Vector component coefficients seperated by single space>",argV[0]); |
|||
} |
|||
else{ |
|||
printf("Vector for ["); |
|||
for(i=1;i<argC;i++){ |
|||
printf("%s,",argV[i]); |
|||
} |
|||
printf("\b] -> "); |
|||
vector = (double*)malloc((argC-1)*sizeof(double)); |
|||
for(i=1;i<=argC;i++){ |
|||
vector[i-1] = atof(argV[i]); |
|||
if(vector[i-1]==0.0) |
|||
zeroCount++; |
|||
if(vector[i-1]!=0.0 && firstNonZero==-1) |
|||
firstNonZero = i-1; |
|||
} |
|||
if(zeroCount == argC){ |
|||
printf("0"); |
|||
} |
|||
else{ |
|||
for(i=0;i<argC;i++){ |
|||
if(i==firstNonZero && vector[i]==1) |
|||
printf("e%d ",i+1); |
|||
else if(i==firstNonZero && vector[i]==-1) |
|||
printf("- e%d ",i+1); |
|||
else if(i==firstNonZero && vector[i]<0 && fabs(vector[i])-abs(vector[i])>0.0) |
|||
printf("- %lf e%d ",fabs(vector[i]),i+1); |
|||
else if(i==firstNonZero && vector[i]<0 && fabs(vector[i])-abs(vector[i])==0.0) |
|||
printf("- %ld e%d ",labs(vector[i]),i+1); |
|||
else if(i==firstNonZero && vector[i]>0 && fabs(vector[i])-abs(vector[i])>0.0) |
|||
printf("%lf e%d ",vector[i],i+1); |
|||
else if(i==firstNonZero && vector[i]>0 && fabs(vector[i])-abs(vector[i])==0.0) |
|||
printf("%ld e%d ",vector[i],i+1); |
|||
else if(fabs(vector[i])==1.0 && i!=0) |
|||
printf("%c e%d ",(vector[i]==-1)?'-':'+',i+1); |
|||
else if(i!=0 && vector[i]!=0 && fabs(vector[i])-abs(vector[i])>0.0) |
|||
printf("%c %lf e%d ",(vector[i]<0)?'-':'+',fabs(vector[i]),i+1); |
|||
else if(i!=0 && vector[i]!=0 && fabs(vector[i])-abs(vector[i])==0.0) |
|||
printf("%c %ld e%d ",(vector[i]<0)?'-':'+',labs(vector[i]),i+1); |
|||
} |
|||
} |
|||
} |
|||
free(vector); |
|||
return 0; |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
C:\rossetaCode>vectorDisplay.exe 1 2 3 |
|||
Vector for [1,2,3] -> e1 + 2 e2 + 3 e3 |
|||
C:\rossetaCode>vectorDisplay.exe 0 0 0 |
|||
Vector for [0,0,0] -> 0 |
|||
C:\rossetaCode>vectorDisplay.exe 0 1 2 3 |
|||
Vector for [0,1,2,3] -> e2 + 2 e3 + 3 e4 |
|||
C:\rossetaCode>vectorDisplay.exe 1 0 3 4 |
|||
Vector for [1,0,3,4] -> e1 + 3 e3 + 4 e4 |
|||
C:\rossetaCode>vectorDisplay.exe 1 2 0 |
|||
Vector for [1,2,0] -> e1 + 2 e2 |
|||
C:\rossetaCode>vectorDisplay.exe 0 0 0 |
|||
Vector for [0,0,0] -> 0 |
|||
C:\rossetaCode>vectorDisplay.exe 0 |
|||
Vector for [0] -> 0 |
|||
C:\rossetaCode>vectorDisplay.exe 1 1 1 |
|||
Vector for [1,1,1] -> e1 + e2 + e3 |
|||
C:\rossetaCode>vectorDisplay.exe -1 -1 -1 |
|||
Vector for [-1,-1,-1] -> - e1 - e2 - e3 |
|||
C:\rossetaCode>vectorDisplay.exe -1 -2 0 -3 |
|||
Vector for [-1,-2,0,-3] -> - e1 - 2 e2 - 3 e4 |
|||
C:\rossetaCode>vectorDisplay.exe -1 |
|||
Vector for [-1] -> - e1 |
|||
</pre> |
|||
=={{header|C sharp|C#}}== |
|||
{{trans|D}} |
|||
<syntaxhighlight lang="csharp">using System; |
|||
using System.Collections.Generic; |
|||
using System.Text; |
|||
namespace DisplayLinearCombination { |
|||
class Program { |
|||
static string LinearCombo(List<int> c) { |
|||
StringBuilder sb = new StringBuilder(); |
|||
for (int i = 0; i < c.Count; i++) { |
|||
int n = c[i]; |
|||
if (n < 0) { |
|||
if (sb.Length == 0) { |
|||
sb.Append('-'); |
|||
} else { |
|||
sb.Append(" - "); |
|||
} |
|||
} else if (n > 0) { |
|||
if (sb.Length != 0) { |
|||
sb.Append(" + "); |
|||
} |
|||
} else { |
|||
continue; |
|||
} |
|||
int av = Math.Abs(n); |
|||
if (av != 1) { |
|||
sb.AppendFormat("{0}*", av); |
|||
} |
|||
sb.AppendFormat("e({0})", i + 1); |
|||
} |
|||
if (sb.Length == 0) { |
|||
sb.Append('0'); |
|||
} |
|||
return sb.ToString(); |
|||
} |
|||
static void Main(string[] args) { |
|||
List<List<int>> combos = new List<List<int>>{ |
|||
new List<int> { 1, 2, 3}, |
|||
new List<int> { 0, 1, 2, 3}, |
|||
new List<int> { 1, 0, 3, 4}, |
|||
new List<int> { 1, 2, 0}, |
|||
new List<int> { 0, 0, 0}, |
|||
new List<int> { 0}, |
|||
new List<int> { 1, 1, 1}, |
|||
new List<int> { -1, -1, -1}, |
|||
new List<int> { -1, -2, 0, -3}, |
|||
new List<int> { -1}, |
|||
}; |
|||
foreach (List<int> c in combos) { |
|||
var arr = "[" + string.Join(", ", c) + "]"; |
|||
Console.WriteLine("{0,15} -> {1}", arr, LinearCombo(c)); |
|||
} |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|C++}}== |
|||
{{trans|D}} |
|||
<syntaxhighlight lang="cpp">#include <iomanip> |
|||
#include <iostream> |
|||
#include <sstream> |
|||
#include <vector> |
|||
template<typename T> |
|||
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) { |
|||
auto it = v.cbegin(); |
|||
auto end = v.cend(); |
|||
os << '['; |
|||
if (it != end) { |
|||
os << *it; |
|||
it = std::next(it); |
|||
} |
|||
while (it != end) { |
|||
os << ", " << *it; |
|||
it = std::next(it); |
|||
} |
|||
return os << ']'; |
|||
} |
|||
std::ostream& operator<<(std::ostream& os, const std::string& s) { |
|||
return os << s.c_str(); |
|||
} |
|||
std::string linearCombo(const std::vector<int>& c) { |
|||
std::stringstream ss; |
|||
for (size_t i = 0; i < c.size(); i++) { |
|||
int n = c[i]; |
|||
if (n < 0) { |
|||
if (ss.tellp() == 0) { |
|||
ss << '-'; |
|||
} else { |
|||
ss << " - "; |
|||
} |
|||
} else if (n > 0) { |
|||
if (ss.tellp() != 0) { |
|||
ss << " + "; |
|||
} |
|||
} else { |
|||
continue; |
|||
} |
|||
int av = abs(n); |
|||
if (av != 1) { |
|||
ss << av << '*'; |
|||
} |
|||
ss << "e(" << i + 1 << ')'; |
|||
} |
|||
if (ss.tellp() == 0) { |
|||
return "0"; |
|||
} |
|||
return ss.str(); |
|||
} |
|||
int main() { |
|||
using namespace std; |
|||
vector<vector<int>> combos{ |
|||
{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}, |
|||
}; |
|||
for (auto& c : combos) { |
|||
stringstream ss; |
|||
ss << c; |
|||
cout << setw(15) << ss.str() << " -> "; |
|||
cout << linearCombo(c) << '\n'; |
|||
} |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|Cowgol}}== |
|||
<syntaxhighlight lang="cowgol">include "cowgol.coh"; |
|||
sub abs(n: int32): (r: uint32) is |
|||
if n < 0 |
|||
then r := (-n) as uint32; |
|||
else r := n as uint32; |
|||
end if; |
|||
end sub; |
|||
sub lincomb(scalar: [int32], size: intptr) is |
|||
var first: uint8 := 1; |
|||
var item: uint8 := 1; |
|||
sub print_sign() is |
|||
if first == 1 then |
|||
if [scalar] < 0 then print("-"); end if; |
|||
else |
|||
if [scalar] < 0 |
|||
then print(" - "); |
|||
else print(" + "); |
|||
end if; |
|||
end if; |
|||
end sub; |
|||
sub print_term() is |
|||
if [scalar] == 0 then return; end if; |
|||
print_sign(); |
|||
if abs([scalar]) > 1 then |
|||
print_i32(abs([scalar])); |
|||
print("*"); |
|||
end if; |
|||
print("e("); |
|||
print_i8(item); |
|||
print(")"); |
|||
first := 0; |
|||
end sub; |
|||
while size > 0 loop |
|||
print_term(); |
|||
scalar := @next scalar; |
|||
size := size - 1; |
|||
item := item + 1; |
|||
end loop; |
|||
if first == 1 then |
|||
print("0"); |
|||
end if; |
|||
print_nl(); |
|||
end sub; |
|||
var a1: int32[] := {1, 2, 3}; lincomb(&a1[0], @sizeof a1); |
|||
var a2: int32[] := {0, 1, 2, 3}; lincomb(&a2[0], @sizeof a2); |
|||
var a3: int32[] := {1, 0, 3, 4}; lincomb(&a3[0], @sizeof a3); |
|||
var a4: int32[] := {1, 2, 0}; lincomb(&a4[0], @sizeof a4); |
|||
var a5: int32[] := {0, 0, 0}; lincomb(&a5[0], @sizeof a5); |
|||
var a6: int32[] := {0}; lincomb(&a6[0], @sizeof a6); |
|||
var a7: int32[] := {1, 1, 1}; lincomb(&a7[0], @sizeof a7); |
|||
var a8: int32[] := {-1, -1, -1}; lincomb(&a8[0], @sizeof a8); |
|||
var a9: int32[] := {-1, -2, 0, 3}; lincomb(&a9[0], @sizeof a9); |
|||
var a10: int32[] := {-1}; lincomb(&a10[0], @sizeof a10);</syntaxhighlight> |
|||
{{out}} |
|||
<pre>e(1) + 2*e(2) + 3*e(3) |
|||
e(2) + 2*e(3) + 3*e(4) |
|||
e(1) + 3*e(3) + 4*e(4) |
|||
e(1) + 2*e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2*e(2) + 3*e(4) |
|||
-e(1)</pre> |
|||
=={{header|D}}== |
|||
{{trans|Kotlin}} |
|||
<syntaxhighlight lang="d">import std.array; |
|||
import std.conv; |
|||
import std.format; |
|||
import std.math; |
|||
import std.stdio; |
|||
string linearCombo(int[] c) { |
|||
auto sb = appender!string; |
|||
foreach (i, n; c) { |
|||
if (n==0) continue; |
|||
string op; |
|||
if (n < 0) { |
|||
if (sb.data.empty) { |
|||
op = "-"; |
|||
} else { |
|||
op = " - "; |
|||
} |
|||
} else if (n > 0) { |
|||
if (!sb.data.empty) { |
|||
op = " + "; |
|||
} |
|||
} |
|||
auto av = abs(n); |
|||
string coeff; |
|||
if (av != 1) { |
|||
coeff = to!string(av) ~ "*"; |
|||
} |
|||
sb.formattedWrite("%s%se(%d)", op, coeff, i+1); |
|||
} |
|||
if (sb.data.empty) { |
|||
return "0"; |
|||
} |
|||
return sb.data; |
|||
} |
|||
void main() { |
|||
auto combos = [ |
|||
[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], |
|||
]; |
|||
foreach (c; combos) { |
|||
auto arr = c.format!"%s"; |
|||
writefln("%-15s -> %s", arr, linearCombo(c)); |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|Draco}}== |
|||
<syntaxhighlight lang="draco">proc abs(int n) int: if n<0 then -n else n fi corp |
|||
proc write_term(word index; int scalar; bool first) void: |
|||
if first then |
|||
if scalar<0 then write("-") fi |
|||
else |
|||
write(if scalar<0 then " - " else " + " fi) |
|||
fi; |
|||
if abs(scalar)>1 then |
|||
write(abs(scalar), '*') |
|||
fi; |
|||
write("e(",index,")") |
|||
corp |
|||
proc lincomb([*]int terms) void: |
|||
bool first; |
|||
word index; |
|||
first := true; |
|||
for index from 0 upto dim(terms,1)-1 do |
|||
if terms[index] /= 0 then |
|||
write_term(index+1, terms[index], first); |
|||
first := false |
|||
fi |
|||
od; |
|||
writeln(if first then "0" else "" fi) |
|||
corp |
|||
proc main() void: |
|||
[3]int a1 = (1,2,3); |
|||
[4]int a2 = (0,1,2,3); |
|||
[4]int a3 = (1,0,3,4); |
|||
[3]int a4 = (1,2,0); |
|||
[3]int a5 = (0,0,0); |
|||
[1]int a6 = (0); |
|||
[3]int a7 = (1,1,1); |
|||
[3]int a8 = (-1,-1,-1); |
|||
[4]int a9 = (-1,-2,0,3); |
|||
[1]int a10 = (-1); |
|||
lincomb(a1); lincomb(a2); lincomb(a3); lincomb(a4); |
|||
lincomb(a5); lincomb(a6); lincomb(a7); lincomb(a8); |
|||
lincomb(a9); lincomb(a10) |
|||
corp</syntaxhighlight> |
|||
{{out}} |
|||
<pre>e(1) + 2*e(2) + 3*e(3) |
|||
e(2) + 2*e(3) + 3*e(4) |
|||
e(1) + 3*e(3) + 4*e(4) |
|||
e(1) + 2*e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2*e(2) + 3*e(4) |
|||
-e(1)</pre> |
|||
=={{header|EasyLang}}== |
|||
{{trans|Ring}} |
|||
<syntaxhighlight> |
|||
scalars[][] = [ [ 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 ] ] |
|||
for n = 1 to len scalars[][] |
|||
str$ = "" |
|||
for m = 1 to len scalars[n][] |
|||
scalar = scalars[n][m] |
|||
if scalar <> 0 |
|||
if scalar = 1 |
|||
str$ &= "+e" & m |
|||
elif scalar = -1 |
|||
str$ &= "-e" & m |
|||
else |
|||
if scalar > 0 |
|||
str$ &= strchar 43 & scalar & "*e" & m |
|||
else |
|||
str$ = scalar & "*e" & m |
|||
. |
|||
. |
|||
. |
|||
. |
|||
if str$ = "" |
|||
str$ = 0 |
|||
. |
|||
if substr str$ 1 1 = "+" |
|||
str$ = substr str$ 2 (len str$ - 1) |
|||
. |
|||
print str$ |
|||
. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e1+2*e2+3*e3 |
|||
e2+2*e3+3*e4 |
|||
e1+3*e3+4*e4 |
|||
e1+2*e2 |
|||
0 |
|||
0 |
|||
e1+e2+e3 |
|||
-e1-e2-e3 |
|||
-3*e4 |
|||
-e1 |
|||
</pre> |
|||
=={{header|EchoLisp}}== |
=={{header|EchoLisp}}== |
||
< |
<syntaxhighlight lang="scheme"> |
||
;; build an html string from list of coeffs |
;; build an html string from list of coeffs |
||
Line 70: | Line 1,015: | ||
(for/string ((linear linears)) |
(for/string ((linear linears)) |
||
(format "%a -> <span style='color:blue'>%a</span> <br>" linear (linear->html linear))))) |
(format "%a -> <span style='color:blue'>%a</span> <br>" linear (linear->html linear))))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
(1 2 3) -> <span style='color:blue'> e<sub>1</sub> + 2*e<sub>2</sub> + 3*e<sub>3</sub> </span> <br>(0 1 2 3) -> <span style='color:blue'> e<sub>2</sub> + 2*e<sub>3</sub> + 3*e<sub>4</sub> </span> <br>(1 0 3 4) -> <span style='color:blue'> e<sub>1</sub> + 3*e<sub>3</sub> + 4*e<sub>4</sub> </span> <br>(1 2 0) -> <span style='color:blue'> e<sub>1</sub> + 2*e<sub>2</sub> </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<sub>1</sub> + e<sub>2</sub> + e<sub>3</sub> </span> <br>(-1 -1 -1) -> <span style='color:blue'>- e<sub>1</sub> - e<sub>2</sub> - e<sub>3</sub> </span> <br>(-1 -2 0 -3) -> <span style='color:blue'>- e<sub>1</sub> - 2*e<sub>2</sub> - 3*e<sub>4</sub> </span> <br>(-1) -> <span style='color:blue'>- e<sub>1</sub> </span> <br> |
(1 2 3) -> <span style='color:blue'> e<sub>1</sub> + 2*e<sub>2</sub> + 3*e<sub>3</sub> </span> <br>(0 1 2 3) -> <span style='color:blue'> e<sub>2</sub> + 2*e<sub>3</sub> + 3*e<sub>4</sub> </span> <br>(1 0 3 4) -> <span style='color:blue'> e<sub>1</sub> + 3*e<sub>3</sub> + 4*e<sub>4</sub> </span> <br>(1 2 0) -> <span style='color:blue'> e<sub>1</sub> + 2*e<sub>2</sub> </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<sub>1</sub> + e<sub>2</sub> + e<sub>3</sub> </span> <br>(-1 -1 -1) -> <span style='color:blue'>- e<sub>1</sub> - e<sub>2</sub> - e<sub>3</sub> </span> <br>(-1 -2 0 -3) -> <span style='color:blue'>- e<sub>1</sub> - 2*e<sub>2</sub> - 3*e<sub>4</sub> </span> <br>(-1) -> <span style='color:blue'>- e<sub>1</sub> </span> <br> |
||
Line 76: | Line 1,021: | ||
=={{header|Elixir}}== |
=={{header|Elixir}}== |
||
{{works with|Elixir|1.3}} |
{{works with|Elixir|1.3}} |
||
< |
<syntaxhighlight lang="elixir">defmodule Linear_combination do |
||
def display(coeff) do |
def display(coeff) do |
||
Enum.with_index(coeff) |
Enum.with_index(coeff) |
||
Line 107: | Line 1,052: | ||
[-1] |
[-1] |
||
] |
] |
||
Enum.each(coeffs, &Linear_combination.display(&1))</ |
Enum.each(coeffs, &Linear_combination.display(&1))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 122: | Line 1,067: | ||
-e(1) |
-e(1) |
||
</pre> |
</pre> |
||
=={{header|F_Sharp|F#}}== |
|||
===The function=== |
|||
<syntaxhighlight lang="fsharp"> |
|||
// Display a linear combination. Nigel Galloway: March 28th., 2018 |
|||
let fN g = |
|||
let rec fG n g=match g with |
|||
|0::g -> fG (n+1) g |
|||
|1::g -> printf "+e(%d)" n; fG (n+1) g |
|||
|(-1)::g -> printf "-e(%d)" n; fG (n+1) g |
|||
|i::g -> printf "%+de(%d)" i n; fG (n+1) g |
|||
|_ -> printfn "" |
|||
let rec fN n g=match g with |
|||
|0::g -> fN (n+1) g |
|||
|1::g -> printf "e(%d)" n; fG (n+1) g |
|||
|(-1)::g -> printf "-e(%d)" n; fG (n+1) g |
|||
|i::g -> printf "%de(%d)" i n; fG (n+1) g |
|||
|_ -> printfn "0" |
|||
fN 1 g |
|||
</syntaxhighlight> |
|||
===The Task=== |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN [1;2;3] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1)+2e(2)+3e(3) |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN [0;1;2;3] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(2)+2e(3)+3e(4) |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[1;0;3;4] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1)+3e(3)+4e(4) |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[1;2;0] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1)+2e(2) |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[0;0;0] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[0] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[1;1;1] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1)+e(2)+e(3) |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[-1;-1;-1] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
-e(1)-e(2)-e(3) |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[-1;-2;0;-3] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
-e(1)-2e(2)-3e(4) |
|||
</pre> |
|||
<syntaxhighlight lang="fsharp"> |
|||
fN[1] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1) |
|||
</pre> |
|||
=={{header|Factor}}== |
|||
<syntaxhighlight lang="factor">USING: formatting kernel match math pair-rocket regexp sequences ; |
|||
MATCH-VARS: ?a ?b ; |
|||
: choose-term ( coeff i -- str ) |
|||
1 + { } 2sequence { |
|||
{ 0 _ } => [ "" ] |
|||
{ 1 ?a } => [ ?a "e(%d)" sprintf ] |
|||
{ -1 ?a } => [ ?a "-e(%d)" sprintf ] |
|||
{ ?a ?b } => [ ?a ?b "%d*e(%d)" sprintf ] |
|||
} match-cond ; |
|||
: linear-combo ( seq -- str ) |
|||
[ choose-term ] map-index harvest " + " join |
|||
R/ \+ -/ "- " re-replace [ "0" ] when-empty ; |
|||
{ { 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 } } |
|||
[ dup linear-combo "%-14u -> %s\n" printf ] each</syntaxhighlight> |
|||
{{out}} |
|||
<pre>{ 1 2 3 } -> e(1) + 2*e(2) + 3*e(3) |
|||
{ 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 2 0 } -> e(1) + 2*e(2) |
|||
{ 0 0 0 } -> 0 |
|||
{ 0 } -> 0 |
|||
{ 1 1 1 } -> e(1) + e(2) + e(3) |
|||
{ -1 -1 -1 } -> -e(1) - e(2) - e(3) |
|||
{ -1 -2 0 -3 } -> -e(1) - 2*e(2) - 3*e(4) |
|||
{ -1 } -> -e(1)</pre> |
|||
=={{header|Go}}== |
|||
{{trans|Kotlin}} |
|||
<syntaxhighlight lang="go">package main |
|||
import ( |
|||
"fmt" |
|||
"strings" |
|||
) |
|||
func linearCombo(c []int) string { |
|||
var sb strings.Builder |
|||
for i, n := range c { |
|||
if n == 0 { |
|||
continue |
|||
} |
|||
var op string |
|||
switch { |
|||
case n < 0 && sb.Len() == 0: |
|||
op = "-" |
|||
case n < 0: |
|||
op = " - " |
|||
case n > 0 && sb.Len() == 0: |
|||
op = "" |
|||
default: |
|||
op = " + " |
|||
} |
|||
av := n |
|||
if av < 0 { |
|||
av = -av |
|||
} |
|||
coeff := fmt.Sprintf("%d*", av) |
|||
if av == 1 { |
|||
coeff = "" |
|||
} |
|||
sb.WriteString(fmt.Sprintf("%s%se(%d)", op, coeff, i+1)) |
|||
} |
|||
if sb.Len() == 0 { |
|||
return "0" |
|||
} else { |
|||
return sb.String() |
|||
} |
|||
} |
|||
func main() { |
|||
combos := [][]int{ |
|||
{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}, |
|||
} |
|||
for _, c := range combos { |
|||
t := strings.Replace(fmt.Sprint(c), " ", ", ", -1) |
|||
fmt.Printf("%-15s -> %s\n", t, linearCombo(c)) |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1) |
|||
</pre> |
|||
=={{header|Groovy}}== |
|||
{{trans|Java}} |
|||
<syntaxhighlight lang="groovy">class LinearCombination { |
|||
private static String linearCombo(int[] c) { |
|||
StringBuilder sb = new StringBuilder() |
|||
for (int i = 0; i < c.length; ++i) { |
|||
if (c[i] == 0) continue |
|||
String op |
|||
if (c[i] < 0 && sb.length() == 0) { |
|||
op = "-" |
|||
} else if (c[i] < 0) { |
|||
op = " - " |
|||
} else if (c[i] > 0 && sb.length() == 0) { |
|||
op = "" |
|||
} else { |
|||
op = " + " |
|||
} |
|||
int av = Math.abs(c[i]) |
|||
String coeff = av == 1 ? "" : "" + av + "*" |
|||
sb.append(op).append(coeff).append("e(").append(i + 1).append(')') |
|||
} |
|||
if (sb.length() == 0) { |
|||
return "0" |
|||
} |
|||
return sb.toString() |
|||
} |
|||
static void main(String[] args) { |
|||
int[][] combos = [ |
|||
[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] |
|||
] |
|||
for (int[] c : combos) { |
|||
printf("%-15s -> %s\n", Arrays.toString(c), linearCombo(c)) |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|Haskell}}== |
|||
<syntaxhighlight lang="haskell">import Text.Printf (printf) |
|||
linearForm :: [Int] -> String |
|||
linearForm = strip . concat . zipWith term [1..] |
|||
where |
|||
term :: Int -> Int -> String |
|||
term i c = case c of |
|||
0 -> mempty |
|||
1 -> printf "+e(%d)" i |
|||
-1 -> printf "-e(%d)" i |
|||
c -> printf "%+d*e(%d)" c i |
|||
strip str = case str of |
|||
'+':s -> s |
|||
"" -> "0" |
|||
s -> s</syntaxhighlight> |
|||
Testing |
|||
<syntaxhighlight lang="haskell">coeffs :: [[Int]] |
|||
coeffs = [ [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] ]</syntaxhighlight> |
|||
<pre>λ> mapM_ (print . linearForm) coeffs |
|||
"e(1)+2*e(2)+3*e(3)" |
|||
"e(2)+2*e(3)+3*e(4)" |
|||
"e(1)+3*e(3)+4*e(4)" |
|||
"e(1)+2*e(2)" |
|||
"0" |
|||
"0" |
|||
"e(1)+e(2)+e(3)" |
|||
"-e(1)-e(2)-e(3)" |
|||
"-e(1)-2*e(2)-3*e(4)" |
|||
"-e(1)"</pre> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Line 127: | Line 1,374: | ||
Implementation: |
Implementation: |
||
< |
<syntaxhighlight lang="j">fourbanger=:3 :0 |
||
e=. ('e(',')',~])@":&.> 1+i.#y |
e=. ('e(',')',~])@":&.> 1+i.#y |
||
firstpos=. 0< {.y-.0 |
firstpos=. 0< {.y-.0 |
||
Line 140: | Line 1,387: | ||
case. do. pfx,(":|x),'*',y |
case. do. pfx,(":|x),'*',y |
||
end. |
end. |
||
)</ |
)</syntaxhighlight> |
||
Example use: |
Example use: |
||
< |
<syntaxhighlight lang="j"> fourbanger 1 2 3 |
||
e(1)+2*e(2)+3*e(3) |
e(1)+2*e(2)+3*e(3) |
||
fourbanger 0 1 2 3 |
fourbanger 0 1 2 3 |
||
Line 161: | Line 1,408: | ||
-e(1)-2*e(2)-3*e(4) |
-e(1)-2*e(2)-3*e(4) |
||
fourbanger _1 |
fourbanger _1 |
||
-e(1)</ |
-e(1)</syntaxhighlight> |
||
=={{header|Java}}== |
|||
{{trans|Kotlin}} |
|||
<syntaxhighlight lang="java">import java.util.Arrays; |
|||
public class LinearCombination { |
|||
private static String linearCombo(int[] c) { |
|||
StringBuilder sb = new StringBuilder(); |
|||
for (int i = 0; i < c.length; ++i) { |
|||
if (c[i] == 0) continue; |
|||
String op; |
|||
if (c[i] < 0 && sb.length() == 0) { |
|||
op = "-"; |
|||
} else if (c[i] < 0) { |
|||
op = " - "; |
|||
} else if (c[i] > 0 && sb.length() == 0) { |
|||
op = ""; |
|||
} else { |
|||
op = " + "; |
|||
} |
|||
int av = Math.abs(c[i]); |
|||
String coeff = av == 1 ? "" : "" + av + "*"; |
|||
sb.append(op).append(coeff).append("e(").append(i + 1).append(')'); |
|||
} |
|||
if (sb.length() == 0) { |
|||
return "0"; |
|||
} |
|||
return sb.toString(); |
|||
} |
|||
public static void main(String[] args) { |
|||
int[][] combos = new int[][]{ |
|||
new int[]{1, 2, 3}, |
|||
new int[]{0, 1, 2, 3}, |
|||
new int[]{1, 0, 3, 4}, |
|||
new int[]{1, 2, 0}, |
|||
new int[]{0, 0, 0}, |
|||
new int[]{0}, |
|||
new int[]{1, 1, 1}, |
|||
new int[]{-1, -1, -1}, |
|||
new int[]{-1, -2, 0, -3}, |
|||
new int[]{-1}, |
|||
}; |
|||
for (int[] c : combos) { |
|||
System.out.printf("%-15s -> %s\n", Arrays.toString(c), linearCombo(c)); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|jq}}== |
|||
<syntaxhighlight lang="jq">def linearCombo: |
|||
reduce to_entries[] as {key: $k,value: $v} (""; |
|||
if $v == 0 then . |
|||
else |
|||
(if $v < 0 and length==0 then "-" |
|||
elif $v < 0 then " - " |
|||
elif $v > 0 and length==0 then "" |
|||
else " + " |
|||
end) as $sign |
|||
| ($v|fabs) as $av |
|||
| (if ($av == 1) then "" else "\($av)*" end) as $coeff |
|||
| . + "\($sign)\($coeff)e\($k)" |
|||
end) |
|||
| if length==0 then "0" else . end ; |
|||
# The exercise |
|||
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .; |
|||
=={{header|Perl 6}}== |
|||
<lang perl6>sub linear-combination(@coeff) { |
|||
(@coeff Z=> map { "e($_)" }, 1 .. *) |
|||
.grep(+*.key) |
|||
.map({ .key ~ '*' ~ .value }) |
|||
.join(' + ') |
|||
.subst('+ -', '- ', :g) |
|||
.subst(/<|w>1\*/, '', :g) |
|||
|| '0' |
|||
} |
|||
say linear-combination($_) for |
|||
[1, 2, 3], |
[1, 2, 3], |
||
[0, 1, 2, 3], |
[0, 1, 2, 3], |
||
Line 184: | Line 1,497: | ||
[-1, -1, -1], |
[-1, -1, -1], |
||
[-1, -2, 0, -3], |
[-1, -2, 0, -3], |
||
[-1 |
[-1] |
||
| "\(lpad(15)) => \(linearCombo)" |
|||
;</lang> |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<syntaxhighlight lang="sh"> [1,2,3] => e0 + 2*e1 + 3*e2 |
|||
[0,1,2,3] => e1 + 2*e2 + 3*e3 |
|||
[1,0,3,4] => e0 + 3*e2 + 4*e3 |
|||
[1,2,0] => e0 + 2*e1 |
|||
[0,0,0] => 0 |
|||
[0] => 0 |
|||
[1,1,1] => e0 + e1 + e2 |
|||
[-1,-1,-1] => -e0 - e1 - e2 |
|||
[-1,-2,0,-3] => -e0 - 2*e1 - 3*e3 |
|||
[-1] => -e0</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
<syntaxhighlight lang="julia"># v0.6 |
|||
linearcombination(coef::Array) = join(collect("$c * e($i)" for (i, c) in enumerate(coef) if c != 0), " + ") |
|||
for c in [[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]] |
|||
@printf("%20s -> %s\n", c, linearcombination(c)) |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre> [1, 2, 3] -> 1 * e(1) + 2 * e(2) + 3 * e(3) |
|||
[0, 1, 2, 3] -> 1 * e(2) + 2 * e(3) + 3 * e(4) |
|||
[1, 0, 3, 4] -> 1 * e(1) + 3 * e(3) + 4 * e(4) |
|||
[1, 2, 0] -> 1 * e(1) + 2 * e(2) |
|||
[0, 0, 0] -> |
|||
[0] -> |
|||
[1, 1, 1] -> 1 * e(1) + 1 * e(2) + 1 * e(3) |
|||
[-1, -1, -1] -> -1 * e(1) + -1 * e(2) + -1 * e(3) |
|||
[-1, -2, 0, -3] -> -1 * e(1) + -2 * e(2) + -3 * e(4) |
|||
[-1] -> -1 * e(1)</pre> |
|||
=={{header|Kotlin}}== |
|||
<syntaxhighlight lang="scala">// version 1.1.2 |
|||
fun linearCombo(c: IntArray): String { |
|||
val sb = StringBuilder() |
|||
for ((i, n) in c.withIndex()) { |
|||
if (n == 0) continue |
|||
val op = when { |
|||
n < 0 && sb.isEmpty() -> "-" |
|||
n < 0 -> " - " |
|||
n > 0 && sb.isEmpty() -> "" |
|||
else -> " + " |
|||
} |
|||
val av = Math.abs(n) |
|||
val coeff = if (av == 1) "" else "$av*" |
|||
sb.append("$op${coeff}e(${i + 1})") |
|||
} |
|||
return if(sb.isEmpty()) "0" else sb.toString() |
|||
} |
|||
fun main(args: Array<String>) { |
|||
val combos = arrayOf( |
|||
intArrayOf(1, 2, 3), |
|||
intArrayOf(0, 1, 2, 3), |
|||
intArrayOf(1, 0, 3, 4), |
|||
intArrayOf(1, 2, 0), |
|||
intArrayOf(0, 0, 0), |
|||
intArrayOf(0), |
|||
intArrayOf(1, 1, 1), |
|||
intArrayOf(-1, -1, -1), |
|||
intArrayOf(-1, -2, 0, -3), |
|||
intArrayOf(-1) |
|||
) |
|||
for (c in combos) { |
|||
println("${c.contentToString().padEnd(15)} -> ${linearCombo(c)}") |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1) |
|||
</pre> |
|||
=={{header|Lambdatalk}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
{def linearcomb |
|||
{def linearcomb.r |
|||
{lambda {:a :n :i} |
|||
{if {= :i :n} |
|||
then |
|||
else {let { {:e e({+ :i 1})} |
|||
{:v {abs {A.get :i :a}}} |
|||
{:s {if {< {A.get :i :a} 0} then - else +}} |
|||
} {if {= :v 0} then else |
|||
{if {= :v 1} then :s :e else :s :v*:e}}} |
|||
{linearcomb.r :a :n {+ :i 1}} }}} |
|||
{lambda {:a} |
|||
{S.replace _LAMB_[^\s]+ by 0 in |
|||
{let { {:r {linearcomb.r {A.new :a} {S.length :a} 0}} |
|||
} {if {W.equal? {S.first :r} +} then {S.rest :r} else :r} }}}} |
|||
-> linearcomb |
|||
{linearcomb 1 2 3} -> e(1) + 2*e(2) + 3*e(3) |
|||
{linearcomb -1 -2 0 -3} -> - e(1) - 2*e(2) - 3*e(4) |
|||
{linearcomb 0 1 2 3} -> e(2) + 2*e(3) + 3*e(4) |
|||
{linearcomb 1 0 3 4} -> e(1) + 3*e(3) + 4*e(4) |
|||
{linearcomb 1 2 0} -> e(1) + 2*e(2) |
|||
{linearcomb 0 0 0} -> 0 |
|||
{linearcomb 0} -> 0 |
|||
{linearcomb 1 1 1} -> e(1) + e(2) + e(3) |
|||
{linearcomb -1 -1 -1} -> - e(1) - e(2) - e(3) |
|||
{linearcomb -1} -> - e(1) |
|||
</syntaxhighlight> |
|||
=={{header|Lua}}== |
|||
{{trans|C#}} |
|||
<syntaxhighlight lang="lua">function t2s(t) |
|||
local s = "[" |
|||
for i,v in pairs(t) do |
|||
if i > 1 then |
|||
s = s .. ", " .. v |
|||
else |
|||
s = s .. v |
|||
end |
|||
end |
|||
return s .. "]" |
|||
end |
|||
function linearCombo(c) |
|||
local sb = "" |
|||
for i,n in pairs(c) do |
|||
local skip = false |
|||
if n < 0 then |
|||
if sb:len() == 0 then |
|||
sb = sb .. "-" |
|||
else |
|||
sb = sb .. " - " |
|||
end |
|||
elseif n > 0 then |
|||
if sb:len() ~= 0 then |
|||
sb = sb .. " + " |
|||
end |
|||
else |
|||
skip = true |
|||
end |
|||
if not skip then |
|||
local av = math.abs(n) |
|||
if av ~= 1 then |
|||
sb = sb .. av .. "*" |
|||
end |
|||
sb = sb .. "e(" .. i .. ")" |
|||
end |
|||
end |
|||
if sb:len() == 0 then |
|||
sb = "0" |
|||
end |
|||
return sb |
|||
end |
|||
function main() |
|||
local combos = { |
|||
{ 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 } |
|||
} |
|||
for i,c in pairs(combos) do |
|||
local arr = t2s(c) |
|||
print(string.format("%15s -> %s", arr, linearCombo(c))) |
|||
end |
|||
end |
|||
main()</syntaxhighlight> |
|||
{{out}} |
|||
<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">tests = {{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}}; |
|||
Column[TraditionalForm[Total[MapIndexed[#1 e[#2[[1]]] &, #]]] & /@ tests]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>e(1)+2e(2)+3e(3) |
|||
e(2)+2e(3)+3e(4) |
|||
e(1)+3e(3)+4e(4) |
|||
e(1)+2e(2) |
|||
0 |
|||
0 |
|||
e(1)+e(2)+e(3) |
|||
-e(1)-e(2)-e(3) |
|||
-e(1)-2e(2)-3e(4) |
|||
-e(1)</pre> |
|||
=={{header|Modula-2}}== |
|||
<syntaxhighlight lang="modula2">MODULE Linear; |
|||
FROM FormatString IMPORT FormatString; |
|||
FROM Terminal IMPORT WriteString,WriteLn,ReadChar; |
|||
PROCEDURE WriteInt(n : INTEGER); |
|||
VAR buf : ARRAY[0..15] OF CHAR; |
|||
BEGIN |
|||
FormatString("%i", buf, n); |
|||
WriteString(buf) |
|||
END WriteInt; |
|||
PROCEDURE WriteLinear(c : ARRAY OF INTEGER); |
|||
VAR |
|||
buf : ARRAY[0..15] OF CHAR; |
|||
i,j : CARDINAL; |
|||
b : BOOLEAN; |
|||
BEGIN |
|||
b := TRUE; |
|||
j := 0; |
|||
FOR i:=0 TO HIGH(c) DO |
|||
IF c[i]=0 THEN CONTINUE END; |
|||
IF c[i]<0 THEN |
|||
IF b THEN WriteString("-") |
|||
ELSE WriteString(" - ") END; |
|||
ELSIF c[i]>0 THEN |
|||
IF NOT b THEN WriteString(" + ") END; |
|||
END; |
|||
IF c[i] > 1 THEN |
|||
WriteInt(c[i]); |
|||
WriteString("*") |
|||
ELSIF c[i] < -1 THEN |
|||
WriteInt(-c[i]); |
|||
WriteString("*") |
|||
END; |
|||
FormatString("e(%i)", buf, i+1); |
|||
WriteString(buf); |
|||
b := FALSE; |
|||
INC(j) |
|||
END; |
|||
IF j=0 THEN WriteString("0") END; |
|||
WriteLn |
|||
END WriteLinear; |
|||
TYPE |
|||
Array1 = ARRAY[0..0] OF INTEGER; |
|||
Array3 = ARRAY[0..2] OF INTEGER; |
|||
Array4 = ARRAY[0..3] OF INTEGER; |
|||
BEGIN |
|||
WriteLinear(Array3{1,2,3}); |
|||
WriteLinear(Array4{0,1,2,3}); |
|||
WriteLinear(Array4{1,0,3,4}); |
|||
WriteLinear(Array3{1,2,0}); |
|||
WriteLinear(Array3{0,0,0}); |
|||
WriteLinear(Array1{0}); |
|||
WriteLinear(Array3{1,1,1}); |
|||
WriteLinear(Array3{-1,-1,-1}); |
|||
WriteLinear(Array4{-1,-2,0,-3}); |
|||
WriteLinear(Array1{-1}); |
|||
ReadChar |
|||
END Linear.</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
{{trans|Kotlin}} |
|||
<syntaxhighlight lang="nim">import strformat |
|||
proc linearCombo(c: openArray[int]): string = |
|||
for i, n in c: |
|||
if n == 0: continue |
|||
let op = if n < 0: |
|||
if result.len == 0: "-" else: " - " |
|||
else: |
|||
if n > 0 and result.len == 0: "" else: " + " |
|||
let av = abs(n) |
|||
let coeff = if av == 1: "" else: $av & '*' |
|||
result &= fmt"{op}{coeff}e({i + 1})" |
|||
if result.len == 0: |
|||
result = "0" |
|||
const Combos = [@[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]] |
|||
for c in Combos: |
|||
echo fmt"{($c)[1..^1]:15} → {linearCombo(c)}"</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[1, 2, 3] → e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] → e(1) + 2*e(2) |
|||
[0, 0, 0] → 0 |
|||
[0] → 0 |
|||
[1, 1, 1] → e(1) + e(2) + e(3) |
|||
[-1, -1, -1] → -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] → -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] → -e(1)</pre> |
|||
=={{header|OCaml}}== |
|||
<syntaxhighlight lang="ocaml">let fmt_linear_comb = |
|||
let rec head e = function |
|||
| 0 :: t -> head (succ e) t |
|||
| 1 :: t -> Printf.sprintf "e(%u)%s" e (tail (succ e) t) |
|||
| -1 :: t -> Printf.sprintf "-e(%u)%s" e (tail (succ e) t) |
|||
| a :: t -> Printf.sprintf "%d*e(%u)%s" a e (tail (succ e) t) |
|||
| _ -> "0" |
|||
and tail e = function |
|||
| 0 :: t -> tail (succ e) t |
|||
| 1 :: t -> Printf.sprintf " + e(%u)%s" e (tail (succ e) t) |
|||
| -1 :: t -> Printf.sprintf " - e(%u)%s" e (tail (succ e) t) |
|||
| a :: t when a < 0 -> Printf.sprintf " - %u*e(%u)%s" (-a) e (tail (succ e) t) |
|||
| a :: t -> Printf.sprintf " + %u*e(%u)%s" a e (tail (succ e) t) |
|||
| _ -> "" |
|||
in |
|||
head 1 |
|||
let () = |
|||
List.iter (fun v -> print_endline (fmt_linear_comb v)) [ |
|||
[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]]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
e(1) + 2*e(2) + 3*e(3) |
|||
e(2) + 2*e(3) + 3*e(4) |
|||
e(1) + 3*e(3) + 4*e(4) |
|||
e(1) + 2*e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2*e(2) - 3*e(4) |
|||
-e(1) |
|||
</pre> |
|||
=={{header|Perl}}== |
|||
<syntaxhighlight lang="perl">use strict; |
|||
use warnings; |
|||
use feature 'say'; |
|||
sub linear_combination { |
|||
my(@coef) = @$_; |
|||
my $e = ''; |
|||
for my $c (1..+@coef) { $e .= "$coef[$c-1]*e($c) + " if $coef[$c-1] } |
|||
$e =~ s/ \+ $//; |
|||
$e =~ s/1\*//g; |
|||
$e =~ s/\+ -/- /g; |
|||
$e or 0; |
|||
} |
|||
say linear_combination($_) for |
|||
[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 ]</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre>e(1) + 2*e(2) + 3*e(3) |
<pre>e(1) + 2*e(2) + 3*e(3) |
||
Line 197: | Line 1,899: | ||
-e(1) - 2*e(2) - 3*e(4) |
-e(1) - 2*e(2) - 3*e(4) |
||
-e(1)</pre> |
-e(1)</pre> |
||
=={{header|Phix}}== |
|||
{{trans|Tcl}} |
|||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
<span style="color: #008080;">function</span> <span style="color: #000000;">linear_combination</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">fe</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">e</span><span style="color: #0000FF;">]</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #000000;">fe</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #000000;">fe</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">"+"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">elsif</span> <span style="color: #000000;">fe</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">"-"</span> |
|||
<span style="color: #008080;">elsif</span> <span style="color: #000000;">fe</span><span style="color: #0000FF;">></span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"+%d*"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fe</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">else</span> |
|||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d*"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fe</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"e(%d)"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span> <span style="color: #008080;">then</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"0"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span> |
|||
<span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},</span> |
|||
<span style="color: #0000FF;">{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}}</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">ti</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> |
|||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%12s -> %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">linear_combination</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">)})</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
{1,2,3} -> e(1)+2*e(2)+3*e(3) |
|||
{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,2,0} -> e(1)+2*e(2) |
|||
{0,0,0} -> 0 |
|||
{0} -> 0 |
|||
{1,1,1} -> e(1)+e(2)+e(3) |
|||
{-1,-1,-1} -> -e(1)-e(2)-e(3) |
|||
{-1,-2,0,-3} -> -e(1)-2*e(2)-3*e(4) |
|||
{-1} -> -e(1) |
|||
</pre> |
|||
=={{header|PureBasic}}== |
|||
<syntaxhighlight lang="purebasic">; Process and output values. |
|||
Procedure WriteLinear(Array c.i(1)) |
|||
Define buf$, |
|||
i.i, j.i, b,i |
|||
b = #True |
|||
j = 0 |
|||
For i = 0 To ArraySize(c(), 1) |
|||
If c(i) = 0 : Continue : EndIf |
|||
If c(i) < 0 |
|||
If b : Print("-") : Else : Print(" - ") : EndIf |
|||
ElseIf c(i) > 0 |
|||
If Not b : Print(" + ") : EndIf |
|||
EndIf |
|||
If c(i) > 1 |
|||
Print(Str(c(i))+"*") |
|||
ElseIf c(i) < -1 |
|||
Print(Str(-c(i))+"*") |
|||
EndIf |
|||
Print("e("+Str(i+1)+")") |
|||
b = #False |
|||
j+1 |
|||
Next |
|||
If j = 0 : Print("0") : EndIf |
|||
PrintN("") |
|||
EndProcedure |
|||
Macro VectorHdl(Adr_Start, Adr_Stop) |
|||
; 1. Output of the input values |
|||
Define buf$ = "[", *adr_ptr |
|||
For *adr_ptr = Adr_Start To Adr_Stop - SizeOf(Integer) Step SizeOf(Integer) |
|||
buf$ + Str(PeekI(*adr_ptr)) |
|||
If *adr_ptr >= Adr_Stop - SizeOf(Integer) |
|||
buf$ + "] -> " |
|||
Else |
|||
buf$ + ", " |
|||
EndIf |
|||
Next |
|||
buf$ = RSet(buf$, 25) |
|||
Print(buf$) |
|||
; 2. Reserve memory, pass and process values. |
|||
Dim a.i((Adr_Stop - Adr_Start) / SizeOf(Integer) -1) |
|||
CopyMemory(Adr_Start, @a(0), Adr_Stop - Adr_Start) |
|||
WriteLinear(a()) |
|||
EndMacro |
|||
If OpenConsole("") |
|||
; Pass memory addresses of the data. |
|||
VectorHdl(?V1, ?_V1) |
|||
VectorHdl(?V2, ?_V2) |
|||
VectorHdl(?V3, ?_V3) |
|||
VectorHdl(?V4, ?_V4) |
|||
VectorHdl(?V5, ?_V5) |
|||
VectorHdl(?V6, ?_V6) |
|||
VectorHdl(?V7, ?_V7) |
|||
VectorHdl(?V8, ?_V8) |
|||
VectorHdl(?V9, ?_V9) |
|||
VectorHdl(?V10, ?_V10) |
|||
Input() |
|||
EndIf |
|||
End 0 |
|||
DataSection |
|||
V1: |
|||
Data.i 1,2,3 |
|||
_V1: |
|||
V2: |
|||
Data.i 0,1,2,3 |
|||
_V2: |
|||
V3: |
|||
Data.i 1,0,3,4 |
|||
_V3: |
|||
V4: |
|||
Data.i 1,2,0 |
|||
_V4: |
|||
V5: |
|||
Data.i 0,0,0 |
|||
_V5: |
|||
V6: |
|||
Data.i 0 |
|||
_V6: |
|||
V7: |
|||
Data.i 1,1,1 |
|||
_V7: |
|||
V8: |
|||
Data.i -1,-1,-1 |
|||
_V8: |
|||
V9: |
|||
Data.i -1,-2,0,-3 |
|||
_V9: |
|||
V10: |
|||
Data.i -1 |
|||
_V10: |
|||
EndDataSection</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1) |
|||
</pre> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python"> |
||
def linear(x): |
def linear(x): |
||
return ' + '.join(['{}e({})'.format('-' if v == -1 else '' if v == 1 else str(v) + '*', i + 1) |
return ' + '.join(['{}e({})'.format('-' if v == -1 else '' if v == 1 else str(v) + '*', i + 1) |
||
Line 206: | Line 2,083: | ||
list(map(lambda x: print(linear(x)), [[1, 2, 3], [0, 1, 2, 3], [1, 0, 3, 4], [1, 2, 0], |
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]])) |
[0, 0, 0], [0], [1, 1, 1], [-1, -1, -1], [-1, -2, 0, 3], [-1]])) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 222: | Line 2,099: | ||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
< |
<syntaxhighlight lang="racket">#lang racket/base |
||
(require racket/match racket/string) |
(require racket/match racket/string) |
||
Line 255: | Line 2,132: | ||
(-1 -2 0 -3) |
(-1 -2 0 -3) |
||
(-1))) |
(-1))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
Line 267: | Line 2,144: | ||
-e(1)-e(2)-e(3) |
-e(1)-e(2)-e(3) |
||
-e(1)-2*e(2)-3*e(4) |
-e(1)-2*e(2)-3*e(4) |
||
-e(1)</pre> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
<syntaxhighlight lang="raku" line>sub linear-combination(@coeff) { |
|||
(@coeff Z=> map { "e($_)" }, 1 .. *) |
|||
.grep(+*.key) |
|||
.map({ .key ~ '*' ~ .value }) |
|||
.join(' + ') |
|||
.subst('+ -', '- ', :g) |
|||
.subst(/<|w>1\*/, '', :g) |
|||
|| '0' |
|||
} |
|||
say linear-combination($_) for |
|||
[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 ] |
|||
;</syntaxhighlight> |
|||
{{out}} |
|||
<pre>e(1) + 2*e(2) + 3*e(3) |
|||
e(2) + 2*e(3) + 3*e(4) |
|||
e(1) + 3*e(3) + 4*e(4) |
|||
e(1) + 2*e(2) |
|||
0 |
|||
0 |
|||
e(1) + e(2) + e(3) |
|||
-e(1) - e(2) - e(3) |
|||
-e(1) - 2*e(2) - 3*e(4) |
|||
-e(1)</pre> |
-e(1)</pre> |
||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
< |
<syntaxhighlight lang="rexx">/*REXX program displays a finite liner combination in an infinite vector basis. */ |
||
@.=.; |
@.= .; @.1 = ' 1, 2, 3 ' /*define a specific test case for build*/ |
||
@.2 = ' 0, 1, 2, 3 ' /* " " " " " " " */ |
|||
@.3 = ' 1, 0, 3, 4 ' /* " " " " " " " */ |
|||
@.4 = ' 1, 2, 0 ' /* " " " " " " " */ |
|||
@.5 = ' 0, 0, 0 ' /* " " " " " " " */ |
|||
@.6 = 0 /* " " " " " " " */ |
|||
@.7 = ' 1, 1, 1 ' /* " " " " " " " */ |
|||
@.8 = ' -1, -1, -1 ' /* " " " " " " " */ |
|||
@.9 = ' -1, -2, 0, -3 ' /* " " " " " " " */ |
|||
@.10 = -1 /* " " " " " " " */ |
|||
do j=1 while @.j\==.; |
do j=1 while @.j\==.; n= 0 /*process each vector; zero element cnt*/ |
||
y=space( translate(@.j, ,',') ) |
y= space( translate(@.j, ,',') ) /*elide commas and superfluous blanks. */ |
||
$= /*nullify output (liner combination).*/ |
$= /*nullify output (liner combination).*/ |
||
do k=1 for words(y); #=word(y, k) |
do k=1 for words(y); #= word(y, k) /* ◄───── process each of the elements.*/ |
||
if #=0 then iterate; a=abs(# / 1) |
if #=0 then iterate; a= abs(# / 1) /*if the value is zero, then ignore it.*/ |
||
if #<0 then s= '- ' /*define the sign: minus (-). */ |
|||
else s= '+ ' /* " " " plus (+). */ |
|||
n= n + 1 /*bump the number of elements in vector*/ |
|||
if n==1 then s= strip(s) /*if the 1st element used, remove blank*/ |
|||
if a\==1 then s= s || a'*' /*if multiplier is unity, then ignore #*/ |
|||
end /*k*/ |
|||
$= $ s'e('k")" /*construct a liner combination element*/ |
|||
end /*k*/ |
|||
$=strip( strip($), 'L', "+") /*strip leading plus sign (1st element)*/ |
|||
$= strip( strip($), 'L', "+") /*strip leading plus sign (1st element)*/ |
|||
if $=='' then $= 0 /*handle special case of no elements. */ |
|||
say right( space(@.j), 20) ' ──► ' strip($) /*align the output for presentation. */ |
say right( space(@.j), 20) ' ──► ' strip($) /*align the output for presentation. */ |
||
end /*j*/ /*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
end /*j*/ |
|||
{{out|output|text= when using the default inputs:}} |
|||
/*stick a fork in it, we're all done. */</lang> |
|||
'''output''' when using the default inputs: |
|||
<pre> |
<pre> |
||
1, 2, 3 ──► e(1) + 2*e(2) + 3*e(3) |
1, 2, 3 ──► e(1) + 2*e(2) + 3*e(3) |
||
Line 310: | Line 2,223: | ||
-1 ──► -e(1) |
-1 ──► -e(1) |
||
</pre> |
</pre> |
||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
# Project : Display a linear combination |
|||
scalars = [[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]] |
|||
for n=1 to len(scalars) |
|||
str = "" |
|||
for m=1 to len(scalars[n]) |
|||
scalar = scalars[n] [m] |
|||
if scalar != "0" |
|||
if scalar = 1 |
|||
str = str + "+e" + m |
|||
elseif scalar = -1 |
|||
str = str + "" + "-e" + m |
|||
else |
|||
if scalar > 0 |
|||
str = str + char(43) + scalar + "*e" + m |
|||
else |
|||
str = str + "" + scalar + "*e" + m |
|||
ok |
|||
ok |
|||
ok |
|||
next |
|||
if str = "" |
|||
str = "0" |
|||
ok |
|||
if left(str, 1) = "+" |
|||
str = right(str, len(str)-1) |
|||
ok |
|||
see str + nl |
|||
next |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
e1+2*e2+3*e3 |
|||
e2+2*e3+3*e4 |
|||
e1+3*e3+4*e4 |
|||
e1+2*e2 |
|||
0 |
|||
0 |
|||
e1+e2+e3 |
|||
-e1-e2-e3 |
|||
-e1-2*e2-3*e4 |
|||
-e1 |
|||
</pre> |
|||
=={{header|RPL}}== |
|||
RPL can handle both stack-based program flows and algebraic expressions, which is quite useful for tasks such as this one. |
|||
{{works with|Halcyon Calc|4.2.7}} |
|||
===Straightforward approach=== |
|||
This version has the disadvantage of sometimes interchanging some terms when simplifying the expression by the COLCT function. |
|||
≪ → scalars |
|||
≪ '0' 1 scalars SIZE FOR j |
|||
scalars j GET |
|||
"e" j →STR + STR→ * + |
|||
NEXT |
|||
COLCT COLCT |
|||
≫ ≫ |
|||
'COMB→' STO |
|||
===Full-compliant version=== |
|||
The constant π is here simply used to facilitate the construction of the algebraic expression; it is then eliminated during the conversion into a string. |
|||
≪ → scalars |
|||
≪ "" 1 scalars SIZE FOR j |
|||
'π' scalars j GET "e" j →STR + STR→ * + →STR |
|||
OVER SIZE NOT OVER 3 3 SUB "+" AND 4 3 IFTE |
|||
OVER SIZE 1 - SUB + |
|||
NEXT |
|||
≫ |
|||
IF DUP "" == THEN DROP "0" END |
|||
≫ |
|||
'COMB→' STO |
|||
≪ { { 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 } } |
|||
{ } 1 3 PICK SIZE FOR j |
|||
OVER j GET COMB→ + |
|||
NEXT |
|||
SWAP DROP |
|||
≫ EVAL |
|||
{{out}} |
|||
<pre> |
|||
1: { "e1+2*e2+3*e3" "e2+2*e3+3*e4" "e1+3*e3+4*e4" "e1+2*e2" "0" "0" "e1+e2+e3" "-e1-e2-e3" "-e1-2*e2-3*e4" "-e1" } |
|||
</pre> |
|||
=={{header|Ruby}}== |
|||
{{trans|D}} |
|||
<syntaxhighlight lang="ruby">def linearCombo(c) |
|||
sb = "" |
|||
c.each_with_index { |n, i| |
|||
if n == 0 then |
|||
next |
|||
end |
|||
if n < 0 then |
|||
if sb.length == 0 then |
|||
op = "-" |
|||
else |
|||
op = " - " |
|||
end |
|||
elsif n > 0 then |
|||
if sb.length > 0 then |
|||
op = " + " |
|||
else |
|||
op = "" |
|||
end |
|||
else |
|||
op = "" |
|||
end |
|||
av = n.abs() |
|||
if av != 1 then |
|||
coeff = "%d*" % [av] |
|||
else |
|||
coeff = "" |
|||
end |
|||
sb = sb + "%s%se(%d)" % [op, coeff, i + 1] |
|||
} |
|||
if sb.length == 0 then |
|||
return "0" |
|||
end |
|||
return sb |
|||
end |
|||
def main |
|||
combos = [ |
|||
[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], |
|||
] |
|||
for c in combos do |
|||
print "%-15s -> %s\n" % [c, linearCombo(c)] |
|||
end |
|||
end |
|||
main()</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|Rust}}== |
|||
<syntaxhighlight lang="rust"> |
|||
use std::fmt::{Display, Formatter, Result}; |
|||
use std::process::exit; |
|||
struct Coefficient(usize, f64); |
|||
impl Display for Coefficient { |
|||
fn fmt(&self, f: &mut Formatter<'_>) -> Result { |
|||
let i = self.0; |
|||
let c = self.1; |
|||
if c == 0. { |
|||
return Ok(()); |
|||
} |
|||
write!( |
|||
f, |
|||
" {} {}e({})", |
|||
if c < 0. { |
|||
"-" |
|||
} else if f.alternate() { |
|||
" " |
|||
} else { |
|||
"+" |
|||
}, |
|||
if (c.abs() - 1.).abs() < f64::EPSILON { |
|||
"".to_string() |
|||
} else { |
|||
c.abs().to_string() + "*" |
|||
}, |
|||
i + 1 |
|||
) |
|||
} |
|||
} |
|||
fn usage() { |
|||
println!("Usage: display-linear-combination a1 [a2 a3 ...]"); |
|||
} |
|||
fn linear_combination(coefficients: &[f64]) -> String { |
|||
let mut string = String::new(); |
|||
let mut iter = coefficients.iter().enumerate(); |
|||
// find first nonzero argument |
|||
loop { |
|||
match iter.next() { |
|||
Some((_, &c)) if c == 0. => { |
|||
continue; |
|||
} |
|||
Some((i, &c)) => { |
|||
string.push_str(format!("{:#}", Coefficient(i, c)).as_str()); |
|||
break; |
|||
} |
|||
None => { |
|||
string.push('0'); |
|||
return string; |
|||
} |
|||
} |
|||
} |
|||
// print subsequent arguments |
|||
for (i, &c) in iter { |
|||
string.push_str(format!("{}", Coefficient(i, c)).as_str()); |
|||
} |
|||
string |
|||
} |
|||
fn main() { |
|||
let mut coefficients = Vec::new(); |
|||
let mut args = std::env::args(); |
|||
args.next(); // drop first argument |
|||
// parse arguments into floats |
|||
for arg in args { |
|||
let c = arg.parse::<f64>().unwrap_or_else(|e| { |
|||
eprintln!("Failed to parse argument \"{}\": {}", arg, e); |
|||
exit(-1); |
|||
}); |
|||
coefficients.push(c); |
|||
} |
|||
// no arguments, print usage and exit |
|||
if coefficients.is_empty() { |
|||
usage(); |
|||
return; |
|||
} |
|||
println!("{}", linear_combination(&coefficients)); |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 2 3 -> e(1) + 2*e(2) + 3*e(3) |
|||
</pre> |
|||
=={{header|Scala}}== |
|||
<syntaxhighlight lang="scala">object LinearCombination extends App { |
|||
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), |
|||
Seq(1, 1, 1), Seq(-1, -1, -1), Seq(-1, -2, 0, -3), Seq(-1)) |
|||
private def linearCombo(c: Seq[Int]): String = { |
|||
val sb = new StringBuilder |
|||
for {i <- c.indices |
|||
term = c(i) |
|||
if term != 0} { |
|||
val av = math.abs(term) |
|||
def op = if (term < 0 && sb.isEmpty) "-" |
|||
else if (term < 0) " - " |
|||
else if (term > 0 && sb.isEmpty) "" else " + " |
|||
sb.append(op).append(if (av == 1) "" else s"$av*").append("e(").append(i + 1).append(')') |
|||
} |
|||
if (sb.isEmpty) "0" else sb.toString |
|||
} |
|||
for (c <- combos) { |
|||
println(f"${c.mkString("[", ", ", "]")}%-15s -> ${linearCombo(c)}%s") |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
{{trans|Tcl}} |
|||
<syntaxhighlight lang="ruby">func linear_combination(coeffs) { |
|||
var res = "" |
|||
for e,f in (coeffs.kv) { |
|||
given(f) { |
|||
when (1) { |
|||
res += "+e(#{e+1})" |
|||
} |
|||
when (-1) { |
|||
res += "-e(#{e+1})" |
|||
} |
|||
case (.> 0) { |
|||
res += "+#{f}*e(#{e+1})" |
|||
} |
|||
case (.< 0) { |
|||
res += "#{f}*e(#{e+1})" |
|||
} |
|||
} |
|||
} |
|||
res -= /^\+/ |
|||
res || 0 |
|||
} |
|||
var tests = [ |
|||
%n{1 2 3}, |
|||
%n{0 1 2 3}, |
|||
%n{1 0 3 4}, |
|||
%n{1 2 0}, |
|||
%n{0 0 0}, |
|||
%n{0}, |
|||
%n{1 1 1}, |
|||
%n{-1 -1 -1}, |
|||
%n{-1 -2 0 -3}, |
|||
%n{-1}, |
|||
] |
|||
tests.each { |t| |
|||
printf("%10s -> %-10s\n", t.join(' '), linear_combination(t)) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> 1 2 3 -> e(1)+2*e(2)+3*e(3) |
|||
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 2 0 -> e(1)+2*e(2) |
|||
0 0 0 -> 0 |
|||
0 -> 0 |
|||
1 1 1 -> e(1)+e(2)+e(3) |
|||
-1 -1 -1 -> -e(1)-e(2)-e(3) |
|||
-1 -2 0 -3 -> -e(1)-2*e(2)-3*e(4) |
|||
-1 -> -e(1) </pre> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
This solution strives for legibility rather than golf. |
This solution strives for legibility rather than golf. |
||
< |
<syntaxhighlight lang="tcl">proc lincom {factors} { |
||
set exp 0 |
set exp 0 |
||
set res "" |
set res "" |
||
Line 349: | Line 2,590: | ||
} { |
} { |
||
puts [format "%10s -> %-10s" $test [lincom $test]] |
puts [format "%10s -> %-10s" $test [lincom $test]] |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 362: | Line 2,603: | ||
-1 -2 0 -3 -> -e(1)-2*e(2)-3*e(4) |
-1 -2 0 -3 -> -e(1)-2*e(2)-3*e(4) |
||
-1 -> -e(1) </pre> |
-1 -> -e(1) </pre> |
||
=={{header|Visual Basic .NET}}== |
|||
{{trans|C#}} |
|||
<syntaxhighlight lang="vbnet">Imports System.Text |
|||
Module Module1 |
|||
Function LinearCombo(c As List(Of Integer)) As String |
|||
Dim sb As New StringBuilder |
|||
For i = 0 To c.Count - 1 |
|||
Dim n = c(i) |
|||
If n < 0 Then |
|||
If sb.Length = 0 Then |
|||
sb.Append("-") |
|||
Else |
|||
sb.Append(" - ") |
|||
End If |
|||
ElseIf n > 0 Then |
|||
If sb.Length <> 0 Then |
|||
sb.Append(" + ") |
|||
End If |
|||
Else |
|||
Continue For |
|||
End If |
|||
Dim av = Math.Abs(n) |
|||
If av <> 1 Then |
|||
sb.AppendFormat("{0}*", av) |
|||
End If |
|||
sb.AppendFormat("e({0})", i + 1) |
|||
Next |
|||
If sb.Length = 0 Then |
|||
sb.Append("0") |
|||
End If |
|||
Return sb.ToString() |
|||
End Function |
|||
Sub Main() |
|||
Dim combos = New List(Of List(Of Integer)) From { |
|||
New List(Of Integer) From {1, 2, 3}, |
|||
New List(Of Integer) From {0, 1, 2, 3}, |
|||
New List(Of Integer) From {1, 0, 3, 4}, |
|||
New List(Of Integer) From {1, 2, 0}, |
|||
New List(Of Integer) From {0, 0, 0}, |
|||
New List(Of Integer) From {0}, |
|||
New List(Of Integer) From {1, 1, 1}, |
|||
New List(Of Integer) From {-1, -1, -1}, |
|||
New List(Of Integer) From {-1, -2, 0, -3}, |
|||
New List(Of Integer) From {-1} |
|||
} |
|||
For Each c In combos |
|||
Dim arr = "[" + String.Join(", ", c) + "]" |
|||
Console.WriteLine("{0,15} -> {1}", arr, LinearCombo(c)) |
|||
Next |
|||
End Sub |
|||
End Module</syntaxhighlight> |
|||
{{out}} |
|||
<pre> [1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1)</pre> |
|||
=={{header|V (Vlang)}}== |
|||
{{trans|Go}} |
|||
<syntaxhighlight lang="v (vlang)">import strings |
|||
fn linear_combo(c []int) string { |
|||
mut sb := strings.new_builder(128) |
|||
for i, n in c { |
|||
if n == 0 { |
|||
continue |
|||
} |
|||
mut op := '' |
|||
match true { |
|||
n < 0 && sb.len == 0 { |
|||
op = "-" |
|||
} |
|||
n < 0{ |
|||
op = " - " |
|||
} |
|||
n > 0 && sb.len == 0 { |
|||
op = "" |
|||
} |
|||
else{ |
|||
op = " + " |
|||
} |
|||
} |
|||
mut av := n |
|||
if av < 0 { |
|||
av = -av |
|||
} |
|||
mut coeff := "$av*" |
|||
if av == 1 { |
|||
coeff = "" |
|||
} |
|||
sb.write_string("$op${coeff}e(${i+1})") |
|||
} |
|||
if sb.len == 0 { |
|||
return "0" |
|||
} else { |
|||
return sb.str() |
|||
} |
|||
} |
|||
fn main() { |
|||
combos := [ |
|||
[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], |
|||
] |
|||
for c in combos { |
|||
println("${c:-15} -> ${linear_combo(c)}") |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - 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}} |
|||
<syntaxhighlight lang="wren">import "./fmt" for Fmt |
|||
var linearCombo = Fn.new { |c| |
|||
var sb = "" |
|||
var i = 0 |
|||
for (n in c) { |
|||
if (n != 0) { |
|||
var op = (n < 0 && sb == "") ? "-" : |
|||
(n < 0) ? " - " : |
|||
(n > 0 && sb == "") ? "" : " + " |
|||
var av = n.abs |
|||
var coeff = (av == 1) ? "" : "%(av)*" |
|||
sb = sb + "%(op)%(coeff)e(%(i + 1))" |
|||
} |
|||
i = i + 1 |
|||
} |
|||
return (sb == "") ? "0" : sb |
|||
} |
|||
var combos = [ |
|||
[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] |
|||
] |
|||
for (c in combos) { |
|||
Fmt.print("$-15s -> $s", c.toString, linearCombo.call(c)) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) |
|||
[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, 2, 0] -> e(1) + 2*e(2) |
|||
[0, 0, 0] -> 0 |
|||
[0] -> 0 |
|||
[1, 1, 1] -> e(1) + e(2) + e(3) |
|||
[-1, -1, -1] -> -e(1) - e(2) - e(3) |
|||
[-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) |
|||
[-1] -> -e(1) |
|||
</pre> |
|||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
{{trans| |
{{trans|Raku}} |
||
< |
<syntaxhighlight lang="zkl">fcn linearCombination(coeffs){ |
||
[1..].zipWith(fcn(n,c){ if(c==0) "" else "%s*e(%s)".fmt(c,n) },coeffs) |
[1..].zipWith(fcn(n,c){ if(c==0) "" else "%s*e(%s)".fmt(c,n) },coeffs) |
||
.filter().concat("+").replace("+-","-").replace("1*","") |
.filter().concat("+").replace("+-","-").replace("1*","") |
||
or 0 |
or 0 |
||
}</ |
}</syntaxhighlight> |
||
< |
<syntaxhighlight lang="zkl">T(T(1,2,3),T(0,1,2,3),T(1,0,3,4),T(1,2,0),T(0,0,0),T(0),T(1,1,1),T(-1,-1,-1), |
||
T(-1,-2,0,-3),T(-1),T) |
T(-1,-2,0,-3),T(-1),T) |
||
.pump(Console.println,linearCombination);</ |
.pump(Console.println,linearCombination);</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
Latest revision as of 00:53, 7 May 2024
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Display a finite linear combination in an infinite vector basis .
Write a function that, when given a finite list of scalars ,
creates a string representing the linear combination in an explicit format often used in mathematics, that is:
where
The output must comply to the following rules:
- don't show null terms, unless the whole combination is null.
- e(1) is fine, e(1) + 0*e(3) or e(1) + 0 is wrong.
- don't show scalars when they are equal to one or minus one.
- e(3) is fine, 1*e(3) is wrong.
- don't prefix by a minus sign if it follows a preceding term. Instead you use subtraction.
- e(4) - e(5) is fine, e(4) + -e(5) is wrong.
Show here output for the following lists of scalars:
1) 1, 2, 3 2) 0, 1, 2, 3 3) 1, 0, 3, 4 4) 1, 2, 0 5) 0, 0, 0 6) 0 7) 1, 1, 1 8) -1, -1, -1 9) -1, -2, 0, -3 10) -1
11l
F linear(x)
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]]
print(linear(x))
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) + 3*e(4) -e(1)
Ada
with Ada.Text_Io;
with Ada.Strings.Unbounded;
with Ada.Strings.Fixed;
procedure Display_Linear is
subtype Position is Positive;
type Coefficient is new Integer;
type Combination is array (Position range <>) of Coefficient;
function Linear_Combination (Comb : Combination) return String is
use Ada.Strings.Unbounded;
use Ada.Strings;
Accu : Unbounded_String;
begin
for Pos in Comb'Range loop
case Comb (Pos) is
when Coefficient'First .. -1 =>
Append (Accu, (if Accu = "" then "-" else " - "));
when 0 => null;
when 1 .. Coefficient'Last =>
Append (Accu, (if Accu /= "" then " + " else ""));
end case;
if Comb (Pos) /= 0 then
declare
Abs_Coeff : constant Coefficient := abs Comb (Pos);
Coeff_Image : constant String := Fixed.Trim (Coefficient'Image (Abs_Coeff), Left);
Exp_Image : constant String := Fixed.Trim (Position'Image (Pos), Left);
begin
if Abs_Coeff /= 1 then
Append (Accu, Coeff_Image & "*");
end if;
Append (Accu, "e(" & Exp_Image & ")");
end;
end if;
end loop;
return (if Accu = "" then "0" else To_String (Accu));
end Linear_Combination;
use Ada.Text_Io;
begin
Put_Line (Linear_Combination ((1, 2, 3)));
Put_Line (Linear_Combination ((0, 1, 2, 3)));
Put_Line (Linear_Combination ((1, 0, 3, 4)));
Put_Line (Linear_Combination ((1, 2, 0)));
Put_Line (Linear_Combination ((0, 0, 0)));
Put_Line (Linear_Combination ((1 => 0)));
Put_Line (Linear_Combination ((1, 1, 1)));
Put_Line (Linear_Combination ((-1, -1, -1)));
Put_Line (Linear_Combination ((-1, -2, 0, -3)));
Put_Line (Linear_Combination ((1 => -1)));
end Display_Linear;
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) - 3*e(4) -e(1)
ALGOL 68
Using implicit multiplication operators, as in the C and Mathematica samples.
BEGIN # display a string representation of some linear combinations #
# returns a string representing the sum of the terms of a linear combination #
# whose coefficients are the elements of coeffs #
PROC linear combination = ( []INT coeffs )STRING:
BEGIN
[]INT cf = coeffs[ AT 1 ]; # ensure the lower bound is 1 #
STRING result := "";
BOOL first term := TRUE;
FOR i FROM LWB cf TO UPB cf DO
IF INT c = cf[ i ];
c /= 0
THEN # non-null element #
IF first term THEN
# first term - only add the operator if it is "-" #
IF c < 0 THEN result +:= "-" FI;
first term := FALSE
ELSE
# second or subsequent term - separate from the previous #
# and always add the operator #
result +:= " " + IF c < 0 THEN "-" ELSE "+" FI + " "
FI;
# add the coefficient, unless it is one #
IF ABS c /= 1 THEN
result +:= whole( ABS c, 0 )
FI;
# add the vector #
result +:= "e(" + whole( i, 0 ) + ")"
FI
OD;
IF result = "" THEN "0" ELSE result FI
END # linear combination # ;
# test cases #
[][]INT tests = ( ( 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 )
);
FOR i FROM LWB tests TO UPB tests DO
print( ( linear combination( tests[ i ] ), newline ) )
OD
END
- Output:
e(1) + 2e(2) + 3e(3) e(2) + 2e(3) + 3e(4) e(1) + 3e(3) + 4e(4) e(1) + 2e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2e(2) - 3e(4) -e(1)
APL
lincomb←{
fmtco←{
mul←(⍵≠1)/(⍕|⍵),'*'
mul,'e(',(⍕⍺),')'
}
co←⊃¨fmtco/¨(⍵≠0)/(⍳⍴,⍵),¨|⍵
sgn←'-+'[1+(×⍵)/×⍵]
lc←(('+'=⊃)↓⊢)∊sgn,¨co
0=⍴lc:'0' ⋄ lc
}
- Output:
↑lincomb¨(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) e(1)+2*e(2)+3*e(3) e(2)+2*e(3)+3*e(4) e(1)+3*e(3)+4*e(4) e(1)+2*e(2) 0 0 e(1)+e(2)+e(3) -e(1)+e(2)+e(3) -e(1)+2*e(2)-3*e(4) -e(1)
Arturo
linearCombination: function [coeffs][
combo: new []
loop.with:'i coeffs 'x [
case [x]
when? [=0] []
when? [=1] -> 'combo ++ ~"e(|i+1|)"
when? [= neg 1] -> 'combo ++ ~"-e(|i+1|)"
else -> 'combo ++ ~"|x|*e(|i+1|)"
]
join.with: " + " 'combo
replace 'combo {/\+ -/} "- "
(empty? combo)? -> "0" -> combo
]
loop @[
[1 2 3]
[0 1 2 3]
[1 0 3 4]
[1 2 0]
[0 0 0]
[0]
[1 1 1]
@[neg 1 neg 1 neg 1]
@[neg 1 neg 2 0 neg 3]
@[neg 1]
] => [print linearCombination &]
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) - 3*e(4) -e(1)
BASIC
Applesoft BASIC
The Spanish word "cadena" means "string" in English.
100 READ UX,UY
110 DIM SCALARS(UX,UY)
120 FOR N = 1 TO UX
130 FOR M = 1 TO UY
140 READ SCALARS(N,M)
150 NEXT M,N
160 DATA10,4
170 DATA1,2,3,0,0,1,2,3
180 DATA1,0,3,4,1,2,0,0
190 DATA0,0,0,0,0,0,0,0
200 DATA1,1,1,0,-1,-1,-1,0
210 DATA-1,-2,0,-3,-1,0,0,0
220 FOR N = 1 TO UX
230 CADENA$ = ""
240 FOR M = 1 TO UY
250 SCALAR = SCALARS(N,M)
260 IF SCALAR THEN CADENA$ = CADENA$ + CHR$ (44 - SGN (SCALAR)) + MID$ ( STR$ ( ABS (SCALAR)) + "*",1,255 * ( ABS (SCALAR) < > 1)) + "E" + STR$ (M)
270 NEXT M
280 IF CADENA$ = "" THEN CADENA$ = "0"
290 IF LEFT$ (CADENA$,1) = "+" THEN CADENA$ = RIGHT$ (CADENA$, LEN (CADENA$) - 1)
300 PRINT CADENA$
310 NEXT N
Chipmunk Basic
100 dim scalars(10,4)
110 scalars(1,1) = 1 : scalars(1,2) = 2 : scalars(1,3) = 3
120 scalars(2,1) = 0 : scalars(2,2) = 1 : scalars(2,3) = 2 : scalars(2,4) = 3
130 scalars(3,1) = 1 : scalars(3,2) = 0 : scalars(3,3) = 3 : scalars(3,4) = 4
140 scalars(4,1) = 1 : scalars(4,2) = 2 : scalars(4,3) = 0
150 scalars(5,1) = 0 : scalars(5,2) = 0 : scalars(5,3) = 0
160 scalars(6,1) = 0
170 scalars(7,1) = 1 : scalars(7,2) = 1 : scalars(7,3) = 1
180 scalars(8,1) = -1 : scalars(8,2) = -1 : scalars(8,3) = -1
190 scalars(9,1) = -1 : scalars(9,2) = -2 : scalars(9,3) = 0 : scalars(9,4) = -3
200 scalars(10,1) = -1
210 cls
220 for n = 1 to ubound(scalars)
230 cadena$ = ""
240 scalar = 0
250 for m = 1 to ubound(scalars,2)
260 scalar = scalars(n,m)
270 if scalar <> 0 then
280 if scalar = 1 then
290 cadena$ = cadena$+"+e"+str$(m)
300 else
310 if scalar = -1 then
320 cadena$ = cadena$+"-e"+str$(m)
330 else
340 if scalar > 0 then
350 cadena$ = cadena$+chr$(43)+str$(scalar)+"*e"+str$(m)
360 else
370 cadena$ = cadena$+str$(scalar)+"*e"+str$(m)
380 endif
390 endif
400 endif
410 endif
420 next m
430 if cadena$ = "" then cadena$ = "0"
440 if left$(cadena$,1) = "+" then cadena$ = right$(cadena$,len(cadena$)-1)
450 print cadena$
460 next n
470 end
FreeBASIC
Dim scalars(1 To 10, 1 To 4) As Integer => {{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}}
For n As Integer = 1 To Ubound(scalars)
Dim As String cadena = ""
Dim As Integer scalar
For m As Integer = 1 To Ubound(scalars,2)
scalar = scalars(n, m)
If scalar <> 0 Then
If scalar = 1 Then
cadena &= "+e" & m
Elseif scalar = -1 Then
cadena &= "-e" & m
Else
If scalar > 0 Then
cadena &= Chr(43) & scalar & "*e" & m
Else
cadena &= scalar & "*e" & m
End If
End If
End If
Next m
If cadena = "" Then cadena = "0"
If Left(cadena, 1) = "+" Then cadena = Right(cadena, Len(cadena)-1)
Print cadena
Next n
Sleep
- Output:
Same as Ring entry.
GW-BASIC
100 DIM SKLS(10, 4)
110 SKLS(1, 1) = 1: SKLS(1, 2) = 2: SKLS(1, 3) = 3
120 SKLS(2, 1) = 0: SKLS(2, 2) = 1: SKLS(2, 3) = 2: SKLS(2, 4) = 3
130 SKLS(3, 1) = 1: SKLS(3, 2) = 0: SKLS(3, 3) = 3: SKLS(3, 4) = 4
140 SKLS(4, 1) = 1: SKLS(4, 2) = 2: SKLS(4, 3) = 0
150 SKLS(5, 1) = 0: SKLS(5, 2) = 0: SKLS(5, 3) = 0
160 SKLS(6, 1) = 0
170 SKLS(7, 1) = 1: SKLS(7, 2) = 1: SKLS(7, 3) = 1
180 SKLS(8, 1) = -1: SKLS(8, 2) = -1: SKLS(8, 3) = -1
190 SKLS(9, 1) = -1: SKLS(9, 2) = -2: SKLS(9, 3) = 0: SKLS(9, 4) = -3
200 SKLS(10, 1) = -1
210 CLS
220 FOR N = 1 TO 10
230 CAD$ = ""
240 SCL = 0
250 FOR M = 1 TO 4
260 SCL = SKLS(N, M)
270 IF SCL <> 0 THEN IF SCL = 1 THEN CAD$ = CAD$ + "+e" + STR$(M) ELSE IF SCL = -1 THEN CAD$ = CAD$ + "-e" + STR$(M) ELSE IF SCL > 0 THEN CAD$ = CAD$ + CHR$(43) + STR$(SCL) + "*e" + STR$(M) ELSE CAD$ = CAD$ + STR$(SCL) + "*e" + STR$(M)
280 NEXT M
290 IF CAD$ = "" THEN CAD$ = "0"
300 IF LEFT$(CAD$, 1) = "+" THEN CAD$ = RIGHT$(CAD$, LEN(CAD$) - 1)
310 PRINT CAD$
320 NEXT N
330 END
MSX Basic
The GW-BASIC solution works without any changes.ht>
QBasic
DIM scalars(1 TO 10, 1 TO 4)
scalars(1, 1) = 1: scalars(1, 2) = 2: scalars(1, 3) = 3
scalars(2, 1) = 0: scalars(2, 2) = 1: scalars(2, 3) = 2: scalars(2, 4) = 3
scalars(3, 1) = 1: scalars(3, 2) = 0: scalars(3, 3) = 3: scalars(3, 4) = 4
scalars(4, 1) = 1: scalars(4, 2) = 2: scalars(4, 3) = 0
scalars(5, 1) = 0: scalars(5, 2) = 0: scalars(5, 3) = 0
scalars(6, 1) = 0
scalars(7, 1) = 1: scalars(7, 2) = 1: scalars(7, 3) = 1
scalars(8, 1) = -1: scalars(8, 2) = -1: scalars(8, 3) = -1
scalars(9, 1) = -1: scalars(9, 2) = -2: scalars(9, 3) = 0: scalars(9, 4) = -3
scalars(10, 1) = -1
CLS
FOR n = 1 TO UBOUND(scalars)
cadena$ = ""
scalar = 0
FOR m = 1 TO UBOUND(scalars, 2)
scalar = scalars(n, m)
IF scalar <> 0 THEN
IF scalar = 1 THEN
cadena$ = cadena$ + "+e" + STR$(m)
ELSEIF scalar = -1 THEN
cadena$ = cadena$ + "-e" + STR$(m)
ELSE
IF scalar > 0 THEN
cadena$ = cadena$ + CHR$(43) + STR$(scalar) + "*e" + STR$(m)
ELSE
cadena$ = cadena$ + STR$(scalar) + "*e" + STR$(m)
END IF
END IF
END IF
NEXT m
IF cadena$ = "" THEN cadena$ = "0"
IF LEFT$(cadena$, 1) = "+" THEN cadena$ = RIGHT$(cadena$, LEN(cadena$) - 1)
PRINT cadena$
NEXT n
END
Yabasic
dim scalars(10,4)
scalars(1,1) = 1: scalars(1,2) = 2: scalars(1,3) = 3
scalars(2,1) = 0: scalars(2,2) = 1: scalars(2,3) = 2: scalars(2,4) = 3
scalars(3,1) = 1: scalars(3,2) = 0: scalars(3,3) = 3: scalars(3,4) = 4
scalars(4,1) = 1: scalars(4,2) = 2: scalars(4,3) = 0
scalars(5,1) = 0: scalars(5,2) = 0: scalars(5,3) = 0
scalars(6,1) = 0
scalars(7,1) = 1: scalars(7,2) = 1: scalars(7,3) = 1
scalars(8,1) = -1: scalars(8,2) = -1: scalars(8,3) = -1
scalars(9,1) = -1: scalars(9,2) = -2: scalars(9,3) = 0: scalars(9,4) = -3
scalars(10,1) = -1
for n = 1 to arraysize(scalars(),1)
cadena$ = ""
for m = 1 to arraysize(scalars(),2)
scalar = scalars(n, m)
if scalar <> 0 then
if scalar = 1 then
cadena$ = cadena$ + "+e" + str$(m)
else
if scalar = -1 then
cadena$ = cadena$ + "-e" + str$(m)
else
if scalar > 0 then
cadena$ = cadena$ + chr$(43) + str$(scalar) + "*e" + str$(m)
else
cadena$ = cadena$ + str$(scalar) + "*e" + str$(m)
fi
fi
fi
fi
next m
if cadena$ = "" cadena$ = "0"
if left$(cadena$, 1) = "+" cadena$ = right$(cadena$, len(cadena$)-1)
print cadena$
next n
end
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>
#include<stdio.h>
#include<math.h> /*Optional, but better if included as fabs, labs and abs functions are being used. */
int main(int argC, char* argV[])
{
int i,zeroCount= 0,firstNonZero = -1;
double* vector;
if(argC == 1){
printf("Usage : %s <Vector component coefficients seperated by single space>",argV[0]);
}
else{
printf("Vector for [");
for(i=1;i<argC;i++){
printf("%s,",argV[i]);
}
printf("\b] -> ");
vector = (double*)malloc((argC-1)*sizeof(double));
for(i=1;i<=argC;i++){
vector[i-1] = atof(argV[i]);
if(vector[i-1]==0.0)
zeroCount++;
if(vector[i-1]!=0.0 && firstNonZero==-1)
firstNonZero = i-1;
}
if(zeroCount == argC){
printf("0");
}
else{
for(i=0;i<argC;i++){
if(i==firstNonZero && vector[i]==1)
printf("e%d ",i+1);
else if(i==firstNonZero && vector[i]==-1)
printf("- e%d ",i+1);
else if(i==firstNonZero && vector[i]<0 && fabs(vector[i])-abs(vector[i])>0.0)
printf("- %lf e%d ",fabs(vector[i]),i+1);
else if(i==firstNonZero && vector[i]<0 && fabs(vector[i])-abs(vector[i])==0.0)
printf("- %ld e%d ",labs(vector[i]),i+1);
else if(i==firstNonZero && vector[i]>0 && fabs(vector[i])-abs(vector[i])>0.0)
printf("%lf e%d ",vector[i],i+1);
else if(i==firstNonZero && vector[i]>0 && fabs(vector[i])-abs(vector[i])==0.0)
printf("%ld e%d ",vector[i],i+1);
else if(fabs(vector[i])==1.0 && i!=0)
printf("%c e%d ",(vector[i]==-1)?'-':'+',i+1);
else if(i!=0 && vector[i]!=0 && fabs(vector[i])-abs(vector[i])>0.0)
printf("%c %lf e%d ",(vector[i]<0)?'-':'+',fabs(vector[i]),i+1);
else if(i!=0 && vector[i]!=0 && fabs(vector[i])-abs(vector[i])==0.0)
printf("%c %ld e%d ",(vector[i]<0)?'-':'+',labs(vector[i]),i+1);
}
}
}
free(vector);
return 0;
}
- Output:
C:\rossetaCode>vectorDisplay.exe 1 2 3 Vector for [1,2,3] -> e1 + 2 e2 + 3 e3 C:\rossetaCode>vectorDisplay.exe 0 0 0 Vector for [0,0,0] -> 0 C:\rossetaCode>vectorDisplay.exe 0 1 2 3 Vector for [0,1,2,3] -> e2 + 2 e3 + 3 e4 C:\rossetaCode>vectorDisplay.exe 1 0 3 4 Vector for [1,0,3,4] -> e1 + 3 e3 + 4 e4 C:\rossetaCode>vectorDisplay.exe 1 2 0 Vector for [1,2,0] -> e1 + 2 e2 C:\rossetaCode>vectorDisplay.exe 0 0 0 Vector for [0,0,0] -> 0 C:\rossetaCode>vectorDisplay.exe 0 Vector for [0] -> 0 C:\rossetaCode>vectorDisplay.exe 1 1 1 Vector for [1,1,1] -> e1 + e2 + e3 C:\rossetaCode>vectorDisplay.exe -1 -1 -1 Vector for [-1,-1,-1] -> - e1 - e2 - e3 C:\rossetaCode>vectorDisplay.exe -1 -2 0 -3 Vector for [-1,-2,0,-3] -> - e1 - 2 e2 - 3 e4 C:\rossetaCode>vectorDisplay.exe -1 Vector for [-1] -> - e1
C#
using System;
using System.Collections.Generic;
using System.Text;
namespace DisplayLinearCombination {
class Program {
static string LinearCombo(List<int> c) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < c.Count; i++) {
int n = c[i];
if (n < 0) {
if (sb.Length == 0) {
sb.Append('-');
} else {
sb.Append(" - ");
}
} else if (n > 0) {
if (sb.Length != 0) {
sb.Append(" + ");
}
} else {
continue;
}
int av = Math.Abs(n);
if (av != 1) {
sb.AppendFormat("{0}*", av);
}
sb.AppendFormat("e({0})", i + 1);
}
if (sb.Length == 0) {
sb.Append('0');
}
return sb.ToString();
}
static void Main(string[] args) {
List<List<int>> combos = new List<List<int>>{
new List<int> { 1, 2, 3},
new List<int> { 0, 1, 2, 3},
new List<int> { 1, 0, 3, 4},
new List<int> { 1, 2, 0},
new List<int> { 0, 0, 0},
new List<int> { 0},
new List<int> { 1, 1, 1},
new List<int> { -1, -1, -1},
new List<int> { -1, -2, 0, -3},
new List<int> { -1},
};
foreach (List<int> c in combos) {
var arr = "[" + string.Join(", ", c) + "]";
Console.WriteLine("{0,15} -> {1}", arr, LinearCombo(c));
}
}
}
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
C++
#include <iomanip>
#include <iostream>
#include <sstream>
#include <vector>
template<typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
auto it = v.cbegin();
auto end = v.cend();
os << '[';
if (it != end) {
os << *it;
it = std::next(it);
}
while (it != end) {
os << ", " << *it;
it = std::next(it);
}
return os << ']';
}
std::ostream& operator<<(std::ostream& os, const std::string& s) {
return os << s.c_str();
}
std::string linearCombo(const std::vector<int>& c) {
std::stringstream ss;
for (size_t i = 0; i < c.size(); i++) {
int n = c[i];
if (n < 0) {
if (ss.tellp() == 0) {
ss << '-';
} else {
ss << " - ";
}
} else if (n > 0) {
if (ss.tellp() != 0) {
ss << " + ";
}
} else {
continue;
}
int av = abs(n);
if (av != 1) {
ss << av << '*';
}
ss << "e(" << i + 1 << ')';
}
if (ss.tellp() == 0) {
return "0";
}
return ss.str();
}
int main() {
using namespace std;
vector<vector<int>> combos{
{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},
};
for (auto& c : combos) {
stringstream ss;
ss << c;
cout << setw(15) << ss.str() << " -> ";
cout << linearCombo(c) << '\n';
}
return 0;
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Cowgol
include "cowgol.coh";
sub abs(n: int32): (r: uint32) is
if n < 0
then r := (-n) as uint32;
else r := n as uint32;
end if;
end sub;
sub lincomb(scalar: [int32], size: intptr) is
var first: uint8 := 1;
var item: uint8 := 1;
sub print_sign() is
if first == 1 then
if [scalar] < 0 then print("-"); end if;
else
if [scalar] < 0
then print(" - ");
else print(" + ");
end if;
end if;
end sub;
sub print_term() is
if [scalar] == 0 then return; end if;
print_sign();
if abs([scalar]) > 1 then
print_i32(abs([scalar]));
print("*");
end if;
print("e(");
print_i8(item);
print(")");
first := 0;
end sub;
while size > 0 loop
print_term();
scalar := @next scalar;
size := size - 1;
item := item + 1;
end loop;
if first == 1 then
print("0");
end if;
print_nl();
end sub;
var a1: int32[] := {1, 2, 3}; lincomb(&a1[0], @sizeof a1);
var a2: int32[] := {0, 1, 2, 3}; lincomb(&a2[0], @sizeof a2);
var a3: int32[] := {1, 0, 3, 4}; lincomb(&a3[0], @sizeof a3);
var a4: int32[] := {1, 2, 0}; lincomb(&a4[0], @sizeof a4);
var a5: int32[] := {0, 0, 0}; lincomb(&a5[0], @sizeof a5);
var a6: int32[] := {0}; lincomb(&a6[0], @sizeof a6);
var a7: int32[] := {1, 1, 1}; lincomb(&a7[0], @sizeof a7);
var a8: int32[] := {-1, -1, -1}; lincomb(&a8[0], @sizeof a8);
var a9: int32[] := {-1, -2, 0, 3}; lincomb(&a9[0], @sizeof a9);
var a10: int32[] := {-1}; lincomb(&a10[0], @sizeof a10);
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) + 3*e(4) -e(1)
D
import std.array;
import std.conv;
import std.format;
import std.math;
import std.stdio;
string linearCombo(int[] c) {
auto sb = appender!string;
foreach (i, n; c) {
if (n==0) continue;
string op;
if (n < 0) {
if (sb.data.empty) {
op = "-";
} else {
op = " - ";
}
} else if (n > 0) {
if (!sb.data.empty) {
op = " + ";
}
}
auto av = abs(n);
string coeff;
if (av != 1) {
coeff = to!string(av) ~ "*";
}
sb.formattedWrite("%s%se(%d)", op, coeff, i+1);
}
if (sb.data.empty) {
return "0";
}
return sb.data;
}
void main() {
auto combos = [
[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],
];
foreach (c; combos) {
auto arr = c.format!"%s";
writefln("%-15s -> %s", arr, linearCombo(c));
}
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Draco
proc abs(int n) int: if n<0 then -n else n fi corp
proc write_term(word index; int scalar; bool first) void:
if first then
if scalar<0 then write("-") fi
else
write(if scalar<0 then " - " else " + " fi)
fi;
if abs(scalar)>1 then
write(abs(scalar), '*')
fi;
write("e(",index,")")
corp
proc lincomb([*]int terms) void:
bool first;
word index;
first := true;
for index from 0 upto dim(terms,1)-1 do
if terms[index] /= 0 then
write_term(index+1, terms[index], first);
first := false
fi
od;
writeln(if first then "0" else "" fi)
corp
proc main() void:
[3]int a1 = (1,2,3);
[4]int a2 = (0,1,2,3);
[4]int a3 = (1,0,3,4);
[3]int a4 = (1,2,0);
[3]int a5 = (0,0,0);
[1]int a6 = (0);
[3]int a7 = (1,1,1);
[3]int a8 = (-1,-1,-1);
[4]int a9 = (-1,-2,0,3);
[1]int a10 = (-1);
lincomb(a1); lincomb(a2); lincomb(a3); lincomb(a4);
lincomb(a5); lincomb(a6); lincomb(a7); lincomb(a8);
lincomb(a9); lincomb(a10)
corp
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) + 3*e(4) -e(1)
EasyLang
scalars[][] = [ [ 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 ] ]
for n = 1 to len scalars[][]
str$ = ""
for m = 1 to len scalars[n][]
scalar = scalars[n][m]
if scalar <> 0
if scalar = 1
str$ &= "+e" & m
elif scalar = -1
str$ &= "-e" & m
else
if scalar > 0
str$ &= strchar 43 & scalar & "*e" & m
else
str$ = scalar & "*e" & m
.
.
.
.
if str$ = ""
str$ = 0
.
if substr str$ 1 1 = "+"
str$ = substr str$ 2 (len str$ - 1)
.
print str$
.
- Output:
e1+2*e2+3*e3 e2+2*e3+3*e4 e1+3*e3+4*e4 e1+2*e2 0 0 e1+e2+e3 -e1-e2-e3 -3*e4 -e1
EchoLisp
;; build an html string from list of coeffs
(define (linear->html coeffs)
(define plus #f)
(or*
(for/fold (html "") ((a coeffs) (i (in-naturals 1)))
(unless (zero? a)
(set! plus (if plus "+" "")))
(string-append html
(cond
((= a 1) (format "%a e<sub>%d</sub> " plus i))
((= a -1) (format "- e<sub>%d</sub> " i))
((> a 0) (format "%a %d*e<sub>%d</sub> " plus a i))
((< a 0) (format "- %d*e<sub>%d</sub> " (abs a) i))
(else ""))))
"0"))
(define linears '((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)))
(define (task linears)
(html-print ;; send string to stdout
(for/string ((linear linears))
(format "%a -> <span style='color:blue'>%a</span> <br>" linear (linear->html linear)))))
- Output:
(1 2 3) -> e1 + 2*e2 + 3*e3
(0 1 2 3) -> e2 + 2*e3 + 3*e4
(1 0 3 4) -> e1 + 3*e3 + 4*e4
(1 2 0) -> e1 + 2*e2
(0 0 0) -> 0
(0) -> 0
(1 1 1) -> e1 + e2 + e3
(-1 -1 -1) -> - e1 - e2 - e3
(-1 -2 0 -3) -> - e1 - 2*e2 - 3*e4
(-1) -> - e1
Elixir
defmodule Linear_combination do
def display(coeff) do
Enum.with_index(coeff)
|> Enum.map_join(fn {n,i} ->
{m,s} = if n<0, do: {-n,"-"}, else: {n,"+"}
case {m,i} do
{0,_} -> ""
{1,i} -> "#{s}e(#{i+1})"
{n,i} -> "#{s}#{n}*e(#{i+1})"
end
end)
|> String.trim_leading("+")
|> case do
"" -> IO.puts "0"
str -> IO.puts str
end
end
end
coeffs =
[ [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]
]
Enum.each(coeffs, &Linear_combination.display(&1))
- Output:
e(1)+2*e(2)+3*e(3) e(2)+2*e(3)+3*e(4) e(1)+3*e(3)+4*e(4) e(1)+2*e(2) 0 0 e(1)+e(2)+e(3) -e(1)-e(2)-e(3) -e(1)-2*e(2)-3*e(4) -e(1)
F#
The function
// Display a linear combination. Nigel Galloway: March 28th., 2018
let fN g =
let rec fG n g=match g with
|0::g -> fG (n+1) g
|1::g -> printf "+e(%d)" n; fG (n+1) g
|(-1)::g -> printf "-e(%d)" n; fG (n+1) g
|i::g -> printf "%+de(%d)" i n; fG (n+1) g
|_ -> printfn ""
let rec fN n g=match g with
|0::g -> fN (n+1) g
|1::g -> printf "e(%d)" n; fG (n+1) g
|(-1)::g -> printf "-e(%d)" n; fG (n+1) g
|i::g -> printf "%de(%d)" i n; fG (n+1) g
|_ -> printfn "0"
fN 1 g
The Task
fN [1;2;3]
- Output:
e(1)+2e(2)+3e(3)
fN [0;1;2;3]
- Output:
e(2)+2e(3)+3e(4)
fN[1;0;3;4]
- Output:
e(1)+3e(3)+4e(4)
fN[1;2;0]
- Output:
e(1)+2e(2)
fN[0;0;0]
- Output:
0
fN[0]
- Output:
0
fN[1;1;1]
- Output:
e(1)+e(2)+e(3)
fN[-1;-1;-1]
- Output:
-e(1)-e(2)-e(3)
fN[-1;-2;0;-3]
- Output:
-e(1)-2e(2)-3e(4)
fN[1]
- Output:
e(1)
Factor
USING: formatting kernel match math pair-rocket regexp sequences ;
MATCH-VARS: ?a ?b ;
: choose-term ( coeff i -- str )
1 + { } 2sequence {
{ 0 _ } => [ "" ]
{ 1 ?a } => [ ?a "e(%d)" sprintf ]
{ -1 ?a } => [ ?a "-e(%d)" sprintf ]
{ ?a ?b } => [ ?a ?b "%d*e(%d)" sprintf ]
} match-cond ;
: linear-combo ( seq -- str )
[ choose-term ] map-index harvest " + " join
R/ \+ -/ "- " re-replace [ "0" ] when-empty ;
{ { 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 } }
[ dup linear-combo "%-14u -> %s\n" printf ] each
- Output:
{ 1 2 3 } -> e(1) + 2*e(2) + 3*e(3) { 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 2 0 } -> e(1) + 2*e(2) { 0 0 0 } -> 0 { 0 } -> 0 { 1 1 1 } -> e(1) + e(2) + e(3) { -1 -1 -1 } -> -e(1) - e(2) - e(3) { -1 -2 0 -3 } -> -e(1) - 2*e(2) - 3*e(4) { -1 } -> -e(1)
Go
package main
import (
"fmt"
"strings"
)
func linearCombo(c []int) string {
var sb strings.Builder
for i, n := range c {
if n == 0 {
continue
}
var op string
switch {
case n < 0 && sb.Len() == 0:
op = "-"
case n < 0:
op = " - "
case n > 0 && sb.Len() == 0:
op = ""
default:
op = " + "
}
av := n
if av < 0 {
av = -av
}
coeff := fmt.Sprintf("%d*", av)
if av == 1 {
coeff = ""
}
sb.WriteString(fmt.Sprintf("%s%se(%d)", op, coeff, i+1))
}
if sb.Len() == 0 {
return "0"
} else {
return sb.String()
}
}
func main() {
combos := [][]int{
{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},
}
for _, c := range combos {
t := strings.Replace(fmt.Sprint(c), " ", ", ", -1)
fmt.Printf("%-15s -> %s\n", t, linearCombo(c))
}
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Groovy
class LinearCombination {
private static String linearCombo(int[] c) {
StringBuilder sb = new StringBuilder()
for (int i = 0; i < c.length; ++i) {
if (c[i] == 0) continue
String op
if (c[i] < 0 && sb.length() == 0) {
op = "-"
} else if (c[i] < 0) {
op = " - "
} else if (c[i] > 0 && sb.length() == 0) {
op = ""
} else {
op = " + "
}
int av = Math.abs(c[i])
String coeff = av == 1 ? "" : "" + av + "*"
sb.append(op).append(coeff).append("e(").append(i + 1).append(')')
}
if (sb.length() == 0) {
return "0"
}
return sb.toString()
}
static void main(String[] args) {
int[][] combos = [
[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]
]
for (int[] c : combos) {
printf("%-15s -> %s\n", Arrays.toString(c), linearCombo(c))
}
}
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Haskell
import Text.Printf (printf)
linearForm :: [Int] -> String
linearForm = strip . concat . zipWith term [1..]
where
term :: Int -> Int -> String
term i c = case c of
0 -> mempty
1 -> printf "+e(%d)" i
-1 -> printf "-e(%d)" i
c -> printf "%+d*e(%d)" c i
strip str = case str of
'+':s -> s
"" -> "0"
s -> s
Testing
coeffs :: [[Int]]
coeffs = [ [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] ]
λ> mapM_ (print . linearForm) coeffs "e(1)+2*e(2)+3*e(3)" "e(2)+2*e(3)+3*e(4)" "e(1)+3*e(3)+4*e(4)" "e(1)+2*e(2)" "0" "0" "e(1)+e(2)+e(3)" "-e(1)-e(2)-e(3)" "-e(1)-2*e(2)-3*e(4)" "-e(1)"
J
Implementation:
fourbanger=:3 :0
e=. ('e(',')',~])@":&.> 1+i.#y
firstpos=. 0< {.y-.0
if. */0=y do. '0' else. firstpos}.;y gluedto e end.
)
gluedto=:4 :0 each
pfx=. '+-' {~ x<0
select. |x
case. 0 do. ''
case. 1 do. pfx,y
case. do. pfx,(":|x),'*',y
end.
)
Example use:
fourbanger 1 2 3
e(1)+2*e(2)+3*e(3)
fourbanger 0 1 2 3
e(2)+2*e(3)+3*e(4)
fourbanger 1 0 3 4
e(1)+3*e(3)+4*e(4)
fourbanger 0 0 0
0
fourbanger 0
0
fourbanger 1 1 1
e(1)+e(2)+e(3)
fourbanger _1 _1 _1
-e(1)-e(2)-e(3)
fourbanger _1 _2 0 _3
-e(1)-2*e(2)-3*e(4)
fourbanger _1
-e(1)
Java
import java.util.Arrays;
public class LinearCombination {
private static String linearCombo(int[] c) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < c.length; ++i) {
if (c[i] == 0) continue;
String op;
if (c[i] < 0 && sb.length() == 0) {
op = "-";
} else if (c[i] < 0) {
op = " - ";
} else if (c[i] > 0 && sb.length() == 0) {
op = "";
} else {
op = " + ";
}
int av = Math.abs(c[i]);
String coeff = av == 1 ? "" : "" + av + "*";
sb.append(op).append(coeff).append("e(").append(i + 1).append(')');
}
if (sb.length() == 0) {
return "0";
}
return sb.toString();
}
public static void main(String[] args) {
int[][] combos = new int[][]{
new int[]{1, 2, 3},
new int[]{0, 1, 2, 3},
new int[]{1, 0, 3, 4},
new int[]{1, 2, 0},
new int[]{0, 0, 0},
new int[]{0},
new int[]{1, 1, 1},
new int[]{-1, -1, -1},
new int[]{-1, -2, 0, -3},
new int[]{-1},
};
for (int[] c : combos) {
System.out.printf("%-15s -> %s\n", Arrays.toString(c), linearCombo(c));
}
}
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
jq
def linearCombo:
reduce to_entries[] as {key: $k,value: $v} ("";
if $v == 0 then .
else
(if $v < 0 and length==0 then "-"
elif $v < 0 then " - "
elif $v > 0 and length==0 then ""
else " + "
end) as $sign
| ($v|fabs) as $av
| (if ($av == 1) then "" else "\($av)*" end) as $coeff
| . + "\($sign)\($coeff)e\($k)"
end)
| if length==0 then "0" else . end ;
# The exercise
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
[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]
| "\(lpad(15)) => \(linearCombo)"
- Output:
[1,2,3] => e0 + 2*e1 + 3*e2
[0,1,2,3] => e1 + 2*e2 + 3*e3
[1,0,3,4] => e0 + 3*e2 + 4*e3
[1,2,0] => e0 + 2*e1
[0,0,0] => 0
[0] => 0
[1,1,1] => e0 + e1 + e2
[-1,-1,-1] => -e0 - e1 - e2
[-1,-2,0,-3] => -e0 - 2*e1 - 3*e3
[-1] => -e0
Julia
# v0.6
linearcombination(coef::Array) = join(collect("$c * e($i)" for (i, c) in enumerate(coef) if c != 0), " + ")
for c in [[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]]
@printf("%20s -> %s\n", c, linearcombination(c))
end
- Output:
[1, 2, 3] -> 1 * e(1) + 2 * e(2) + 3 * e(3) [0, 1, 2, 3] -> 1 * e(2) + 2 * e(3) + 3 * e(4) [1, 0, 3, 4] -> 1 * e(1) + 3 * e(3) + 4 * e(4) [1, 2, 0] -> 1 * e(1) + 2 * e(2) [0, 0, 0] -> [0] -> [1, 1, 1] -> 1 * e(1) + 1 * e(2) + 1 * e(3) [-1, -1, -1] -> -1 * e(1) + -1 * e(2) + -1 * e(3) [-1, -2, 0, -3] -> -1 * e(1) + -2 * e(2) + -3 * e(4) [-1] -> -1 * e(1)
Kotlin
// version 1.1.2
fun linearCombo(c: IntArray): String {
val sb = StringBuilder()
for ((i, n) in c.withIndex()) {
if (n == 0) continue
val op = when {
n < 0 && sb.isEmpty() -> "-"
n < 0 -> " - "
n > 0 && sb.isEmpty() -> ""
else -> " + "
}
val av = Math.abs(n)
val coeff = if (av == 1) "" else "$av*"
sb.append("$op${coeff}e(${i + 1})")
}
return if(sb.isEmpty()) "0" else sb.toString()
}
fun main(args: Array<String>) {
val combos = arrayOf(
intArrayOf(1, 2, 3),
intArrayOf(0, 1, 2, 3),
intArrayOf(1, 0, 3, 4),
intArrayOf(1, 2, 0),
intArrayOf(0, 0, 0),
intArrayOf(0),
intArrayOf(1, 1, 1),
intArrayOf(-1, -1, -1),
intArrayOf(-1, -2, 0, -3),
intArrayOf(-1)
)
for (c in combos) {
println("${c.contentToString().padEnd(15)} -> ${linearCombo(c)}")
}
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Lambdatalk
{def linearcomb
{def linearcomb.r
{lambda {:a :n :i}
{if {= :i :n}
then
else {let { {:e e({+ :i 1})}
{:v {abs {A.get :i :a}}}
{:s {if {< {A.get :i :a} 0} then - else +}}
} {if {= :v 0} then else
{if {= :v 1} then :s :e else :s :v*:e}}}
{linearcomb.r :a :n {+ :i 1}} }}}
{lambda {:a}
{S.replace _LAMB_[^\s]+ by 0 in
{let { {:r {linearcomb.r {A.new :a} {S.length :a} 0}}
} {if {W.equal? {S.first :r} +} then {S.rest :r} else :r} }}}}
-> linearcomb
{linearcomb 1 2 3} -> e(1) + 2*e(2) + 3*e(3)
{linearcomb -1 -2 0 -3} -> - e(1) - 2*e(2) - 3*e(4)
{linearcomb 0 1 2 3} -> e(2) + 2*e(3) + 3*e(4)
{linearcomb 1 0 3 4} -> e(1) + 3*e(3) + 4*e(4)
{linearcomb 1 2 0} -> e(1) + 2*e(2)
{linearcomb 0 0 0} -> 0
{linearcomb 0} -> 0
{linearcomb 1 1 1} -> e(1) + e(2) + e(3)
{linearcomb -1 -1 -1} -> - e(1) - e(2) - e(3)
{linearcomb -1} -> - e(1)
Lua
function t2s(t)
local s = "["
for i,v in pairs(t) do
if i > 1 then
s = s .. ", " .. v
else
s = s .. v
end
end
return s .. "]"
end
function linearCombo(c)
local sb = ""
for i,n in pairs(c) do
local skip = false
if n < 0 then
if sb:len() == 0 then
sb = sb .. "-"
else
sb = sb .. " - "
end
elseif n > 0 then
if sb:len() ~= 0 then
sb = sb .. " + "
end
else
skip = true
end
if not skip then
local av = math.abs(n)
if av ~= 1 then
sb = sb .. av .. "*"
end
sb = sb .. "e(" .. i .. ")"
end
end
if sb:len() == 0 then
sb = "0"
end
return sb
end
function main()
local combos = {
{ 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 }
}
for i,c in pairs(combos) do
local arr = t2s(c)
print(string.format("%15s -> %s", arr, linearCombo(c)))
end
end
main()
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Mathematica / Wolfram Language
tests = {{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}};
Column[TraditionalForm[Total[MapIndexed[#1 e[#2[[1]]] &, #]]] & /@ tests]
- Output:
e(1)+2e(2)+3e(3) e(2)+2e(3)+3e(4) e(1)+3e(3)+4e(4) e(1)+2e(2) 0 0 e(1)+e(2)+e(3) -e(1)-e(2)-e(3) -e(1)-2e(2)-3e(4) -e(1)
Modula-2
MODULE Linear;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
PROCEDURE WriteInt(n : INTEGER);
VAR buf : ARRAY[0..15] OF CHAR;
BEGIN
FormatString("%i", buf, n);
WriteString(buf)
END WriteInt;
PROCEDURE WriteLinear(c : ARRAY OF INTEGER);
VAR
buf : ARRAY[0..15] OF CHAR;
i,j : CARDINAL;
b : BOOLEAN;
BEGIN
b := TRUE;
j := 0;
FOR i:=0 TO HIGH(c) DO
IF c[i]=0 THEN CONTINUE END;
IF c[i]<0 THEN
IF b THEN WriteString("-")
ELSE WriteString(" - ") END;
ELSIF c[i]>0 THEN
IF NOT b THEN WriteString(" + ") END;
END;
IF c[i] > 1 THEN
WriteInt(c[i]);
WriteString("*")
ELSIF c[i] < -1 THEN
WriteInt(-c[i]);
WriteString("*")
END;
FormatString("e(%i)", buf, i+1);
WriteString(buf);
b := FALSE;
INC(j)
END;
IF j=0 THEN WriteString("0") END;
WriteLn
END WriteLinear;
TYPE
Array1 = ARRAY[0..0] OF INTEGER;
Array3 = ARRAY[0..2] OF INTEGER;
Array4 = ARRAY[0..3] OF INTEGER;
BEGIN
WriteLinear(Array3{1,2,3});
WriteLinear(Array4{0,1,2,3});
WriteLinear(Array4{1,0,3,4});
WriteLinear(Array3{1,2,0});
WriteLinear(Array3{0,0,0});
WriteLinear(Array1{0});
WriteLinear(Array3{1,1,1});
WriteLinear(Array3{-1,-1,-1});
WriteLinear(Array4{-1,-2,0,-3});
WriteLinear(Array1{-1});
ReadChar
END Linear.
Nim
import strformat
proc linearCombo(c: openArray[int]): string =
for i, n in c:
if n == 0: continue
let op = if n < 0:
if result.len == 0: "-" else: " - "
else:
if n > 0 and result.len == 0: "" else: " + "
let av = abs(n)
let coeff = if av == 1: "" else: $av & '*'
result &= fmt"{op}{coeff}e({i + 1})"
if result.len == 0:
result = "0"
const Combos = [@[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]]
for c in Combos:
echo fmt"{($c)[1..^1]:15} → {linearCombo(c)}"
- Output:
[1, 2, 3] → e(1) + 2*e(2) + 3*e(3) [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, 2, 0] → e(1) + 2*e(2) [0, 0, 0] → 0 [0] → 0 [1, 1, 1] → e(1) + e(2) + e(3) [-1, -1, -1] → -e(1) - e(2) - e(3) [-1, -2, 0, -3] → -e(1) - 2*e(2) - 3*e(4) [-1] → -e(1)
OCaml
let fmt_linear_comb =
let rec head e = function
| 0 :: t -> head (succ e) t
| 1 :: t -> Printf.sprintf "e(%u)%s" e (tail (succ e) t)
| -1 :: t -> Printf.sprintf "-e(%u)%s" e (tail (succ e) t)
| a :: t -> Printf.sprintf "%d*e(%u)%s" a e (tail (succ e) t)
| _ -> "0"
and tail e = function
| 0 :: t -> tail (succ e) t
| 1 :: t -> Printf.sprintf " + e(%u)%s" e (tail (succ e) t)
| -1 :: t -> Printf.sprintf " - e(%u)%s" e (tail (succ e) t)
| a :: t when a < 0 -> Printf.sprintf " - %u*e(%u)%s" (-a) e (tail (succ e) t)
| a :: t -> Printf.sprintf " + %u*e(%u)%s" a e (tail (succ e) t)
| _ -> ""
in
head 1
let () =
List.iter (fun v -> print_endline (fmt_linear_comb v)) [
[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]]
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) - 3*e(4) -e(1)
Perl
use strict;
use warnings;
use feature 'say';
sub linear_combination {
my(@coef) = @$_;
my $e = '';
for my $c (1..+@coef) { $e .= "$coef[$c-1]*e($c) + " if $coef[$c-1] }
$e =~ s/ \+ $//;
$e =~ s/1\*//g;
$e =~ s/\+ -/- /g;
$e or 0;
}
say linear_combination($_) for
[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 ]
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) - 3*e(4) -e(1)
Phix
with javascript_semantics function linear_combination(sequence f) string res = "" for e=1 to length(f) do integer fe = f[e] if fe!=0 then if fe=1 then if length(res) then res &= "+" end if elsif fe=-1 then res &= "-" elsif fe>0 and length(res) then res &= sprintf("+%d*",fe) else res &= sprintf("%d*",fe) end if res &= sprintf("e(%d)",e) end if end for if res="" then res = "0" end if return res end function constant tests = {{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}} for i=1 to length(tests) do sequence ti = tests[i] printf(1,"%12s -> %s\n",{sprint(ti), linear_combination(ti)}) end for
- Output:
{1,2,3} -> e(1)+2*e(2)+3*e(3) {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,2,0} -> e(1)+2*e(2) {0,0,0} -> 0 {0} -> 0 {1,1,1} -> e(1)+e(2)+e(3) {-1,-1,-1} -> -e(1)-e(2)-e(3) {-1,-2,0,-3} -> -e(1)-2*e(2)-3*e(4) {-1} -> -e(1)
PureBasic
; Process and output values.
Procedure WriteLinear(Array c.i(1))
Define buf$,
i.i, j.i, b,i
b = #True
j = 0
For i = 0 To ArraySize(c(), 1)
If c(i) = 0 : Continue : EndIf
If c(i) < 0
If b : Print("-") : Else : Print(" - ") : EndIf
ElseIf c(i) > 0
If Not b : Print(" + ") : EndIf
EndIf
If c(i) > 1
Print(Str(c(i))+"*")
ElseIf c(i) < -1
Print(Str(-c(i))+"*")
EndIf
Print("e("+Str(i+1)+")")
b = #False
j+1
Next
If j = 0 : Print("0") : EndIf
PrintN("")
EndProcedure
Macro VectorHdl(Adr_Start, Adr_Stop)
; 1. Output of the input values
Define buf$ = "[", *adr_ptr
For *adr_ptr = Adr_Start To Adr_Stop - SizeOf(Integer) Step SizeOf(Integer)
buf$ + Str(PeekI(*adr_ptr))
If *adr_ptr >= Adr_Stop - SizeOf(Integer)
buf$ + "] -> "
Else
buf$ + ", "
EndIf
Next
buf$ = RSet(buf$, 25)
Print(buf$)
; 2. Reserve memory, pass and process values.
Dim a.i((Adr_Stop - Adr_Start) / SizeOf(Integer) -1)
CopyMemory(Adr_Start, @a(0), Adr_Stop - Adr_Start)
WriteLinear(a())
EndMacro
If OpenConsole("")
; Pass memory addresses of the data.
VectorHdl(?V1, ?_V1)
VectorHdl(?V2, ?_V2)
VectorHdl(?V3, ?_V3)
VectorHdl(?V4, ?_V4)
VectorHdl(?V5, ?_V5)
VectorHdl(?V6, ?_V6)
VectorHdl(?V7, ?_V7)
VectorHdl(?V8, ?_V8)
VectorHdl(?V9, ?_V9)
VectorHdl(?V10, ?_V10)
Input()
EndIf
End 0
DataSection
V1:
Data.i 1,2,3
_V1:
V2:
Data.i 0,1,2,3
_V2:
V3:
Data.i 1,0,3,4
_V3:
V4:
Data.i 1,2,0
_V4:
V5:
Data.i 0,0,0
_V5:
V6:
Data.i 0
_V6:
V7:
Data.i 1,1,1
_V7:
V8:
Data.i -1,-1,-1
_V8:
V9:
Data.i -1,-2,0,-3
_V9:
V10:
Data.i -1
_V10:
EndDataSection
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Python
def linear(x):
return ' + '.join(['{}e({})'.format('-' if v == -1 else '' if v == 1 else str(v) + '*', i + 1)
for i, v in enumerate(x) if v] or ['0']).replace(' + -', ' - ')
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]]))
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) + 3*e(4) -e(1)
Racket
#lang racket/base
(require racket/match racket/string)
(define (linear-combination->string es)
(let inr ((es es) (i 1) (rv ""))
(match* (es rv)
[((list) "") "0"]
[((list) rv) rv]
[((list (? zero?) t ...) rv)
(inr t (add1 i) rv)]
[((list n t ...) rv)
(define ±n
(match* (n rv)
;; zero is handled above
[(1 "") ""]
[(1 _) "+"]
[(-1 _) "-"]
[((? positive? n) (not "")) (format "+~a*" n)]
[(n _) (format "~a*" n)]))
(inr t (add1 i) (string-append rv ±n "e("(number->string i)")"))])))
(for-each
(compose displayln linear-combination->string)
'((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)))
- Output:
e(1)+2*e(2)+3*e(3) e(2)+2*e(3)+3*e(4) e(1)+3*e(3)+4*e(4) e(1)+2*e(2) 0 0 e(1)+e(2)+e(3) -e(1)-e(2)-e(3) -e(1)-2*e(2)-3*e(4) -e(1)
Raku
(formerly Perl 6)
sub linear-combination(@coeff) {
(@coeff Z=> map { "e($_)" }, 1 .. *)
.grep(+*.key)
.map({ .key ~ '*' ~ .value })
.join(' + ')
.subst('+ -', '- ', :g)
.subst(/<|w>1\*/, '', :g)
|| '0'
}
say linear-combination($_) for
[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 ]
;
- Output:
e(1) + 2*e(2) + 3*e(3) e(2) + 2*e(3) + 3*e(4) e(1) + 3*e(3) + 4*e(4) e(1) + 2*e(2) 0 0 e(1) + e(2) + e(3) -e(1) - e(2) - e(3) -e(1) - 2*e(2) - 3*e(4) -e(1)
REXX
/*REXX program displays a finite liner combination in an infinite vector basis. */
@.= .; @.1 = ' 1, 2, 3 ' /*define a specific test case for build*/
@.2 = ' 0, 1, 2, 3 ' /* " " " " " " " */
@.3 = ' 1, 0, 3, 4 ' /* " " " " " " " */
@.4 = ' 1, 2, 0 ' /* " " " " " " " */
@.5 = ' 0, 0, 0 ' /* " " " " " " " */
@.6 = 0 /* " " " " " " " */
@.7 = ' 1, 1, 1 ' /* " " " " " " " */
@.8 = ' -1, -1, -1 ' /* " " " " " " " */
@.9 = ' -1, -2, 0, -3 ' /* " " " " " " " */
@.10 = -1 /* " " " " " " " */
do j=1 while @.j\==.; n= 0 /*process each vector; zero element cnt*/
y= space( translate(@.j, ,',') ) /*elide commas and superfluous blanks. */
$= /*nullify output (liner combination).*/
do k=1 for words(y); #= word(y, k) /* ◄───── process each of the elements.*/
if #=0 then iterate; a= abs(# / 1) /*if the value is zero, then ignore it.*/
if #<0 then s= '- ' /*define the sign: minus (-). */
else s= '+ ' /* " " " plus (+). */
n= n + 1 /*bump the number of elements in vector*/
if n==1 then s= strip(s) /*if the 1st element used, remove blank*/
if a\==1 then s= s || a'*' /*if multiplier is unity, then ignore #*/
$= $ s'e('k")" /*construct a liner combination element*/
end /*k*/
$= strip( strip($), 'L', "+") /*strip leading plus sign (1st element)*/
if $=='' then $= 0 /*handle special case of no elements. */
say right( space(@.j), 20) ' ──► ' strip($) /*align the output for presentation. */
end /*j*/ /*stick a fork in it, we're all done. */
- output when using the default inputs:
1, 2, 3 ──► e(1) + 2*e(2) + 3*e(3) 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, 2, 0 ──► e(1) + 2*e(2) 0, 0, 0 ──► 0 0 ──► 0 1, 1, 1 ──► e(1) + e(2) + e(3) -1, -1, -1 ──► -e(1) - e(2) - e(3) -1, -2, 0, -3 ──► -e(1) - 2*e(2) - 3*e(4) -1 ──► -e(1)
Ring
# Project : Display a linear combination
scalars = [[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]]
for n=1 to len(scalars)
str = ""
for m=1 to len(scalars[n])
scalar = scalars[n] [m]
if scalar != "0"
if scalar = 1
str = str + "+e" + m
elseif scalar = -1
str = str + "" + "-e" + m
else
if scalar > 0
str = str + char(43) + scalar + "*e" + m
else
str = str + "" + scalar + "*e" + m
ok
ok
ok
next
if str = ""
str = "0"
ok
if left(str, 1) = "+"
str = right(str, len(str)-1)
ok
see str + nl
next
Output:
e1+2*e2+3*e3 e2+2*e3+3*e4 e1+3*e3+4*e4 e1+2*e2 0 0 e1+e2+e3 -e1-e2-e3 -e1-2*e2-3*e4 -e1
RPL
RPL can handle both stack-based program flows and algebraic expressions, which is quite useful for tasks such as this one.
Straightforward approach
This version has the disadvantage of sometimes interchanging some terms when simplifying the expression by the COLCT function.
≪ → scalars ≪ '0' 1 scalars SIZE FOR j scalars j GET "e" j →STR + STR→ * + NEXT COLCT COLCT ≫ ≫ 'COMB→' STO
Full-compliant version
The constant π is here simply used to facilitate the construction of the algebraic expression; it is then eliminated during the conversion into a string.
≪ → scalars ≪ "" 1 scalars SIZE FOR j 'π' scalars j GET "e" j →STR + STR→ * + →STR OVER SIZE NOT OVER 3 3 SUB "+" AND 4 3 IFTE OVER SIZE 1 - SUB + NEXT ≫ IF DUP "" == THEN DROP "0" END ≫ 'COMB→' STO
≪ { { 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 } } { } 1 3 PICK SIZE FOR j OVER j GET COMB→ + NEXT SWAP DROP ≫ EVAL
- Output:
1: { "e1+2*e2+3*e3" "e2+2*e3+3*e4" "e1+3*e3+4*e4" "e1+2*e2" "0" "0" "e1+e2+e3" "-e1-e2-e3" "-e1-2*e2-3*e4" "-e1" }
Ruby
def linearCombo(c)
sb = ""
c.each_with_index { |n, i|
if n == 0 then
next
end
if n < 0 then
if sb.length == 0 then
op = "-"
else
op = " - "
end
elsif n > 0 then
if sb.length > 0 then
op = " + "
else
op = ""
end
else
op = ""
end
av = n.abs()
if av != 1 then
coeff = "%d*" % [av]
else
coeff = ""
end
sb = sb + "%s%se(%d)" % [op, coeff, i + 1]
}
if sb.length == 0 then
return "0"
end
return sb
end
def main
combos = [
[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],
]
for c in combos do
print "%-15s -> %s\n" % [c, linearCombo(c)]
end
end
main()
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Rust
use std::fmt::{Display, Formatter, Result};
use std::process::exit;
struct Coefficient(usize, f64);
impl Display for Coefficient {
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
let i = self.0;
let c = self.1;
if c == 0. {
return Ok(());
}
write!(
f,
" {} {}e({})",
if c < 0. {
"-"
} else if f.alternate() {
" "
} else {
"+"
},
if (c.abs() - 1.).abs() < f64::EPSILON {
"".to_string()
} else {
c.abs().to_string() + "*"
},
i + 1
)
}
}
fn usage() {
println!("Usage: display-linear-combination a1 [a2 a3 ...]");
}
fn linear_combination(coefficients: &[f64]) -> String {
let mut string = String::new();
let mut iter = coefficients.iter().enumerate();
// find first nonzero argument
loop {
match iter.next() {
Some((_, &c)) if c == 0. => {
continue;
}
Some((i, &c)) => {
string.push_str(format!("{:#}", Coefficient(i, c)).as_str());
break;
}
None => {
string.push('0');
return string;
}
}
}
// print subsequent arguments
for (i, &c) in iter {
string.push_str(format!("{}", Coefficient(i, c)).as_str());
}
string
}
fn main() {
let mut coefficients = Vec::new();
let mut args = std::env::args();
args.next(); // drop first argument
// parse arguments into floats
for arg in args {
let c = arg.parse::<f64>().unwrap_or_else(|e| {
eprintln!("Failed to parse argument \"{}\": {}", arg, e);
exit(-1);
});
coefficients.push(c);
}
// no arguments, print usage and exit
if coefficients.is_empty() {
usage();
return;
}
println!("{}", linear_combination(&coefficients));
}
- Output:
1 2 3 -> e(1) + 2*e(2) + 3*e(3)
Scala
object LinearCombination extends App {
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),
Seq(1, 1, 1), Seq(-1, -1, -1), Seq(-1, -2, 0, -3), Seq(-1))
private def linearCombo(c: Seq[Int]): String = {
val sb = new StringBuilder
for {i <- c.indices
term = c(i)
if term != 0} {
val av = math.abs(term)
def op = if (term < 0 && sb.isEmpty) "-"
else if (term < 0) " - "
else if (term > 0 && sb.isEmpty) "" else " + "
sb.append(op).append(if (av == 1) "" else s"$av*").append("e(").append(i + 1).append(')')
}
if (sb.isEmpty) "0" else sb.toString
}
for (c <- combos) {
println(f"${c.mkString("[", ", ", "]")}%-15s -> ${linearCombo(c)}%s")
}
}
Sidef
func linear_combination(coeffs) {
var res = ""
for e,f in (coeffs.kv) {
given(f) {
when (1) {
res += "+e(#{e+1})"
}
when (-1) {
res += "-e(#{e+1})"
}
case (.> 0) {
res += "+#{f}*e(#{e+1})"
}
case (.< 0) {
res += "#{f}*e(#{e+1})"
}
}
}
res -= /^\+/
res || 0
}
var tests = [
%n{1 2 3},
%n{0 1 2 3},
%n{1 0 3 4},
%n{1 2 0},
%n{0 0 0},
%n{0},
%n{1 1 1},
%n{-1 -1 -1},
%n{-1 -2 0 -3},
%n{-1},
]
tests.each { |t|
printf("%10s -> %-10s\n", t.join(' '), linear_combination(t))
}
- Output:
1 2 3 -> e(1)+2*e(2)+3*e(3) 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 2 0 -> e(1)+2*e(2) 0 0 0 -> 0 0 -> 0 1 1 1 -> e(1)+e(2)+e(3) -1 -1 -1 -> -e(1)-e(2)-e(3) -1 -2 0 -3 -> -e(1)-2*e(2)-3*e(4) -1 -> -e(1)
Tcl
This solution strives for legibility rather than golf.
proc lincom {factors} {
set exp 0
set res ""
foreach f $factors {
incr exp
if {$f == 0} {
continue
} elseif {$f == 1} {
append res "+e($exp)"
} elseif {$f == -1} {
append res "-e($exp)"
} elseif {$f > 0} {
append res "+$f*e($exp)"
} else {
append res "$f*e($exp)"
}
}
if {$res eq ""} {set res 0}
regsub {^\+} $res {} res
return $res
}
foreach test {
{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}
} {
puts [format "%10s -> %-10s" $test [lincom $test]]
}
- Output:
1 2 3 -> e(1)+2*e(2)+3*e(3) 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 2 0 -> e(1)+2*e(2) 0 0 0 -> 0 0 -> 0 1 1 1 -> e(1)+e(2)+e(3) -1 -1 -1 -> -e(1)-e(2)-e(3) -1 -2 0 -3 -> -e(1)-2*e(2)-3*e(4) -1 -> -e(1)
Visual Basic .NET
Imports System.Text
Module Module1
Function LinearCombo(c As List(Of Integer)) As String
Dim sb As New StringBuilder
For i = 0 To c.Count - 1
Dim n = c(i)
If n < 0 Then
If sb.Length = 0 Then
sb.Append("-")
Else
sb.Append(" - ")
End If
ElseIf n > 0 Then
If sb.Length <> 0 Then
sb.Append(" + ")
End If
Else
Continue For
End If
Dim av = Math.Abs(n)
If av <> 1 Then
sb.AppendFormat("{0}*", av)
End If
sb.AppendFormat("e({0})", i + 1)
Next
If sb.Length = 0 Then
sb.Append("0")
End If
Return sb.ToString()
End Function
Sub Main()
Dim combos = New List(Of List(Of Integer)) From {
New List(Of Integer) From {1, 2, 3},
New List(Of Integer) From {0, 1, 2, 3},
New List(Of Integer) From {1, 0, 3, 4},
New List(Of Integer) From {1, 2, 0},
New List(Of Integer) From {0, 0, 0},
New List(Of Integer) From {0},
New List(Of Integer) From {1, 1, 1},
New List(Of Integer) From {-1, -1, -1},
New List(Of Integer) From {-1, -2, 0, -3},
New List(Of Integer) From {-1}
}
For Each c In combos
Dim arr = "[" + String.Join(", ", c) + "]"
Console.WriteLine("{0,15} -> {1}", arr, LinearCombo(c))
Next
End Sub
End Module
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
V (Vlang)
import strings
fn linear_combo(c []int) string {
mut sb := strings.new_builder(128)
for i, n in c {
if n == 0 {
continue
}
mut op := ''
match true {
n < 0 && sb.len == 0 {
op = "-"
}
n < 0{
op = " - "
}
n > 0 && sb.len == 0 {
op = ""
}
else{
op = " + "
}
}
mut av := n
if av < 0 {
av = -av
}
mut coeff := "$av*"
if av == 1 {
coeff = ""
}
sb.write_string("$op${coeff}e(${i+1})")
}
if sb.len == 0 {
return "0"
} else {
return sb.str()
}
}
fn main() {
combos := [
[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],
]
for c in combos {
println("${c:-15} -> ${linear_combo(c)}")
}
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
Wren
import "./fmt" for Fmt
var linearCombo = Fn.new { |c|
var sb = ""
var i = 0
for (n in c) {
if (n != 0) {
var op = (n < 0 && sb == "") ? "-" :
(n < 0) ? " - " :
(n > 0 && sb == "") ? "" : " + "
var av = n.abs
var coeff = (av == 1) ? "" : "%(av)*"
sb = sb + "%(op)%(coeff)e(%(i + 1))"
}
i = i + 1
}
return (sb == "") ? "0" : sb
}
var combos = [
[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]
]
for (c in combos) {
Fmt.print("$-15s -> $s", c.toString, linearCombo.call(c))
}
- Output:
[1, 2, 3] -> e(1) + 2*e(2) + 3*e(3) [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, 2, 0] -> e(1) + 2*e(2) [0, 0, 0] -> 0 [0] -> 0 [1, 1, 1] -> e(1) + e(2) + e(3) [-1, -1, -1] -> -e(1) - e(2) - e(3) [-1, -2, 0, -3] -> -e(1) - 2*e(2) - 3*e(4) [-1] -> -e(1)
zkl
fcn linearCombination(coeffs){
[1..].zipWith(fcn(n,c){ if(c==0) "" else "%s*e(%s)".fmt(c,n) },coeffs)
.filter().concat("+").replace("+-","-").replace("1*","")
or 0
}
T(T(1,2,3),T(0,1,2,3),T(1,0,3,4),T(1,2,0),T(0,0,0),T(0),T(1,1,1),T(-1,-1,-1),
T(-1,-2,0,-3),T(-1),T)
.pump(Console.println,linearCombination);
- Output:
e(1)+2*e(2)+3*e(3) e(2)+2*e(3)+3*e(4) e(1)+3*e(3)+4*e(4) e(1)+2*e(2) 0 0 e(1)+e(2)+e(3) -e(1)-e(2)-e(3) -e(1)-2*e(2)-3*e(4) -e(1) 0
- Programming Tasks
- Solutions by Programming Task
- 11l
- Ada
- ALGOL 68
- APL
- Arturo
- BASIC
- Applesoft BASIC
- Chipmunk Basic
- FreeBASIC
- GW-BASIC
- MSX Basic
- QBasic
- Yabasic
- C
- C sharp
- C++
- Cowgol
- D
- Draco
- EasyLang
- EchoLisp
- Elixir
- F Sharp
- Factor
- Go
- Groovy
- Haskell
- J
- Java
- Jq
- Julia
- Kotlin
- Lambdatalk
- Lua
- Mathematica
- Wolfram Language
- Modula-2
- Nim
- OCaml
- Perl
- Phix
- PureBasic
- Python
- Racket
- Raku
- REXX
- Ring
- RPL
- Ruby
- Rust
- Scala
- Sidef
- Tcl
- Visual Basic .NET
- V (Vlang)
- Wren
- Wren-fmt
- Zkl