Reto

Dado un número entero divisible por 9 y un dígito faltante, encuentre el dígito faltante.

El dígito faltante puede estar representado por cualquier carácter que no sean los dígitos 0-9 siempre que sea coherente.

Si el dígito faltante puede ser 0 o 9, muestre algo para indicarlo.

Suponga que el usuario es lo suficientemente inteligente como para poner solo un dígito faltante y un número, etc.

Casos de prueba

En los casos de prueba, el dígito faltante se representa con un signo de interrogación.

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

Python , 21 bytes

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

Pruébalo en línea!

Solía Irepresentar un dígito faltante.

Alice , 12 bytes

/o&
\i@/+R9%

Pruébalo en línea!

Emite 0si el resultado puede ser 0 o 9.

Explicación

/   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

Salidas 9 si podrían ser 0 o 9.

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

Japt, 7 bytes

Intenté algunas soluciones, pero la más corta fue similar a la mayoría de las demás, excepto que no necesitamos reemplazarla ?al principio.

Puede tomar cualquier carácter no numérico como el dígito faltante. Salidas 0cuando la solución puede ser eso o 9.

¬x*J u9

Intentalo

Explicación

Entrada implícita de cadena U. ¬se divide en una matriz de caracteres individuales, xreduce la matriz al ignorar los elementos no numéricos, *Jmultiplica cada elemento por -1 y u9obtiene el módulo positivo del resultado.

JavaScript (ES6), 18 bytes

Espera a +como el dígito faltante. Devuelve 9para 0 o 9 .

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

Casos de prueba

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

Una salida de 0significa que el resultado podría ser 0 o 9 .

þSO(9%

Pruébalo en línea! o como un conjunto de pruebas

Explicación

þ        # 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 gracias a RiaD}

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

Pruébalo en línea!

Usuarios ]por dígitos faltantes.
Emite 0si el dígito faltante podría ser 0 o 9.

Pyth, 9 7 bytes

%_s-Qd9

Utiliza el espacio como delimitador y devuelve 0 si el resultado podría ser 0 o 9.

Pruébalo en línea

Explicación

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

Prólogo (SWI) , 59 bytes

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

Pruébalo en línea!

¡Yay para la programación lógica!

Explicación

Primero hacemos un predicado *, que se mantiene cuando se aplica a cero y la lista vacía. Nuestro predicado también se cumple cuando el frente de la lista está entre 0 y 9 y cuando agregamos el dígito principal mod 9 se mantiene el predicado.

Luego definimos +simplemente ser este predicado con 0el primer argumento. Es decir, queremos que la suma digital sea un múltiplo de 9.

Prolog hace todo el trabajo de encontrar soluciones para nosotros.

Befunge-93 , 16 bytes

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

Pruébalo en línea!

Una versión de una línea de la respuesta Befunge de James Holderness que logra reducir dos bytes. Esto esencialmente comprime el código en una línea, invierte la dirección y aprovecha el hecho de que Befunge no salta al final de la línea. Me sugirió que publicara una respuesta separada con una explicación. El código toma un * como representación del dígito faltante y genera un 9 para 0 o 9.

Cómo 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) fue elegido como el carácter faltante porque contrarresta el valor inicial del dígito, 3.

Látex, muchos 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, ilegible ( 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

Solo se permite espacio como dígito desconocido en este código.

J , ₁₄ 12 bytes

-2 bytes gracias a @BolceBussiere

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

Sinceramente, no sé por qué "."0interpreta ?como 0, pero lo hace en mi intérprete y en TIO, así que no voy a cuestionarlo. (Actualización: ver comentarios para una explicación de por qué).

Este enfoque simplemente toma la suma de los dígitos, lo niega restando de 9 y lo toma el módulo 9.

Pruébalo en línea!

Gelatina , 11 9 6 bytes

|0SN%9

Explicación

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

Una salida de 0 significa que el resultado podría ser 0 o 9.

Pruébalo en línea!

Guardado 2 bytes gracias al Sr. Xcoder . Cuando se utiliza el cada rápido ( €) durante la evaluación, la división del número en dígitos era redundante.

Guardado 3 bytes gracias a Dennis . Puede bit a bit O la entrada con 0 en lugar de analizar manualmente la entrada como un número mientras elimina los ceros iniciales y los no dígitos.

Swift , 51 bytes

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

Pruébalo en línea!

Befunge-93 (PyFunge) , 22 21 bytes

Me di cuenta de que no necesito usar ?para representar el dígito ausente, así que usé uno que es un múltiplo de 9 después de restar 48: x
Esto me permitió jugar golf 3+, pero solo me ahorró 1 byte debido a la longitud del primera línea antes del condicional :(

Un puerto de mi respuesta Befunge-98:
5 bytes más para verificar si hemos alcanzado EOF,
1 byte más para presionar 48 ("0" vs '0),
1 byte más a imprimir con la respuesta .@,
y 1 byte más, ya que el segundo La línea tiene un espacio
para un total de 8 bytes más.

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

Pruébalo en línea!

Emite 0si el dígito faltante podría ser 0 o 9.

Esto solo funciona en el intérprete de PyFunge por las razones que se explican a continuación.

Explicación

Gran parte de esta explicación está copiada de mi explicación de Befunge-98 , ya que ese programa es muy similar a este._{^{enchufe descarado}}

En la primera línea del programa, sumamos los dígitos, incluida la x, que se trata como un 72 debido a su valor ASCII. Sin embargo, la suma será la misma una vez que hayamos modificado por 9, así que esto es 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

Si solo modificáramos por 9, nos quedaríamos con el dígito incorrecto, porque queremos 9 - (sum % 9). Sin embargo, podemos hacerlo mejor que 9\-, lo que restaría el resto de 9: si hacemos que la suma sea negativa antes de modificar por 9, obtendremos un resultado positivo, equivalente al 9 - (sum % 9)de algunos intérpretes. Esto es lo que nos obliga a usar los intérpretes de PyFunge para Befunge 93 y 98, ya que es el único en TIO que hace esto. Los otros nos dan un valor entre -8 y 8 en lugar de 0 y 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

Me di cuenta de que no necesito usar ?para representar el dígito ausente, así que usé uno que es un múltiplo de 9 después de restar 48: x
Esto me permitió jugar golf 3+.

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

Pruébalo en línea!

Usa un x como el dígito que falta, porque su valor ASCII es divisible por 9 después de restar 48 (y es bueno porque se usa comúnmente como una variable en matemáticas).

Salidas a través del código de salida (porque qes un byte más corto que .@)
Salidas 0si el dígito faltante podría ser 0 o 9.

Esto solo funciona en el intérprete de PyFunge por las razones que se explican a continuación.

Explicación

En la primera línea del programa, sumamos los dígitos, incluido el x, que se trata como un 72 debido a su valor ASCII. Sin embargo, la suma será la misma una vez que hayamos modificado por 9, por lo que esto es 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

Si solo modificáramos por 9, nos quedaríamos con el dígito incorrecto, porque queremos 9 - (sum % 9). Sin embargo, podemos hacerlo mejor que 9\-, lo que restaría el resto de 9: si hacemos que la suma sea negativa antes de modificar por 9, obtendremos un resultado positivo, equivalente al 9 - (sum % 9) de algunos intérpretes . Esto es lo que nos obliga a usar los intérpretes de PyFunge para Befunge 93 y 98, ya que es el único en TIO que hace esto. Los otros nos dan un valor entre -8 y 8 en lugar de 0 y 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 '(cualquier carácter que tenga una distancia 0divisible por "0" servirá, incluido él 0mismo).

Una salida de 0significa ya sea 0o 9.

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

Pruébalo en línea!

Explicación

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 gracias a @Unihedron

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

Pruébalo en línea!

Befunge-93, 28 27 19 18 bytes

El crédito debe ir a Mistah Figgins , cuya respuesta de PyFunge me mostró que no necesitaba una verificación especial para el carácter del dígito faltante, si solo se aseguró de que el valor ASCII fuera un múltiplo de nueve.

Un agradecimiento adicional a Jo King que demostró que no era necesario convertir completamente los caracteres a su equivalente numérico, y que simplemente podría restar 3 para obtener un valor relativo a la base 9 (ASCII 0menos 3 es 45, un múltiplo de 9) .

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

Pruébalo en línea!

Para que esto funcione, debe usar el carácter *para el dígito faltante (hay otros que también podrían funcionar, pero eso es lo mejor).

Emite 9si el dígito faltante podría ser 0 o 9.

Explicación

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.

Esencialmente estamos calculando la suma de todos los dígitos, más 45 por dígito (que finalmente se cancelará cuando modifiquemos con 9). Esta suma se resta de 3 (nuestro total inicial), y 39 adicionales se restan por el dígito faltante (ASCII* menos tres). De nuevo, 3 menos 39 es un múltiplo de 9, por lo que se cancela cuando modificamos con 9.

Así que al final estamos calculando la suma negativa de todos los dígitos, mod 9, más 9, es decir

9 - (digitsum % 9)

Y eso nos da el dígito faltante.

Befunge-98 (PyFunge) , 8 bytes

#q~3--9%

Pruébalo en línea!

Salidas a través del código de salida. Al igual que con la respuesta de Mistah Figgin , solo funciona con Pyfunge, donde un número negativo mod 9 se vuelve positivo. Utiliza una x como el dígito faltante.

PowerShell , 40 bytes

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

Pruébalo en línea!o Verificar todos los casos de prueba

Toma entrada como '123x'en $a. Construye un rango 0ay 9usa Where-Object(aquí abreviado como |?) para extraer esos enteros que coinciden con la cláusula. La cláusula toma $a, realiza una expresión regular -replacepara reemplazar el xcon el dígito actual $_y obtiene el mod 9 con %9. Por lo tanto, si 9 se divide de manera uniforme, será cero. Tomamos el booleano-no del mismo, que hace que los ceros sean verdaderos y todo lo demás falsey, de modo que satisfaga la cláusula Where-Object. Esos resultados se dejan en la tubería y la salida es implícita.

Haskell , 35 bytes

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

Pruébalo en línea!

Retina , 35 34 25 bytes

Si ?puede ser 0 or 9, el resultado se muestra como 9.

.
$*
1{9}

^
9$*;
+`;1

.

Pruébalo en línea

Explicación

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

Pruébalo en línea!

No le importa qué carácter significa el dígito faltante siempre que no sea un dígito.

Tcl, 53 bytes

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

Al igual que con otras respuestas, esto se acorta al no decir explícitamente "0 o 9".
En cambio, un resultado de "9" significa 0 o 9.

Pruébalo en línea!

Explicación

Funciona bastante simple. Emplea una expresión regular para:

• dividir el argumento en dígitos individuales
• eliminar cualquier signo de interrogación no sea dígito (s)
• intercalar los dígitos con signos más

Luego evalúa 9 - (sum_of_digits mod 9) para llegar a un valor final en 1..9, que luego puts.

Se 0$argvrequiere el 0 inicial (en ) en caso de que el signo de interrogación aparezca primero en la entrada; Un signo más a la izquierda en la secuencia transformada no es un problema expr.

Pyth , 8 bytes

%_iz19 9

Pruébalo en línea!

Usos en Ilugar de ?.

• Convertir a base 19.
• Negar.
• Módulo 9.

APL (Dyalog) , 13 bytes

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

Pruébalo en línea!

El dígito que falta es ⍬.

brainfuck , 50 bytes

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

Pruébalo en línea!

Imprime un 9 para 0 o 9. El carácter perdido se representa con:

Cómo 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

El carácter que falta debe ser un carácter que tenga un mod 9 de 4, +3 porque restamos 3 de los dígitos normales y +1 para la inicialización del total como 1.

Como nota al margen, hay una gran ineficiencia en el código por el bien del golf, ya que cada dígito restablecerá el total 5 veces cada uno, en lugar de solo una vez si resté 48 en lugar de 3.

> <> , 35 33 25 21 15 bytes

Una salida de 0significa que el resultado podría ser 0 o 9 .

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

Pruébalo en línea!

Ahorró 6 bytes gracias a Jo King al usar 'para representar dígitos faltantes.

Java 8, 36 34 bytes

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

Regresa 9cuando ambos 0y9 son válidos.

Explicación:

Pruébalo en línea.

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