Yeni Modern Zamanlarda , Charlie Chaplin bir bilgisayarla karşılaştığında, işçilerin eşyaları doğru bir şekilde sıralayıp sıralamadıklarını belirlemek için tasnif görevlisi olarak tasnif bahçesinde çalışıyor. Söz konusu eşyalar mermerler paketidir. Tek Sayıda Mermerli Paketler Kırmızı Sepette, Çift Mermerli Paketler Mavi Sepette Yığınlanır.

Charlie Chaplin'in, sıralama prosedüründe herhangi bir anormallik olup olmadığını doğrulayacak programı delmesi gerekiyor . Hemen patronu Mack Swain, kodlaması gereken bir algoritmayı paylaşıyor.

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

İşi Check_Digit'i belirlemek ve Patronunun hesapladığı değerle eşleştirmektir.

Charlie Chaplin öğle saatlerinde Mack Swain'in çekmecesine gizlice girebildi ve çekmecesinin ilk 46 32 sütunda yumruklu tek bir kartı olduğunu belirledi (yani Mack sadece 46 32 karakterli bir program yazabildi ).

Charlie Chaplin'in mümkün olduğunca az satır içeren bir program yazmak için ninja'nın tüm kodunun yardımına ihtiyacı olacaktır. Birisi Patronundan daha kısa bir program bulabilirse, 50 puanlık bir bonus açıklar.

özet

Bir liste / dizi / vektör pozitif sayılar (tek ve çift) verildiğinde, listedeki array(int [])/vector<int>/listtek ve çift sayıların toplamlarının karelerinin toplamının kökünü hesaplayan ve hesaplayan bir işlev yazmanız gerekir .

Programın boyutu, işlev gövdesinin boyutudur, yani işlev imzasının boyutu hariç.

Misal

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

Gerçek çıktının uygulamanın kayan nokta hassasiyetine bağlı olarak değişebileceğini unutmayın .

Puan

Puan olarak hesaplanır Σ(Characters in your Program) - 46. Puan olarak hesaplanır Σ(Characters in your Program) - 32. Topluluktan yapılan düzenli yükselişin yanı sıra, en düşük negatif puan 50 puan ek bonus kazanacaktır.

Düzenle

1. Skoru hesaplamak için kullanılan ofset 46'dan 32'ye değiştirildi. Not, bu durum liderlik kurulu / ödül uygunluğunu etkilemez veya herhangi bir çözümü geçersiz kılmaz.

Karar

Ninjalar arasındaki korkunç bir düellodan sonra, Bay Chaplin bazı harika cevaplar aldı. Maalesef cevapların çok azı kuraldan gereksiz bir şekilde yararlanmaya çalıştı ve çok yararlı olmadı. Aslında adil bir düello istedi ve mantığın fonksiyon imzaları içinde kodlandığı yere cevaplar sonunda fonksiyon imzasının çözümün ayrılmaz bir parçası olduğu anlamına gelecektir. Sonunda, Ninja FireFly açık bir kazanan oldu ve ona hak ettiği bonusu verdi. Büyük Afiş (her gün güncellenir)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ 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&|+//.]

("İşlev gövdesi" olarak parantez içine alınmalı veya bir ada bağlı olmalıdır.)

açıklama

Tobia'nın APL cevaplarında yaptığı gibi her parçanın ne yaptığına dair ayrıntılı bir inceleme yapmaya çalıştım.

               +//. ]    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&| +//. ]))

+/&.:*:yerine iki karakter daha kaydetmek için |@j./OI'nin karmaşık büyüklük numarasından faydalanılabilir.

Misal

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

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

Orijinal versiyon:

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

Tüm fonksiyon tanımı 53 karakter, sadece gövde 48'dir.

Sorun tanımından tam olarak yararlanarak ve hemen hemen her şeyi vücuttan ve imzaya taşıyarak güncellenmiş sürüm:

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

Yeni işlev tanımı artık toplam 63 "zımba" dır, ancak işlev VÜCUT artık sadece BİR BARAJ KARAKTERİ UZUN. Ayrıca artık küresel ad alanını bozmuyor! : D

Kullanımı:

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

İşlev gövdesi 24 karakterden oluşur.

Kullanımı:

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

Ruby 2.1+ - (Toplam 39 karakter - 7 gövde dışı - 32 ofset = 0)

Biraz farklı bir yaklaşım. Bir kompleks sayı oluşturmak a+b*işekilde ave btek ve çift sayı toplamları olan list, sırasıyla. Sonra mutlak değeri alıyorum.

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

5 karakterden daha uzun ama 1.9.3+ sürümünde çalışan önceki çözümüm:

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

Son bir notta, Rails + Ruby 2.1+'ye izin verildiyse Array#sum, vücudu sadece 25 karaktere düşürmek için kullanabiliriz :

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

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

Burada çok yeni bir şey yok, sadece son Pythagoras mücadelesinde gördüğüm karmaşık sayı hilesi, kompaktlık için lambda ve sözdizimi / parantez minimizasyonu:

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

Güncelleme - birkaç karakter kaydedildi. Karmaşık bileşeni 0 / 1'e yükseltmenin hilesi için @DSM'ye teşekkürler.

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

Tamam, soruyu okumak ve 'fonksiyonun gövdesi' sayım kuralını tanımak başka bir 2 karakter daha kaydeder:

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

iPython testi:

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

Örneğin:

      {.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] çift ​​paket, tek paket listelerini üretir.

İç kısım Tr, her ikisi de kare ve sonra toplanan toplamları bulur (dış tarafından Tr).

N irrasyonel bir sayıdan (bir tamsayının kare kökü) ondalık bir yaklaşıma dönüştürür.

Misal

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

78,492

Sayıya f[n_]:=dahil edilmezse , ek bir karakter kaydedilebilir.

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

Misal

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)

@Tomas tarafından önerilen dizileri kullanma. Bu, bazı karakterleri kaydeder, çünkü her bir sayının paritesini hesaplayabilir ve bir dallanma yöntemi olarak parite ile ince ayar yapmak ve doğru değerleri doğru kayıtlara koymak yerine bir dizin olarak kullanabilirsiniz. Ayrıca, dizi / dizin kullanılmasa bile dizilerin size 0 vereceği ortaya çıkar, bu nedenle hiçbir şey başlatmanız gerekmez.

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

Sayıların zaten yığın üzerinde olduğunu varsayar ve sonucu tamamlandığında kalan tek değer olarak bırakır.

Ölçek:

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

Tek ve çift sayıları saklamak için o ve e kayıtlarını kullanan ilk sürüm .

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

Bir lambda işlevi kullanmak satırları, sekmeleri ve return.

Misal:

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

Yakut (66-32 = 34)

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

Ölçek:

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

Yakut, 55-46 = 9

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

Ölçek:

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

uygulama

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

Çıktı

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

Kahve, (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??

GolfScript'in bu konuda çok şansı olduğunu sanmıyorum!

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

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

Not: Sadece eğlence için, bu da işe yarıyor, ne yazık ki gerekli karakter sayısını değiştirmiyor:

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

Prolog (73-32 = 41)

Burada fonksiyon gövdesi olarak ': -' işaretinden sonra her şeyi sayıyoruz.

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

Çağrı fonksiyonu şöyle:

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

Matlab (44-46 = -2)

İşlev gövdesi 44 karakterdir:

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

Toplam fonksiyon aşağıdaki gibidir:

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

Fonksiyon testleri:

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

Bu biraz zipsihir kullanarak daha kısa olabilir , ama şimdilik:

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

Tamamlanması için, zip sihri yapabileceğiniz ortaya çıkıyor, ancak size daha fazla (birkaç karakterle) mal oluyor, bu nedenle, biri bunlardan birini geliştiremediği sürece, yukarıda duruyor:

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

Okunabilir

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

Yine de pek deyimsiz.

Haskell, 64C - 46 = 18

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

Okumak çok zor değil. Örnek çalışma:

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

Java kodunda gerçek yöntem

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

Test Sınıfı

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

Bu bir acemi olmak için geldim en iyisidir. Eminim daha kısa versiyonlar da olmalı.

DÜZENLE:

Kodun indirgenmiş bir sürümü olabilir:

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

Bu sürümde yalnızca 64 (orijinal yanıttan 21 daha az) karakter vardır.

Söyledi, 64-32 = 32

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

Terimin liberal kullanımı yoluyla Bir fonksiyon yazın

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)

uygulama

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

Çıktı

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

BaseX , XQuery işlemci olarak kullanıldı.

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 bunun için iyi değil. Çoğu kısayol daha fazla karakter (tuples vb.) Olur

Dikkat edilmesi gereken tek şey:

• {lists,sum}bir işlev referansıdır lists:sumve çağrılabilir
• Çift sayılar , tek sayılar listesinin tam listeden çıkarılmasıyla --( liste çıkarılması ) hesaplanır.

Şunu kullanarak arayabilir:

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

Çıktı: 78.49203781276162

Haskell

57-32 = 25

Crazedgremlins cevabının düz optimizasyonu:

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

optimizasyonları:

• read$showdaha kısa fromIntegral- 3 karakter
• s=sum\nve ikisinin stoplam uzunluğu 8 karakter, iki sumtanesi sadece 6 karakterdir. - 2 karakter
• filtreyi operatöre yapmak boşluk ihtiyacını ortadan kaldırır - 2 karakter

Ayrıca operatöre daha fazla şey eklemeyi denedim, ancak bu kadar uzun oldu:

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