New Modern Timesでは、チャーリーチャップリンがコンピューターに遭遇すると、作業員がアイテムを正しく並べ替えているかどうかを確認するための検証者として、並べ替えヤードで雇用されています。問題のアイテムはビー玉のパケットです。奇数のビー玉を持つパケットは赤いバスケットに積み上げられ、偶数のビー玉を持つパケットは青いバスケットに積み上げられます。

チャーリー・チャップリンは、ソート手順に異常があるかどうかを検証するプログラムをパンチすることになっています。マック・スウェインは彼の直属の上司であり、彼がコーディングする必要があるアルゴリズムを共有しています。

アルゴリズム

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

彼の仕事は、Check_Digitを決定し、上司が計算した値と照合することです。

チャーリーチャップリンは昼食時にマックスウェインの引き出しに忍び込み、彼の引き出しには最初の46 32列にパンチのある1枚のカードがあると判断できました（つまり、マックは46 32文字しかプログラムを書くことができませんでした）。

チャーリーチャップリンは、できる限り少ない行でプログラムを作成するために、すべてのコード忍者の助けが必要になります。彼はまた、誰かが自分のボスよりも短いプログラムを思い付くことができる場合、50ポイントのボーナスを発表します。

概要

正の数のリスト/配列/ベクトル（奇数および偶数）を指定すると、関数を記述する必要があります。 array(int [])/vector<int>/listの合計の平方和を計算するルートを計算。

プログラムのサイズは、関数の本体のサイズです。つまり、関数シグネチャのサイズは除外されます。

例

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

注、実際の出力は、実装の浮動小数点の精度によって異なる場合があります。

スコア

スコアはとして計算されΣ(Characters in your Program) - 46ます。スコアはとして計算されΣ(Characters in your Program) - 32ます。コミュニティからの通常の投票とは別に、最低のネガティブスコアには50ポイントの追加ボーナスが与えられます。

編集

1. スコアの計算に使用されたオフセットは、46から32に変更されました。これは、リーダーボード/報奨金の資格に影響したり、ソリューションを無効にしたりすることはありません。

評決

忍者同士の恐ろしい決闘の後、チャップリン氏は素晴らしい答えを受け取りました。残念ながら、ルールの不当な利用を試みた回答はほとんどなく、あまり役に立ちませんでした。彼は実際に公正な決闘を望み、関数シグネチャ内でロジックがコーディングされている場合、最終的には関数シグネチャがソリューションの不可欠な部分であることを意味します。最後に、Ninja FireFlyは明確な勝者であり、彼に値するボーナスを彼に与えました。 リーダーボード（毎日更新）

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

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

（「関数本体」として;括弧で囲むか、名前にバインドする必要があります。）

説明

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

+/&.:*:|@j./OIの複雑なマグニチュードトリックを使用してさらに2つの文字を保存することで置き換えることができます。

例

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

ES6、（ 48-32 ）= 16（1-32）= -31

元のバージョン：

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

関数定義全体は53文字、本文は48文字です。

更新されたバージョン。問題定義を最大限に活用し、ほとんどすべてを本体から署名に移動します。

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

新しい関数定義は合計で63個の「パンチ」になりましたが、関数BODYは単なる1文字の長さです。さらに、グローバル名前空間が破損することもなくなりました！：D

使用法：

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

関数本体は24文字で構成されています。

使用法：

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

Ruby 2.1+ —（合計39文字-7非ボディ-32オフセット= 0）

少し異なるアプローチ。とがそれぞれの偶数と奇数の合計となるa+b*iような複素数を作成します。次に、絶対値を取得します。ablist

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

私の以前のソリューションは、5文字以上ですが、1.9.3以降で動作します：

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

最後の注意点として、Rails + Ruby 2.1+が許可された場合Array#sum、本文をわずか25文字まで下げることができます。

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

Python 2.7：45、いや：40、いや：38-32 = 6

ここでは新しいものは何もありません。最近のピタゴラスの挑戦で見た複素数のトリック、コンパクトさのためのラムダ、および構文/括弧の最小化の組み合わせだけです：

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

更新-いくつかの文字を保存しました。複雑なコンポーネントを0/1に上げるコツを@DSMに感謝します。

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

質問を読んで「関数の本体」カウントルールを認識すると、さらに2文字が節約されます。

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

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

例えば：

      {.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] 偶数パケット、奇数パケットのリストを作成します。

内側Trは合計を見つけます。両方とも平方され、合計されます（外側でTr）。

N 無理数（整数の平方根）から小数近似に変換します。

例

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

78.492

f[n_]:=がカウントに含まれていない場合、追加の文字を保存できます。

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

例

f[{9, 5, 5, 5, 15, 17, 9, 20, 4, 20}]

78.492

コナ、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で提案されている配列の使用。これにより、各数値のパリティを計算してインデックスとして使用できるため、適切なレジスタに正しい値を分岐して配置する方法としてwithパリティを調整する代わりに、いくつかの文字を節約できます。また、配列/インデックスが使用されていない場合でも、配列は0を与えるため、何も初期化する必要はありません。

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

数値はすでにスタック上にあり、結果は、終了時に残された唯一の値として残ります。

テスト：

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

レジスタoおよびeを使用して奇数および偶数を格納する最初のバージョン。

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

ラムダ関数を使用すると、改行、タブ、およびreturn。

例：

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

ルビー（66-32 = 34）

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

テスト：

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

ルビー、55-46 = 9

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

テスト：

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

ジュリア、40-46 = -6

実装

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

出力

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

コーヒースクリプト、（57-32 = 25）

実装

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にはこれに関するチャンスはあまりないと思います！

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

完全なコード：

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：ただの楽しみのために、これも機能します。悲しいことに、必要な文字数は変わりません：

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

プロローグ（73-32 = 41）

ここでは、「：-」以降のすべてを関数本体としてカウントします。

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

次のような関数を呼び出します。

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

Matlab（44-46 = -2）

関数の本文は44文字です。

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

次のような合計機能：

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

機能のテスト：

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

これはいくつかのzip魔法を使用して短くなる可能性がありますが、今のところ：

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

完了のために、zipマジックを実行できることがわかりますが、コストが（数文字分）増えるため、誰かがこれらのいずれかを改善できない限り、上記のとおりです。

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

読みやすい

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

しかし、ほとんど慣用的ではありません。

ハスケル、64C-46 = 18

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

読みにくい。実行例：

*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コードの実際のメソッド

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

テストクラス

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

これは私が初心者であることを思いつく最高です。いくつかの短いバージョンもあるはずです。

編集：

コードの縮小版は次のとおりです。

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

このバージョンには64文字（元の回答より21少ない文字）しかありません。

つまり、64-32 = 32

VB.net（81c-11c = 70）-32 = 38

「関数を書く」という用語のリベラルな使用を介して

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）

実装

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

出力

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

BaseXはXQueryプロセッサとして使用されました。

アーラン：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はこれには適していません。ほとんどのショートカットは、より多くの文字（タプルなど）になります

唯一の注意事項：

• {lists,sum}への関数参照であり、呼び出すlists:sumことができます
• 偶数は、完全なリストから奇数リストを減算--（リスト減算）することにより計算されます

を使用して呼び出すことができます：

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

出力： 78.49203781276162

ハスケル

57-32 = 25

crazedgremlinsの直接的な最適化の答え：

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

最適化：

• read$showより短いfromIntegral- 3つの文字
• s=sum\ntwo sの合計の長さは8文字で、two sumは6文字です。- 2つの文字
• フィルタを演算子にすると、空白が不要になります-2文字

また、オペレーターにさらに多くのものを追加しようとしましたが、それは同じくらい長くなりました：

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