En los Nuevos Tiempos Modernos , cuando Charlie Chaplin se encuentra con una computadora, está empleado en el patio de clasificación, como un validador para determinar si los trabajadores están clasificando correctamente los elementos. Los artículos en cuestión son paquetes de canicas. Los paquetes con un número impar de canicas se apilan en la canasta roja y los paquetes con un número par de canicas se apilan en la canasta azul.

Se supone que Charlie Chaplin golpea el programa que se validaría si hay alguna anomalía en el procedimiento de clasificación. Mack Swain, su jefe inmediato, comparte un algoritmo que necesita codificar.

Algoritmo

L = List of Marble packets that's already sorted
L_ODD = List of packets with Odd Number of Marbles
L_EVEN = List of packets with Even Number of Marbles
Check_Digit = √(ΣL_ODD² + ΣL_EVEN²)

Su trabajo es determinar el Check_Digit y relacionarlo con el valor que calcula su jefe.

Charlie Chaplin, durante sus horas de almuerzo, pudo escabullirse al cajón de Mack Swain y determinar que su cajón tiene una sola tarjeta con golpes en las primeras 46 32 columnas (lo que significa que Mack pudo escribir un programa con solo 46 32 caracteres).

Charlie Chaplin ahora necesitaría la ayuda de todos los códigos ninja para escribir un programa con la menor cantidad de líneas posible. También anuncia una bonificación de 50 puntos, si alguien puede idear un programa que sea más corto que su Jefe.

Resumen

Dada una lista / matriz / vector de números positivos (pares e impares), debe escribir una función que acepte array(int [])/vector<int>/listy calcule la raíz de la suma de los cuadrados de las sumas de números impares y pares en la lista.

El tamaño del programa es el tamaño del cuerpo de la función, es decir, excluyendo el tamaño de la firma de la función.

Ejemplo

List = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]
Odd = [9, 5, 5, 5, 15, 17, 9]
Even = [20, 4, 20]
Check_Digit = √(ΣOdd² + ΣEven²) = 78.49203781276162

Tenga en cuenta que la salida real puede variar según la precisión de coma flotante de la implementación.

Puntuación

La puntuación se calcula como Σ(Characters in your Program) - 46. La puntuación se calcula como Σ(Characters in your Program) - 32. Además de la votación regular de la comunidad, el puntaje negativo más bajo recibiría una bonificación adicional de 50 puntos.

Editar

1. La compensación que se usó para calcular el puntaje se cambió de 46 a 32. Tenga en cuenta que esto no afectaría la elegibilidad de la tabla de clasificación / recompensa ni invalidaría ninguna solución.

Veredicto

Después de un horrible duelo entre los Ninjas, el Sr. Chaplin recibió algunas respuestas maravillosas. Lamentablemente, pocas de las respuestas intentaron aprovechar indebidamente la regla y no fueron muy útiles. En realidad, quería un duelo justo y las respuestas donde la lógica estaba codificada dentro de las firmas de funciones eventualmente significarían que la firma de funciones es una parte integral de la solución. Finalmente, Ninja FireFly fue el claro ganador y le otorgó el bono que se merece. Tabla de clasificación (actualizada todos los días)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ Rank │      Ninja      │   Dialect    │ Punches │ Scores │ Votes ┤
╞══════╪═════════════════╪══════════════╪═════════╪════════╪═══════╡
│  0   │     FireFly     │      J       │   17    │  -15   │   6   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  1   │     tmartin     │     Kona     │   22    │  -10   │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  2   │ Sven Hohenstein │      R       │   24    │   -8   │   7   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  3   │    Ben Reich    │  GolfScript  │   30    │   -2   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  4   │    mollmerx     │      k       │   31    │   -1   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  5   │ David Carraher  │ Mathematica  │   31    │   -1   │   3   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  6   │     tmartin     │      Q       │   34    │   2    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  7   │     daniero     │      dc      │   35    │   3    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  8   │    psion5mx     │    Python    │   38    │   6    │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  9   │       O-I       │     Ruby     │   39    │   7    │   5   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  10  │      gggg       │    Julia     │   40    │   8    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  11  │ FakeRainBrigand │  LiveScript  │   50    │   18   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  12  │    Sylwester    │    Perl5     │   50    │   18   │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  13  │     daniero     │     Ruby     │   55    │   23   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  14  │    vasuakeel    │ Coffeescript │   57    │   25   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  15  │      dirkk      │    XQuery    │   63    │   31   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  16  │  crazedgremlin  │   Haskell    │   64    │   32   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  17  │   Uri Agassi    │     Ruby     │   66    │   34   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  18  │     Sumedh      │     JAVA     │   67    │   35   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  19  │      Danny      │  Javascript  │   67    │   35   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  20  │     deroby      │      c#      │   69    │   37   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  21  │  Adam Speight   │      VB      │   70    │   38   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  22  │    Andrakis     │    Erlang    │   82    │   50   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  23  │      Sp0T       │     PHP      │   85    │   53   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  24  │    brendanb     │   Clojure    │   87    │   55   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  25  │  Merin Nakarmi  │      C#      │   174   │  142   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  26  │    Boopathi     │     JAVA     │   517   │  485   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  27  │      Noyo       │     ES6      │    ?    │   ?    │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  28  │     shiona      │   Haskell    │    ?    │   ?    │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  29  │      Vivek      │     int      │    ?    │   ?    │   0   │
└──────┴─────────────────┴──────────────┴─────────┴────────┴───────┘

J, 18 17 caracteres - 32 = ⁻15

[:+/&.:*:2&|+//.]

(Como "cuerpo de función"; debe estar entre paréntesis o vinculado a un nombre).

Explicación

Traté de hacer una vista detallada de lo que hace cada pieza, como lo hace Tobia en las respuestas de APL.

               +//. ]    NB. sum up partitions
           2&|           NB.   given by equality on (x mod 2)
        *:               NB. square,
   +/                    NB. sum,
     &.:                 NB. then revert the squaring (square-root)
                         NB. (f&.:g in general acts like g⁻¹(f(g(x))))
[:                       NB. (syntax to indicate composition of +/&.:*: and (2&| +//. ]))

+/&.:*:podría reemplazarse |@j./haciendo uso del complejo truco de magnitud de OI para salvar otros dos caracteres.

Ejemplo

   f =: [:+/&.:*:2&|+//.]
   f 20 9 4 5 5 5 15 17 20 9
78.492

ES6, ( 48-32 ) = 16 (1-32) = -31

Versión original:

f=l=>(e=o=0)+l.map(x=>x%2?e+=x:o+=x)&&Math.hypot(e,o)

La definición de la función completa es de 53 caracteres, el cuerpo solo tiene 48.

Versión actualizada, aprovechando al máximo la definición del problema y moviendo casi todo fuera del cuerpo a la firma:

f=(l,e=0,o=0,g=x=>x%2?e+=x:o+=x,c=l.map(g)&&Math.hypot(e,o))=>c

La nueva definición de la función ahora es de 63 "golpes" en total, pero la función CUERPO ahora es solo SOLO UN CARÁCTER MALDITO DE LARGO. Además, ¡ya no corrompe el espacio de nombres global! :RE

Uso:

>>> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161

R, (24-32) = −8

f=function(x)
    sum(by(x,x%%2,sum)^2)^.5  

El cuerpo de la función consta de 24 caracteres.

Uso:

f(c(20, 9, 4, 5, 5, 5, 15, 17, 20, 9))
[1] 78.49204

Ruby 2.1+ - (39 caracteres en total - 7 sin cuerpo - 32 desplazamiento = 0)

Enfoque ligeramente diferente. Creo un número complejo a+b*ital que ay bson las sumas de los números pares e impares en list, respectivamente. Entonces solo tomo el valor absoluto.

f=->l{l.reduce{|s,x|s+x*1i**(x%2)}.abs}

Mi solución anterior, que tiene 5 caracteres más pero funciona en 1.9.3+:

f=->l{l.reduce{|s,x|s+x*?i.to_c**(x%2)}.abs}

En una nota final, si se permitieran Rails + Ruby 2.1+, podemos usar Array#sumpara reducir el cuerpo a solo 25 caracteres:

l.sum{|x|x+1i**(x%2)}.abs

Python 2.7: 45, no: 40, no: 38 - 32 = 6

Nada muy nuevo aquí, solo una combinación del truco de números complejos que vi en el reciente desafío de Pitágoras, lambda para la compacidad y minimización de sintaxis / paréntesis:

lambda x:abs(sum(a*(1-a%2+a%2*1j)for a in x))

Actualización: guardado algunos caracteres. Gracias a @DSM por el truco de elevar el componente complejo a 0/1.

lambda x:abs(sum(a*1j**(a%2)for a in x))

Ok, leer la pregunta y reconocer la regla de conteo del 'cuerpo de la función' ahorra otros 2 caracteres:

def f(x):
    return abs(sum(a*1j**(a%2)for a in x))

Prueba de iPython:

In [650]: x = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]

In [651]: print (lambda l:abs(sum(a*(1-a%2+a%2*1j)for a in l)))(x)
78.4920378128

...

In [31]: def f(x):
   ....:     return abs(sum(a*1j**(a%2)for a in x))
   ....:

In [32]: f(x)
Out[32]: 78.49203781276162

APL (27-46 = -19)

{.5*⍨+/2*⍨+⌿⍵×[1]z,⍪~z←2|⍵}

p.ej:

      {.5*⍨+/2*⍨+⌿⍵×[1]z,⍪~z←2|⍵} 20 9 4 5 5 5 15 17 20 9
78.49203781

Mathematica 31-32 = -1

√Tr[(Tr/@GatherBy[#,OddQ])²]//N &

GatherBy[#,OddQ] produce las listas de paquetes pares e impares.

El interno Trencuentra los totales, los cuales son al cuadrado y luego se suman (por el exterior Tr).

N convierte de un número irracional (la raíz cuadrada de un entero) a una aproximación decimal.

Ejemplo

√Tr[(Tr/@GatherBy[#,OddQ])²]//N &[{9, 5, 5, 5, 15, 17, 9, 20, 4, 20}]

78,492

Si f[n_]:=no se incluye en el recuento, se puede guardar un personaje adicional.

    f[n_]:=
    √Tr[(Tr/@GatherBy[n,OddQ])²]//N 

Ejemplo

f[{9, 5, 5, 5, 15, 17, 9, 20, 4, 20}]

78,492

Kona, 22-32 = -10

{(+/(+/'x@=x!2)^2)^.5}

Perl5: (50-32 = 18)

map{$0[$_&1]+=$_}@ARGV;print sqrt$0[0]**2+$0[1]**2

dc 3 (35-32)

Usando matrices, como lo sugiere @Tomas. Esto ahorra algunos caracteres porque puedo calcular la paridad de cada número y usarlo como índice, en lugar de ajustarlo con paridad como método de ramificación y poner los valores correctos en los registros correctos. También resulta que las matrices le darán un 0 incluso si la matriz / índice no se ha utilizado, por lo que no tiene que inicializar nada.

[d2%dsP;S+lP:Sz0<L]dsLx0;S2^1;S2^+v

Asume que los números ya están en la pila y deja el resultado como el único valor que queda cuando se hace.

Prueba:

$ dc  
20 9 4 5 5 5 15 17 20 9  
[d2%dsP;S+lP:Sz0<L]dsLx0;S2^1;S2^+v 
p
78

dc 16 (48-32)

Primera versión usando los registros o y e para almacenar los números pares e impares.

0dsose[dd2%rd1+2%*lo+so*le+sez0<x]dsxxle2^lo2^+v

Python, 9 (55-46)

lambda x:sum([sum([i*(d-i%2) for i in x])**2for d in(0,1)])**0.5

El uso de una función lambda ahorra algunos bytes en líneas nuevas, pestañas y return.

Ejemplo:

x = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]
print (lambda x:sum([sum([i*(d-i%2) for i in x])**2for d in(0,1)])**0.5)(x)
78.4920378128

Rubí (66-32 = 34)

f=->a{o,e=a.partition(&:odd?).map{|x|x.reduce(:+)**2};(e+o)**0.5}

prueba:

f.([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
=> 78.49203781276162 

Rubí, 55 - 46 = 9

f=->a{h=[0,0];a.map{|v|h[v%2]+=v};e,o=h;(e*e+o*o)**0.5}

Prueba:

f[[20, 9, 4, 5, 5, 5, 15, 17, 20, 9]] => 78.49203781276162`

Q, 34-32 = 2

{sqrt sum{x*x}(+/')(.)x(=)x mod 2}

.

q){sqrt sum{x*x}(+/')(.)x(=)x mod 2} 20 9 4 5 5 5 15 17 20 9
78.492037812761623

Julia, 40-46 = -6

Implementación

function f(l)
    a=sum(l);b=sum(l[l%2 .==1]);hypot(a-b,b)
end

Salida

julia> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161

Coffeescript, (57 - 32 = 25)

Implementacion

f=(a)->r=[0,0];r[e%2]+=e for e in a;[e,o]=r;(e*e+o*o)**.5

GolfScript 30

.{2%},]{{+}*}/.@\-]{2?}/+2-1??

¡No creo que GolfScript tenga muchas posibilidades en este caso!

c #: 69-32 = 37

double t=l.Sum(),o=l.Sum(x=>x*(x%2)),e=t-o;return Math.Sqrt(o*o+e*e);

Código completo:

class Program
{
    static void Main(string[] args)
    {
        int[] list = { 20, 9, 4, 5, 5, 5, 15, 17, 20, 9 };
        Console.WriteLine(F(list));
        Console.ReadKey();
    }

    static double F(int[] l)
    {
        double t = l.Sum(),  // total sum of all elements
               o = l.Sum(x => x * (x % 2)),  // total of odd elements, if even %2 will return zero
               e = t - o; // even = total - odd
        return Math.Sqrt(o * o + e * e);
    }        
}

PD: Solo por diversión, esto también funciona, lamentablemente no cambia la cantidad de caracteres necesarios:

double t=l.Sum(),o=l.Sum(x=>x*(x%2));return Math.Sqrt(t*t-2*o*(t-o));

Prólogo (73 - 32 = 41)

Aquí contamos todo después de ': -' como el cuerpo de la función.

f([],0,0,0).
f([H|T],O,E,X):-(1 is H mod 2,f(T,S,E,_),O is H+S,!;f(T,O,S,_),E is H+S),sqrt(O*O+E*E,X).

Llame a la función así:

f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9],_,_,X).

Matlab (44-46 = -2)

El cuerpo de la función tiene 44 caracteres:

C=mod(A,2)>0;O=(sum(A(C))^2+sum(A(~C))^2)^.5

Función total de la siguiente manera:

function O = Q(A)
C=mod(A,2)>0;O=(sum(A(C))^2+sum(A(~C))^2)^.5
end

Pruebas de la función:

>> A = [20 9 4 5 5 5 15 17 20 9];
>> Q(A)

O =

   78.4920


ans =

   78.4920

>> B = [8 3 24 1 9 8 4 5 52];
>> Q(B)

O =

   97.6729


ans =

   97.6729

Python 2.7 - 64-46 = 18

Esto podría ser más corto usando algo de zipmagia, pero por ahora:

(sum(s for s in x if s%2)**2+sum(s for s in x if s%2==0)**2)**.5

Para completar, resulta que puedes hacer magia mágica, pero te cuesta más (por unos pocos caracteres), por lo que se destaca lo anterior, a menos que alguien pueda mejorar cualquiera de estos:

sum(map(lambda i:sum(i)**2,zip(*[[(0,i),(i,0)][i%2]for i in x])))**.5

C # 174

using System;class P{static void Main(){double[] L={20,9,4,5,5,5,15,17,20,9};double O=0,E=0;foreach(int i in L){if(i%2==0)E+=i;else O+=i;}Console.Write(Math.Sqrt(E*E+O*O));}}

Legible

using System;
class P
{
  static void Main()
  {
      double[] L = { 20, 9, 4, 5, 5, 5, 15, 17, 20, 9 };
      double O = 0, E = 0;
      foreach (int i in L)
      {
        if (i % 2 == 0)
            E += i;
        else
            O += i;
      }
      Console.Write(Math.Sqrt(E * E + O * O));
   }
}

Clojure = 87 - 46 = 41

(defn cd [v]
  (let [a apply ** #(* % %)]
    (Math/sqrt(a + (map #(** (a + (% 1)))(group-by even? v))))))

Aunque apenas idiomático.

Haskell, 64C - 46 = 18

c x=sqrt$fromIntegral$s(f odd x)^2+s(f even x)^2
f=filter
s=sum

No es muy difícil de leer. Ejemplo de ejecución:

*Main> c [1..10]
39.05124837953327

int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));

Método real en código java

public static void checkDigit(int[] n)
{
    int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));
}

Clase de prueba

public class Sint
{
    public static void main(String[] args)
    {
        if(args == null || args.length == 0)
            args = "20 9 4 5 5 5 15 17 20 9".split(" ");
        int[] n = null;
        try
        {
            n = new int[args.length];
            for(int i=0; i<args.length; i++)
                n[i] = Integer.parseInt(args[i]);
            System.out.print("int array is: ");
            for(int dd : n) System.out.print(dd+", ");
            System.out.print("\n");
            checkDigit(n);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void checkDigit(int[] n)
    {
        int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));
    }
}

PHP 85-32 = 53

$a=$b=0;foreach($x as $q){if(($q%2)==0)$a=$a+$q;else$b=$b+$q;}echo sqrt($a*$a+$b*$b);

Esto es lo mejor que se me ocurre ser un novato. Estoy seguro de que también debe haber algunas versiones más cortas.

EDITAR:

Una versión reducida del código podría ser:

foreach($x as$q)($q%2)?$a=$a+$q:$b=$b+$q;echo sqrt($a*$a+$b*$b);

Esta versión solo tiene 64 caracteres (21 menos que la respuesta original).

Dicho así, 64-32 = 32

VB.net (81c - 11c = 70) - 32 = 38

Mediante el uso liberal del término Escribir una función

Function(n)Math.Sqrt(n.Sum(Function(x)x Mod 2=0)^2+n.Sum(Function(x)x Mod 2=1)^2)

XQuery, (63 - 32 = 31)

Implementación

declare default function namespace 'http://www.w3.org/2005/xpath-functions/math';
declare function local:f($s) {
  sqrt(pow(fn:sum($s[. mod 2=0]),2)+pow(fn:sum($s[. mod 2=1]),2))
};

Salida

local:f((20, 9, 4, 5, 5, 5, 15, 17, 20, 9))

BaseX se utilizó como procesador XQuery.

Erlang: 82C - 32 = 50

fun(L)->F={lists,sum},O=[X||X<-L,X rem 2>0],E=F(L--O),math:sqrt(F(O)*F(O)+E*E)end.

Erlang no es genial para esto. La mayoría de los atajos terminan siendo más personajes (tuplas, etc.)

Las únicas cosas reales de nota:

• {lists,sum} es una referencia de función a lists:sum y se puede llamar
• Los números pares se calculan restando --( restar lista ) la lista de números impares de la lista completa

Puede llamar usando:

fun(L)->F={lists,sum},O=[X||X<-L,X rem 2>0],E=F(L--O),math:sqrt(F(O)*F(O)+E*E)end([20,9,4,5,5,5,15,17,20,9]).

Salida: 78.49203781276162

Haskell

57-32 = 25

La optimización directa de cgreedgremlins responde:

c x=sqrt$read$show$sum(odd%x)^2+sum(even%x)^2
(%)=filter

Optimizaciones:

• read$showes más corto que fromIntegral- 3 caracteres
• s=sum\ny dos stiene una longitud total de 8 caracteres, dos sumson solo 6 caracteres. - 2 caracteres
• hacer filtro en el operador elimina la necesidad de espacios en blanco - 2 caracteres

También intenté agregar más cosas al operador, pero terminó siendo igual de largo:

c x=sqrt$read$show$odd%x+even%x
(%)=(((^2).sum).).filter