Электрическая розетка

23

Это проблема из NCPC 2005 . У Роя есть квартира только с одной электрической розеткой, но у него есть несколько разветвителей. Подсчитайте максимальное количество розеток, которое он может иметь, используя удлинители, которые он имеет. Количество розеток на удлинитель указано в качестве входных данных.

Получается, что если количество выходов полос соответственно

p1,p2,…,pn

тогда количество розеток равно ,

1−n+∑ipi

или

.

1+p1−1+p2−1+⋯+pn−1

Входные данные для программы или функции представляют собой непустую последовательность натуральных чисел.

Примеры

2 3 4
> 7
2 4 6
> 10
1 1 1 1 1 1 1 1
> 1
100 1000 10000
> 11098
code-golf  number  arithmetic 
— Пол Г.Д.
источник
17
И я думал, что ты не должен был заковывать в цепи электропитание ...
— Джои,
Насколько я могу судить, мой ответ Retina - единственный ответ, использующий унарный ввод. Возможно, вы захотите взглянуть на обсуждение комментариев там: codegolf.stackexchange.com/questions/71047/electrical-outlet/… ... Если вы считаете, что унарное решение - это слишком много взлома, что не в духе Задача, я рад, что вы указали, что входные данные должны быть в десятичном виде (и затем исправят мой ответ соответственно).
— Мартин Эндер
7
Поскольку электричество стоит очень дорого, ваш код должен быть как можно короче, чтобы не использовать больше энергии
— кошка,
1
@cat Время выкопать старую машину хьюстера и механические компьютеры.
— Pharap
1
@immibis, конечно, но вывод будет обрабатываться как информация, содержащаяся в потоке байтов, а не как то, что происходит с помощью вашего терминала.
— Мартин Эндер

Ответы:

29

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

 1

Конечный перевод строки является значительным.

Ввод - это разделенный пробелами список унарных чисел .

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

объяснение

Код просто удаляет все пробелы, а также 1после них из строки. Вот почему это работает:

Добавление в унарном простое: просто объединить числа, что аналогично удалению разделителей. Уменьшение на 1 также просто: просто удалите a 1из каждого числа. Мы хотим на 1 больше, чем сумма уменьшенных входных данных, поэтому мы просто удаляем только те 1s, которые мы находим после пробелов, тем самым уменьшая все, кроме первого ввода.

— Мартин Эндер
источник
1
Мне интересно, если вход в унарный должен быть разрешен.
— Джон Дворжак
@JanDvorak это по умолчанию, если в запросе явно не указан десятичный ввод. (См. Ссылку в ответе.) Не имеет значения, Джелли все равно выигрывает.
— Мартин Эндер
@ MartinBüttner В этом вопросе приведены примеры данных и исходного задания. Не думаете ли вы (если не указано иное), что это должен быть необходимый (хотя и недостаточный) критерий для передачи, чтобы код работал с дословными образцами данных?
— nitro2k01
1
@ nitro2k01 Нет (в этом случае большинство ответов, вероятно, будут недействительными). Если в задаче явно не указан один конкретный формат ввода, мы обычно предполагаем, что списки могут быть взяты в любом собственном формате списка . То же самое относится и к числовым форматам (по крайней мере, одинарные и с целыми числами, поскольку байтовые значения разрешены консенсусом, если только вызов не запрещает их). Практически невозможно включить образцы данных во все мыслимые исходные форматы ввода в задачу.
— Мартин Эндер
@ MartinBüttner Имо, это не проблема, к которой обращается рекомендация. То, что все еще говорит против этого, - то, что (если я не ошибаюсь), это не работает, потому что унарный - поддерживаемый или собственный формат чисел в Retina, но это работает, когда вы обрабатываете строку как строковые данные. Это хак. Это даже умный взлом, но я все еще не уверен, что это по правилам. Если бы разделенные пробелом унарные числа были собственным форматом в Retina так же, как список байтов является собственным форматом в bf, я согласился бы с рекомендацией, и у меня было бы другое мнение.
— nitro2k01
9

Гексагония , 18 14 байтов

.?<_(@'")>{+.!

Развернутая:

  . ? <
 _ ( @ '
" ) > { +
 . ! . .
  . . .

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

Я не думаю, что длина стороны 2 возможна, но должно быть более эффективное решение с длиной стороны 3, чем это.

Это обычный подход «уменьшить все, сумма, приращение», но мне придется добавить диаграммы позже, чтобы показать, как именно это работает в гексагонии.

— Мартин Эндер
источник
7

Python, 24 байта

lambda*n:1-len(n)+sum(n)

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

— Mego
источник
1
Это предполагает, что функция сначала назначается, а затем применяется к входу из другой переменной.
— juandesant
1
@juandesant ... это прекрасно. Это функциональный литерал, который является допустимой формой представления.
— FlipTack
7

Haskell, 17 15 байт

foldl1$(+).pred

Пример использования: ( foldl1$(+).pred ) [2,4,6]-> 10.

Старая версия, другой подход, 17 байт: succ.sum.map pred.

— Ними
источник
6

J, 6 байт

+/+1-#

Сумма плюс один минус длина. Сложите в скобки и примените это так:

   (+/+1-#) 2 3 4
7
— Линн
источник
6

Лабиринт , 9 байт

"?;)!@
+(

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

Обычный праймер:

  • Лабиринт 2D и основанный на стеке. Стеки имеют бесконечное количество нулей на дне.
  • Когда указатель инструкции достигает соединения, он проверяет вершину стека, чтобы определить, куда повернуть дальше. Отрицательный слева, ноль вперед и положительный справа.

Здесь мы начинаем в левом верхнем углу ", без операции, направляясь вправо. Следующее ?, что читает int из STDIN (отбрасывая символы, которые не могут быть проанализированы как целое число, например, пробелы). Теперь у нас есть два случая:

Если вход положительный, мы поворачиваем направо, выполняя:

(            decrement top of stack
+            add top two stack elements
             [continue loop]

Если ввод равен нулю (что происходит в EOF), мы идем прямо, выполняя:

;            pop zero from EOF
)            increment top of stack
!            output top of stack as number
@            halt program
— Sp3000
источник
5

Pyth, 5 байт

hstMQ

приращение (сумма (карта (уменьшение, ввод)))

— Линн
источник
5

ES6, 25 байт

a=>a.map(n=>r+=n-1,r=1)|r
— Нил
источник
4
Я собирался написать: «Один из редких случаев, когда Лоуни выигрывает игру» ... и это тоже 25 l=>l.reduce((a,b)=>a+b-1).
— edc65
@ edc65 Да, (,b)это дорого, но мне тоже нравится эта версия.
— Нил
4

05AB1E , 4 байта

Код:

E<O>

Объяснение:

E     # Evaluates input
 <    # Decrement on list
  O   # Compute the total sum
   >  # Increment on the sum
      # Implicit: output top of the stack

Принимает ввод как массив (например [3, 4, 5]).

— Аднан
источник
Очень элегантно для игры в гольф
— Pharap
4

Звездный , 26 24 байта

, + '`      + ** `, +'*.

Ожидает разделенные новой строкой целые числа. Попробуйте онлайн!

Спасибо @ MartinBüttner за -2 байта.

,           Read line as integer
 + '        Dupe and jump to label 1 if nonzero
`           Set label 0
      +     Push 1
 *          Sub
*           Add
 `          Set label 1
,           Read line as integer
 + '        Dupe and jump to label 0 if nonzero
*           Add
.           Output as integer

Цикл развернут, так что первое число не уменьшается, что исключает необходимость увеличения. Нажатие номера дорого в Звездном ...

— Sp3000
источник
Я считаю только 20 байтов.
— Эддисон Крамп
1
@VoteToClose Вы посчитали лидирующие пробелы? (Я предполагаю, что вы говорите о 26 байтах)
— Sp3000
4

Утилиты Bash + GNU, 16

Если есть Nудлинители, то N-1в списке ввода, разделенном запятыми, должны быть разделители. Все, что нам нужно сделать, это заменить разделители - 1 +и арифметически оценить:

sed s/,/-1+/g|bc

Или используя тот же трюк:

Pure Bash (без внешних утилит), 19

echo $[${1//,/-1+}]
— Цифровая травма
источник
3

APL (NARS 2000), 13 10 байт

{1+(+/⍵)-⍴∊⍵}

Изменить: до 10 с подходом Линн (лучше).

{1++/1-⍨⍵}

— Koneke
источник
3

CJam, 7 байтов

q~:(:+)

Проверьте это здесь.

Тот же подход, что и у Линн (уменьшить все, сумма, увеличить). Это также работает для 8 байтов (и, возможно, немного интереснее):

q~{(+}*

Это сворачивает «уменьшить, добавить» по списку. Делая это, декремент применяется только ко всем элементам, кроме первого, так что нам не нужно заботиться о приращении отдельно.

— Мартин Эндер
источник
3

Perl 6, 14 байт

{1+[+] --«@_}

использование 

my &f = {1+[+] --«@_}

say f([2,3,4]) # 7
say f([2,4,6]) # 10
say f([1,1,1,1,1,1,1,1]) # 1
say f([100,1000,10000]) # 11098
— Клавиатурный
источник
Я полностью намеревался отредактировать свой ответ на ту же самую вещь (см.
— Html
11 байт:{.sum-$_+1}
— nwellnhof
2

Perl 6 , 20 байт

put 1+sum --«@*ARGS

(Вы можете использовать <<вместо «)

Использование:

$ perl6 -e 'put 1+sum --«@*ARGS' 100 1000 10000
11098
— Брэд Гилберт b2gills
источник
«Это оператор Perl?
— user253751
@immibis На самом деле это часть нескольких операторов Perl 6. @arraya »+« @arrayb ++«@array @array».method @array»++ « a 'space separated' list of words »Некоторые из них называются мета-операторами, так как они объединяются с другими операторами. (Perl 5 не имеет этих операторов в настоящее время.)
— Брэд Гилберт b2gills
2

Perl 5 23 + 2 = 25 или 19 + 2 = 21

Требуются -apфлаги:

map{$.+=($_-1)}@F;$_=$.

Сохраняется в файл и запускается как

perl -ap file.pl

РЕДАКТИРОВАТЬ: Другой ответ, меньше (19 + 2), но в основном скопированы из ответа dev-null:

$.+=$_-1for@F;$_=$.
— ChatterOne
источник
2

F #, 25 байт

Seq.fold(fun s n->s+n-1)1

Это функция, которая принимает массив / список / последовательность целых чисел и возвращает требуемый результат.

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

Seq.foldпозволяет применять функцию к каждому элементу последовательности, сохраняя при этом некоторое состояние. Результат функции применительно к первому элементу даст состояние, которое будет помещено в функцию для второго элемента, и так далее. Например, чтобы подвести итог списка [1; 3; 4; 10], вы должны написать это так:

Seq.fold (fun sum element -> sum + element) 0 [1; 3; 4; 10]
         (       function to apply        ) ^ (sequence to process)
                                     ( initial state )

Который будет применяться так:

// First, initial state  + first element
0 + 1  = 1
// Then, previous state + next element until the end of the sequence
1 + 3  = 4
4 + 4  = 8
8 + 10 = 18

С последним состоянием является возвращаемое значение Seq.fold .

— Roujo
источник
2

𝔼𝕊𝕄𝕚𝕟, 5 символов / 7 байтов

ï⒭+‡_

Try it here (Firefox only).

Использует пользовательскую кодировку с 10-битными символами (thx @Dennis!). Запустите encode('ï⒭+‡_')в консоли JS, чтобы получить закодированную форму, иdecode(/*ENCODED TEXT HERE*/) декодировать закодированную форму.

объяснение

Переводит на Javascript ES6 как:

i=>i.reduce(($,_)=>$+--_)
— Mama Fun Roll
источник
Интересная кодировка.
— lirtosiast
Это тоже работает довольно хорошо.
— Mama Fun Roll
2

Морнингтон Полумесяц , 1909 1873 1839 байтов

Take Northern Line to Stockwell
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Turnham Green
Take District Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Embankment
Take Northern Line to Stockwell
Take Northern Line to Embankment
Take Circle Line to Temple
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Blackfriars
Take Circle Line to Embankment
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Parsons Green
Take District Line to Embankment
Take Circle Line to Blackfriars
Take Circle Line to Bank
Take Northern Line to Angel
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

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

— pppery
источник
«90% всех инструкций касаются линии округа». Это потому, что Район - это место, где находятся все арифметические станции. Тем не менее, на TIO, это не работает ни для одного из примеров .
— NieDzejkob
1873 байта , используя более короткие имена строк, где это возможно
— NieDzejkob
У интерпретатора
— TIO
Хорошо поймал. Я послал пиар, который это исправляет.
— NieDzejkob
1

Python 3, 79 байт

import sys
print(sum(map(lambda x: int(x)-1, sys.stdin.readline().split()))+1)
— Пол Г.Д.
источник
Похоже, вы считаете новую строку двумя байтами. Возможно, замените его точкой с запятой, чтобы сохранить байт. Несколько пробелов тоже можно убрать.
— Даффи
1

Рубин, 30 байтов

$*.inject(1){|s,v|s+=v.to_i-1}

Достаточно просто - начиная с 1, сложите предоставленные числа, каждое -1 (аргументы командной строки в $*). Стыд injectэто такое длинное слово.

— Chowlett
источник
1

PowerShell, 19 байт

$args-join'-1+'|iex

Обратите внимание, что 1 + p1-1 + p2-1 + ... + pn-1эквивалентноp1-1 + p2-1 + ... + pn .

Принимает ввод как отдельные аргументы командной строки с $args. Мы -joinвместе с -1+разделителем для создания строки, такие как 2-1+3-1+4. Затем строка передается по каналу Invoke-Expression(аналогично eval) и выводит результат.

— AdmBorkBork
источник
1

Perl, 21 + 2 = 23 байта

$a+=$_-1for@F;say++$a

Требуется -aи -E:

$ perl -aE'$a+=$_-1for@F;say++$a'<<<'2 3 4'
7
— andlrc
источник
Вы можете использовать -aфлаг, чтобы получить @Fпеременную с уже разделенными элементами, и заменить -n на -p, чтобы вам это не понадобилось say, уменьшив его до 21 + 2:$a+=$_-1for@F;$_=++$a
— ChatterOne
Использование -pвместо того sayже, потому что мне нужно использовать в $_=любом случае.
— andlrc
@ChatterOne -aхорошая идея!
— andlrc
1

Brainfuck, 15 байтов

Предположение: оператор, возвращает 0, когда все входные данные исчерпаны, и нет удлинителей с 0 штекерами. Кроме того, IO должен быть в байтовых значениях вместо кодов символов ASCII.

+>,[-[-<+>],]<.

Пояснение: при этом используются 2 регистра. Регистр накопителя «Значение», представляющий количество устройств, которые можно подключить, и регистр «текущего шнура», который отслеживает значение текущего шнура. Он начинается с увеличения значения на 1 для существующего выхода. Затем для каждого удлинителя он вычитает единицу из значения, так как вилка берется, а затем увеличивает значение на количество вилок.

Большинство онлайн-переводчиков не работают в режиме ввода необработанных байтов. Чтобы проверить это онлайн, используйте этот код:

+>,[->-[>+<-----]>---[-<+>]<[-<->]<[-<+>],]<.
— Итан
источник
Могу ли я где-нибудь протестировать программу?
— Пол GD
Спасибо, исправил эти ошибки. Я не знаю ни одного онлайн-переводчика, который работает в байтовом режиме. Я могу собрать реализацию, которая вычитает «0» из входных данных, которые будут работать на любом онлайн-интерпретаторе.
— Итан
Если вы хотите проверить код, запустите его здесь: copy.sh/brainfuck Не ставьте пробелы между числовыми значениями. К сожалению, поскольку он работает в режиме ASCII, демонстрационный код будет работать только с однозначными значениями. Однако 15-байтовая версия будет правильно работать со значением <= 255. После запуска просмотрите дамп памяти, чтобы просмотреть окончательное значение.
— Итан
Однажды BF будет иметь надлежащие стандарты для ожидаемого ввода-вывода, и мы просто сможем сказать, «используя стандарт 3» вместо, например, «ввод и вывод - все asciii завершается нулевым символом».
— Pharap
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.