Nel New Modern Times , quando Charlie Chaplin incontra un computer, viene impiegato nell'iarda di smistamento, come validatore per determinare se gli operai stanno ordinando correttamente gli oggetti. Gli articoli in questione sono pacchetti di marmi. I pacchetti con numero dispari di biglie sono impilati nel cestino rosso e i pacchetti con numero pari di biglie sono impilati nel cestino blu.

Charlie Chaplin dovrebbe dare un pugno al programma che verificherebbe se c'è qualche anomalia nella procedura di smistamento. Mack Swain, il suo capo immediato, condivide un algoritmo di cui ha bisogno per codificare.

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²)

Il suo compito è determinare Check_Digit e abbinarlo a qualunque valore abbia mai calcolato il suo Boss.

Charlie Chaplin durante le sue ore di pranzo, è stato in grado di intrufolarsi nel cassetto di Mack Swain e determinare, che il suo cassetto ha una sola carta con pugni sulle prime 46 colonne 32 (il che significa che Mack è stato in grado di scrivere un programma con solo 46 32 caratteri).

Charlie Chaplin ora avrebbe bisogno dell'aiuto di tutti i ninja del codice per scrivere un programma con il minor numero di righe possibile. Annuncia anche un bonus di 50 punti, se qualcuno può escogitare un programma più corto del suo capo.

Sommario

Dato un elenco / matrice / vettore di numeri positivi (pari e dispari), è necessario scrivere una funzione, che accetti array(int [])/vector<int>/liste calcoli la radice della somma dei quadrati delle somme dei numeri pari e dispari nell'elenco.

La dimensione del programma è la dimensione del corpo della funzione, ovvero esclude la dimensione della firma della funzione.

Esempio

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

Nota , l'output effettivo potrebbe variare in base alla precisione in virgola mobile dell'implementazione.

Punto

Il punteggio è calcolato come Σ(Characters in your Program) - 46. Il punteggio è calcolato come Σ(Characters in your Program) - 32. A parte il normale miglioramento da parte della community, il punteggio negativo più basso riceverà un bonus aggiuntivo di 50 punti.

modificare

1. L'offset utilizzato per calcolare il punteggio è stato modificato da 46 a 32. Nota, ciò non influirebbe sull'ammissibilità della classifica / ricompensa o invaliderebbe qualsiasi soluzione.

Verdetto

Dopo un raccapricciante duello tra i Ninja, Chaplin ricevette delle risposte meravigliose. Purtroppo alcune delle risposte hanno cercato di trarre indebito vantaggio dalla regola e non sono state molto utili. Voleva in realtà un duello equo e le risposte in cui la logica era codificata all'interno delle firme di funzione alla fine avrebbe significato che la firma di funzione è parte integrante della soluzione. Alla fine, Ninja FireFly è stato il chiaro vincitore e gli ha assegnato il bonus che merita. Classifica (aggiornata ogni giorno)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ 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 caratteri - 32 = ⁻15

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

(Come "corpo della funzione"; deve essere racchiuso tra parentesi o associato a un nome.)

Spiegazione

Ho provato a fare una vista esplosa di ciò che ogni pezzo fa, come fa Tobia nelle risposte 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&| +//. ]))

+/&.:*:potrebbe essere sostituito con |@j./l'uso del complesso trucco di grandezza di OI per salvare ancora altri due personaggi.

Esempio

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

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

Versione originale:

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

L'intera definizione della funzione è di 53 caratteri, solo il corpo è 48.

Versione aggiornata, sfruttando appieno la definizione del problema e spostando praticamente tutto dal corpo e nella 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 nuova definizione della funzione ora è di 63 "pugni" in totale, ma la funzione CORPO ora è solo UN PERSONAGGIO DANNO LUNGO. Inoltre non corrompe più lo spazio dei nomi globale! : D

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  

Il corpo della funzione è composto da 24 caratteri.

Uso:

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

Ruby 2.1+ - (39 caratteri totali - 7 non-body - 32 offset = 0)

Approccio leggermente diverso. Creo un numero complesso a+b*itale che ae bsono rispettivamente le somme dei numeri pari e dispari list. Quindi prendo solo il valore assoluto.

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

La mia soluzione precedente, che è più lunga di 5 caratteri ma funziona su 1.9.3+:

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

In una nota finale, se Rails + Ruby 2.1+ fosse consentito, possiamo usare Array#sumper ridurre il corpo a soli 25 caratteri:

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

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

Niente di molto nuovo qui, solo una combinazione del complesso trucco dei numeri che ho visto nella recente sfida di Pitagora, lambda per compattezza e minimizzazione della sintassi / parentesi:

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

Aggiornamento: salvato alcuni caratteri. Grazie a @DSM per il trucco di portare il componente complesso a 0/1.

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

Ok, leggendo la domanda e riconoscendo la regola di conteggio 'body of the function' si salvano altri 2 caratteri:

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

Test di 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|⍵}

per esempio:

      {.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 gli elenchi di pacchetti pari e pacchetti dispari.

L'interno Trtrova i totali, entrambi i quali sono quadrati e quindi sommati (dall'esterno Tr).

N converte da un numero irrazionale (la radice quadrata di un numero intero) in un'approssimazione decimale.

Esempio

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

78,492

Se f[n_]:=non è incluso nel conteggio, è possibile salvare un personaggio aggiuntivo.

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

Esempio

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)

Utilizzo di array, come suggerito da @Tomas. Questo salva alcuni caratteri perché posso calcolare la parità di ogni numero e usarlo come indice, invece di modificare la parità con un metodo di ramificazione e mettere i giusti valori nei registri giusti. Inoltre, gli array ti daranno uno 0 anche se l'array / index non è stato usato, quindi non devi inizializzare nulla.

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

Presuppone che i numeri siano già in pila e lascia il risultato come unico valore rimasto al termine.

Test:

$ 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)

Prima versione che utilizza i registri o ed e per memorizzare numeri pari e dispari.

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

L'uso di una funzione lambda consente di salvare alcuni byte su newline, tab e return .

Esempio:

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

Rubino (66-32 = 34)

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

test:

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

Rubino, 55-46 = 9

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

Test:

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

Implementazione

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

Produzione

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

Coffeescript, (57-32 = 25)

implementaion

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??

Non credo che GolfScript abbia molte possibilità su questo!

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);

Codice 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);
    }        
}

PS: Solo per divertimento, funziona anche questo, purtroppo non cambia il numero di personaggi necessari:

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

Prolog (73-32 = 41)

Qui contiamo tutto dopo ': -' come corpo della funzione.

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).

Chiamare la funzione in questo modo:

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

Matlab (44-46 = -2)

Il corpo della funzione è di 44 caratteri:

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

Funzione totale come segue:

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

Test della funzione:

>> 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

Questo potrebbe essere più breve usando un po 'di zipmagia, ma per ora:

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

Per il completamento, si scopre che puoi fare zip magic, ma ti costa di più (di alcuni caratteri), quindi quanto sopra vale, a meno che qualcuno non possa migliorare uno di questi:

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));}}

Leggibile

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))))))

Difficilmente idiomatico, però.

Haskell, 64C - 46 = 18

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

Non troppo difficile da leggere. Esempio di esecuzione:

*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));

Metodo effettivo nel codice 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));
}

Classe di prova

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);

Questo è il migliore che mi viene in mente di essere un principiante. Sono sicuro che ci devono essere anche alcune versioni più brevi.

MODIFICARE:

Una versione ridotta del codice potrebbe essere:

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

Questa versione ha solo 64 caratteri (21 in meno della risposta originale).

Detto questo, 64-32 = 32

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

Tramite l'uso liberale del termine Scrivi una funzione

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)

Implementazione

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))
};

Produzione

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

BaseX è stato usato come processore XQuery.

Erlang: 82 ° C - 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 non è eccezionale per questo. Molte scorciatoie finiscono per essere più personaggi (tuple ecc.)

Le uniche cose degne di nota:

• {lists,sum}è un riferimento di funzione a lists:sume può essere chiamato
• I numeri pari vengono calcolati sottraendo --( sottrai l' elenco ) l'elenco dei numeri dispari dall'elenco completo

Puoi chiamare 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]).

Produzione: 78.49203781276162

Haskell

57 - 32 = 25

Risposta diretta all'ottimizzazione dei crazedgremlins:

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

ottimizzazioni:

• read$showè inferiore a fromIntegral- 3 caratteri
• s=sum\ne due sha una lunghezza totale di 8 caratteri, due sumè solo 6 caratteri. - 2 caratteri
• trasformare il filtro in operatore elimina la necessità di spazi bianchi - 2 caratteri

Ho anche provato ad aggiungere più cose all'operatore, ma alla fine è stato altrettanto lungo:

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