math - Código Golf: Todos+-*/ Combinaciones para 3 enteros

code-golf

Question

Escriba un programa que tome 3 enteros separados por espacios y realice cada combinación de operaciones de suma, resta, multiplicación y división posibles y muestre el resultado con la combinación de operaciones utilizada.

Ejemplo:

$./solution 1 2 3

Resultados en la siguiente salida

1+2+3 = 6

1-2-3 = -4

1*2*3 = 6

1/2/3 = 0 (respuestas enteras solamente, redondear a .5)

1*2-3 = -1

3*1+2 = 5

etc ...

Se aplican las reglas de orden de operación, suponga que no se usarán paréntesis, es decir, (3-1)*2 = 4 no es una combinación, aunque podría implementar esto para "crédito adicional"

Para los resultados donde ocurre una división por 0, simplemente devuelva NaN

Editar: Permutando la entrada es necesario, es decir, si la entrada es 1 2 3 , entonces 3*1*2 es una combinación válida.

Answer 1

Delphi - 838 747 caracteres

Versión de una sola línea (Original)

program p;{$APPTYPE CONSOLE}uses SysUtils;type g=Integer;function a(b,c:g):g;begin a:=b+c;end;function s(b,c:g):g;begin s:=b-c;end;function m(b,c:g):g;begin m:=b*c;end;function d(b,c:g):g;begin d:=b div c;end;type t=function(b,c:g):g;r=record f:t;c:char;p:boolean;end;procedure q(l:Array of g;w,e:r);var b:String;x,y,z:g;begin for x:=0 to 2 do for y:=0 to 2 do for z:=0 to 2 do if not((x=y)or(x=z)or(y=z))then begin try if(w.p)or not(w.p xor e.p)then b:=IntToStr(e.f(w.f(l[x],l[y]),l[z]))else b:=IntToStr(w.f(l[x],e.f(l[y],l[z])));except b:=''NaN'';end;writeln(l[x],w.c,l[y],e.c,l[z],''='',b);end;end;const O:Array[0..3]of r=((f:a;c:''+'';p:false),(f:s;c:''-'';p:false),(f:m;c:''*'';p :true),(f:d;c:''/'';p:true));var L:Array[0..2] of g;I,J:g; begin for I:=0 to 2 do L[I]:=StrToInt(ParamStr(I+1));for I:=0 to 3 do for J:=0 to 3 do q(l,o[I],o[J]);end.

Versión de línea única (reducida a 747 caracteres)

program p;{$APPTYPE CONSOLE}uses SysUtils,Math;type g=integer;t=function(b,c:g):g;r=record f:t;p:boolean;end;function a(b,c:g):g;begin a:=b+c end;function s(b,c:g):g;begin s:=b-c end;function m(b,c:g):g;begin m:=b*c end;function d(b,c:g):g;begin d:=b div c end;const f=true;u=false;n=[1..4];b=[1..3];c=''+-*/'';O:Array[1..4]of r=((f:a;p:f),(f:s;p:f),(f:m;p:u),(f:d;p:u));var l: Array[1..3]of g;I,J,x,y,z:g;w,e:r;begin for I in b do l[I]:=StrToInt(ParamStr(I));for I in n do for J in n do for x in b do for y in b do for z in b do if not((x=y)or(x=z)or(y=z))then begin w:=O[I];e:=O[J];write(l[x],c[I],l[y],c[J],l[z],''='');try writeLn(ifthen(w.p or not(w.p xor e.p),e.f(w.f(l[x],l[y]),l[z]),w.f(l[x],e.f(l[y],l[z]))))except writeln(''NaN'')end;end;end.

Formateado:

program p;
{$APPTYPE CONSOLE}
uses SysUtils;
type
g = Integer;
function a(b, c: g): g;
begin
a := b + c;
end;
function s(b, c: g): g;
begin
s := b - c;
end;
function m(b, c: g): g;
begin
m := b * c;
end;
function d(b, c: g): g;
begin
d := b div c;
end;
type
t = function(b, c: g): g;
r = record
f: t;
c: char;
p: boolean;
end;
procedure q(l: Array of g; w, e: r);
var
b: String;
x, y, z: g;
begin
for x := 0 to 2 do
for y := 0 to 2 do
for z := 0 to 2 do
if not((x = y) or (x = z) or (y = z)) then
begin
try
if (w.p) or not(w.p xor e.p) then
b := IntToStr(e.f(w.f(l[x], l[y]), l[z]))
else
b := IntToStr(w.f(l[x], e.f(l[y], l[z])));
except
b := ''NaN'';
end;
writeln(l[x], w.c, l[y], e.c, l[z], ''='', b);
end;
end;
const
O: Array [0..3] of r = ((f: a; c: ''+''; p: false), (f: s; c: ''-''; p: false),
(f: m; c: ''*''; p: true), (f: d; c: ''/''; p: true));
var
l: Array [0..2] of g;
I, J: g;
begin
for I := 0 to 2 do
l[I] := StrToInt(ParamStr(I + 1));
for I := 0 to 3 do
for J := 0 to 3 do
q(l, O[I], O[J]);
end.

Este es de lejos el código más feo que he escrito.

Answer 2

Java - 666 caracteres

_{También tiene oneliners, afortunadamente tenemos Eclipse y el formato de código automático de Netbeans. :-) También implementó paréntesis (pero también contiene operaciones triviales)?}

public class CodeGolf{static String[]o={"+","-","/","*"};static void p(N a,int b,N c,int d,N e,int i){System.out.printf("%s%s(%s%s%s) = %s/n",a,o[b],c,o[d],e,new N(a,b,new N(c,d,e)));}public static void main(String[]v){N[]n={new N(v[0]),new N(v[1]),new N(v[2])};for(int i=0,j=0,k=0,l=0,m=0;m<3;i++,j+=i==4?1:0,i%=4,k+=j==4?1:0,j%=4,l+=k==3?1:0,k%=3,m+=l==3?1:0,l%=3){p(n[k],i,n[l],j,n[m],0);}}static class N{Double v;N(String s){v=v.parseDouble(s);}N(N a,int o,N b){if(a.v==null||b.v==null)return;double x=b.v, y=a.v; switch(o){case 0:x=-x;case 1:v=y-x;return;case 3:v=y*x;x=0;case 2:if(x!=0)v=y/x;}}public String toString(){return v!=null?""+Math.round(v):"NaN";}}}

Ampliado, formateado, versión con comentarios :

public class CodeGolf {
// operators
static String[] o = {"+", "-", "/", "*"};
// print
static void p(N a, int b, N c, int d, N e, int i) {
System.out.printf("%s%s(%s%s%s) = %s/n", a, o[b], c, o[d], e,
new N(a, b, new N(c, d, e))); // calculate
}
public static void main(String[] v) {
N[] n = {new N(v[0]), new N(v[1]), new N(v[2])};
// Nested for-loops? Nah, too much code!
// Conditional operator, modulus is way cooler.
for (int i = 0, j = 0,
k = 0, l = 0, m = 0; m < 3; i++,
j += i == 4 ? 1 : 0,
i %= 4,
k += j == 4 ? 1 : 0,
j %= 4,
l += k == 3 ? 1 : 0,
k %= 3,
m += l == 3 ? 1 : 0,
l %= 3) {
p(n[k], i, n[l], j, n[m], 0);
}
}
// number wrapper
static class N {
Double v;
// parse input
N(String s) {
v = v.parseDouble(s);
}
// calculate input
N(N a, int o, N b) {
// NaN''s should fall through
if (a.v == null || b.v == null) {
return;
}
double x = b.v, y = a.v;
// operator execution
switch (o) {
case 0:
x = -x;
// fall through; y + x = y - (-x)
case 1:
v = y - x;
return; // break would make it 665 characters, not as cool
case 3:
v = y * x;
x = 0;
// fall through; no return needed
case 2:
if (x != 0) {
v = y / x;
}
// will NaN because v = null if x = 0
}
}
// rounding and NaN
public String toString() {
return v != null ? "" + Math.round(v) : "NaN";
}
}

}

Iterar en ambos operadores (4 * 4) y permutar en operandos, dos (3! * 2) marcas (4 * 4 * 3 * 2 * 2 = 192 posibilidades).

⁺ / - 2.5 horas :-) ¡Disfrútalo!

Answer 3

Javascript, 169 caracteres

(sin contar saltos de línea e indentación innecesarios)

Editar : ahora con permutación de entrada

o=" ";i=i.split(o);z="+-*/";for(y=0;y<27;y++)for(x=0;x<16;x++){a=y/9|0;b=(y/3|0)%3;c=y%3;if(a!=b&&a!=c&&b!=c){s=i[a]+z[x/4|0]+i[b]+z[x%4]+i[c];o+=s+"="+~~(eval(s)+.5);}}

Con sangría:

o=" ";
i=i.split(o);
z="+-*/";
for(y=0;y<27;y++)
for(x=0;x<16;x++)
{
a=y/9|0;
b=(y/3|0)%3;
c=y%3;
if(a!=b&&a!=c&&b!=c)
{
s=i[a]+z[x/4|0]+i[b]+z[x%4]+i[c];
o+=s+"="+~~(eval(s)+.5);
}
}

Answer 4

Perl - 76 letras

$a=1;$b=2;$c=3;
warn eval for map{$x=$_;map"$a$x$b$_$c",@a}@a=split//,''+-/*'';

Answer 5

do

600 bytes en el disco con terminaciones de línea de DOS.

#define C B a,B b
#define D(N,O)B N(C){return a O b;}
#define E(A,B,C)i=A;j=B;k=C;X(m,p)X(m,m)X(t,t)X(d,t)X(t,d)X(d,d)Y(m,p)Y(p,p)Y(p,t)Y(p,d)Y(m,t)Y(m,d)
#define U"%.0f"
#define P(S,T)printf(U Z(S)U Z(T)U"="U"/n",v[i],v[j],v[k],
#define p +
#define m -
#define t *
#define d /
#define X(S,T)P(S,T)f##S(f##T(v[i],v[j]),v[k]));
#define Y(S,T)P(S,T)f##S(v[i],f##T(v[j],v[k])));
#define Z(A)#A
typedef double B;D(fp,+)D(fm,-)D(ft,*)B fd(C){return b?(int)(a/b+.5):-0.0;}main(int i,char*b[]){int j,k;B v[3]={atoi(b[1]),atoi(b[2]),atoi(b[3])};E(0,1,2)E(0,2,1)E(1,0,2)E(1,2,0)E(2,0,1)E(2,1,0)}

C no parece tener literales NaN, por lo que obtienes -0 si hay algo mal en lugar de eso.

Sin embargo, creo que se ajusta a la ley de lo contrario. (Tenga en cuenta que el tipo de datos es el double modo que si DID tiene un NaN allí, se imprimirá como tal con printf .)

Answer 6

Bash shell, 126 - 169 - 156 - 140 caracteres

Debería funcionar en cualquier Bash semi-moderno, creo (probado con GNU bash, 3.2.48 (1) x86_64-apple-build).

Maneja la división por cero (caso Nan ).

Todas las sugerencias y comentarios son bienvenidos!

for a in $@;do
s+={`echo $@|tr '' '' ,`}{+,-,*,/};done
for i in `eval echo ${s::${#s}-9}`;do
[[ $i == */0* ]]&&y=Nan||y=$[$i];echo $i=$y;done

Los parámetros de suministro a través de la línea de comando:

./combinate.sh 5 0 12

Answer 7

F #, 584 bytes

(incluye sangría necesaria y LF)

let d a b=if b=0.0 then nan else a/b
let o=["*",((*),1);"+",((+),0);"/",(d,1);"-",((-),0)]
let b=double
let rec z=function|[x]->[x,[]]|x::s->(x,s)::List.map(fun(y,l)->y,x::l)(z s)
let rec p=function|[]->[[]]|l->z l|>List.collect(fun(x,r)->p r|>List.map(fun l->x::l))
let f=fst
let e o p x y z=if snd o<snd p then (f o)x ((f p) y z) else (f p)((f o) x y)z
[<EntryPoint>]let m a=
for i in p(Seq.toList a)do
let x,y,z=b i.[0],b i.[1],b i.[2]
for j in[for j in o do for k in o do yield[j;k]]do
printfn "%.0f%s%.0f%s%.0f = %.0f" x (f j.[0])y (f j.[1])z (e(snd j.[0])(snd j.[1])x y z)
0

Felicitaciones a kvb por su función de permutaciones .

Terminó siendo bastante similar en estructura a la solución C # de Thomas (tal vez porque su solución ya es bastante funcional)

Answer 8

Haskell, 221 caracteres

Argh !!, las importaciones tardan 50 caracteres.

import Data.List
import System
import Text.Printf
o=zip[(+),(-),(*),(/)]"+-*/"
main=do v<-getArgs;sequence[printf"%.0g%c(%.0g%c%.0g)=%.0g/n"x h y i z$f x$g y z|(f,h)<-o,(g,i)<-o,[x,y,z]<-permutations(map read v::[Float])]

getArgs needs System, printf needs Text.Printf, permutations needs Data.List, el [[Float]] es necesario porque / necesita una instancia de Fractional. No podemos usar div porque arrojará cuando se divida por cero.

Básicamente, esto itera sobre todas las combinaciones posibles de operadores y permutaciones de argumentos de entrada e imprime el resultado.

El 3 %.0g puede reemplazarse por %g para eliminar 6 caracteres, pero el resultado será 1.0/(2.0*3.0)=0 que es feo.

~$ ./a.out 0 4 9
0+(4+9)=13
4+(0+9)=13
9+(4+0)=13
4+(9+0)=13
9+(0+4)=13
0+(9+4)=13
0+(4-9)=-5
4+(0-9)=-5
9+(4-0)=13
4+(9-0)=13
9+(0-4)=5
0+(9-4)=5
0+(4*9)=36
4+(0*9)=4
9+(4*0)=9
4+(9*0)=4
9+(0*4)=9
0+(9*4)=36
0+(4/9)=0
4+(0/9)=4
9+(4/0)=Infinity
4+(9/0)=Infinity
9+(0/4)=9
0+(9/4)=2
0-(4+9)=-13
4-(0+9)=-5
9-(4+0)=5
4-(9+0)=-5
9-(0+4)=5
0-(9+4)=-13
0-(4-9)=5
4-(0-9)=13
9-(4-0)=5
4-(9-0)=-5
9-(0-4)=13
0-(9-4)=-5
0-(4*9)=-36
4-(0*9)=4
9-(4*0)=9
4-(9*0)=4
9-(0*4)=9
0-(9*4)=-36
0-(4/9)=-0
4-(0/9)=4
9-(4/0)=-Infinity
4-(9/0)=-Infinity
9-(0/4)=9
0-(9/4)=-2
0*(4+9)=0
4*(0+9)=36
9*(4+0)=36
4*(9+0)=36
9*(0+4)=36
0*(9+4)=0
0*(4-9)=-0
4*(0-9)=-36
9*(4-0)=36
4*(9-0)=36
9*(0-4)=-36
0*(9-4)=0
0*(4*9)=0
4*(0*9)=0
9*(4*0)=0
4*(9*0)=0
9*(0*4)=0
0*(9*4)=0
0*(4/9)=0
4*(0/9)=0
9*(4/0)=Infinity
4*(9/0)=Infinity
9*(0/4)=0
0*(9/4)=0
0/(4+9)=0
4/(0+9)=0
9/(4+0)=2
4/(9+0)=0
9/(0+4)=2
0/(9+4)=0
0/(4-9)=-0
4/(0-9)=-0
9/(4-0)=2
4/(9-0)=0
9/(0-4)=-2
0/(9-4)=0
0/(4*9)=0
4/(0*9)=Infinity
9/(4*0)=Infinity
4/(9*0)=Infinity
9/(0*4)=Infinity
0/(9*4)=0
0/(4/9)=0
4/(0/9)=Infinity
9/(4/0)=0
4/(9/0)=0
9/(0/4)=Infinity
0/(9/4)=0

Answer 9

J, 75 55 caracteres.

Emite números racionales, no enteros.

(],"1''='',"1 ":@x:@".)(('' '',>@{.),@,.":"0@>@{:)"1>{(,{;~''+-*%'');<<"1(i.!3)A.

La versión anterior que no permute la entrada (tenía 55 caracteres)

(],"1''='',"1 ":@x:@".)(>,{;~''+-*%'')('' ''I.@:E.s)}"1 s=:":

Ejemplo (tenga en cuenta que el orden de las operaciones de J es de derecha a izquierda):

 (],"1''='',"1 ":@x:@".)(('' '',>@{.),@,.":"0@>@{:)"1>{(,{;~''+-*%'');<<"1(i.!3)A.1 2 3
1+2+3=6
1+3+2=6
2+1+3=6
2+3+1=6
3+1+2=6
3+2+1=6
1+2-3=0
1+3-2=2
2+1-3=0
2+3-1=4
3+1-2=2
3+2-1=4
1+2*3=7
1+3*2=7
2+1*3=5
2+3*1=5
3+1*2=5
3+2*1=5
1+2%3=5r3
1+3%2=5r2
2+1%3=7r3
2+3%1=5
3+1%2=7r2
3+2%1=5
1-2+3=_4
1-3+2=_4
2-1+3=_2
2-3+1=_2
3-1+2=0
3-2+1=0
1-2-3=2
1-3-2=0
2-1-3=4
2-3-1=0
3-1-2=4
3-2-1=2
1-2*3=_5
1-3*2=_5
2-1*3=_1
2-3*1=_1
3-1*2=1
3-2*1=1
1-2%3=1r3
1-3%2=_1r2
2-1%3=5r3
2-3%1=_1
3-1%2=5r2
3-2%1=1
1*2+3=5
1*3+2=5
2*1+3=8
2*3+1=8
3*1+2=9
3*2+1=9
1*2-3=_1
1*3-2=1
2*1-3=_4
2*3-1=4
3*1-2=_3
3*2-1=3
1*2*3=6
1*3*2=6
2*1*3=6
2*3*1=6
3*1*2=6
3*2*1=6
1*2%3=2r3
1*3%2=3r2
2*1%3=2r3
2*3%1=6
3*1%2=3r2
3*2%1=6
1%2+3=1r5
1%3+2=1r5
2%1+3=1r2
2%3+1=1r2
3%1+2=1
3%2+1=1
1%2-3=_1
1%3-2=1
2%1-3=_1
2%3-1=1
3%1-2=_3
3%2-1=3
1%2*3=1r6
1%3*2=1r6
2%1*3=2r3
2%3*1=2r3
3%1*2=3r2
3%2*1=3r2
1%2%3=3r2
1%3%2=2r3
2%1%3=6
2%3%1=2r3
3%1%2=6
3%2%1=3r2

Answer 10

Lua - 240 letras

Nota: Imprime 1. # INF y -1. # INF en lugar de NaN.

a,b,c=...o="+-*/"f=function(...)g=table.concat({...})loadstring(''x=''..g)()print(g..'' = ''..math.floor(x+.5))end for d in o:gmatch(".")do for e in o:gmatch(".")do f(a,d,b,e,c)f(a,d,c,e,b)f(b,d,a,e,c)f(b,d,c,e,a)f(c,d,a,e,b)f(c,d,b,e,a)end end

Salida

5+0+13 = 18 5+13+0 = 18 0+5+13 = 18 0+13+5 = 18 13+5+0 = 18 13+0+5 = 18 5+0-13 = -8 5+13-0 = 18 0+5-13 = -8 0+13-5 = 8 13+5-0 = 18 13+0-5 = 8 5+0*13 = 5 5+13*0 = 5 0+5*13 = 65 0+13*5 = 65 13+5*0 = 13 13+0*5 = 13 5+0/13 = 5 5+13/0 = 1.#INF 0+5/13 = 0 0+13/5 = 3 13+5/0 = 1.#INF 13+0/5 = 13 5-0+13 = 18 5-13+0 = -8 0-5+13 = 8 0-13+5 = -8 13-5+0 = 8 13-0+5 = 18 5-0-13 = -8 5-13-0 = -8 0-5-13 = -18 0-13-5 = -18 13-5-0 = 8 13-0-5 = 8 5-0*13 = 5 5-13*0 = 5 0-5*13 = -65 0-13*5 = -65 13-5*0 = 13 13-0*5 = 13 5-0/13 = 5 5-13/0 = -1.#INF 0-5/13 = 0 0-13/5 = -3 13-5/0 = -1.#INF 13-0/5 = 13 5*0+13 = 13 5*13+0 = 65 0*5+13 = 13 0*13+5 = 5 13*5+0 = 65 13*0+5 = 5 5*0-13 = -13 5*13-0 = 65 0*5-13 = -13 0*13-5 = -5 13*5-0 = 65 13*0-5 = -5 5*0*13 = 0 5*13*0 = 0 0*5*13 = 0 0*13*5 = 0 13*5*0 = 0 13*0*5 = 0 5*0/13 = 0 5*13/0 = 1.#INF 0*5/13 = 0 0*13/5 = 0 13*5/0 = 1.#INF 13*0/5 = 0 5/0+13 = 1.#INF 5/13+0 = 0 0/5+13 = 13 0/13+5 = 5 13/5+0 = 3 13/0+5 = 1.#INF 5/0-13 = 1.#INF 5/13-0 = 0 0/5-13 = -13 0/13-5 = -5 13/5-0 = 3 13/0-5 = 1.#INF 5/0*13 = 1.#INF 5/13*0 = 0 0/5*13 = 0 0/13*5 = 0 13/5*0 = 0 13/0*5 = 1.#INF 5/0/13 = 1.#INF 5/13/0 = 1.#INF 0/5/13 = 0 0/13/5 = 0 13/5/0 = 1.#INF 13/0/5 = 1.#INF

Answer 11

Perl 130 caracteres

Siempre que las bibliotecas externas estén permitidas:

use Algorithm::Permute"permute";
permute{for$x(@a=qw(+ - / *)){for$y(@a){$_="@ARGV";s/ /$x/;s/ /$y/;printf"
$_ = %.0f",eval}}}@ARGV

La 2da nueva línea es significativa.

Sin un módulo, y suponiendo que las tres entradas son distintas, aquí hay otra solución:

 @n=& ARGV;
@o=( q[+],
"-", q{/}, ''*'' );;
for$ {a}(@ n){ for
$b(@n){for$c(@ {n}){ for $x(
@o){for$y(@o){ ($a-$ b)*($a-$c)* ($b-$
c)||next;$_=$a .$x.$ b."$y$c";$% =42
/84+ eval; print"",$_, "$S="
,$S, $%,$/ }}} }};
;sub ARGV{ $S= $".
"";@ ARGV} ;1+ 2+3

Answer 12

Python (171 caracteres)

Esto evita el déficit de la solución anterior de python (solo números de 1 dígito codificados, dependencia de las bibliotecas más nuevas). Lee de stdin: si quieres cmdline, reemplaza "raw_input (). Split ()" con "sys.argv [1: 4]"

x=raw_input().split()
for e in[x[i/3]+p+x[i%3]+''.''+q+x[3-i/3-i%3]for i in range(9)if i%4for p in''+-*/''for q in''+-*/'']:
try:r=round(eval(e))
except:r=''NaN''
print e,''='',r

PD. disminuyó a 147-> 138
pps. cambió los cálculos de int a float con redondeo, 138-> 153
ppps. soporte adicional para / 0 = NaN, 153-> 179
pppps. disminuyó 179-> 177 ppppps. belleza sacrificada por brevedad, 177-> 171

Answer 13

Python - 125 175 177 caracteres:

(ahora no cuenta la sangría)
Se agregó la entrada de la línea de comandos, no más restricción de un solo dígito / distinto de cero, funciona con cero (NaN)

import sys
from itertools import permutations as p
for i,j,k in p(sys.argv[1:4],3):
for x,y in p(''+-*/''*2,2):
s=i+x+j+''.''+y+k
try:e=eval(s)
except:e=''NaN''
print s,''='',e

Todavía No hay más trunca en lugar de redondear a 0.5

Answer 14

Rubí

(lee de la lista de argumentos y devuelve NaN si no es divisible)

(Sería solo la última línea si ruby ​​tuviera una biblioteca de permutación)

class Array
def perm(n = size)
if size < n or n < 0
elsif n == 0
yield([])
else
self[1..-1].perm(n - 1) do |x|
(0...n).each do |i|
yield(x[0...i] + [first] + x[i..-1])
end
end
self[1..-1].perm(n) do |x|
yield(x)
end
end
end
end
ARGV.perm(3){|a,b,c| "++//**--".split(//).perm(2){ |d,e| x=a+d+b+e+c;puts "#{x} = #{eval(x)}" rescue puts "#{x} = NaN"} }

Answer 15

Ruby, 105 110 142 114 caracteres

o=%w{+ - * /};[*ARGV.permutation].product(o.product o).map{|x,y|e=x.zip(y)*"";p"#{e}=#{eval(e)rescue:N}"}

Uso

ruby prog.rb 1 2 3

Explicación

# o = ["+", "-", "*", "/"]
o=%w{+ - * /};
# ARGV = array of numbers. Generate all permutations, and apply splat operator
[*ARGV.permutation]
# Generate cartesian product of all permuted numbers and operators
# There will be 16 operator permutations, and 6 number permutations giving a
# total of 96 elements
.product(o.product o)
# For each of the 96 pairs, merge the operators and numbers into 1 array.
# ex - [1,2,3].zip(["+", "-"]) gives [[1, ''+''], [2, ''-''], [3, nil]]
# then convert the array to string by multiplying with "" => "1+2-3"
.each{|x,y|e=x.zip(y)*"";
# print output and eval result. On exception return infinity - ∞
p"#{e}=#{eval(e)rescue:N}"}

Salida

1+2+3=6
1+2-3=0
1+2*3=7
1+2/3=1
1-2+3=2
1-2-3=-4
1-2*3=-5
1-2/3=1
1*2+3=5
1*2-3=-1
1*2*3=6
1*2/3=0
1/2+3=3
1/2-3=-3
1/2*3=0
1/2/3=0
1+3+2=6
1+3-2=2
1+3*2=7
1+3/2=2
1-3+2=0
1-3-2=-4
1-3*2=-5
1-3/2=0
1*3+2=5
1*3-2=1
1*3*2=6
1*3/2=1
1/3+2=2
1/3-2=-2
1/3*2=0
1/3/2=0
2+1+3=6
2+1-3=0
2+1*3=5
2+1/3=2
2-1+3=4
2-1-3=-2
2-1*3=-1
2-1/3=2
2*1+3=5
2*1-3=-1
2*1*3=6
2*1/3=0
2/1+3=5
2/1-3=-1
2/1*3=6
2/1/3=0
2+3+1=6
2+3-1=4
2+3*1=5
2+3/1=5
2-3+1=0
2-3-1=-2
2-3*1=-1
2-3/1=-1
2*3+1=7
2*3-1=5
2*3*1=6
2*3/1=6
2/3+1=1
2/3-1=-1
2/3*1=0
2/3/1=0
3+1+2=6
3+1-2=2
3+1*2=5
3+1/2=3
3-1+2=4
3-1-2=0
3-1*2=1
3-1/2=3
3*1+2=5
3*1-2=1
3*1*2=6
3*1/2=1
3/1+2=5
3/1-2=1
3/1*2=6
3/1/2=1
3+2+1=6
3+2-1=4
3+2*1=5
3+2/1=5
3-2+1=2
3-2-1=0
3-2*1=1
3-2/1=1
3*2+1=7
3*2-1=5
3*2*1=6
3*2/1=6
3/2+1=2
3/2-1=0
3/2*1=1
3/2/1=1

Answer 16

OK, no es realmente corto, pero lo publico de todos modos, solo por diversión ...

Tenga en cuenta que a diferencia de la mayoría de las otras respuestas, esta no usa eval ya que no está disponible en C # (sería mucho más corto con ella)

C #, 729 caracteres

using System;using System.Linq;using w=System.Double;class Op{public char c;public int p;public Func<w,w,w>f;}class Program{static void Main(string[]p){var nb=p.Select((n,i)=>new{n=w.Parse(n),i});var op=new[]{new Op{c=''+'',p=0,f=(a,b)=>a+b},new Op{c=''-'',p=0,f=(a,b)=>a-b},new Op{c=''*'',p=1,f=(a,b)=>a*b},new Op{c=''/'',p=1,f=(a,b)=>a/b},};Func<Op,Op,Func<w,w,w,w>>fg=(o1,o2)=>(x,y,z)=>o1.p>=o2.p?o2.f(o1.f(x,y),z):o1.f(x,o2.f(y,z));Func<w,w>nan=d=>w.IsInfinity(d)?w.NaN:d;var res=from o1 in op from o2 in op from x in nb from y in nb where x.i!=y.i from z in nb where z.i!=x.i&&z.i!=y.i let r=nan(fg(o1,o2)(x.n,y.n,z.n))select string.Format("{0}{1}{2}{3}{4}={5:F0}",x.n,o1.c,y.n,o2.c,z.n,r);res.ToList().ForEach(Console.WriteLine);}}

Versión expandida

using System;
using System.Linq;
using w=System.Double;
// Operator class
// c = character
// p = priority
// f = function
class Op { public char c; public int p; public Func<w, w, w> f; }
class Program
{
static void Main(string[] args)
{
// Parse the input and associate each number with its index
var nb = args.Select((n, i) => new { n = w.Parse(n), i });
// Operators definition
var op = new[]
{
new Op { c = ''+'', p = 0, f = (a, b) => a + b },
new Op { c = ''-'', p = 0, f = (a, b) => a - b },
new Op { c = ''*'', p = 1, f = (a, b) => a * b },
new Op { c = ''/'', p = 1, f = (a, b) => a / b },
};
// Function generator to compute the result ; handles operator priority
Func<Op, Op, Func<w, w, w, w>> fg =
(o1, o2) =>
(x, y, z) =>
o1.p >= o2.p
? o2.f(o1.f(x, y), z)
: o1.f(x, o2.f(y, z));
// Converts +/- Infinity to NaN
Func<w, w> nan = d => w.IsInfinity(d) ? w.NaN : d;
// Results
var res =
// Combinations of 2 operators
from o1 in op
from o2 in op
// Permutations of numbers
from x in nb
from y in nb
where x.i != y.i
from z in nb
where z.i != x.i && z.i != y.i
// Compute result
let r = nan(fg(o1, o2)(x.n, y.n, z.n))
// Format output
select string.Format("{0} {1} {2} {3} {4} = {5:F0}", x.n, o1.c, y.n, o2.c, z.n, r);
res.ToList().ForEach(Console.WriteLine);
}
}

¿Quién dijo que no puedes hacer programación funcional en C #? ;)

EDITAR: corregido para que funcione con números duplicados

Answer 17

F #: 280 caracteres, incl. nuevas líneas

La versión ilegible:

let q s=System.Data.DataTable().Compute(s,"")|>string|>float
let e(a,b,c)=let o=["+";"-";"*";"/"]in for x in o do for y in o do let s=a+x+b+y+c in printfn"%s=%.0f"s (q s)
[<EntryPoint>]let p(A:_[])=(for i=0 to 2 do let p,q,r=A.[i],A.[(i+1)%3],A.[(i+2)%3]in e(p,q,r);e(p,r,q));0

La versión de tl; dr:

//This program needs to be compiled as a console project
//It needs additional references to System.Data and System.Xml
//This function evaluates a string expression to a float
//It (ab)uses the Compute method of System.Data.DataTable which acts
//as .Net''s own little eval()
let q s =
//the answer is an object
System.Data.DataTable().Compute(s,"")
//so convert it to a string and then parse it as a float
|> string
|> float
//This function first generates all 6 permutations of a 3-tuple of strings
//and then inserts all operator combination between the entries
//Finally it prints the expression and its evaluated result
let e (a,b,c) =
let o = ["+";"-";"*";"/"]
//a double loop to get all operator combos
for x in o
do for y in o do
let s=a+x+b+y+c //z is expression to evaluate
//print the result as expression = result,
//the %.0f formatter takes care of rounding
printfn "%s=%.0f" s (q s)
//This is the entry point definition.
//A is the array of command line args as strings.
[<EntryPoint>]
let p(A:_[]) =
//Generate all permutations:
//for each index i:
// put the i-th element at the front and add the two remaining elements
// once in original order and once swapped. Voila: 6 permutations.
for i=0 to 2 do
let p,q,r = A.[i], A.[(i+1)%3], A.[(i+2)%3]
e(p,q,r) //evaluate and print "p + <op> + q + <another op> + r"
e(p,r,q) //evaluate and print "p + <op> + r + <another op> + q"
0 //the execution of the program apparently needs to return an integer

Ejemplo de salida:

> ConsoleApplication1 1 2 0
1+2+0=3
1+2-0=3
1+2*0=1
1+2/0=Infinity
1-2+0=-1
1-2-0=-1
1-2*0=1
1-2/0=-Infinity
1*2+0=2
1*2-0=2
1*2*0=0
1*2/0=Infinity
1/2+0=1
1/2-0=1
1/2*0=0
1/2/0=Infinity
1+0+2=3
1+0-2=-1
1+0*2=1
1+0/2=1
...