Вызов

Учитывая целое число, делимое на 9 и одну пропущенную цифру, найдите пропущенную цифру.

Недостающая цифра может быть представлена ​​любым символом, кроме цифр 0-9, если она соответствует.

Если пропущенная цифра может быть 0 или 9, выведите что-нибудь для обозначения этого.

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

Тестовые случаи

В тестовых случаях отсутствующая цифра представлена ​​знаком вопроса

123? -> 3
?999 -> 0 or 9
?0023 -> 4
000?1 -> 8

Python , 21 байт

lambda s:-int(s,19)%9

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

Я имел обыкновение Iпредставлять отсутствующую цифру.

Алиса , 12 байт

/o&
\i@/+R9%

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

Выводится, 0если результат может быть 0 или 9.

объяснение

/   Switch to Ordinal mode.
i   Read all input as a string.
&   Fold the next operation over the characters of this strings.
/   Switch to Cardinal mode (not an operation).
+   Add. Implicitly converts each character to the integer value it represents
    and adds it to the top of the stack. The top of the stack is initially, implicitly
    zero. When the character is "?", it is simply discarded, which adds the top of
    the stack to another implicit zero beneath, so the "?" is effectively skipped.
R   Negate. Multiplies the sum by -1.
9%  Modulo 9. This gives the result.
\   Switch to Ordinal mode.
o   Implicitly convert the result to a string and print it.
@   Terminate the program.

JavaScript (ES6), 40 байт

Выходы 9, если могут быть 0 или 9.

f=_=>9-([..._].reduce((a,b)=>a+~~b,0)%9)

Japt, 7 байт

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

Может принимать любой нечисловой символ в качестве отсутствующей цифры. Выходы , 0когда решение может быть то , что или 9.

¬x*J u9

Попытайся

объяснение

Неявный ввод строки U. ¬разбивает на массив отдельных символов, xуменьшает массив путем добавления игнорирования любых нечисловых элементов, *Jумножает каждый элемент на -1 и u9получает положительный модуль результата.

JavaScript (ES6), 18 байт

Ожидается +как отсутствующая цифра. Возвращает 9на 0 или 9 .

s=>9-eval(9+s+9)%9

Контрольные примеры

let f =

s=>9-eval(9+s+9)%9

console.log(f('123+'))  // -> 3
console.log(f('+999'))  // -> 0 or 9
console.log(f('+0023')) // -> 4
console.log(f('000+1')) // -> 8

05AB1E , 7 6 байтов

Вывод 0означает, что результатом может быть 0 или 9 .

þSO(9%

Попробуйте онлайн! или как тестовый набор

объяснение

þ        # remove non-digits from input
 S       # split to list of digits
  O      # sum list
   (     # negate
    9%   # mod by 9

Python 2 , 44 41 35 байт

^{-6 байт благодаря RiaD}

lambda n:-sum(ord(c)-3for c in n)%9

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

Пользователи ]за отсутствующей цифрой.
Выводится, 0если пропущенная цифра может быть 0 или 9.

Pyth, 9 7 байт

%_s-Qd9

Использует пробел в качестве разделителя и возвращает 0, если результатом может быть 0 или 9.

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

объяснение

%_s-Qd9
   -Qd   Remove the space from the input.
  s      Convert it to an integer.
%_    9  Negate mod 9.

Пролог (SWI) , 59 байт

0*[].
X*[H|T]:-between(0,9,H),U is mod(X+H,9),U*T.
+X:-0*X.

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

Yay для логического программирования!

объяснение

Сначала мы создаем предикат *, который сохраняется при применении к нулю и пустому списку. Наш предикат также сохраняется, когда начало списка находится между 0 и 9, и когда мы добавляем ведущую цифру мод 9, предикат удерживается.

Затем мы определяем +этот предикат 0как первый аргумент. То есть мы хотим, чтобы цифровая сумма была кратна 9.

Пролог выполняет всю основную работу по поиску решений для нас.

Befunge-93 , 16 байт

1+!_#@3#.--9%~:#

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

Однолинейная версия ответа Джеймса Холдернесса «Befunge», в котором удается сбрить два байта. Это по существу сжимает код до одной строки, меняет направление и использует тот факт, что Befunge не пропускает конец строки. Он предложил мне опубликовать отдельный ответ с объяснением. Код принимает * как представление отсутствующей цифры и выводит 9 для 0 или 9.

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

1+!_  3  --9% Initialises the pointer going right and initialises the digitsum with 3

1+!_         ~: Gets input and checks whether it is end of input (-1)

      3  - Subtract three from the input. 
           This turns the ASCII values of digits into their mod 9 equivalent ("0"(48)=>45(mod 9)=>0)

          -9% Subtract the value from the digitsum and mod it with 9
              This keeps the digitsum as a negative digit greater than -9
              Repeat this until the input ends

Now this is where it gets tricky.
At the end of input, the stack looks like this:
  -(Digitsum%9), Copy of EOF input (-1)
The pointer is moving left from the _
 +!_ Invert the -1 to get 0 and add it to the digitsum (does nothing but get rid of the -1)
1           %~ Adds 1 mod -1 (no input) = 0 to the stack
         --9 Subtracts 9 from 0, yielding -9 and subtracts that from the digitsum. 
             This makes the digitsum positive and equal to 9-(digitsum%9), our desired value
     @  . Finally, print and exit

* (ASCII-значение 42) было выбрано в качестве пропущенного символа, поскольку оно противодействует начальному значению цифры, 3.

LaTeX, много байтов ( 1000 628 614)

\RequirePackage{expl3}
\ExplSyntaxOn
\tl_new:N \l_divnine_input_tl
\int_new:N \l_divnine_sum_int
\def \getnum {
  \typein [ \l_divnine_input_tl ] { Input\space a\space number }
  \tl_map_function:NN \l_divnine_input_tl \divnine_sum:n
  \int_set:Nn \l_tmpa_int { 9 - \int_mod:nn { \l_divnine_sum_int } { 9 } }
  \typeout
    { The\space missing\space digit\space is:\space
      \int_use:N \l_tmpa_int
      \int_compare:nNnT { \l_tmpa_int } = { 0 } { \space or\space 9 }
    }
}
\cs_new:Nn \divnine_sum:n {
  \regex_match:nnT { \d } { #1 } { \int_add:Nn \l_divnine_sum_int { #1 } }
}
\ExplSyntaxOff
\getnum
\stop

LaTeX, неразборчиво ( 348 334 байта)

\RequirePackage{expl3}\ExplSyntaxOn\int_new:N\1\tl_new:N\2\def\3{\typein[\2]{Input\space a\space number}\tl_map_function:NN\2\4\int_set:Nn\1{9-\int_mod:nn{\1}{9}}\typeout{The\space missing\space digit\space is:\space\int_use:N\1\int_compare:nNnT{\1}={0}{\space or\space9}}}\def\4#1{\regex_match:nnT{\d}{#1}{\int_add:Nn\1{#1}}}\3\stop

LaTeX, 132 байта

\RequirePackage{expl3}\typein[\1].\newcount\2{\ExplSyntaxOn\int_gset:Nn\2{9-\int_mod:nn\19}}\typeout{\the\2 \ifnum\2=9or 0\fi}\stop

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

J , ₁₄ 12 байт

-2 байта благодаря @BolceBussiere

9|9-[:+/"."0

Я, честно говоря, не знаю, почему "."0интерпретирует ?как 0, но так поступает с моим переводчиком и с TIO, поэтому я не собираюсь подвергать это сомнению. (Обновление: см. Комментарии для объяснения почему).

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

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

Желе , 11 9 6 байт

|0SN%9

объяснение

|0     # Read input while removing non-digits (question marks) and removing leading zeros
  S    # Sum the digits
   N   # Negate
    %9 # Mod by 9

Выход 0 означает, что результатом может быть 0 или 9.

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

Сохранено 2 байта благодаря г-ну Xcoder . При использовании Every quick ( €) во время оценки разбиение числа на цифры было излишним.

Сохранено 3 байта благодаря Денису . Можно поразрядно ИЛИ вводить с 0 вместо ручного анализа ввода как числа, удаляя начальные нули и не цифры.

Swift , 51 байт

{9-Int("0"+$0.filter{"?" != $0})!%9}as(String)->Int

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

Befunge-93 (PyFunge) , 22 21 байт

Я понял, что мне не нужно использовать ?для представления отсутствующей цифры, поэтому я использовал одну, кратную 9, после вычитания 48: x
это позволило мне выйти из игры 3+, но сэкономило только 1 байт из-за длины первая строка перед условной :(

Порт моего ответа Befunge-98: еще
5 байтов, чтобы проверить, достигли ли мы EOF, еще
1 байт, чтобы нажать 48 ( "0"против '0), еще
1 байт, чтобы напечатать ответ .@,
и еще 1 байт, потому что второй строка содержит пробел
в общей сложности еще 8 байтов.

~:0`!#|_"0"-+
 @.%9-<

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

Выводится, 0если пропущенная цифра может быть 0 или 9.

Это работает только в интерпретаторе PyFunge по причинам, объясненным ниже.

объяснение

Большая часть этого объяснения скопирована из моего объяснения Befunge-98 , так как эта программа очень похожа на эту. _{^{бесстыдная вилка}}

В первой строке программы мы суммируем цифры, включая x, который рассматривается как 72 из-за значения ASCII. Тем не менее, сумма будет такой же, как только мы изменим на 9, так что это не имеет значения.

~:0`!#|_"0"-+    THE FIRST LINE
~                Gets a character from input - If it is negative, we've reached EOF
 :0`!            Pushes 0 if the character is positive, 0 otherwise
     #|_         Goes to the next line if the value if 0
                     This also gets the negative value off the stack by using a |
        "0"-     Subtracts 48 to account for taking in ASCII values
            +    Adds this adjusted value to the sum

Если бы мы просто изменили на 9, мы остались бы с неправильной цифрой, потому что мы хотим 9 - (sum % 9). Однако, мы можем сделать лучше, чем 9\-, что бы вычесть остаток из 9: если мы сделаем сумму отрицательной перед моддингом на 9, мы получим положительный результат, эквивалентный 9 - (sum % 9)некоторым интерпретаторам. Это то, что требует от нас использования интерпретаторов PyFunge как для Befunge 93, так и для 98, поскольку это единственный TIO, который делает это. Другие дают нам значение между -8 и 8 вместо 0 и 8

 @.%9-<    THE SECOND LINE
      <    Redirects the IP onto this line
     -     Subtracts the sum from an implicit 0, making it negative
   %9      Mods the sum by 9
 @.        Prints the digit and exits

Befunge-98 (PyFunge) , 15 13 байт

Я понял, что мне не нужно использовать ?для представления отсутствующей цифры, поэтому я использовал одну, кратную 9, после вычитания 48: x
Это позволило мне играть в гольф 3+.

#v~'0-+
q>-9%

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

Используется xкак отсутствующая цифра, потому что ее значение ASCII делится на 9 после вычитания 48 (и это хорошо, потому что его обычно используют как переменную в математике).

Выходы через код выхода (потому что qна один байт короче .@)
Выходы, 0если пропущенная цифра может быть 0 или 9.

Это работает только в интерпретаторе PyFunge по причинам, объясненным ниже.

объяснение

В первой строке программы мы суммируем цифры, включая x, который рассматривается как 72 из-за его значения ASCII. Тем не менее, сумма будет такой же, как только мы изменим на 9, так что это не имеет значения.

#v~'0-+    THE FIRST LINE
#v~        Pushes the next character from input, and goes to the second line on EOF
   '0-     Subtracts 48 to account for taking in ASCII values
      +    Adds this adjusted value to the sum

Если бы мы просто изменили на 9, мы остались бы с неправильной цифрой, потому что мы хотим 9 - (sum % 9). Однако, мы можем сделать лучше, чем 9\-, что бы вычесть остаток из 9: если мы сделаем сумму отрицательной перед моддингом на 9, мы получим положительный результат, эквивалентный 9 - (sum % 9) некоторым интерпретаторам . Это то, что требует от нас использования интерпретаторов PyFunge как для Befunge 93, так и для 98, поскольку это единственный TIO, который делает это. Другие дают нам значение между -8 и 8 вместо 0 и 8.

q>-9%    THE SECOND LINE
 >       Redirects the IP onto this line
  -      Subtracts the sum from an implicit 0, making it negative
   9%    Mods the sum by 9
q        Outputs via exit code, ending the program

Рубин , 22 байта

Использует '(подойдет любой символ, расстояние до 0которого делится на «0», включая 0самого себя).

Выход 0означает либо 0или 9.

p -(gets.sum+6*~/$/)%9

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

объяснение

p     # print after inspecting
  -(  # unary negative, for reversing result of modulus (a-b%a)
    gets.sum # ascii value of string
    + 6*~/$/ # add six for each size (in chars) of input, so "0" translates to 0
  )%9 # mod 9
      # find remainder after dividing 9
      # except it's inverted so it's remainder to add to divide 9

Рубин , 46 , 41 байт

-5 благодаря @Unihedron

->s{-s.chars.sum{|i|?<>i ? i.to_i : 0}%9}

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

Befunge-93, 28 27 19 18 байт

Нужно отдать должное Mistah Figgins , чей ответ PyFunge показал мне, что вам не нужна специальная проверка на отсутствие символа, если вы просто убедитесь, что значение ASCII кратно девяти.

Дополнительная благодарность Джо Кингу, который показал, что вам не нужно полностью преобразовывать символы в их числовые эквиваленты, и вы можете просто вычесть 3, чтобы получить значение, относящееся к основанию 9 (ASCII 0минус 3 равно 45, кратно 9) ,

3_v#`0:~--
%9_@.+9

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

Чтобы это работало, вы должны использовать символ *для пропущенной цифры (есть и другие, которые также могут работать, но это лучше).

Выводится, 9если пропущенная цифра может быть 0 или 9.

объяснение

3             Push 3 onto the stack.
 _            Since this is non-zero, drop the 3 and branch left.
3             Now executing right to left, push 3 again.
        --    Negate twice, leaving the value unchanged as our starting sum.

       ~      Now we start the main loop, reading a character from stdin.
    `0:       Duplicate and check if it's > 0, i.e. not end-of-stream.
 _ #          If so, continue to the left.
3        -    Subtract 3 to make the number relative to base 9.
        -     Then subtract it from the total, and repeat the loop.

  v           Once we reach the end of the input, we go down.
  _           Drop the EOF character from the stack and go left.
%9   +9       Mod the total with 9, and add 9.
   @.         Output the result and exit.

По сути, мы рассчитываем сумму всех цифр плюс 45 за цифру (которая в конечном итоге будет отменена, когда мы модифицируем с 9). Эта сумма вычитается из 3 (наша начальная сумма), а дополнительные 39 вычитаются из отсутствующей цифры (ASCII *минус три). Опять же, что 3 минус 39 кратно 9, так что мы отменяем, когда мы мод с 9.

Итак, в конце мы вычисляем отрицательную сумму всех цифр, мод 9, плюс 9, т.е.

9 - (digitsum % 9)

И это дает нам недостающую цифру.

Befunge-98 (PyFunge) , 8 байт

#q~3--9%

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

Выходы через код выхода. Как и в случае с ответом Mistah Figgin , он работает только с Pyfunge, где отрицательное число mod 9 становится положительным. Использует х в качестве отсутствующей цифры.

PowerShell , 40 байт

param($a)0..9|?{!(($a-replace'x',$_)%9)}

Попробуйте онлайн! или проверить все контрольные примеры

Принимает участие как '123x'в $a. Создаст диапазон 0для 9и использования Where-Object(здесь сокращенно |?) , чтобы вытащить эти целые числа , которые соответствуют пункту. Предложение принимает $a, выполняет регулярное выражение -replaceдля замены xтекущей цифры $_и получает мод 9 с %9. Таким образом, если 9 делится поровну, это будет ноль. Мы берем булево-не-его значение, которое превращает нули в истинность, а все остальное ложно, так что удовлетворяет предложению Where-Object. Эти результаты остаются в конвейере, а вывод неявным.

Haskell , 35 байт

f s=9-sum[read[i]|i<-s,i<':']`mod`9

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

Сетчатка , 35 34 25 байт

Если это ?возможно 0 or 9, результат отображается как 9.

.
$*
1{9}

^
9$*;
+`;1

.

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

объяснение

.       Sum of the digits in unary + 1
$*
1{9}    Modulo 9

^       Prepend 9 semicolons, for subtracting
9$*;
+`;1    Subtract from 9

.       Back to decimal

Perl 5 , 23 байта

$_=- s/\D//r%9;s/0/0|9/

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

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

Tcl, 53 байта

puts [expr 9-([regsub -all (\\d)\\D? 0$argv +\\1])%9]

Как и в случае с другими ответами, это делается короче, если не сказать явно «0 или 9».
Вместо этого результат «9» означает либо 0, либо 9.

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

объяснение

Это работает довольно просто. Он использует регулярное выражение для:

• разбить аргумент на отдельные цифры
• Устранить любые вопросительные знаки без цифр
• чередовать цифры со знаком плюс

Затем он оценивает 9 - (sum_of_digits mod 9), чтобы получить окончательное значение в 1..9, которое оно затем puts.

Ведущий 0 (в 0$argv) требуется только в том случае, если вопросительный знак стоит первым на входе; ведущий знак плюс в преобразованной последовательности не является проблемой для expr.

Pyth , 8 байт

%_iz19 9

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

Использует Iвместо ?.

• Конвертировать в базу 19.
• Отрицание.
• По модулю 9

APL (Dyalog) , 13 байт

{9-9|+/,↑⍎¨⍵}

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

Недостающая цифра есть ⍬.

брейкфук , 50 байт

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

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

Печатает 9 для 0 или 9. Отсутствующий символ представлен:

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

Tape Format:
    0 Total Input 0

The total is represented as 9-digitSum%9

+>,[ Start loop with 1 as the total
    --- Subtract 3 from the inputted byte to make the value%9 equal to the digit
    [   While the input byte exists
      <-                 Decrement the total
      [<<]>[<+++++++++<] If the total is 0, reset it to 9
      >>-                Decrement the input byte
    ]
,] Continue loop until there is no input
-[<+>-----]<---. Add 48 to the total to convert the digit to the ascii value and output it

Пропущенный символ должен быть символом с модом 9 4, +3, потому что мы вычитаем 3 из нормальных цифр и +1 для инициализации всего как 1.

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

> <> , 35 33 25 21 15 байт

Вывод 0означает, что результатом может быть 0 или 9 .

0i:&0(?n&3--9%!

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

Сохраненные 6 байт благодаря Джо Кингу , используя 'для представления недостающих цифр.

Java 8, 36 34 байта

s->9-s.map(c->c>57?0:c-48).sum()%9

Возвращает, 9когда оба 0и 9действительны.

Объяснение:

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

s->                               // Method with IntStream parameter and int return-type
   9-                             //  Return 9, minus:
     s.map(c->c>57?0:c-48).sum()  //   The sum of the digits (ignoring the question mark)
     %9                           //   modulo-9