В 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 столбцам (что означает, что Мэк смог написать программу, содержащую только 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&|+//.]

(Как «тело функции»; должно быть заключено в скобки или связано с именем.)

объяснение

Я попытался по-разному взглянуть на то, что делает каждая пьеса, как Тобия в ответах 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 теперь просто ОДНА ЧЕРТАЯ СИМВОЛ. Плюс это больше не портит глобальное пространство имен! : 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такое, что 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

Python 2.7: 45, нет: 40, нет: 38 - 32 = 6

Здесь нет ничего нового, просто комбинация трюка с комплексными числами, который я видел в недавнем вызове Пифагора, лямбда для компактности и минимизация синтаксиса / круглых скобок:

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

Обновление - сохранено несколько символов. Спасибо @DSM за хитрость поднятия сложного компонента до 0/1.

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

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

Coffeescript, (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 есть много шансов на это!

с #: 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).

Матлаб (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

Для завершения выясняется, что вы можете делать магию молнии, но это стоит вам больше (на несколько символов), поэтому вышеприведенное стоит, если кто-то не может улучшить ни один из этих:

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

Хотя вряд ли идиоматичный.

Haskell, 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.

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.

Эрланг не подходит для этого. В большинстве случаев ярлыки становятся больше символов (кортежей и т. Д.)

Единственные реальные вещи на заметку:

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

Haskell

57 - 32 = 25

Прямая оптимизация крейзгремлинов:

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

Оптимизации:

• read$showкороче fromIntegral- 3 символа
• s=sum\nи два sимеет общую длину 8 символов, два sum- всего 6 символов. - 2 символа
• превращение фильтра в оператора избавляет от необходимости пробелов - 2 символа

Я также попытался добавить больше материала для оператора, но это оказалось так же долго:

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