Реализуйте калькулятор iOS 11

43

В iOS 11 есть ошибка, которая делает результат 1 + 2 + 3 равным 24 . Это связано со скоростью анимации, но в любом случае:

Задача сделать 1 + 2 + 3 == 24. Но только это. Таким образом, вы должны предоставить функцию, которая правильно суммирует большинство последовательностей, но возвращает, 24когда аргументы есть 1, 2и 3в любом порядке.

Пример входных данных:

1 2 => 3
3 4 => 7
1 2 3 4 5 6 7 8 9 => 45
3 2 1 => 24
2 1 3 => 24
1 1 => 2
1 2 3 => 24
40 2 => 42
1 2 2 4 => 9
1 2 3 4 1 2 3 => 16
1 => 1
1 23 => 24
0 1 2 => 3
3 2 3 => 8

Ввод может быть в любом формате, если ваш код принимает любое количество аргументов.

  • Поддержка отрицательных чисел не требуется (для работы требуются все неотрицательные числа, включая 0)
  • Мы предполагаем правильный ввод

Отличия от другого подобного вопроса: «Что вы получаете, когда умножаете 6 на 9? (42)» :

  • В этом случае ваша функция должна принимать любое количество аргументов. Старый вопрос указывает ровно 2.
  • В этом случае порядок не имеет значения, в то время как старый вопрос указывал, что порядок 6 9является обязательным и 9 6должен оцениваться правильно.
code-golf  math  number 
— Hauleth
источник
23
Кроме того, iOS 11 не работает так. Это должно быть , как это вместо этого. ( объяснение кода )
— user202729
3
@ user202729 Вопрос, вероятно, вдохновлен iOS 11. Я не думаю, что ОП просит вас полностью его воспроизвести.
— Okx
2
@ Точно. Это для удовольствия, а не для реализации 1 к 1. Конечно, это можно изменить на предложение пользователя 202729, но если он захочет, он может создать новую задачу с такой задачей.
— Хаулет
3
Входные данные целые?
— xnor
9
Одна из причин, по которой это сложная задача, заключается в том, что свойство, связанное с этой комбинацией чисел, является особенным. Еще одна причина, по которой это сложная задача, заключается в том, что Apple смеется над тем, чтобы расставить приоритеты (их представление) относительно UX над функциональностью.
— НХ.

Ответы:

11

Ява 8, 109 106 101 90 75 74 71 66 байт

a->{int s=0,p=0;for(int i:a){s+=i;p|=1<<i;}return s<7&p==14?24:s;}

-12 байт благодаря @ OlivierGrégoire .
-31 байт благодаря @Nevay .

Объяснение:

Попробуй это здесь.

a->{                  // Method with integer-array parameter and boolean return-type
  int s=0,            //  Sum-integer, starting at 0
      p=1;            //  Product-integer, starting at 1
  for(int i:a){       //  Loop over the input-array
    s+=i;             //   Add current item to sum
    p|=1<<i;          //   Take 1 bitwise left-shifted with `i`, and bitwise-OR it with `p`
  }                   //  End of loop
  return p==14        //  If `p` is now exactly 14 (`0b1110`)
    &s<7?             //  and the sum is 6 or lower:
     24               //   Return 24
    :                 //  Else:
     s;               //   Return the sum
}                     // End of method

(Неэффективное) доказательство того, что только [1,2,3](в любом порядке) будут возможные результаты, когда pis 0b1110( p==14) и сумма меньше 6 или ниже ( s<7): попробуйте здесь.

p==14( 0b1110) Вычисляется как истина тогда и только тогда входные значения по модулю 32 крышки значения 1, 2и 3и не содержат никаких других значений ( p|=1<<i) (каждое значение должно произойти 1+ раза). Сумма входных данных, которые совпадают, p==14будет больше, чем 6для любого ввода, кроме 1,2,3( s=a*1+b*2+c*3+u*32с a>0,b>0,c>0,u>=0).
@Nevay

Старый 71 байт ответ:

a->{int s=0,p=1;for(int i:a){s+=i;p*=i;}return a.length==3&p==s?s*4:s;}

Доказательство того, что для любых трех заданных ненулевых натуральных чисел только [1,2,3](в любом порядке) будет иметь сумму, равную ее произведению ( 1+2+3 == 1*2*3) (с положительной суммой):
Когда сумма равна произведению , Leo Kurlandchik & Andrzej Nowicki

(Неэффективное) доказательство того, что только [1,2,3](в любом порядке) и [0,0,0]будут возможные результаты с неотрицательными числами и длиной 3: попробуйте здесь.
Так s*4будет и 6*4 = 24для [1,2,3], и 0*4 = 0для [0,0,0].

— Кевин Круйссен
источник
7

MATL , 13 байт

stGp=18*Gda*+

Попробуйте онлайн!

Он на два байта длиннее, чем другой ответ MATL, но в нем используется совершенно другой (и IMO более интересный) подход, поэтому я решил, что его стоит опубликовать.

Объяснение:

Это решение использует тот факт, что:

Сумма и произведение массива с тремя элементами равны, только если массив является перестановкой 1,2,3.

Он принимает входные данные, вычисляет сумму sи дублирует ее t. Затем он проверяет, равна ли сумма произведению Gp=. Мы умножаем логическое значение 1/0на 18 18*и проверяем, есть ли в векторе неидентичные значения da*(опять же, умножаем на логическое значение any(diff(x)). Затем умножаем эти два, добавляем последнее число к исходной сумме.

Пошаговое объяснение:

Предположим, что вход [1, 2, 3]:

s                              % Implicit input, calculate the sum
                               % 6
 t                             % Duplicate the sum:
                               % 6, 6
  G                            % Grab input
                               % 6, 6, [1,2,3]
   p                           % Calculate the product
                               % 6, 6, 6
    =                          % Check if the last two elements are equal
                               % 6, 1 (true)
     18*                       % Push 18, multiply by the last number
                               % 6, 18
        G                      % Grab input
                               % 6, 18, [1,2,3]
         d                     % Calculate the difference between each element
                               % 6, 18, [1,1]
          a                    % any non zero elements?
                               % 6, 18, 1 (true)
           *                   % Multiply last two numbers
                               % 6, 18
            +                  % Add numbers. Result: 24
— Стьюи Гриффин
источник
6

Python 2 , 39 байт

lambda*a:sum(a)+18*(sorted(a)==[1,2,3])

Попробуйте онлайн!

Использует альтернативный метод добавления 18, если отсортированный ввод [1, 2, 3]превосходит другой ответ Python на один байт.

— FlipTack
источник
sorted(a)==[1,2,3]может стать set(a)=={1,2,3}экономить 3 байта.
— mypetlion
1
@mypetlion К сожалению, это приведет к истине для списков с дубликатами, такими как[1, 2, 3, 3]
— FlipTack
Woops. Я думал, что мы были ограничены ровно 3 входами.
— mypetlion
6

Haskell , 37 байт

f[a,b,c]|2^a+2^b+2^c==14=24
f l=sum l

Попробуйте онлайн!

Мы используем сопоставление с образцом, чтобы поймать исключительный случай.

Haskell не имеет встроенной сортировки. Равенство 2^a+2^b+2^c==14выполняется только [a,b,c]перестановкой из [1,2,3]неотрицательных целых чисел. Короче a+b+c=a*b*cпочти работает, но удовлетворен [0,0,0], и добавление проверки ,a>0делает его на 1 байт длиннее.

— XNOR
источник
4

Октава , 34 байта

@(x)sum(x)+isequal(sort(x),1:3)*18

Попробуйте онлайн!

или 

@(x)(s=sum(x))+18*~(s-6|prod(x)-6)

Попробуйте онлайн!

или

@(x)(s=sum(x))+18*~(s-prod(x)|s-6)

Это короче, чем подход, используемый другими @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Объяснение:

Он берет сумму вектора и добавляет 18, если отсортированный вектор равен 1,2,3. Это даст, 6+18=24если вектор является перестановкой 1,2,3, и просто сумму вектора, если нет.

— Стьюи Гриффин
источник
4

PHP, 116 байт

Это моя первая попытка поиграть в гольф, и это PHP, язык, который явно отстой в гольфе, так как я редко вижу его здесь, так что ... хм, я пробовал?

<?php
//call as var/www/html/cg_ios.php --'1 2 3 4 5'
$i=$argv[1];$a=(explode(' ',$i));echo((($b=array_sum($a))==6&&count($a)==3&&in_array(3,$a)&&!in_array(0,$a)?24:$b));

Примечание: я не включил комментарий в bytecount.

Ungolfed

Ничего особенного

$i=$argv[1];             //Read the input from the command line
$a=array_filter($c=explode(' ',$i)) //Split the input string into an array, use Whitespace as delimiter
                         //also, remove all 0 from the array, since they are not important at all
echo(                    //print the result
    ($b=array_sum($a) == 6  //If The SUM of the Array is 6 ...
        &&               //... AND ...
    (count($c) == 3)     //... the array has exactly 3 values ...
        &&               //... AND ...
    in_array(3,$a)       // ... the array contains the value 3 ...
        &&               // ... AND ...  
    !in_array(0,$a)      //... the array contains no zeros
        ?
    24                   //print 24
        :
    $b));     //print the sum of the array values we saved earlier

Если вы хотите проверить это в PHPFiddle, а не в консоли, вы, очевидно, можете заменить $iна что угодно.

Спасибо Оливье Грегуару, который ознакомил меня с комбинацией строк, [0,3,3]которая возвращалась 24 ранее, а также помог мне сэкономить несколько символов, сохранив array_sumи вернув их вместо повторного запуска функции.

— Ю НЕТ РАБОТЫ
источник
Добро пожаловать на сайт и приятного первого поста!
— Caird Coneheringaahing
Как насчет входных значений [0, 3, 3]? Кроме того, вы не можете сохранить результат array_sum($a)в переменной и использовать его повторно?
— Оливье Грегуар
@ OlivierGrégoire Это тоже исправлено, я явно пропустил это дело. Я, наверное, мог бы придумать лучшее решение, хотя это - даже для моих стандартов - действительно ... грязно.
— НЕТ РАБОТЫ
Гольф-код отсутствует $ на argv [1]
— manassehkatz-Reinstate Моника
4

R, 47 байтов 34 байта 36 байтов

x=scan();all(sort(x)==1:3)*18+sum(x)

Попробуйте онлайн!

Суммируйте входные данные и добавьте 18, если входной набор равен 1: 3.
Спасибо @mlt за удаление 11 байтов. Спасибо @ Ayb4btu за выявление ошибки в коде с чрезмерным перетеканием

— отметка
источник
3

Javascript ES6, 39 байт

Спасибо @Herman Lauenstein

a=>a.sort()=="1,2,3"?24:eval(a.join`+`)


f=a=>a.sort()=="1,2,3"?24:eval(a.join`+`)

console.log(f([1,2,3]));
console.log(f([1,2,3,4]));
Развернуть фрагмент

Предыдущий ответ

Javascript ES6, 66 байт

a=>(n=[1,2,3],a.every(_=>n.includes(_))?24:a.reduce((x,y)=>x+y,0))

Попытайся

f=a=>(n=[1,2,3],a.every(_=>n.includes(_))?24:a.reduce((x,y)=>x+y,0))

console.log(f([1,2,3]));
console.log(f([1,3,2]));
console.log(f([1,2,3,4]));
Развернуть фрагмент

— Weedoze
источник
58 байт:a=>(Array.sort(a).join()=="1,2,3"?24:a.reduce((x,y)=>x+y))
— Okx
a.sort()=="1,2,3"работает.
— Нил
39 байтов: a=>a.sort()=="1,2,3"?24:eval(a.joinBT+BT)(замените BT на кавычки)
— Герман Л
3

Swift, 67 байт

func z(i: [Int])->Int{return i.sorted()==[1,2,3] ?24:i.reduce(0,+)}

Может сделать это до 27 байт с расширениями на [Int], но это будет обманом :(

— Доминик Бухер
источник
1
Добро пожаловать на сайт! Это соревнование по коду для игры в код, пожалуйста, вы можете сыграть в гольф как можно больше кода, например, удалив пробелы. Кроме того, я не знаю Swift, но если я прав, это сохраняет входные данные в переменной, что недопустимо. Вам, однако, разрешено превратить это в функцию.
— caird coinheringaahing
1
Гольф немного вниз func z(i:[Int]){print(i.sorted()==[1,2,3] ?24:i.reduce(0,+))}.
— г-н Xcoder
1
Или 55 байт (-12): {$0.sorted()==[1,2,3] ?24:$0.reduce(0,+)}as([Int])->Intанонимные функции разрешены нашими стандартными правилами. Вы можете увидеть, как это работает здесь .
— г-н Xcoder
@ Mr.Xcoder, вы можете опустить приведение и добавить его к объявленной вами константе f. или поместите шрифт внутри крышки, и вы избавитесь от as:)
— Доминик Бухер,
2
+1 для Свифта. Это оригинальный исходный код калькулятора iOS?
— GB
2

J, 17 байт

-6 байт благодаря Frowny Frog

+/*1+3*1 2 3-:/:~

Суммируйте все числа +/и умножьте результат на (псевдокод) 1 + 3*(is123 ? 1 : 0). То есть возвращать результаты без изменений, если только в отсортированном списке 1 2 3мы не умножим результат на 4.

Попробуйте онлайн!

оригинальный ответ

+/`(24"_)@.(1 2 3-:/:~)

Проверьте, является ли отсортированный ввод 1 2 3- если да, вызовите функцию константы 24 ( 24"_); если нет, верните сумму+/

Попробуйте онлайн!

— Ион
источник
Я действительно не знаю J, но могу 1 2 3→ i.3?
— Уриэль
@ Uriel, i.3производит 0 1 2, так что вам нужно сделать, 1+i.3что не экономит символов, но менее ясно.
— Иона
верно, я забыл, что индекс J равен 0
— Уриэль
[:+/8"0^:(1 2 3-:/:~)
— FrownyFrog
+/@,[*3*1 2 3-:/:~
— FrownyFrog
2

Lua , 116 81 байт

-7 байт благодаря Джонатану

Принимает ввод как аргументы командной строки

Z=0S={}for i=1,#arg do
j=arg[i]+0S[j]=0Z=Z+j
end
print(#S>2 and#arg<4 and 24or Z)

Попробуйте онлайн!

Объяснение:

Работает путем создания разреженного массива Sи добавления нулей в индексах, соответствующих входным значениям. Если параметры имеют 3, 4, 7разреженный массив, в этих индексах будут только числа. С этим массивом мы получаем его длину с оператором, #который считает от индекса 1до более высокого индекса, который имеет значение в нем, если эта длина точно 3, это означает, что в позиции были элементы 1, 2и 3это то, что мы находясь в поиске. Длина разреженного массива всегда будет между 0и Nгде Nчисло параметров. Поэтому нам просто нужно проверить, равна ли длина как массива параметров, так и разреженного массива 3.

— Фелипе Нарди Батиста
источник
1
— Кевин Круйссен,
Вы ничего не видели (я отредактировал свой комментарий, так как это не было через 5 минут.; P)
— Кевин Круйссен
Да, только что нашел тот же недостаток в моем собственном ответе .. Я исправил это с помощью длины массива == 3 AND A == S AND S> 0. Но я думаю, проверка длины #argsв Lua слишком тяжелая? В этом случае вы можете откатиться до своего 90-
— байтового
— Джонатан С.
@JonathanS. хороший
— Фелипе Нарди Батиста
2

R , 55 45 54 49 57 54 48 байтов

Сохранено много байтов иБлагодаря Ayb4btu неверных решений.

Сохранено 3 9 байт благодаря Джузеппе. Я продолжаю изучать новые способы злоупотребления тем фактом F==0.

"if"((s=sum(x<-scan()))-prod(x)|sum(x|1)-3,s,24)

Попробуйте онлайн!

Другой ответ R выиграл в конце.

— BLT
источник
Сбой для [0,0,0]: возвращает 24вместо 0.
— Оливье Грегуар
Я явно пропустил «неотрицательные» и «может быть одно число» в спецификации. Оставайтесь на линии.
— BLT
c(1,1,2,3)возвращается 28вместо7
— Ayb4btu
@ Ayb4btu Спасибо, хороший улов.
— BLT
1
x=scan();s=sum(x);"if"(s-prod(x)|s-6|length(x)-3,s,24)составляет 54 байта, меняя условие и используя |вместо того, &чтобы мы могли вычесть.
— Джузеппе
1

Сетчатка , 21 байт

O`
^1¶2¶3$
24
.+
$*
1

Попробуйте онлайн!

Входные данные разделены переводом строки, но для удобства набор тестов использует разделение запятыми.

объяснение

O`

Сортировка число (лексический, на самом деле, но мы только заботиться о том случае, когда входы 1, 2, 3в определенном порядке, где это не делает разницы).

^1¶2¶3$
24

Если ввод 1,2,3(в некотором порядке), заменить его на 24.

.+
$*

Перевести все числа в одинарные.

1

Подсчитайте число 1s, которое добавляет унарные числа и преобразует их обратно в десятичное число.

— Мартин Эндер
источник
Из любопытства, исходя из вашего объяснения, я понимаю, что в последней строке подсчитываются все совпадения ( 1в данном случае все s). Retina всегда делает это для единственной заключительной строки? Или же можно посчитать все 1s где-то посередине, а затем продолжить с результатом, чтобы сделать что-то еще (который снова использует две строки для замены действий)? Кроме того, еще один связанный с этим вопрос: какие функции в Retina требуют только одну строку? Сортировка ( O`) является одним из них, а также другими функциями; а какой другой? Просто пытаюсь понять Retina немного больше. :)
— Кевин Круйссен
1
@KevinCruijssen Да, вы можете использовать (подсчет) стадию матча где-то посередине, но вам придется явно пометить ее как стадию матча M`. Только в том случае, если есть единственная Mконечная строка, Retina по умолчанию ставит atch вместо Replace. AGMTSвсе этапы однолинейные, Rэто две линии, Oи Dодна или две линии , в зависимости от того , $используется вариант (который превращает их в своего рода / deduplicate- на этапах). Не стесняйтесь пинговать меня в чате Retina, если у вас есть дополнительные вопросы: chat.stackexchange.com/rooms/41525/retina
— Мартин Эндер,
1

Haskell , 44 байта

f a|sum a==6,product a==6,a<[6]=24|1<2=sum a

Попробуйте онлайн!

Перестановки [1,2,3]являются единственными разделами, 6чей продукт 6, кроме 6самого себя. (Предполагается, что входные данные неотрицательны, что, по-видимому, относится ко всем контрольным случаям ... Я спросил об этом OP).

— Линн
источник
— полностью человек
1

PL / SQL - 135 123 байта

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

if (select sum(s) = exp(sum(ln(s))) from unnest(i) s) then
    return 24;
else
    return (select sum(s) from unnest(i) s);
end if;
— Лео Веске
источник
Добро пожаловать в PPCG! Не могли бы вы попробовать сыграть в гольф, убрав все лишние пробелы, даже если это делает ответ нечитаемым (хотя, пока он компилируется)?
— Оливье Грегуар
1

C ++ 17, 56 54 байта

[](auto...i){return(-i&...)+4|(~i*...)+24?(i+...):24;}

Попробуйте онлайн!

Обратите внимание, что созданный объект функции можно использовать во время компиляции, поэтому тесты выполняются компилятором без запуска программы.

Объяснение:

[]             // Callable object with empty closure,
(auto...i)     // deduced argument types,
{              // and deduced return type
  return       //
      (-i&...) //   If the fold over the bitwise AND of the negation of each argument
    +4|        // is unequal to -4, or
      (~i*...) //   if the product of the bitwise complements of the arguments
    +24?       // is unequal to -24, then
      (i+...): //   return the sum of the arguments, otherwise
      24;}     //   return 24.

Доказательство того , что только неотрицательное , i...для которых (-i&...)равен -4 и (~i*...)равен -24 являются перестановками 1, 2, 3:

Сначала мы заметим, что так как -0= 0, если есть i=, 0то (-i&...) = 0мы заключаем, что все iявляются положительными.

Теперь обратите внимание, что в дополнении 2, -iэквивалентно ~(i - 1), и ~iэквивалентно -(i + 1). Применяя правило де Моргана, мы находим, что (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), так ((i - 1) | ...) = 3; аналогично, -1 ** n * ((i + 1) * ...) = -24так nстранно и ((i + 1) * ...) = 24.

Первичные множители 24 равны 2 ** 3 * 3, поэтому n<= 4. Если n= 1, мы имеем i - 1 = 3и i + 1 = 24, следовательно, n= 3. Запишите iwlog как a <= b <= c, тогда ясно a= 1 как иначе (a + 1)(b + 1)(c + 1)> = 27. Также c<= 4 как в противном случае (a - 1)|(b - 1)|(c - 1)> = 4. cне может быть 4, так как 5 не является коэффициентом 24, поэтому c<= 3. Тогда для удовлетворения (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2, как требуется.

— ecatmur
источник
1

Шелуха , 9 байт

?K24Σ=ḣ3O

Попробуйте онлайн!

объяснение

?K24Σ=ḣ3O
        O    Sort the input
?    =ḣ3     If it is equal to [1,2,3]:
 K24           Return 24
             Else:
    Σ          Return the sum of the input

Предыдущее решение

Дает неправильный результат [2,2] и, возможно, другим входам, но это было более интересно.

?ṁD→E§eΠΣ
     §eΠΣ    Build a two-element list with the product and sum of the input
?   E        If the two elements are equal:
             (true for any permutation of [1,2,3] and the list [0,0,0]
 ṁD            Double both elements and sum them
               (This is 4 times the sum: 24 for permutations of [1,2,3], 0 for [0,0,0])
             Else:
   →          Return the last element (the sum)

Попробуйте онлайн!

— Лео
источник
Это дает 24 для 2,2
— рекурсивный
@ recursive на самом деле дает 16, но вы правы. И, вероятно, это дает неправильные результаты и для некоторых более длинных массивов ... Черт, мне нужно переключиться на скучное решение
— Лев
0

Напористый , 12 байт

gF3RFx?18;S#

Попробуйте онлайн!

Это работает путем сортировки входных данных и, если оно равно [1, 2, 3], добавлением 18. Затем сумма вычисляется и печатается, после чего добавляется 24, равное 18, и в противном случае получается нормальный ответ.

         \ Implicit: Input on stack.
g        \ Sort input ascendingly
F3RF     \ On auxiliary stack, push range(3) -> [1, 2, 3]
x?       \ If the stacks are equal:
  18     \    Append 18 to the input
;
S#       \ Print sum of input.
— FlipTack
источник
0

Желе , 10 9 байт

Ṣ24S⁼?3R¤

Попробуйте онлайн!

-1 байт благодаря Эрику

Альтернатива ( Mr. Xcoder ), также для 9 байтов:

3R⁼Ṣ×18+S

Попробуйте онлайн!

Как это работает

Ṣ24S⁼?3R¤ - Main link. Argument: l (list)

Ṣ         - Sort
     ?    - Ternary if statement
    ⁼     -  Condition: Is l equal to...
      3R¤ -    [1, 2, 3]
 24       -  If condition: Return 24          
   S      -  Else: Return the sum of the list
— Caird Coneheringaahing
источник
Вы можете сделать Ṣ24S⁼?3R¤для 9 байтов.
— Эрик Outgolfer
Или 3R⁼Ṣ×18+Sдля 9 байтов тоже.
— г-н Xcoder
0

Pyth , 9 байт

Отличный подход от другого ответа Пита.

*sQ^4qS3S

Объяснение:

Порт из моего ответа Python

*sQ^4qS3SQ  # Full program (Q at the end is implicit and represents the input)

*           # A * B where A and B are the next two lines
  sQ        # Sum elements of input
  ^4        # 4 to the power of:
    qS3SQ   # Compares sorted input to [1, 2, 3] and returns 0 or 1

Попробуйте онлайн!

— Фелипе Нарди Батиста
источник
0

PowerShell , 44 байта

param($a)($a-join'+'|iex)+18*!(diff(1..3)$a)

Попробуйте онлайн!

Аналогичен алгоритму Python и JavaScript. Принимает ввод как буквенный массив $a. Потом сразу суммы$a , что образует левый оператор+ .

Правая рука - это diff(псевдоним для Compare-Object) 1,2,3и $a- это либо пустой массив, если они равны, либо непустой массив различных элементов, если они не равны, - заключенный в логическое значение-not. Таким образом, если они равны, это делает пустой массив (значение Фолси) в$true .

Это затем умножается на то, 18что неявно приводит $trueк 1и $falseк 0. Так что правая часть будет, 18если массивы одинаковые, а в 0противном случае. Это дает правильный результат, 24если входной массив находится 1,2,3в любой перестановке, и суммирование входного массива в противном случае.

— AdmBorkBork
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.