New Modern Times 에서 Charlie Chaplin은 컴퓨터를 만나면 정렬 마당에서 작업자가 항목을 올바르게 정렬하고 있는지 확인하는 유효성 검사기로 고용됩니다. 문제의 아이템은 구슬의 패킷입니다. 홀수의 구슬이있는 패킷은 빨간색 바구니에 쌓이고 짝수의 구슬이있는 패킷은 파란색 바구니에 쌓입니다.

Charlie Chaplin은 분류 절차에 이상이 있는지 확인 하는 프로그램을 작성 해야합니다. Mack Swain의 직속 보스는 코딩해야하는 알고리즘을 공유합니다.

연산

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을 결정하고 그의 Boss가 계산하는 값과 일치시키는 것입니다.

Charlie Chaplin은 점심 시간 동안 Mack Swain의 서랍으로 몰래 들어가서 첫 번째 46 32 열에 펀치가있는 단일 카드를 가지고 있음을 확인했습니다 (Mack는 46 32 자로 만 프로그램을 작성할 수 있음을 의미 함 ).

Charlie Chaplin은 가능한 한 적은 수의 라인으로 프로그램을 작성하기 위해 모든 코드 닌자의 도움이 필요합니다. 누군가가 그의 보스보다 짧은 프로그램을 만들 수 있다면 그는 또한 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의 복잡한 크기 트릭 을 사용하여 다른 두 문자를 저장 하는 것으로 대체 할 수 있습니다 .

예

   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는 이제 ONE DAMN CHARACTER LONG입니다. 또한 더 이상 전역 네임 스페이스를 손상시키지 않습니다! :디

용법:

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

약간 다른 접근법. I는 복소수 생성 a+b*i되도록을 a및 b짝수 및 홀수의 합은에 list각각. 그런 다음 나는 절대 가치를 취합니다.

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

파이썬 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))

좋아, 질문을 읽고 '함수 본문'카운트 규칙을 인식하면 다른 두 문자가 절약됩니다.

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

매스 매 티카 31-32 = -1

√Tr[(Tr/@GatherBy[#,OddQ])²]//N &

GatherBy[#,OddQ] 짝수 패킷, 홀수 패킷 목록을 생성합니다.

내부 Tr는 총계를 구합니다. 둘 다 제곱 된 다음 합산됩니다 (외부 Tr).

N 비이성적 인 숫자 (정수의 제곱근)에서 10 진수 근사값으로 변환합니다.

예

√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가 제안한 배열 사용. 이것은 각 숫자의 패리티를 계산하고 인덱스로 사용할 수 있기 때문에 일부 문자를 절약합니다. 또한 배열 / 인덱스를 사용하지 않은 경우에도 배열에서 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

파이썬, 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)

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가 이것에 대해 많은 기회를 가지고 있다고 생각하지 않습니다!

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

추신 : 재미를 위해서도 이것도 효과가 있습니다. 슬프게도 필요한 문자 수를 변경하지 않습니다.

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

파이썬 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));
   }
}

클로저 = 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));

자바 코드의 실제 메소드

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.

얼랭은 이것에 좋지 않습니다. 대부분의 단축키는 더 많은 문자 (튜플 등)가됩니다.

주의해야 할 유일한 사실 :

• {lists,sum}함수 참조 lists:sum이며 호출 가능
• 짝수 는 전체 목록에서 홀수 목록 을 빼서 --( list subtract ) 계산 합니다.

다음을 사용하여 전화 할 수 있습니다.

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\n2 s의 총 길이는 8 자이며 2 sum의 문자는 6 자입니다. - 2 개 문자
• 공백 문자가 없어도 연산자로 필터를 만들 수 있습니다 -2 자

나는 또한 연산자에 더 많은 것을 추가하려고 시도했지만 결국 길어졌습니다.

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