No New Modern Times , quando Charlie Chaplin encontra um computador, ele é empregado no pátio de classificação, como um validador para determinar se os trabalhadores estão classificando corretamente os itens. Os itens em questão são pacotes de bolinhas de gude. Pacotes com número ímpar de bolinhas de gude são empilhados na cesta vermelha e pacotes com número par de bolinhas de gude são empilhados na cesta azul.

Charlie Chaplin deveria perfurar o programa que seria validado se houver alguma anomalia no processo de classificação. Mack Swain, seu chefe imediato, compartilha um algoritmo que ele precisa 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²)

Seu trabalho é determinar o Check_Digit e combiná-lo com o valor que seu chefe calcular.

Charlie Chaplin, durante o horário de almoço, conseguiu esgueirar-se para a gaveta de Mack Swain e determinar que sua gaveta tem um único cartão com socos nas primeiras 46 32 colunas (o que significa que Mack foi capaz de escrever um programa com apenas 46 32 caracteres).

Agora, Charlie Chaplin precisaria da ajuda de todos os ninjas de código para escrever um programa com o menor número possível de linhas. Ele também anuncia um bônus de 50 pontos, se alguém puder criar um programa mais curto que o seu chefe.

Sumário

Dada uma lista / matriz / vetor de números positivos (ímpar e par), você precisa escrever uma função que aceite array(int [])/vector<int>/liste calcule a raiz da soma dos quadrados das somas de números pares e ímpares na lista.

O tamanho do programa é o tamanho do corpo da função, ou seja, excluindo o tamanho da assinatura da função.

Exemplo

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

Observe que a saída real pode variar com base na precisão do ponto flutuante da implementação.

Ponto

A pontuação é calculada como Σ(Characters in your Program) - 46. A pontuação é calculada como Σ(Characters in your Program) - 32. Além da votação regular da comunidade, a menor pontuação negativa receberia um bônus adicional de 50 pontos.

Editar

1. O deslocamento usado para calcular a pontuação foi alterado de 46 para 32. Observe que isso não afetaria a elegibilidade do quadro de líderes / recompensa ou invalidaria qualquer solução.

Veredito

Após um terrível duelo entre os Ninjas, o Sr. Chaplin recebeu algumas respostas maravilhosas. Infelizmente, algumas das respostas tentaram tirar vantagem indevida da regra e não foram muito úteis. Na verdade, ele queria um duelo justo e respostas em que a lógica fosse codificada nas assinaturas de funções acabariam significando que a assinatura da função é parte integrante da solução. Finalmente, Ninja FireFly foi o vencedor e concedeu a ele o bônus que ele merece. Classificação (atualizada todos os dias)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ 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 um "corpo da função"; deve estar entre parênteses ou vinculado a um nome.)

Explicação

Tentei fazer uma visão detalhada do que cada peça faz, como Tobia faz nas respostas da 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&| +//. ]))

+/&.:*:poderia ser substituído pelo |@j./recurso ao complexo truque de magnitude da OI para salvar mais dois caracteres.

Exemplo

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

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

Versão original:

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

A definição da função inteira tem 53 caracteres, o corpo apenas 48.

Versão atualizada, aproveitando ao máximo a definição do problema e movendo praticamente tudo do corpo para a assinatura:

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

A nova definição de função agora é de 63 "socos" total, mas a função BODY agora tem apenas UM DAMN CHARACTER LONG. Além disso, ele não corrompe mais o espaço para nome global! : 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  

O corpo da função consiste em 24 caracteres.

Uso:

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

Ruby 2.1 ou superior - (total de 39 caracteres - 7 não corporais - 32 deslocamento = 0)

Abordagem ligeiramente diferente. Crio um número complexo a+b*ital que ae bsão as somas dos números pares e ímpares list, respectivamente. Então eu apenas pego o valor absoluto.

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

Minha solução anterior, que tem 5 caracteres, mas funciona em 1.9.3+:

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

Em uma nota final, se o Rails + Ruby 2.1+ fosse permitido, podemos usar Array#sumpara reduzir o corpo a meros 25 caracteres:

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

Python 2.7: 45, não: 40, não: 38 - 32 = 6

Nada muito novo aqui, apenas uma combinação do truque de número complexo que vi no recente desafio de Pitágoras, lambda por compacidade e minimização de sintaxe / parênteses:

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

Atualizar - salvou alguns caracteres. Obrigado a @DSM pelo truque de aumentar o componente complexo para 0/1.

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

Ok, ler a pergunta e reconhecer a regra de contagem do 'corpo da função' salva outros 2 caracteres:

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

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

por exemplo:

      {.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] produz as listas de pacotes pares e pacotes ímpares.

O interior Trencontra os totais, ambos ao quadrado e depois somados (pelo exterior Tr).

N converte de um número irracional (a raiz quadrada de um número inteiro) em uma aproximação decimal.

Exemplo

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

78,492

Se f[n_]:=não estiver incluído na contagem, um caractere adicional poderá ser salvo.

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

Exemplo

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 matrizes, conforme sugerido por @Tomas. Isso economiza alguns caracteres, porque eu posso calcular a paridade de cada número e usá-la como um índice, em vez de ajustar a paridade com como um método de ramificação e colocar os valores certos nos registros corretos. Também acontece que as matrizes fornecerão um 0 mesmo que a matriz / índice não tenha sido usado, para que você não precise inicializar nada.

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

Assume que os números já estão na pilha e deixa o resultado como o único valor restante quando terminar.

Teste:

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

Primeira versão usando os registradores o e e para armazenar números pares e ímpares.

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

Usar uma função lambda economiza alguns bytes em novas linhas, guias e return.

Exemplo:

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

Rubi (66 - 32 = 34)

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

teste:

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

Rubi, 55 - 46 = 9

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

Teste:

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

Implementação

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

Resultado

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

Coffeescript, (57 - 32 = 25)

Implementação

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

Eu não acho que o GolfScript tenha muita chance neste!

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

PS: Apenas por diversão, isso funciona também, infelizmente não altera o número de caracteres necessários:

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

Prolog (73 - 32 = 41)

Aqui contamos tudo depois de ': -' como o corpo da função.

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

Função de chamada assim:

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

Matlab (44 - 46 = -2)

O corpo da função possui 44 caracteres:

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

Função total da seguinte maneira:

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

Testes da função:

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

Isso pode ser mais curto usando um pouco de zipmágica, mas por enquanto:

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

Para concluir, você pode fazer zip zip, mas custa mais (por alguns caracteres); portanto, o acima exposto permanece, a menos que alguém possa melhorar um destes:

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

Legível

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

Dificilmente idiomático, no entanto.

Haskell, 64C - 46 = 18

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

Não é muito difícil de ler. Exemplo de execução:

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

Classe de teste

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

Este é o melhor que eu venho sendo um novato. Tenho certeza de que também deve haver versões mais curtas.

EDITAR:

Uma versão reduzida do código pode ser:

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

Esta versão possui apenas 64 caracteres (21 menos que a resposta original).

Dito isso, 64-32 = 32

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

Via uso liberal do termo Write a function

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)

Implementação

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

Resultado

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

O BaseX foi usado como processador XQuery.

Comprimento: 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ão é bom para isso. A maioria dos atalhos acaba sendo mais caracteres (tuplas etc.)

As únicas coisas reais de nota:

• {lists,sum}é uma referência de função lists:sume pode ser chamada
• Os números pares são calculados subtraindo --( subtraia a lista ) a lista de números ímpares da lista completa

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

Resultado: 78.49203781276162

Haskell

57 - 32 = 25

A otimização direta de crazedgremlins responde:

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

Otimizações:

• read$showé menor que fromIntegral- 3 caracteres
• s=sum\ne dois stêm comprimento total de 8 caracteres, dois sumsão apenas 6 caracteres. - 2 caracteres
• transformar o filtro em operador acaba com a necessidade de espaço em branco - 2 caracteres

Também tentei adicionar mais coisas ao operador, mas acabou sendo o mesmo tempo:

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