W New Modern Times , kiedy Charlie Chaplin napotyka komputer, jest on zatrudniony w stoczni sortowania, jako osoba zatwierdzająca, aby ustalić, czy pracownicy prawidłowo sortują przedmioty. Przedmiotowe przedmioty to paczki kulek. Paczki z nieparzystą liczbą kulek są układane w Czerwonym Koszu, a paczki z parzystą liczbą Kul są układane w Niebieskim Koszu.

Charlie Chaplin ma przebić program , który sprawdziłby, czy w procedurze sortowania występuje jakakolwiek anomalia. Mack Swain, jego bezpośredni szef, dzieli algorytm, który musi kodować.

Algorytm

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

Jego zadaniem jest określenie Check_Digit i dopasowanie go do wartości, jaką kiedykolwiek oblicza jego Szef.

Charlie Chaplin podczas lunchu był w stanie przekraść się do szuflady Macka Swaina i ustalić, że jego szuflada ma pojedynczą kartę ze stemplami w pierwszych 46 32 kolumnach (co oznacza, że ​​Mack był w stanie napisać program zawierający tylko 46 32 znaki).

Charlie Chaplin potrzebowałby teraz pomocy wszystkich ninja-kodów, aby napisać program z jak najmniejszą liczbą wierszy. Ogłasza także bonus 50 punktów, jeśli ktoś może wymyślić program krótszy niż jego Szef.

streszczenie

Biorąc pod uwagę listę / tablicę / wektor liczb dodatnich (nieparzyste i parzyste), musisz napisać funkcję, która akceptuje array(int [])/vector<int>/listi oblicza pierwiastek z sumy kwadratów sum liczb nieparzystych i parzystych na liście.

Rozmiar programu to rozmiar treści funkcji, tzn. Z wyłączeniem rozmiaru podpisu funkcji.

Przykład

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

Uwaga: rzeczywista wydajność może się różnić w zależności od precyzji zmiennoprzecinkowej implementacji.

Wynik

Wynik obliczany jest jako Σ(Characters in your Program) - 46. Wynik obliczany jest jako Σ(Characters in your Program) - 32. Oprócz regularnego głosowania społeczności, najniższy wynik ujemny otrzymałby dodatkowy bonus 50 punktów.

Edytować

1. Przesunięcie użyte do obliczenia wyniku zostało zmienione z 46 na 32. Uwaga, nie wpłynie to na kwalifikację do tabeli liderów / nagrody lub nie unieważni żadnego rozwiązania.

Werdykt

Po makabrycznym pojedynku pomiędzy Ninja, pan Chaplin otrzymał wspaniałe odpowiedzi. Niestety niewiele odpowiedzi próbowało w niewłaściwy sposób wykorzystać tę zasadę i nie było zbyt przydatne. Naprawdę chciał uczciwego pojedynku, a odpowiedzi, w których logika została zakodowana w podpisach funkcji, oznaczałyby, że podpis funkcji jest integralną częścią rozwiązania. Wreszcie, Ninja FireFly był wyraźnym zwycięzcą i przyznał mu premię, na którą zasługuje. Tabela liderów (aktualizowana codziennie)

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

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

(Jako „ciało funkcyjne”; musi być umieszczone w nawiasach lub powiązane z nazwą).

Wyjaśnienie

Próbowałem zrobić rozłożony pogląd na to, co robi każdy kawałek, tak jak Tobia w odpowiedziach 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&| +//. ]))

+/&.:*:można go zastąpić złożoną sztuczką wielkości|@j./ OI, aby uratować kolejne dwa znaki.

Przykład

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

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

Orginalna wersja:

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

Definicja całej funkcji wynosi 53 znaki, a sama treść to 48.

Zaktualizowana wersja, w pełni wykorzystująca definicję problemu i przenosząca prawie wszystko z ciała do podpisu:

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

Nowa definicja funkcji ma teraz łącznie 63 „ciosów”, ale funkcja BODY jest teraz JEDNA ZNAKÓW O CHARAKTERZE. Ponadto nie powoduje już uszkodzenia globalnej przestrzeni nazw! :RE

Stosowanie:

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

Ciało funkcji składa się z 24 znaków.

Stosowanie:

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

Ruby 2.1+ - (39 znaków łącznie - 7 bez treści - 32 przesunięcie = 0)

Nieco inne podejście. Tworzę liczbę zespoloną a+b*itakie, że ai bsą sumami parzystych i nieparzystych numerów w list, odpowiednio. Potem biorę tylko wartość bezwzględną.

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

Moje poprzednie rozwiązanie, które ma 5 znaków dłużej, ale działa na wersji 1.9.3+:

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

Ostatecznie, jeśli dozwolone są Rails + Ruby 2.1+, możemy użyć skrótu Array#sumdo zaledwie 25 znaków:

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

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

Nie ma tu nic nowego, tylko kombinacja sztuczki z liczbą złożoną, którą widziałem w ostatnim wyzwaniu Pitagorasa, lambda dla zwięzłości oraz minimalizacja składni / nawiasów:

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

Aktualizacja - zapisano kilka znaków. Dzięki @DSM za sztuczkę podniesienia złożonego komponentu do 0/1.

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

Ok, przeczytanie pytania i rozpoznanie reguły liczenia „treści funkcji” zapisuje kolejne 2 znaki:

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

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

na przykład:

      {.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] tworzy listy parzyste i nieparzyste.

Wewnętrzne Trznajduje sumy, z których oba są podniesione do kwadratu, a następnie zsumowane (przez zewnętrzną Tr).

N konwertuje z liczby niewymiernej (pierwiastek kwadratowy z liczby całkowitej) na przybliżenie dziesiętne.

Przykład

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

78,492

Jeśli f[n_]:=nie zostanie uwzględniony w liczeniu, można zapisać dodatkową postać.

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

Przykład

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)

Używanie tablic, jak sugeruje @Tomas. Oszczędza to niektóre znaki, ponieważ mogę obliczyć parzystość każdej liczby i użyć jej jako indeksu, zamiast dostrajania parzystości jako metody rozgałęziania i umieszczania właściwych wartości we właściwych rejestrach. Okazuje się również, że tablice dadzą ci 0, nawet jeśli tablica / indeks nie był używany, więc nie musisz niczego inicjować.

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

Zakłada, że ​​liczby są już na stosie, i pozostawia wynik jako jedyną wartość pozostałą po zakończeniu.

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)

Pierwsza wersja użyciu rejestrów o i e do przechowywania liczb parzystych i nieparzystych.

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

Użycie funkcji lambda oszczędza niektóre bajty na znakach nowej linii, tabulatorach i return.

Przykład:

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

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

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

Realizacja

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

Wynik

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

Coffeescript, (57 - 32 = 25)

Realizacja

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

Nie sądzę, że GolfScript ma na to dużą szansę!

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

Pełny kod:

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: Dla zabawy to też działa, niestety nie zmienia liczby potrzebnych znaków:

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

Prolog (73 - 32 = 41)

Tutaj liczymy wszystko po „: -” jako ciało funkcji.

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

Funkcja wywołania:

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

Matlab (44–46 = -2)

Treść funkcji ma 44 znaki:

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

Całkowita funkcja w następujący sposób:

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

Testy funkcji:

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

Może być krótszy przy użyciu zipmagii, ale na razie:

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

Na zakończenie okazuje się, że możesz wykonać magię zip, ale kosztuje cię to więcej (o kilka postaci), więc powyższe stoi, chyba że ktoś może poprawić jeden z tych:

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

Czytelny

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

Jednak mało idiomatyczne.

Haskell, 64 ° C - 46 = 18

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

Nie za trudne do odczytania. Przykładowy przebieg:

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

Rzeczywista metoda w kodzie 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));
}

Klasa testowa

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

To najlepsze, jakie kiedykolwiek wymyśliłem jako początkujący. Jestem pewien, że muszą być też krótsze wersje.

EDYTOWAĆ:

Zredukowana wersja kodu może być:

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

Ta wersja ma tylko 64 (21 mniej niż oryginalna odpowiedź) znaków.

Tak powiedział 64-32 = 32

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

Poprzez swobodne użycie terminu Napisz funkcję

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)

Realizacja

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

Wynik

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

BaseX został użyty jako procesor 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 nie nadaje się do tego. Większość skrótów to więcej znaków (krotek itp.)

Jedyne prawdziwe rzeczy warte odnotowania:

• {lists,sum}jest odwołaniem do funkcji lists:sumi można go wywoływać
• Liczby parzyste są obliczane przez odjęcie --( odjęcie listy ) listy liczb nieparzystych od pełnej listy

Może dzwonić za pomocą:

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

Wynik: 78.49203781276162

Haskell

57 - 32 = 25

Prosta optymalizacja crazedgremlins odpowiedź:

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

Optymalizacje:

• read$showjest krótszy niż fromIntegral- 3 znaki
• s=sum\na dwa smają całkowitą długość 8 znaków, dwa sumto tylko 6 znaków. - 2 znaki
• przekształcenie filtru w operatora eliminuje potrzebę spacji - 2 znaki

Próbowałem też dodać więcej elementów do operatora, ale ostatecznie skończyło się to tak długo:

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