aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Initial data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 72d218235f
commit f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Display-a-linear-combination/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Display_a_linear_combination

35
Task/Display-a-linear-combination/00-TASK.txt Normal file
View file

@ -0,0 +1,35 @@
;Task:
Display a finite [[wp:linear combination|linear combination]] in an infinite vector basis <big><math>(e_1, e_2,\ldots)</math></big>.
Write a function that, when given a finite list of scalars <big><math>(\alpha^1,\alpha^2,\ldots)</math></big>, <br>creates a string representing the linear combination <big><math>\sum_i\alpha^i e_i</math></big> in an explicit format often used in mathematics, that is:
:<big><math>\alpha^{i_1}e_{i_1}\pm|\alpha^{i_2}|e_{i_2}\pm|\alpha^{i_3}|e_{i_3}\pm\ldots</math></big>
where <big><math>\alpha^{i_k}\neq 0</math></big>
<br>
The output must comply to the following rules:
* &nbsp; don't show null terms, unless the whole combination is null.
::::::: '''e(1)''' &nbsp; &nbsp; is fine, &nbsp; &nbsp; '''e(1) + 0*e(3)''' &nbsp; &nbsp; or &nbsp; &nbsp; '''e(1) + 0''' &nbsp; &nbsp; is wrong.
* &nbsp; don't show scalars when they are equal to one or minus one.
::::::: '''e(3)''' &nbsp; &nbsp; is fine, &nbsp; &nbsp; '''1*e(3)''' &nbsp; &nbsp; is wrong.
* &nbsp; don't prefix by a minus sign if it follows a preceding term. &nbsp; Instead you use subtraction.
::::::: '''e(4) - e(5)''' &nbsp; &nbsp; is fine, &nbsp; &nbsp; '''e(4) + -e(5)''' &nbsp; &nbsp; is wrong.
<br>
Show here output for the following lists of scalars:
<pre>
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
</pre>
<br><br>

6
Task/Display-a-linear-combination/11l/display-a-linear-combination.11l Normal file
View file

@ -0,0 +1,6 @@
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))

48
Task/Display-a-linear-combination/ALGOL-68/display-a-linear-combination.alg Normal file
View file

@ -0,0 +1,48 @@
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

54
Task/Display-a-linear-combination/Ada/display-a-linear-combination.ada Normal file
View file

@ -0,0 +1,54 @@
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;

26
Task/Display-a-linear-combination/Arturo/display-a-linear-combination.arturo Normal file
View file

@ -0,0 +1,26 @@
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 &]

81
Task/Display-a-linear-combination/C++/display-a-linear-combination.cpp Normal file
View file

@ -0,0 +1,81 @@
#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;
}

57
Task/Display-a-linear-combination/C-sharp/display-a-linear-combination.cs Normal file
View file

@ -0,0 +1,57 @@
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));
}
}
}
}

65
Task/Display-a-linear-combination/C/display-a-linear-combination.c Normal file
View file

@ -0,0 +1,65 @@
#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;
}

53
Task/Display-a-linear-combination/D/display-a-linear-combination.d Normal file
View file

@ -0,0 +1,53 @@
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));
}
}

32
Task/Display-a-linear-combination/EchoLisp/display-a-linear-combination.l Normal file
View file

@ -0,0 +1,32 @@
;; 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)))))

32
Task/Display-a-linear-combination/Elixir/display-a-linear-combination.elixir Normal file
View file

@ -0,0 +1,32 @@
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))

15
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-1.fs Normal file
View file

@ -0,0 +1,15 @@
// 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

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-10.fs Normal file
View file

@ -0,0 +1 @@
fN[-1;-2;0;-3]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-11.fs Normal file
View file

@ -0,0 +1 @@
fN[1]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-2.fs Normal file
View file

@ -0,0 +1 @@
fN [1;2;3]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-3.fs Normal file
View file

@ -0,0 +1 @@
fN [0;1;2;3]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-4.fs Normal file
View file

@ -0,0 +1 @@
fN[1;0;3;4]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-5.fs Normal file
View file

@ -0,0 +1 @@
fN[1;2;0]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-6.fs Normal file
View file

@ -0,0 +1 @@
fN[0;0;0]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-7.fs Normal file
View file

@ -0,0 +1 @@
fN[0]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-8.fs Normal file
View file

@ -0,0 +1 @@
fN[1;1;1]

1
Task/Display-a-linear-combination/F-Sharp/display-a-linear-combination-9.fs Normal file
View file

@ -0,0 +1 @@
fN[-1;-1;-1]

19
Task/Display-a-linear-combination/Factor/display-a-linear-combination.factor Normal file
View file

@ -0,0 +1,19 @@
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

28
Task/Display-a-linear-combination/FreeBASIC/display-a-linear-combination.basic Normal file
View file

@ -0,0 +1,28 @@
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

59
Task/Display-a-linear-combination/Go/display-a-linear-combination.go Normal file
View file

@ -0,0 +1,59 @@
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))
}
}

44
Task/Display-a-linear-combination/Groovy/display-a-linear-combination.groovy Normal file
View file

@ -0,0 +1,44 @@
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))
}
}
}

16
Task/Display-a-linear-combination/Haskell/display-a-linear-combination-1.hs Normal file
View file

@ -0,0 +1,16 @@
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

11
Task/Display-a-linear-combination/Haskell/display-a-linear-combination-2.hs Normal file
View file

@ -0,0 +1,11 @@
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] ]

14
Task/Display-a-linear-combination/J/display-a-linear-combination-1.j Normal file
View file

@ -0,0 +1,14 @@
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.
)

18
Task/Display-a-linear-combination/J/display-a-linear-combination-2.j Normal file
View file

@ -0,0 +1,18 @@
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)

45
Task/Display-a-linear-combination/Java/display-a-linear-combination.java Normal file
View file

@ -0,0 +1,45 @@
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));
}
}
}

29
Task/Display-a-linear-combination/Jq/display-a-linear-combination-1.jq Normal file
View file

@ -0,0 +1,29 @@
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)"

10
Task/Display-a-linear-combination/Jq/display-a-linear-combination-2.jq Normal file
View file

@ -0,0 +1,10 @@
[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

8
Task/Display-a-linear-combination/Julia/display-a-linear-combination.julia Normal file
View file

@ -0,0 +1,8 @@
# 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

36
Task/Display-a-linear-combination/Kotlin/display-a-linear-combination.kotlin Normal file
View file

@ -0,0 +1,36 @@
// 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)}")
}
}

27
Task/Display-a-linear-combination/Lambdatalk/display-a-linear-combination.lambdatalk Normal file
View file

@ -0,0 +1,27 @@
{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)

66
Task/Display-a-linear-combination/Lua/display-a-linear-combination.lua Normal file
View file

@ -0,0 +1,66 @@
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()

2
Task/Display-a-linear-combination/Mathematica/display-a-linear-combination.math Normal file
View file

@ -0,0 +1,2 @@
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]

67
Task/Display-a-linear-combination/Modula-2/display-a-linear-combination.mod2 Normal file
View file

@ -0,0 +1,67 @@
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.

29
Task/Display-a-linear-combination/Nim/display-a-linear-combination.nim Normal file
View file

@ -0,0 +1,29 @@
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)}"

29
Task/Display-a-linear-combination/OCaml/display-a-linear-combination.ocaml Normal file
View file

@ -0,0 +1,29 @@
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]]

16
Task/Display-a-linear-combination/Perl/display-a-linear-combination.pl Normal file
View file

@ -0,0 +1,16 @@
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 ]

38
Task/Display-a-linear-combination/Phix/display-a-linear-combination.phix Normal file
View file

@ -0,0 +1,38 @@
(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 -&gt; %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>
<!--

106
Task/Display-a-linear-combination/PureBasic/display-a-linear-combination.basic Normal file
View file

@ -0,0 +1,106 @@
; 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

6
Task/Display-a-linear-combination/Python/display-a-linear-combination.py Normal file
View file

@ -0,0 +1,6 @@
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]]))

27
Task/Display-a-linear-combination/REXX/display-a-linear-combination.rexx Normal file
View file

@ -0,0 +1,27 @@
/*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. */

33
Task/Display-a-linear-combination/Racket/display-a-linear-combination.rkt Normal file
View file

@ -0,0 +1,33 @@
#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)))

22
Task/Display-a-linear-combination/Raku/display-a-linear-combination.raku Normal file
View file

@ -0,0 +1,22 @@
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 ]
;

29
Task/Display-a-linear-combination/Ring/display-a-linear-combination.ring Normal file
View file

@ -0,0 +1,29 @@
# 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

55
Task/Display-a-linear-combination/Ruby/display-a-linear-combination.rb Normal file
View file

@ -0,0 +1,55 @@
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()

91
Task/Display-a-linear-combination/Rust/display-a-linear-combination.rust Normal file
View file

@ -0,0 +1,91 @@
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));
}

23
Task/Display-a-linear-combination/Scala/display-a-linear-combination.scala Normal file
View file

@ -0,0 +1,23 @@
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")
}
}

38
Task/Display-a-linear-combination/Sidef/display-a-linear-combination.sidef Normal file
View file

@ -0,0 +1,38 @@
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))
}

36
Task/Display-a-linear-combination/Tcl/display-a-linear-combination.tcl Normal file
View file

@ -0,0 +1,36 @@
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]]
}

57
Task/Display-a-linear-combination/V-(Vlang)/display-a-linear-combination.v Normal file
View file

@ -0,0 +1,57 @@
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)}")
}
}

55
Task/Display-a-linear-combination/Visual-Basic-.NET/display-a-linear-combination.vb Normal file
View file

@ -0,0 +1,55 @@
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

34
Task/Display-a-linear-combination/Wren/display-a-linear-combination.wren Normal file
View file

@ -0,0 +1,34 @@
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))
}

5
Task/Display-a-linear-combination/Zkl/display-a-linear-combination-1.zkl Normal file
View file

@ -0,0 +1,5 @@
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
}

3
Task/Display-a-linear-combination/Zkl/display-a-linear-combination-2.zkl Normal file
View file

@ -0,0 +1,3 @@
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);