Desafio

Dado um número inteiro divisível por 9 e um dígito ausente, encontre o dígito ausente.

O dígito ausente pode ser representado por qualquer caractere que não seja os dígitos de 0 a 9, desde que consistente.

Se o dígito ausente puder ser 0 ou 9, digite algo para indicar isso.

Suponha que o usuário seja inteligente o suficiente para colocar apenas um dígito e um número ausentes, etc.

Casos de teste

Nos casos de teste, o dígito ausente é representado por um ponto de interrogação

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

Python , 21 bytes

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

Experimente online!

Eu costumava Irepresentar um dígito ausente.

Alice , 12 bytes

/o&
\i@/+R9%

Experimente online!

Saída 0se o resultado puder ser 0 ou 9.

Explicação

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

Emite 9 se poderia ser 0 ou 9.

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

Japonês, 7 bytes

Tentei algumas soluções, mas a mais curta foi semelhante à maioria das outras, exceto que não precisamos substituí-las ?no início.

Pode assumir qualquer caractere não numérico como o dígito ausente. Saída 0quando a solução pode ser essa ou 9.

¬x*J u9

Tente

Explicação

Entrada implícita da sequência U. ¬divide em uma matriz de caracteres individuais, xreduz a matriz ignorando quaisquer elementos não numéricos, *Jmultiplica cada elemento por -1 e u9obtém o módulo positivo do resultado.

JavaScript (ES6), 18 bytes

Espera a +como o dígito ausente. Retorna 9para 0 ou 9 .

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

Casos de teste

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 bytes

Uma saída de 0significa que o resultado pode ser 0 ou 9 .

þSO(9%

Experimente online! ou como um conjunto de testes

Explicação

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

Python 2 , 44 41 35 bytes

^{-6 bytes graças ao RiaD}

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

Experimente online!

Usuários ]para dígitos ausentes.
Saída 0se o dígito ausente puder ser 0 ou 9.

Pitão, 9 7 bytes

%_s-Qd9

Usa espaço como delimitador e retorna 0 se o resultado puder ser 0 ou 9.

Experimente online

Explicação

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

Prolog (SWI) , 59 bytes

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

Experimente online!

Yay para programação lógica!

Explicação

Primeiro, criamos um predicado *, que é válido quando aplicado a zero e à lista vazia. Nosso predicado também é válido quando a frente da lista está entre 0 e 9 e, quando adicionamos o primeiro dígito mod 9, o predicado é válido.

Em seguida, definimos +como apenas esse predicado 0como o primeiro argumento. Ou seja, queremos que a soma digital seja um múltiplo de 9.

Prolog faz todo o trabalho duro de encontrar soluções para nós.

Befunge-93 , 16 bytes

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

Experimente online!

Uma versão de uma linha da resposta Befunge de James Holderness, que consegue cortar dois bytes. Isso essencialmente comprime o código em uma linha, inverte a direção e tira proveito do fato de o Befunge não pular no final da linha. Ele sugeriu que eu publicasse uma resposta separada com uma explicação. O código usa um * como representando o dígito ausente e gera um 9 para 0 ou 9.

Como funciona

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

* (Valor ASCII 42) foi escolhido como o caractere ausente porque contraria o valor inicial do dígito, 3.

LaTeX, muitos bytes ( 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, ilegível ( 348 334 bytes)

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

\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

Somente o espaço é permitido como dígito desconhecido neste código.

J , ₁₄ 12 bytes

-2 bytes graças a @BolceBussiere

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

Sinceramente, não sei por que "."0interpreta ?como 0, mas faz isso no meu intérprete e no TIO, de modo que não vou questioná-lo. (Atualização: veja os comentários para uma explicação do porquê).

Essa abordagem simplesmente pega a soma dos dígitos, a nega subtraindo 9 e a módulo 9.

Experimente online!

Geléia , 11 9 6 bytes

|0SN%9

Explicação

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

Uma saída de 0 significa que o resultado pode ser 0 ou 9.

Experimente online!

Economizou 2 bytes graças ao Sr. Xcoder . Ao usar o Cada rápido ( €) durante a avaliação, dividir o número em dígitos era redundante.

Economizou 3 bytes graças a Dennis . Pode OR bit a bit com a entrada 0 em vez de analisar manualmente a entrada como um número enquanto remove zeros à esquerda e sem dígitos.

Rápido , 51 bytes

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

Experimente online!

Befunge-93 (PyFunge) , 22 21 bytes

Percebi que não precisava usar ?para representar o dígito ausente. Por isso, usei um múltiplo de 9 após subtrair 48: x
Isso me permite jogar fora 3+, mas só me salvou 1 byte devido ao tamanho do primeira linha antes da condicional :(

Uma porta de minha resposta Befunge-98:
5 mais bytes, a fim de verificar se tenha atingido EOF,
mais um byte de empurrar 48 ( "0"vs '0),
1 mais bytes para imprimir a resposta com .@,
e mais um byte, porque o segundo A linha possui um espaço
para um total de mais 8 bytes.

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

Experimente online!

Saída 0se o dígito ausente puder ser 0 ou 9.

Isso funciona apenas no intérprete PyFunge pelos motivos explicados abaixo.

Explicação

Grande parte dessa explicação é copiada e colada da minha explicação do Befunge-98 , pois esse programa é muito semelhante a este. _{^{plugue descarado}}

Na primeira linha do programa, somamos os dígitos, incluindo x, que é tratado como um 72 por causa de seu valor ASCII. No entanto, a soma será a mesma assim que tivermos modificado por 9, então isso é irrelevante.

~: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

Se apenas modificássemos por 9, ficaríamos com o dígito errado, porque queremos 9 - (sum % 9). No entanto, podemos fazer melhor do que 9\-, que subtrairia o restante de 9: se fizermos a soma negativa antes de modificar por 9, obteremos um resultado positivo, equivalente a 9 - (sum % 9)alguns intérpretes. É isso que exige que usemos os intérpretes PyFunge para o Befunge 93 e 98, pois é o único no TIO que faz isso. Os outros nos dão um valor entre -8 e 8 em vez de 0 e 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 bytes

Percebi que não precisava usar ?para representar o dígito ausente, então usei um múltiplo de 9 após subtrair 48: x
Isso me permite jogar fora o 3+.

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

Experimente online!

Usa um xcomo o dígito ausente, porque seu valor ASCII é divisível por 9 após subtrair 48 (e é bom porque é comumente usado como uma variável em matemática).

Saídas via código de saída (porque qé um byte menor que .@)
Saídas 0se o dígito ausente puder ser 0 ou 9.

Isso funciona apenas no intérprete PyFunge pelos motivos explicados abaixo.

Explicação

Na primeira linha do programa, somamos os dígitos, incluindo o x, que é tratado como um 72 por causa de seu valor ASCII. No entanto, a soma será a mesma assim que tivermos modificado por 9, então isso é irrelevante.

#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

Se apenas modificássemos por 9, ficaríamos com o dígito errado, porque queremos 9 - (sum % 9). No entanto, podemos fazer melhor do que 9\-, que subtrairia o restante de 9: se fizermos a soma negativa antes de modificar por 9, obteremos um resultado positivo, equivalente a 9 - (sum % 9) alguns intérpretes . É isso que exige que usemos os intérpretes PyFunge para o Befunge 93 e 98, pois é o único no TIO que faz isso. Os outros nos dão um valor entre -8 e 8 em vez de 0 e 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

Usos '(qualquer caractere que tenha uma distância 0divisível por "0" será suficiente, inclusive 0ele próprio).

Uma saída de 0significa 0ou 9.

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

Experimente online!

Explicação

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 graças a @Unihedron

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

Experimente online!

Befunge-93, 28 27 19 18 bytes

O crédito deve recair sobre Mistah Figgins , cuja resposta do PyFunge me mostrou que você não precisava de uma verificação especial para o caractere de dígito ausente, se você apenas certificou-se de que o valor ASCII fosse um múltiplo de nove.

Agradecimentos adicionais a Jo King, que mostrou que você não precisava converter totalmente os caracteres em seu equivalente numérico e poderia subtrair 3 para obter um valor relativo à base 9 (ASCII 0menos 3 é 45, múltiplo de 9) .

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

Experimente online!

Para que isso funcione, você deve usar o caractere * para o dígito ausente (existem outros que também podem funcionar, mas esse é o melhor).

Saídas 9se o dígito ausente puder ser 0 ou 9.

Explicação

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.

Basicamente, estamos calculando a soma de todos os dígitos, mais 45 por dígito (que será cancelado quando modificarmos com 9). Essa soma é subtraída de 3 (nosso total inicial) e 39 adicionais são subtraídas pelo dígito ausente (ASCII* menos três). Novamente, 3 menos 39 é um múltiplo de 9, então é cancelado quando modificamos com 9.

Então, no final, estamos calculando a soma negativa de todos os dígitos, mod 9, mais 9, ou seja,

9 - (digitsum % 9)

E isso nos dá o dígito que falta.

Befunge-98 (PyFunge) , 8 bytes

#q~3--9%

Experimente online!

Saídas via código de saída. Como na resposta de Mistah Figgin , ele só funciona com o Pyfunge, onde um número negativo mod 9 se torna positivo. Usa um x como o dígito ausente.

PowerShell , 40 bytes

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

Experimente online! ou Verifique todos os casos de teste

Leva entrada como '123x'em $a. Constrói um intervalo 0para 9e usa Where-Object(aqui abreviado como |?) para extrair os números inteiros que correspondem à cláusula. A cláusula leva $a, executa uma regex -replacepara substituir o xdígito atual $_e obtém o mod 9 por %9. Assim, se 9 dividir uniformemente, será zero. Pegamos o booleano-não, que transforma os zeros em verdade e todo o resto falsey, de modo que satisfaz a cláusula Where-Object. Esses resultados são deixados no pipeline e a saída é implícita.

Haskell , 35 bytes

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

Experimente online!

Retina , 35 34 25 bytes

Se ?possível 0 or 9, o resultado é mostrado como 9.

.
$*
1{9}

^
9$*;
+`;1

.

Experimente online

Explicação

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

Experimente online!

Não liga para qual caractere significa o dígito ausente, contanto que não seja um dígito.

Tcl, 53 bytes

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

Tal como acontece com outras respostas, isso é mais curto ao não dizer explicitamente "0 ou 9".
Em vez disso, um resultado de "9" significa 0 ou 9.

Experimente online!

Explicação

Funciona de maneira bem simples. Emprega uma expressão regular para:

• dividir o argumento em dígitos individuais
• eliminar qualquer ponto de interrogação sem dígito (s)
• intercalar os dígitos com sinais de adição

Em seguida, ele avalia 9 - (sum_of_digits mod 9) para chegar a um valor final em 1..9, que é então puts.

O 0 inicial (in 0$argv) é necessário caso o ponto de interrogação seja o primeiro na entrada; um sinal de adição inicial na sequência transformada não é um problema para expr.

Pitão , 8 bytes

%_iz19 9

Experimente online!

Usa em Ivez de ?.

• Converta na base 19.
• Negar.
• Módulo 9.

APL (Dyalog) , 13 bytes

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

Experimente online!

O dígito ausente é ⍬.

brainfuck , 50 bytes

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

Experimente online!

Imprime um 9 para 0 ou 9. O caractere ausente é representado por:

Como funciona

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

O caractere ausente precisa ser um caractere que possua um mod 9 de 4, +3, porque subtraímos 3 dos dígitos normais e +1 para a inicialização do total como 1.

Como uma observação lateral, há muita ineficiência no código para o golfe, pois cada dígito redefinirá o total de 5 vezes cada, em vez de apenas uma vez, se subtrair 48 em vez de 3.

> <> , 35 33 25 21 15 bytes

Uma saída de 0significa que o resultado pode ser 0 ou 9 .

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

Experimente online!

Economizou 6 bytes graças a Jo King usando 'para representar dígitos ausentes.

Java 8, 36 34 bytes

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

Retorna 9quando ambos 0e 9são válidos.

Explicação:

Experimente 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