Вам будет предоставлена строка. Он будет содержать 9 уникальных целых чисел от 0 до 9. Вы должны вернуть пропущенное целое число. Строка будет выглядеть так:
123456789
> 0
134567890
> 2
867953120
> 4
Вам будет предоставлена строка. Он будет содержать 9 уникальных целых чисел от 0 до 9. Вы должны вернуть пропущенное целое число. Строка будет выглядеть так:
123456789
> 0
134567890
> 2
867953120
> 4
Ответы:
+ красота благодаря @Sarge Borsch
`99066**2`.strip
99066**2
это просто более короткий способ создания строки, которая содержит 0 ~ 9
764**4
можно сохранить два байта.
764**4
отсутствует 5
, 8
и9
763**4
=338920744561
lambda s:-int(s,16)%15
Арифметическое решение. Интерпретирует входную строку как шестнадцатеричную, отрицает ее и получает результат по модулю 15.
⎕D∘~
⎕D
D igits
∘
(связывает левый аргумент со следующей двоичной функцией для создания монадической функции)
~
кроме [аргумент]
⎕D~⊢
⎕D
D igits
~
Кроме
⊢
правильный аргумент
⎕D~⍞
⎕D
D igits
~
Кроме
⍞
ввод символов
10 байтов сохранено благодаря DJMcMayhem!
((([]())[]{}){()()({}[()])}{}[{{}}])
Сумма всех цифр в Ascii составляет 525. Эта программа суммирует входные данные и вычитает их из 525, чтобы получить недостающую цифру.
((([]())[]{}){()()({}[()])}{} )
Нажмите 525. Это использует тот факт, что мы знаем, что для начала будет 9 элементов ввода. Это значит, что[]
значение равно 9, что позволяет нам быстро получить большие числа, например 525.
Далее у нас есть немного:
[{{}}]
который будет суммировать входные данные и вычитать его из общей суммы.
negative(sum(input()))
конец, вы можете злоупотребить ниладой высоты стека, чтобы толкнуть 525 легче. (([][][]()()()){()()({}[()])}{}[{{}}])
должен сэкономить вам 10 байтов
(477-).sum.map fromEnum
Попробуйте онлайн! Использование: (477-).sum.map fromEnum $ "123456890"
. 477 - это сумма кодов символов цифр от 1 до 9, исключая 0. Эта анонимная функция вычисляет 477 минус сумма всех кодов символов цифр, чтобы найти недостающий.
Превращение цифр в целые на один байт длиннее:
(45-).sum.map(read.pure)
foldl(\a b->a-read[b])45
ḟ
.
Ø
= ⎕
, D
= D
, ḟ
= ~
, как в ⎕D~'867953120'
.
Суммирует коды ascii и вычитает из 48 * 9 + 45
->s{477-s.sum}
Используйте как это
f=->s{477-s.sum}
puts f["123456789"]
редактировать 1 байт, за исключением thx @Neil, с гораздо более умным трюком
Сохранение всех значений от 1 до 9 дает 1. Xor 1 еще раз, и результат равен 0. Итак, если какое-либо одно значение отсутствует, результатом будет отсутствующее значение.
s=>eval([1,...s].join`^`)
Тест
f=s=>eval([1,...s].join`^`)
function go() {
var i=I.value;
O.textContent = f(i)
}
go()
<input oninput='go()' value='012987653' id=I>
<pre id=O></pre>
s=>eval([1,...s].join`^`)
сохраняет байт.
-6 Благодаря Basic Sunset
-2 благодаря Мартину Эндеру
.
$*_5$*
+`_1|1_
1
Замените каждую цифру таким количеством _
s и 5 1
s:
.
$*_5$*
Удалить все _
s и a 1
для каждого:
+`_1|1_
Подсчитайте количество 1
s осталось:
1
.
.
^
5
^.
$*9¶
.
$*_
+`_¶_
¶
_
_
до 1
сохранить байт.)
s=>(15-`0x${s}`%15)%15
Port of @ xnor's Python answer, за исключением того, что в JavaScript есть только оператор остатка, а не оператор по модулю, поэтому я не могу сделать это за один шаг. Редактировать: Сохранено 6 байтов благодаря @Arnauld.
s=>[...s].map(c=>r-=c,r=45)|r
;-)
reduce
. +1 в любом случае
s[0]!='0'
, но уже есть ответ, который использует eval
.
s=>(15-`0x${s}`%15)%15
?
-[-[->-<],]>++.
Попробуйте это здесь . Это решение работает только со стандартным Brainfuck (8-битными ячейками), так как оно основано на переносе.
Это редкий день, когда Brainfuck на самом деле может конкурировать, но этот вызов как раз совпал со спецификацией BF очень хорошо!
Вместо того, чтобы прямо разбить этот ответ, я хотел бы пройтись по итерациям, которые я предпринял, потому что я думаю, что это было бы более понятно (и более интересно).
Примечание: это решение во многом основано на ответе Brain-Flak от Wheat Wizard .
В своем ответе Wheat Wizard указал, что сумма значений ASCII от 0-9 сумм до 525. А так как стандартный Brainfuck имеет только понятие [0,255], это делает значение 525% 256 = 13 . То есть вычитание значений ASCII входных данных из 13 позволяет получить недостающую цифру.
Первая версия этой программы была:
1. Поместите 13 в первую ячейку
2. Укажите входные данные во вторую ячейку
3. Вычтите вторую ячейку из первой ячейки
4. Перейдите к 2, если есть оставшиеся входные данные
5. Напечатайте первую ячейку
А вот код для простого решения:
+++++++++++++ #Set the first cell to 13
>, #Take inputs into the second cell
[[<->-],] #Subtract the second cell from the first cell and repeat until inputs are over
<. #Print the first cell
Как указано в его ответе, так как мы знаем, что вход будет иметь длину ровно 9, мы можем использовать это значение как константу и исключить эту длинную строку + в самом начале.
Также не имеет значения, в какой момент мы добавляем 13 (спасибо, коммутативное свойство!), Поэтому мы смешаем это с шагами вычитания и печати.
, #Take input to enter the loop
[[->-<], #Subtract the first cell from the second cell
>+<] #Add 1 for each input; totaling 9
>++++ #Add the missing 4 to make 13
. #And print
Это был мой первоначальный ответ на эту проблему, но мы можем сделать лучше.
Интересно, что предыдущий ответ работает, даже если мы начнем с + вместо
+[[->-<],>+<]>++++.
Брейнфук требовал чего-то в камере, чтобы начать цикл. Мы наивно добавили эту лишнюю 4 в конце, когда она могла бы пойти в других местах.
-[[->-<],>+<]>++.
С некоторыми полностью преднамеренными хитростями цикла (читай: методом проб и ошибок) запуск программы с - - приводит к двум интересным результатам:
1 + 10 + 2 = 13, и в итоге мы получим оригинальный ответ.
Оглядываясь назад, это, вероятно, чрезмерное описание для такой простой программы Brainfuck.
Подумав немного об этом решении, я смог отрезать 2 байта.
Я хотел кое-что прояснить относительно предыдущего шага:
минус для входа в цикл фактически добавляет 1, но на самом деле он вычитает 255 из второй ячейки (в результате 1).
В ретроспективе это очевидно, но вычитание 1 из первой ячейки аналогично добавлению 1 во вторую ячейку (потому что все в первой ячейке вычитается из второй ячейки).
-[-[->-<],]>++.
Мне удалось удалить «> + <», добавив «-» в начале первого цикла. Он должен идти туда, а не туда, где был «> + <», потому что в противном случае программа будет зацикливаться бесконечно.
477-Tr@ToCharacterCode@#&
Чистая функция, принимающая строку в качестве входных данных и возвращающая целое число. Mathematica имеет длинные имена команд и неохотно конвертирует между строками и целыми числами, что особенно плохо в этой задаче. Лучшее, что я смог найти, - это алгоритм из Ruby-ответа от Level River St , который выполняет вычисления на основе суммы ASCII-кодов входной строки; в Mathematica это использует только одно длинное имя команды.
<?=trim(32043**2,$argv[1]);
использует трюк из ответа Рода, чтобы сгенерировать строку, содержащую все цифры, а затем удаляет все цифры, кроме пропущенной.
PHP, 41
for($b=1;$i<9;$b^=$argv[1][$i++]);echo$b;
Этот использует XOR, потому что я еще не видел его.
32043,32286,33144,35172,35337,35757,35853,37176,37905,38772,39147,39336,40545,42744,43902,44016,45567,45624,46587,48852,49314,49353,50706,53976,54918,55446,55524,55581,55626,56532,57321,58413,58455,58554,59403,60984,61575,61866,62679,62961,63051,63129,65634,65637,66105,66276,67677,68763,68781,69513,71433,72621,75759,76047,76182,77346,78072,78453,80361,80445,81222,81945,83919,84648,85353,85743,85803,86073,87639,88623,89079,89145,89355,89523,90144,90153,90198,91248,91605,92214,94695,95154,96702,97779,98055,98802,99066
Я нашел более короткое решение для bash, в котором используется интересный подход к контрольной сумме:
sum -s|dc -e524?--P
Объяснение:
Команда sum
печатает контрольную сумму и количество блоков. Я не знаю много деталей, но использую опцию-s
(алгоритм System V) сделает контрольную сумму равной сумме ASCII каждого входного кода символа. Таким образом, контрольная сумма остается постоянной, когда изменяется порядок тех же вводимых символов.
В 867953120
качестве тестового примера (последний пример), вот как работает скрипт:
sum -s
выходы 473 1
. Если бы не было пропущено целое число, контрольная сумма была бы 525.dc -e524?
толкает 524 и затем трубу ввода. Стек: 1 473 524
. Идея состоит в том, чтобы вычесть контрольную сумму из 525, но так как сумма выводит 1, мне нужно работать с ней.--P
, После применения двух вычитаний (524- (473-1)), стек: 52
. С помощью 'P' я печатаю символ с этим кодом ASCII: 4
пропущенная цифра.function m(s)
character(len=10)::s,t
t='0123456789'
do j=1,10
k=0
do i=1,9
if(s(i:i)==t(j:j))k=1
end do
if(k==0)m=j-1
end do
end
Боюсь, не очень коротко.
Ungolfed:
integer function m(s)
implicit none
character(len=9)::s
character(len=10)::t
integer:: i, j, k
t='0123456789'
do j=1,10
k=0
do i=1,9
if (s(i:i) == t(j:j)) k=1
end do
if (k==0) m=j-1
end do
end function m
A,sq-
A, e# The range from 0 to 9: [0 1 2 3 4 5 6 7 8 9]
s e# Cast to a string: "0123456789"
q e# The input
- e# Remove all characters from the range that are in the input
e# Implicit output
Включает +1 для -r
s/$/0123456789/
:
s/(.)(.*)\1/\2/
t
s/$/0123456789/ # Append 0123456789
: # Start loop
s/(.)(.*)\1/\2/ # remove a duplicate character
t # loop if something changed
ẹ:Ị↔x
Возможно, должно быть короче (я все еще не понимаю, почему ẹ
это необходимо), но это лучшее, что я мог сделать.
ẹ:Ị↔x
ẹ Split the input into a list of characters
:Ị Pair that list with the string "0123456789"
↔x Remove all elements of the list from the string
x
реализация старая и довольно глючная, поэтому вам нужно ẹ
.
¬∋ℕ
должно работать только в 3-х символах - это то, что я попробовал первым - но есть несколько причин, почему это не так, и я не думаю, что есть какой-либо правдоподобный способ изменить Brachylog, чтобы это было.
¬∋ℕ
работа невозможна даже в Прологе, если только вы не программируете то, что вы подразумеваете под этим not in
. ¬
в Brachylog эквивалентно \+
в Prolog, и его значение означает «не доказуемо в предположении закрытого мира», а не «дают мне точки выбора для всего, что не проверяет это» (что почти всегда бесконечное число вещей )
(lambda(s)(- 45(reduce'+ s :key'digit-char-p)))
Ungolfed:
(lambda (s) (- 45 (reduce '+ s :key 'digit-char-p)))
Explaination:
(reduce '+ s :key 'digit-char-p)
Это перебирает символы s
, преобразует их в цифры и добавляет их. Digit-char-p для удобства возвращает номер символа как его «истинное» значение, чтобы его можно было использовать в качестве теста или преобразования.
(- 45 ...)
Вычитание из 45 возвращает цифру, которая отсутствовала на входе.
5v&;52/ni?@.>!&oW+
расширенный
5 v
& ;
5 2 / n i ? @ .
> ! & o W + . .
. .
. .
Использует тот же метод, что и мозг ответ.
Создайте значение -525 в стеке, нажав 5, 2, объединить, нажать 5, объединить и отрицать.
Затем повторно получить вход и добавить, пока не будет достигнут конец ввода.
Удалите последний ввод, отмените (сделайте положительным) последний результат добавления, выведите символ и остановитесь.
Причиной работы от -525 и выше является то, что вывод символов выполняется для каждой входной итерации. Поскольку значение отрицательное, ничего не выводится до тех пор, пока цикл не выйдет и отрицательное значение не станет положительным.
Ввод вводится в ячейку
A1
.
Код:
=REGEXEXTRACT(4&2^29,"[^"&A1&"]")
Сохранено 6 байтов благодаря Стиву Кассу.
Предыдущий код:
=REGEXEXTRACT("0123456789","[^"&A1&"]")
Результат:
=REGEXEXTRACT(0&49^9,"[^"&A1&"]")
также является допустимым решением, учитывая аналогичную логику. Обновленный ответ.
Я сэкономил 1 байт, переместив программу на 1 строку и 1 байт, выполнив более точную математику
~+;@.%a--7;#
Сумма значений ASCII варьируется от 477 до 468 в зависимости от того, какое число отсутствует. Вычитая это из 7, мы получаем диапазон от -470 до -461. Модифицируя это число на 10, мы получаем диапазон 0 - 9, который мы можем затем напечатать.
~+; ;# Sums the ASCII values of all characters to stdIn
~ # The # doesn't skip over the ~ because it's on the end of a line
~ Once EOF is hit, the ~ reverses the IP's direction
;# Jump the ; that was used before
--7 Subtract the sum from 7 (really just 0 - (sum - 7))
%a Mod it by 10
@. Print and exit
Причина, по которой я использую значения ASCII вместо целочисленного ввода, заключается в том, что &
команда в Try it Online останавливает EOF (даже если она должна изменить IP-адрес). ~
Работает правильно, хотя.
#v~+
@>'i5*--,
Сумма значений ASCII всех 10 цифр равна 525. Вычитая сумму данных цифр из 525, мы получаем значение ASCII отсутствующего символа.
#v~+ Sums the ASCII values of all characters on stdIn
Moves to the next line when this is done
>'i5* Pushes 525 (105 * 5)
-- Subtracts the sum from 525
@ , Prints and exits
param($n)0..9|?{$n-notmatch$_}
Принимает входные данные $n
, создает диапазон 0..9
(т. Е. 0, 1, 2 ... 9
), Затем использует Where-Object
предложение ( |?{...}
), чтобы извлечь число, которое выполняет регулярное выражение -notmatch
. Это осталось на конвейере, вывод неявный.
-jkUT
-jkUT
T # 10
U # The unary range of ten: [0,1,..,9]
jk # join that on the empty string
- # set minus
"-jUT" также работает, но выдает новые строки для каждого типа int.