Вам будет предоставлена ​​строка. Он будет содержать 9 уникальных целых чисел от 0 до 9. Вы должны вернуть пропущенное целое число. Строка будет выглядеть так:

123456789
 > 0

134567890
 > 2

867953120
 > 4

Python 2 , 18 16 байт

^{+ красота благодаря @Sarge Borsch}

`99066**2`.strip

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

99066**2 это просто более короткий способ создания строки, которая содержит 0 ~ 9

Python , 22 байта

lambda s:-int(s,16)%15

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

Арифметическое решение. Интерпретирует входную строку как шестнадцатеричную, отрицает ее и получает результат по модулю 15.

APL (Дьялог) , 4 байта

Производная функция

⎕D∘~

⎕D D igits

∘ (связывает левый аргумент со следующей двоичной функцией для создания монадической функции)

~ кроме [аргумент]

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

Функциональный поезд

⎕D~⊢

⎕D D igits

~ Кроме

⊢ правильный аргумент

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

Явная программа

⎕D~⍞

⎕D D igits

~ Кроме

⍞ ввод символов

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

Brain-Flak , 48 38 36 + 3 = 39 байт

10 байтов сохранено благодаря DJMcMayhem!

((([]())[]{}){()()({}[()])}{}[{{}}])

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

объяснение

Сумма всех цифр в Ascii составляет 525. Эта программа суммирует входные данные и вычитает их из 525, чтобы получить недостающую цифру.

((([]())[]{}){()()({}[()])}{}      )

Нажмите 525. Это использует тот факт, что мы знаем, что для начала будет 9 элементов ввода. Это значит, что[] значение равно 9, что позволяет нам быстро получить большие числа, например 525.

Далее у нас есть немного:

                             [{{}}]

который будет суммировать входные данные и вычитать его из общей суммы.

Haskell , 24 23 байта

(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

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

Желе , 3 байта

ØDḟ

Просто фильтрует ( ḟ) входную строку из «0123456789» ( ØD).

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

Руби, 14

Суммирует коды ascii и вычитает из 48 * 9 + 45

->s{477-s.sum}

Используйте как это

f=->s{477-s.sum}

puts f["123456789"]

JavaScript (ES6), 26

редактировать 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>

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

-6 Благодаря Basic Sunset
-2 благодаря Мартину Эндеру

.
$*_5$*
+`_1|1_

1

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

Замените каждую цифру таким количеством _s и 5 1s:

.
$*_5$*

Удалить все _s и a 1для каждого:

+`_1|1_ 

Подсчитайте количество 1s осталось:

1

05AB1E , 6 байтов

45¹SO-

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

45     # Push 45
  ¹    # push input
   S   # Split
    O  # Sum
     - # Subtract (45 - sum)

JavaScript (ES6), 31 29 28 22 байта

s=>(15-`0x${s}`%15)%15

Port of @ xnor's Python answer, за исключением того, что в JavaScript есть только оператор остатка, а не оператор по модулю, поэтому я не могу сделать это за один шаг. Редактировать: Сохранено 6 байтов благодаря @Arnauld.

Brainfuck, 17 15 байт

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

Попробуйте это здесь . Это решение работает только со стандартным Brainfuck (8-битными ячейками), так как оно основано на переносе.

Это редкий день, когда Brainfuck на самом деле может конкурировать, но этот вызов как раз совпал со спецификацией BF очень хорошо!

Вместо того, чтобы прямо разбить этот ответ, я хотел бы пройтись по итерациям, которые я предпринял, потому что я думаю, что это было бы более понятно (и более интересно).
Примечание: это решение во многом основано на ответе Brain-Flak от Wheat Wizard .

объяснение

Шаг 1, 26 байт

В своем ответе 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  

Шаг 2, 19 байт

Как указано в его ответе, так как мы знаем, что вход будет иметь длину ровно 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

Это был мой первоначальный ответ на эту проблему, но мы можем сделать лучше.

Шаг 3, 17 байт

Интересно, что предыдущий ответ работает, даже если мы начнем с + вместо

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

Брейнфук требовал чего-то в камере, чтобы начать цикл. Мы наивно добавили эту лишнюю 4 в конце, когда она могла бы пойти в других местах.

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

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

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

1 + 10 + 2 = 13, и в итоге мы получим оригинальный ответ.

Оглядываясь назад, это, вероятно, чрезмерное описание для такой простой программы Brainfuck.

Шаг 4, 15 байт

Подумав немного об этом решении, я смог отрезать 2 байта.

Я хотел кое-что прояснить относительно предыдущего шага:
минус для входа в цикл фактически добавляет 1, но на самом деле он вычитает 255 из второй ячейки (в результате 1).

В ретроспективе это очевидно, но вычитание 1 из первой ячейки аналогично добавлению 1 во вторую ячейку (потому что все в первой ячейке вычитается из второй ячейки).

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

Мне удалось удалить «> + <», добавив «-» в начале первого цикла. Он должен идти туда, а не туда, где был «> + <», потому что в противном случае программа будет зацикливаться бесконечно.

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

@(x)setdiff('0':'9',x)

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

Mathematica, 25 байтов

477-Tr@ToCharacterCode@#&

Чистая функция, принимающая строку в качестве входных данных и возвращающая целое число. Mathematica имеет длинные имена команд и неохотно конвертирует между строками и целыми числами, что особенно плохо в этой задаче. Лучшее, что я смог найти, - это алгоритм из Ruby-ответа от Level River St , который выполняет вычисления на основе суммы ASCII-кодов входной строки; в Mathematica это использует только одно длинное имя команды.

PHP, 27

<?=trim(32043**2,$argv[1]);

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

PHP, 41

for($b=1;$i<9;$b^=$argv[1][$i++]);echo$b;

Этот использует XOR, потому что я еще не видел его.

Bash + coreutils, 19 байт

Я нашел более короткое решение для 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пропущенная цифра.

Фортран 95, 146 128 байт

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

CJam , 5 байтов

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

GNU sed , 36 байт

Включает +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

Брахилог (2), 5 байт

ẹ:Ị↔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

Common Lisp, 47 байт

(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 возвращает цифру, которая отсутствовала на входе.

Cubix , 18 байт

5v&;52/ni?@.>!&oW+

расширенный

    5 v
    & ;
5 2 / n i ? @ .
> ! & o W + . .
    . .
    . .

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

Использует тот же метод, что и мозг ответ.

Создайте значение -525 в стеке, нажав 5, 2, объединить, нажать 5, объединить и отрицать.
Затем повторно получить вход и добавить, пока не будет достигнут конец ввода.
Удалите последний ввод, отмените (сделайте положительным) последний результат добавления, выведите символ и остановитесь.

Причиной работы от -525 и выше является то, что вывод символов выполняется для каждой входной итерации. Поскольку значение отрицательное, ничего не выводится до тех пор, пока цикл не выйдет и отрицательное значение не станет положительным.

PHP, 37 байт

<?=45-array_sum(str_split($argv[1]));

Баш (+ коммунальные услуги), 2219 байтов

• Используйте seqвместо расширения скобки -3 байта (Thx @Riley!)

seq 0 9|tr -d \\n$1 

Тест

$seq 0 9|tr -d \\n123456789
0

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

Google Sheets, 39 33 байта

Ввод вводится в ячейку A1.

Код:

=REGEXEXTRACT(4&2^29,"[^"&A1&"]")

Сохранено 6 байтов благодаря Стиву Кассу.

Предыдущий код:

=REGEXEXTRACT("0123456789","[^"&A1&"]")

Результат:

Befunge 98, 14 12 байт

Я сэкономил 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-адрес). ~Работает правильно, хотя.

Старая программа , 14 байт

#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

PowerShell , 30 байт

param($n)0..9|?{$n-notmatch$_}

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

Принимает входные данные $n, создает диапазон 0..9(т. Е. 0, 1, 2 ... 9), Затем использует Where-Objectпредложение ( |?{...}), чтобы извлечь число, которое выполняет регулярное выражение -notmatch. Это осталось на конвейере, вывод неявный.

Рёда , 28 байт

{(_/"")|ord _|sum|chr 525-_}

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

Pyth, 5 байт

-jkUT

попытайся!

объяснение

-jkUT
    T   # 10
   U    # The unary range of ten: [0,1,..,9]
 jk     # join that on the empty string
-       # set minus

"-jUT" также работает, но выдает новые строки для каждого типа int.

05AB1E , 5 байтов

žhISK

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

объяснение

žh     # from the string "0123456789"
    K  # remove
  IS   # each digit of the input