Dans les temps modernes , lorsque Charlie Chaplin rencontre un ordinateur, il est employé dans la cour de tri, comme validateur pour déterminer si les travailleurs trient correctement les articles. Les articles en question sont des paquets de billes. Les paquets avec un nombre impair de billes sont empilés dans le panier rouge et les paquets avec un nombre pair de billes sont empilés dans le panier bleu.

Charlie Chaplin est censé frapper le programme qui validerait s'il y a une anomalie dans la procédure de tri. Mack Swain, son patron immédiat, partage un algorithme dont il a besoin pour coder.

Algorithme

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

Son travail consiste à déterminer le Check_Digit et à le faire correspondre avec la valeur jamais calculée par son patron.

Charlie Chaplin pendant ses heures de déjeuner, a pu se faufiler dans le tiroir de Mack Swain et déterminer que son tiroir avait une seule carte avec des poinçons sur les 46 32 premières colonnes (ce qui signifie que Mack était capable d'écrire un programme avec seulement 46 32 caractères).

Charlie Chaplin aurait maintenant besoin de l'aide de tous les ninjas de code pour écrire un programme avec le moins de lignes possible. Il annonce également un bonus de 50 points, si quelqu'un peut proposer un programme plus court que son Boss.

Sommaire

Étant donné une liste / un tableau / un vecteur de nombres positifs (pairs et impairs), vous devez écrire une fonction, qui accepterait la array(int [])/vector<int>/listet calculerait la racine de la somme des carrés des sommes des nombres pairs et impairs dans la liste.

La taille du programme est la taille du corps de la fonction, c'est-à-dire à l'exclusion de la taille de la signature de fonction.

Exemple

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

Remarque , la sortie réelle peut varier en fonction de la précision en virgule flottante de l'implémentation.

But

Le score est calculé comme Σ(Characters in your Program) - 46. Le score est calculé comme Σ(Characters in your Program) - 32. Outre le vote régulier de la communauté, le score négatif le plus bas recevrait un bonus supplémentaire de 50 points.

Éditer

1. Le décalage qui a été utilisé pour calculer le score est passé de 46 à 32. Notez que cela n'affecterait pas l'éligibilité au classement / prime ou invaliderait toute solution.

Verdict

Après un duel horrible entre les Ninjas, M. Chaplin a reçu de merveilleuses réponses. Malheureusement, peu de réponses ont tenté de profiter indûment de la règle et n'ont pas été très utiles. Il voulait en fait un duel équitable et des réponses où la logique était codée dans les signatures de fonction signifierait finalement que la signature de fonction fait partie intégrante de la solution. Enfin, Ninja FireFly a été le vainqueur clair et lui a attribué le bonus qu'il mérite bien. Classement (mis à jour quotidiennement)

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

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

(En tant que "corps de fonction"; doit être entre parenthèses ou lié à un nom.)

Explication

J'ai essayé de faire une vue éclatée de ce que fait chaque pièce, comme Tobia le fait dans les réponses 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&| +//. ]))

+/&.:*: pourrait être remplacé par |@j./ utilisation de l' astuce de magnitude complexe d'OI pour enregistrer encore deux autres caractères.

Exemple

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

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

Version originale:

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

La définition de la fonction entière est de 53 caractères, le corps seulement est de 48.

Version mise à jour, tirant pleinement parti de la définition du problème et déplaçant pratiquement tout hors du corps et dans la signature:

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

La nouvelle définition de la fonction est désormais de 63 "coups de poing" au total, mais le CORPS de la fonction est désormais d'un seul caractère de barrage.De plus, il ne corrompt plus l'espace de noms global! :RÉ

Usage:

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

Le corps de la fonction se compose de 24 caractères.

Usage:

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

Ruby 2.1+ - (39 caractères au total - 7 non-corps - 32 offset = 0)

Approche légèrement différente. Je crée un nombre complexe a+b*itel que aet bsont les sommes des nombres pairs et impairs list, respectivement. Ensuite, je prends juste la valeur absolue.

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

Ma solution précédente, qui est de 5 caractères de plus mais fonctionne sur 1.9.3+:

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

Sur une note finale, si Rails + Ruby 2.1+ était autorisé, nous pouvons utiliser Array#sumpour réduire le corps à seulement 25 caractères:

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

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

Rien de très nouveau ici, juste une combinaison de l'astuce complexe que j'ai vue dans le récent défi Pythagore, lambda pour la compacité et la minimisation de la syntaxe / parenthèse:

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

Mise à jour - enregistré quelques caractères. Merci à @DSM pour l'astuce de porter le composant complexe à 0/1.

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

Ok, la lecture de la question et la reconnaissance de la règle de comptage du 'corps de la fonction' économisent encore 2 caractères:

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

Tests 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|⍵}

par exemple:

      {.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] produit les listes de paquets pairs et de paquets impairs.

L'intérieur Trtrouve les totaux, qui sont tous les deux au carré, puis additionnés (par l'extérieur Tr).

N convertit d'un nombre irrationnel (la racine carrée d'un entier) en une approximation décimale.

Exemple

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

78,492

Si f[n_]:=n'est pas inclus dans le décompte, un caractère supplémentaire peut être enregistré.

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

Exemple

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)

Utilisation de tableaux, comme suggéré par @Tomas. Cela permet d'économiser certains caractères car je peux calculer la parité de chaque nombre et l'utiliser comme index, au lieu de modifier la parité avec comme méthode de branchement et de mettre les bonnes valeurs dans les bons registres. Il s'avère également que les tableaux vous donneront un 0 même si le tableau / index n'a pas été utilisé, vous n'avez donc rien à initialiser.

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

Suppose que les nombres sont déjà sur la pile et laisse le résultat comme la seule valeur qui reste quand c'est fait.

Tester:

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

Première version utilisant les registres o et e pour stocker les nombres pairs et impairs.

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'utilisation d'une fonction lambda enregistre quelques octets sur les sauts de ligne, les onglets et return .

Exemple:

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

Rubis (66 - 32 = 34)

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

tester:

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

Rubis, 55 - 46 = 9

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

Tester:

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

la mise en oeuvre

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

Production

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

Coffeescript, (57 - 32 = 25)

Implémentation

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

Je ne pense pas que GolfScript ait beaucoup de chance sur celui-ci!

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

Code complet:

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: Juste pour le plaisir, cela fonctionne aussi, malheureusement cela ne change pas le nombre de caractères nécessaires:

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

Prolog (73 - 32 = 41)

Ici, nous comptons tout après «: -» comme corps de fonction.

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

Fonction d'appel comme ceci:

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

Matlab (44 - 46 = -2)

Le corps de la fonction comprend 44 caractères:

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

Fonction totale comme suit:

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

Tests de la fonction:

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

Cela pourrait être plus court en utilisant de la zipmagie, mais pour l'instant:

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

Pour terminer, il s'avère que vous pouvez faire de la magie zip, mais cela vous coûte plus cher (de quelques caractères), donc ce qui précède est valable, à moins que quelqu'un ne puisse améliorer l'un ou l'autre:

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

Lisible

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

À peine idiomatique, cependant.

Haskell, 64C - 46 = 18

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

Pas trop difficile à lire. Exemple d'exécution:

*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éthode réelle dans le code 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 de test

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

C'est le meilleur que je pourrais être un débutant. Je suis sûr qu'il doit également y avoir des versions plus courtes.

ÉDITER:

Une version réduite du code pourrait être:

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

Cette version n'a que 64 caractères (21 de moins que la réponse d'origine).

Dit ainsi, 64-32 = 32

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

Via une utilisation libérale du terme Écrire une fonction

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)

la mise en oeuvre

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

Production

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

BaseX a été utilisé comme processeur 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 n'est pas génial pour ça. La plupart des raccourcis finissent par être plus de caractères (tuples, etc.)

Les seules vraies choses à noter:

• {lists,sum}est une référence de fonction lists:sumet peut être appelée
• Les nombres pairs sont calculés en soustrayant --( soustraire la liste ) la liste des nombres impairs de la liste complète

Peut appeler en utilisant:

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

Production: 78.49203781276162

Haskell

57 - 32 = 25

Optimisation directe des crazedgremlins réponse:

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

Optimisations:

• read$showest plus court que fromIntegral- 3 caractères
• s=sum\net deux sa une longueur totale de 8 caractères, deux sumn'est que de 6 caractères. - 2 caractères
• rendre le filtre en opérateur supprime le besoin d'espace blanc - 2 caractères

J'ai également essayé d'ajouter plus de choses à l'opérateur, mais cela a fini par être aussi long:

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