Виклик

Давши ціле число, що ділиться на 9, і одну пропущену цифру, знайдіть пропущену цифру.

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

Якщо відсутня цифра може бути 0 або 9, виведіть щось для позначення.

Припустимо, що користувач досить розумний, щоб помістити лише одну пропущену цифру та одне число тощо

Випробування

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

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

Пітон , 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.

Спробуйте в Інтернеті!

Так, для логічного програмування!

Пояснення

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

Тоді ми визначимось +саме цим присудком0 першим аргументом. Тобто ми хочемо, щоб цифрова сума була кратною 9.

Prolog виконує всю бурхливу роботу щодо пошуку насправді рішень.

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 . При використанні кожного швидкого ( €) під час оцінювання розбиття числа на цифри було зайвим.

Збережено 3 байти завдяки Деннісу . Можна побіжно АБО введення з 0 замість того, щоб вручну розбирати вхід як число, видаляючи провідні нулі та нецифрові цифри.

Свіфт , 51 байт

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

Спробуйте в Інтернеті!

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

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

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

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

Спробуйте в Інтернеті!

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

Це працює лише в інтерпретаторі PyFunge з причин, пояснених нижче.

Пояснення

Значна частина цього пояснення копіюється з мого пояснення Befunge-98 , оскільки ця програма дуже схожа на цю. _{^{безсоромна пробка}}

У першому рядку програми ми підсумовуємо цифри, включаючи х, який трактується як 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 байт

Я зрозумів, що мені не потрібно використовувати ?для відображення відсутньої цифри, тому після віднімання 48 я використав таку, що є кратною 9: 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

If we just modded by 9, we would be left with the wrong digit, because we want 9 - (sum % 9). However, we can do better than 9\-, which would subtract the remainder from 9: if we make the sum negative before modding by 9, we will get a positive result, equivalent to 9 - (sum % 9) in some interpreters. This is what requires us to use the PyFunge interpreters for both Befunge 93 and 98, as it is the only one on TIO that does this. The others give us a value between -8 and 8 instead of 0 and 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

Ruby, 22 bytes

Uses ' (any char that has a distance to 0 that is divisible by "0" will do, including 0 itself).

An output of 0 signifies either 0 or 9.

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

Try it online!

Explanation

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

Ruby, 46, 41 bytes

-5 thanks to @Unihedron

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

Try it online!

Befunge-93, 28 27 19 18 bytes

Credit must go to Mistah Figgins, whose PyFunge answer showed me that you didn't need a special check for the missing digit character, if you just made sure the ASCII value was a multiple of nine.

Additional thanks to Jo King who showed that you didn't need to fully convert the characters to their numeric equivalent, and could simply subtract 3 to get a value that is relative to base 9 (ASCII 0 minus 3 is 45, a multiple of 9).

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

Try it online!

For this to work, you should use the character * for the missing digit (there are others that could also work, but that's the nicest).

Outputs 9 if the missing digit could be 0 or 9.

Explanation

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.

Essentially we are calculating the sum of all digits, plus 45 per digit (which will ultimately be cancelled out when we mod with 9). This sum is subtracted from 3 (our starting total), and an additional 39 is subtracted by the missing digit (ASCII * minus three). Again that 3 minus 39 is a multiple of 9, so it's cancelled out when we mod with 9.

So in the end we're calculating the negative sum of all the digits, mod 9, plus 9, i.e.

9 - (digitsum % 9)

And that's gives us the missing digit.

Befunge-98 (PyFunge), 8 bytes

#q~3--9%

Try it online!

Outputs via exit code. As with Mistah Figgin's answer, it only works with Pyfunge, where a negative number mod 9 becomes positive. Uses an x as the missing digit.

PowerShell, 40 bytes

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

Try it online! or Verify all test cases

Takes input like '123x' into $a. Constructs a range 0 to 9 and uses Where-Object (here abbreviated as |?) to pull out those integers that match the clause. The clause takes $a, performs a regex -replace to replace the x with the current digit $_ and gets the mod 9 with %9. Thus if 9 evenly divides, this will be zero. We take the Boolean-not thereof, which turns the zeros truthy and everything else falsey, so that satisfies the Where-Object clause. Those result(s) are left on the pipeline and output is implicit.

Haskell, 35 bytes

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

Try it online!

Retina, 35 34 25 bytes

If the ? can be 0 or 9, the result is shown as 9.

.
$*
1{9}

^
9$*;
+`;1

.

Try it online

Explanation

.       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 bytes

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

Try it online!

Doesn't care what character signifies the missing digit as long as it isn't a digit.

Tcl, 53 bytes

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

As with other answers, this is made shorter by not explicitly saying “0 or 9”.
Instead, a result of “9” means either 0 or 9.

Try it online!

Explanation

It works pretty simply. It employs a regular expression to:

• split the argument into individual digits
• eliminate any question mark(s) non-digit(s)
• interleave the digits with plus signs

It then evaluates 9 - (sum_of_digits mod 9) to arrive at a final value in 1..9, which it then puts.

The leading 0 (in 0$argv) is required just in case the question mark comes first in the input; a leading plus sign in the transformed sequence is not a problem for expr.

Pyth, 8 bytes

%_iz19 9

Try it online!

Uses I instead of ?.

• Convert to base 19.
• Negate.
• Modulo 9.

APL (Dyalog), 13 bytes

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

Try it online!

The missing digit is ⍬.

brainfuck, 50 bytes

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

Try it online!

Prints a 9 for either 0 or 9. Missing character is represented by :

How It Works

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

The missing character needs to be a character that has a mod 9 of 4, +3 because we subtract 3 from the normal digits and +1 for the initialisation of the total as 1.

As a side note, there is a lot of inefficiency in the code for the sake of golfing, as each digit will reset the total 5 times each, rather than just once sometimes if I subtracted 48 instead of 3.

><>, 35 33 25 21 15 bytes

An output of 0 means the result could be either 0 or 9.

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

Try it online!

Saved 6 bytes thanks to Jo King by using ' to represent missing digits.

Java 8, 36 34 bytes

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

Returns 9 when both 0 and 9 are valid.

Explanation:

Try it online.

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