Di New Modern Times , ketika Charlie Chaplin menemukan komputer, ia dipekerjakan di Yard pemilahan, sebagai validator untuk menentukan apakah para pekerja menyortir barang dengan benar. Item yang dimaksud adalah paket kelereng. Paket dengan jumlah Ganjil Kelereng ditumpuk di Keranjang Merah dan Paket dengan Ganjil Jumlah Kelereng ditumpuk di Keranjang Biru.

Charlie Chaplin seharusnya membuat program yang akan memvalidasi jika ada anomali dalam prosedur penyortiran. Mack Swain, bos langsungnya, membagikan algoritma yang dia perlu kode.

Algoritma

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

Tugasnya adalah menentukan Check_Digit dan mencocokkannya dengan nilai apa pun yang diperhitungkan bosnya.

Charlie Chaplin selama jam makan siangnya, dapat menyelinap ke laci Mack Swain dan menentukan, bahwa laci itu memiliki kartu tunggal dengan pukulan pada 46 32 kolom pertama (yang berarti Mack mampu menulis sebuah program dengan hanya 46 32 karakter).

Charlie Chaplin sekarang membutuhkan bantuan semua ninja kode untuk menulis sebuah program dengan sesedikit mungkin baris. Dia juga mengumumkan bonus 50 poin, jika seseorang dapat membuat program yang lebih pendek dari bosnya.

Ringkasan

Diberikan daftar / larik / vektor angka positif (ganjil dan genap), Anda perlu menulis fungsi, yang akan menerima array(int [])/vector<int>/listdan menghitung akar dari jumlah kuadrat dari jumlah ganjil dan genap dalam daftar.

Ukuran program adalah ukuran tubuh fungsi, yaitu tidak termasuk ukuran tanda tangan fungsi.

Contoh

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

Catatan , output aktual mungkin bervariasi berdasarkan presisi floating point implementasi.

Skor

Skor dihitung sebagai Σ(Characters in your Program) - 46. Skor dihitung sebagai Σ(Characters in your Program) - 32. Terlepas dari upvoting reguler dari komunitas, skor negatif terendah akan menerima bonus tambahan 50 poin.

Edit

1. Offset yang digunakan untuk menghitung Skor telah diubah dari 46 menjadi 32. Catatan, ini tidak akan memengaruhi kelayakan dewan pimpinan / karunia atau membatalkan solusi apa pun.

Putusan

Setelah duel mengerikan antara para Ninja, Tuan Chaplin menerima beberapa jawaban indah. Sayangnya beberapa jawaban mencoba mengambil keuntungan dari aturan yang tidak semestinya dan tidak terlalu berguna. Dia benar-benar menginginkan duel yang adil dan jawaban di mana logika dikodekan dalam tanda tangan fungsi pada akhirnya akan berarti tanda tangan fungsi adalah bagian integral dari solusi. Akhirnya, Ninja FireFly adalah pemenang yang jelas dan memberinya bonus yang layak diterimanya. Papan (diperbarui setiap hari)

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

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

(Sebagai "badan fungsi"; harus di kurung atau diikat ke nama.)

Penjelasan

Saya mencoba membuat pandangan yang meledak tentang apa yang masing-masing bagian lakukan, seperti Tobia lakukan dalam jawaban 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&| +//. ]))

+/&.:*:dapat diganti dengan |@j./memanfaatkan trik magnitudo kompleks OI untuk menyimpan dua karakter lainnya.

Contoh

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

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

Versi asli:

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

Definisi fungsi keseluruhan adalah 53 karakter, hanya tubuh 48.

Versi terbaru, memanfaatkan sepenuhnya definisi masalah dan memindahkan hampir semuanya keluar dari tubuh dan masuk ke tanda tangan:

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

Definisi fungsi baru sekarang total 63 "pukulan", tetapi fungsi BODY sekarang hanya SATU KARAKTER DAMN PANJANG. Plus itu tidak lagi merusak namespace global! : D

Pemakaian:

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

Badan fungsi terdiri dari 24 karakter.

Pemakaian:

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

Ruby 2.1+ - (total 39 karakter - 7 non-tubuh - 32 offset = 0)

Pendekatan yang sedikit berbeda. Saya membuat sejumlah kompleks a+b*isehingga adan badalah jumlah dari genap dan ganjil angka dalam listmasing-masing. Maka saya hanya mengambil nilai absolut.

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

Solusi saya sebelumnya, yang lebih panjang 5 karakter tetapi berfungsi pada 1.9.3+:

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

Pada catatan akhir, jika Rails + Ruby 2.1+ diizinkan, kita dapat menggunakan Array#sumuntuk mendapatkan tubuh hingga 25 karakter:

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

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

Tidak ada yang sangat baru di sini, hanya kombinasi trik bilangan kompleks yang saya lihat dalam tantangan Pythagoras baru-baru ini, lambda untuk kekompakan, dan minimisasi sintaksis / kurung:

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

Perbarui - menyimpan beberapa karakter. Terima kasih kepada @DSM untuk trik menaikkan komponen kompleks ke 0/1.

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

Oke, membaca pertanyaan dan mengenali aturan hitungan 'tubuh fungsi' menyimpan 2 karakter lain:

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

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

misalnya:

      {.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] menghasilkan daftar-paket, daftar-paket ganjil.

Bagian dalam Trmenemukan total, keduanya kuadrat dan kemudian dijumlahkan (oleh bagian luar Tr).

N mengkonversi dari bilangan irasional (akar kuadrat dari bilangan bulat) ke pendekatan desimal.

Contoh

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

78.492

Jika f[n_]:=tidak termasuk dalam hitungan, karakter tambahan dapat disimpan.

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

Contoh

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)

Menggunakan array, seperti yang disarankan oleh @Tomas. Ini menyimpan beberapa karakter karena saya dapat menghitung paritas dari setiap angka dan menggunakannya sebagai indeks, daripada mengubah paritas dengan sebagai metode percabangan dan menempatkan nilai yang tepat di register yang tepat. Juga ternyata array akan memberi Anda 0 bahkan jika array / indeks belum digunakan, jadi Anda tidak perlu menginisialisasi apa pun.

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

Mengasumsikan angka sudah ada di tumpukan, dan meninggalkan hasilnya sebagai satu-satunya nilai yang tersisa ketika selesai.

Uji:

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

Versi pertama menggunakan register o dan e untuk menyimpan angka ganjil dan genap.

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

Menggunakan fungsi lambda menyimpan beberapa byte pada baris baru, tab, dan return .

Contoh:

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

Ruby (66 - 32 = 34)

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

uji:

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

Ruby, 55 - 46 = 9

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

Uji:

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

Penerapan

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

Keluaran

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

Naskah, (57 - 32 = 25)

Implementasi

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

Saya tidak berpikir GolfScript memiliki banyak peluang untuk yang satu ini!

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

Kode lengkap:

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: Hanya untuk bersenang-senang, ini juga berfungsi, sayangnya itu tidak mengubah jumlah karakter yang dibutuhkan:

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

Prolog (73 - 32 = 41)

Di sini kita menghitung semuanya setelah ': -' sebagai fungsi tubuh.

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

Panggil fungsi seperti ini:

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

Matlab (44 - 46 = -2)

Function body adalah 44 karakter:

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

Total fungsi sebagai berikut:

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

Tes fungsi:

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

Ini bisa lebih pendek menggunakan beberapa zipsihir, tetapi untuk saat ini:

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

Untuk penyelesaiannya, ternyata Anda dapat melakukan zip magic, tetapi harganya lebih mahal (oleh beberapa karakter), jadi berdiri di atas, kecuali seseorang dapat memperbaiki salah satu dari ini:

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

Dapat dibaca

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

Namun, hampir tidak idiomatis.

Haskell, 64C - 46 = 18

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

Tidak terlalu sulit dibaca. Contoh dijalankan:

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

Metode aktual dalam kode 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));
}

Kelas Tes

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

Ini adalah yang terbaik aku akan muncul menjadi seorang pemula. Saya yakin pasti ada beberapa versi yang lebih pendek.

EDIT:

Versi kode yang dikurangi dapat berupa:

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

Versi ini hanya memiliki 64 (21 kurang dari jawaban asli) karakter.

Dikatakan demikian, 64-32 = 32

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

Melalui penggunaan liberal istilah Tulis fungsi

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)

Penerapan

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

Keluaran

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

BaseX digunakan sebagai prosesor 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 tidak bagus untuk ini. Kebanyakan pintasan akhirnya menjadi lebih banyak karakter (tuple dll.)

Satu-satunya hal nyata yang perlu diperhatikan:

• {lists,sum} adalah referensi fungsi untuk lists:sum dan dapat dipanggil
• Angka genap dihitung dengan mengurangi --( mengurangi daftar ) daftar angka ganjil dari daftar lengkap

Dapat menelepon menggunakan:

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

Keluaran: 78.49203781276162

Haskell

57 - 32 = 25

Pengoptimalan langsung jawaban crazedgremlins:

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

Optimasi:

• read$showlebih pendek dari fromIntegral- 3 karakter
• s=sum\ndan dua smemiliki total panjang 8 karakter, dua sumhanya 6 karakter. - 2 karakter
• membuat filter menjadi operator tidak perlu spasi - 2 karakter

Saya juga mencoba menambahkan lebih banyak barang ke operator, tetapi akhirnya menjadi sama panjangnya:

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