Sfida

Dato un numero intero divisibile per 9 e una cifra mancante, trova la cifra mancante.

La cifra mancante può essere rappresentata da qualsiasi carattere diverso dalle cifre da 0 a 9 purché sia ​​coerente.

Se la cifra mancante potrebbe essere 0 o 9, emettere qualcosa per indicarlo.

Supponiamo che l'utente sia abbastanza intelligente da mettere solo una cifra mancante e un numero ecc.

Casi test

Nei casi di test la cifra mancante è rappresentata da un punto interrogativo

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

Python , 21 byte

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

Provalo online!

Ho usato Iper rappresentare una cifra mancante.

Alice , 12 byte

/o&
\i@/+R9%

Provalo online!

Emette 0se il risultato può essere 0 o 9.

Spiegazione

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

Emette 9 se potrebbe essere 0 o 9.

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

Japt, 7 byte

Ho provato alcune soluzioni, ma la più breve era simile alla maggior parte delle altre, tranne per il fatto che non è necessario sostituirla ?all'inizio.

Può assumere qualsiasi carattere non numerico come cifra mancante. Emette 0quando la soluzione può essere quella o 9.

¬x*J u9

Provalo

Spiegazione

Immissione implicita della stringa U. ¬si divide in una matrice di singoli caratteri, xriduce la matrice aggiungendo ignorando tutti gli elementi non numerici, *Jmoltiplica ogni elemento per -1 e u9ottiene il modulo positivo del risultato.

JavaScript (ES6), 18 byte

Si aspetta un +come cifra mancante. Restituisce 9per 0 o 9 .

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

Casi test

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 byte

Un'uscita di 0significa che il risultato potrebbe essere 0 o 9 .

þSO(9%

Provalo online! o come una suite di test

Spiegazione

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

Python 2 , 44 41 35 byte

^{-6 byte grazie a RiaD}

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

Provalo online!

Utenti ]per cifre mancanti.
Emette 0se la cifra mancante potrebbe essere 0 o 9.

Pyth, 9 7 byte

%_s-Qd9

Utilizza lo spazio come delimitatore e restituisce 0 se il risultato potrebbe essere 0 o 9.

Provalo online

Spiegazione

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

Prolog (SWI) , 59 byte

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

Provalo online!

Sì per la programmazione logica!

Spiegazione

Innanzitutto facciamo un predicato *, che vale quando applicato a zero e alla lista vuota. Il nostro predicato vale anche quando la parte anteriore dell'elenco è compresa tra 0 e 9 e quando aggiungiamo la cifra iniziale mod 9, il predicato vale.

Definiamo quindi +questo predicato 0come il primo argomento. Cioè vogliamo che la somma digitale sia un multiplo di 9.

Prolog fa tutto il duro lavoro di trovare soluzioni per noi.

Befunge-93 , 16 byte

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

Provalo online!

Una versione a una riga della risposta Befunge di James Holderness che riesce a radere via due byte. Questo essenzialmente comprime il codice su una riga, inverte la direzione e sfrutta il fatto che Befunge non salta alla fine della riga. Mi ha suggerito di pubblicare una risposta separata con una spiegazione. Il codice accetta un * che rappresenta la cifra mancante e genera un 9 per 0 o 9.

Come funziona

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

* (Valore ASCII 42) è stato scelto come carattere mancante perché contrasta il valore iniziale del digit, 3.

LaTeX, molti byte ( 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, illeggibile ( 348 334 byte)

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

\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

In questo codice è consentito solo lo spazio come cifra sconosciuta.

J , ₁₄ 12 byte

-2 byte grazie a @BolceBussiere

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

Onestamente non so perché "."0interpreti ?come 0, ma lo fa sul mio interprete e su TIO, quindi non lo metterò in discussione. (Aggiornamento: vedere i commenti per una spiegazione del perché).

Questo approccio prende semplicemente la somma delle cifre, la nega sottraendo da 9 e la prende modulo 9.

Provalo online!

Gelatina , 11 9 6 byte

|0SN%9

Spiegazione

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

Un'uscita di 0 significa che il risultato potrebbe essere 0 o 9.

Provalo online!

Salvato 2 byte grazie a Mr. Xcoder . Quando si utilizza ogni Quick ( €) durante la valutazione, la divisione del numero in cifre era ridondante.

Salvato 3 byte grazie a Dennis . Può bit a bit OR l'input con 0 invece di analizzare manualmente l'input come numero rimuovendo zeri iniziali e non cifre.

Rapido , 51 byte

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

Provalo online!

Befunge-93 (PyFunge) , 22 21 byte

Mi sono reso conto che non ho bisogno di usare ?per rappresentare la cifra assente, quindi ho usato uno che è un multiplo di 9 dopo aver sottratto 48: x
Questo mi ha permesso di giocare a golf off 3+, ma mi ha salvato solo 1 byte a causa della lunghezza del prima riga prima del condizionale :(

Una porta della mia risposta Befunge-98:
più 5 byte al fine di verificare se abbiamo raggiunto EOF,
più 1 byte a spingere 48 ( "0"vs '0),
1 byte di più per stampare la risposta con .@,
e 1 più byte, perché la seconda La linea ha uno spazio
per un totale di altri 8 byte.

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

Provalo online!

Emette 0se la cifra mancante potrebbe essere 0 o 9.

Questo funziona solo nell'interprete PyFunge per i motivi spiegati di seguito.

Spiegazione

Gran parte di questa spiegazione è copiata e incollata dalla mia spiegazione di Befunge-98 , poiché quel programma è molto simile a questo. _{^{spina spudorata}}

Nella prima riga del programma, sommiamo le cifre, inclusa la x, che viene trattata come un 72 a causa del suo valore ASCII. Tuttavia, la somma sarà la stessa una volta che abbiamo modificato 9, quindi questo è irrilevante.

~: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 modifichiamo solo 9, verremmo lasciati con la cifra sbagliata, perché vogliamo 9 - (sum % 9). Tuttavia, possiamo fare di meglio 9\-, il che sottrarrebbe il resto da 9: se rendessimo la somma negativa prima di modificare di 9, otterremo un risultato positivo, equivalente a quello 9 - (sum % 9)di alcuni interpreti. Questo è ciò che ci impone di utilizzare gli interpreti PyFunge sia per Befunge 93 che per 98, poiché è l'unico su TIO a farlo. Gli altri ci danno un valore tra -8 e 8 invece di 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 byte

Mi sono reso conto che non ho bisogno di usare ?per rappresentare la cifra assente, quindi ho usato uno che è un multiplo di 9 dopo aver sottratto 48: x
Questo mi ha permesso di giocare a golf 3+.

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

Provalo online!

Usa una xcome cifra mancante, perché il suo valore ASCII è divisibile per 9 dopo aver sottratto 48 (ed è bello perché è comunemente usato come variabile in matematica).

Uscite tramite codice di uscita (perché qè un byte più corto di .@)
Uscite 0se la cifra mancante potrebbe essere 0 o 9.

Questo funziona solo nell'interprete PyFunge per i motivi spiegati di seguito.

Spiegazione

Nella prima riga del programma, sommiamo le cifre, incluso il x, che viene trattato come un 72 a causa del suo valore ASCII. Tuttavia, la somma sarà la stessa dopo che abbiamo modificato 9, quindi questo è irrilevante.

#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 modifichiamo solo 9, verremmo lasciati con la cifra sbagliata, perché vogliamo 9 - (sum % 9). Tuttavia, possiamo fare di meglio 9\-, il che sottrarrebbe il resto da 9: se rendessimo la somma negativa prima di modificare di 9, otterremo un risultato positivo, equivalente a quello 9 - (sum % 9) di alcuni interpreti . Questo è ciò che ci impone di utilizzare gli interpreti PyFunge sia per Befunge 93 che per 98, poiché è l'unico su TIO a farlo. Gli altri ci danno un valore tra -8 e 8 invece di 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

Rubino , 22 byte

Usi '(qualsiasi carattere che ha una distanza 0che è divisibile per "0" lo farà, incluso 0se stesso).

Un output di 0indica 0o 9.

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

Provalo online!

Spiegazione

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

Rubino , 46 , 41 byte

-5 grazie a @Unihedron

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

Provalo online!

Befunge-93, 28 27 19 18 byte

Il merito va a Mistah Figgins , la cui risposta di PyFunge mi ha mostrato che non hai bisogno di un controllo speciale per il carattere mancante della cifra, se ti sei appena assicurato che il valore ASCII fosse un multiplo di nove.

Ulteriori ringraziamenti a Jo King che ha dimostrato che non è necessario convertire completamente i caratteri nel loro equivalente numerico e potrebbe semplicemente sottrarre 3 per ottenere un valore relativo alla base 9 (ASCII 0meno 3 è 45, un multiplo di 9) .

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

Provalo online!

Perché questo funzioni, dovresti usare il carattere *per la cifra mancante (ce ne sono altri che potrebbero funzionare, ma è il più bello).

Emette 9se la cifra mancante potrebbe essere 0 o 9.

Spiegazione

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.

In sostanza stiamo calcolando la somma di tutte le cifre, più 45 per cifra (che alla fine verrà annullata quando modiamo con 9). Questa somma viene sottratta da 3 (il nostro totale iniziale) e un ulteriore 39 viene sottratto dalla cifra mancante (ASCII *meno tre). Ancora una volta che 3 meno 39 è un multiplo di 9, quindi viene annullato quando modiamo con 9.

Quindi alla fine stiamo calcolando la somma negativa di tutte le cifre, mod 9, più 9, cioè

9 - (digitsum % 9)

E questo ci dà la cifra mancante.

Befunge-98 (PyFunge) , 8 byte

#q~3--9%

Provalo online!

Uscite tramite codice di uscita. Come per la risposta di Mistah Figgin , funziona solo con Pyfunge, dove un numero negativo mod 9 diventa positivo. Usa una x come cifra mancante.

PowerShell , 40 byte

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

Provalo online! oppure Verifica tutti i casi di test

Accetta input come '123x'in $a. Costruisce una gamma 0di 9e usi Where-Object(qui abbreviato come |?) per tirare fuori quei numeri interi che corrispondono alla clausola. La clausola accetta $a, esegue una regex -replaceper sostituire la xcon la cifra corrente $_e ottiene la mod 9 con %9. Pertanto, se 9 si divide uniformemente, questo sarà zero. Prendiamo il booleano - non di ciò, che trasforma gli zeri in verità e tutto il resto in falso, in modo da soddisfare la clausola Where-Object. Tali risultati vengono lasciati in cantiere e l'output è implicito.

Haskell , 35 byte

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

Provalo online!

Retina , 35 34 25 byte

Se ?può essere 0 or 9, il risultato viene mostrato come 9.

.
$*
1{9}

^
9$*;
+`;1

.

Provalo online

Spiegazione

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

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

Provalo online!

Non importa quale personaggio indica la cifra mancante purché non sia una cifra.

Tcl, 53 byte

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

Come con altre risposte, questo viene abbreviato non dicendo esplicitamente "0 o 9".
Invece, un risultato di "9" significa 0 o 9.

Provalo online!

Spiegazione

Funziona abbastanza semplicemente. Impiega un'espressione regolare per:

• dividere l'argomento in singole cifre
• eliminare eventuali punti interrogativi non cifre
• interlacciare le cifre con i segni più

Quindi valuta 9 - (sum_of_digits mod 9) per arrivare a un valore finale in 1..9, che quindi puts.

Lo 0 (in 0$argv) iniziale è richiesto nel caso in cui il punto interrogativo venga per primo nell'input; un segno più iniziale nella sequenza trasformata non è un problema expr.

Pyth , 8 byte

%_iz19 9

Provalo online!

Utilizza Iinvece di ?.

• Converti in base 19.
• Negare.
• Modulo 9.

APL (Dyalog) , 13 byte

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

Provalo online!

La cifra mancante è ⍬.

Brainfuck , 50 byte

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

Provalo online!

Stampa un 9 per 0 o 9. Il carattere mancante è rappresentato da:

Come funziona

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

Il personaggio mancante deve essere un personaggio che ha una mod 9 di 4, +3 perché sottraggiamo 3 dalle cifre normali e +1 per l'inizializzazione del totale come 1.

Come nota a margine, c'è molta inefficienza nel codice per il bene del golf, poiché ogni cifra reimposterà il totale 5 volte ciascuno, anziché solo una volta a volte se ho sottratto 48 anziché 3.

> <> , 35 33 25 21 15 byte

Un'uscita di 0significa che il risultato potrebbe essere 0 o 9 .

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

Provalo online!

6 byte salvati grazie a Jo King usando 'per rappresentare le cifre mancanti.

Java 8, 36 34 byte

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

Restituisce 9quando entrambi 0e 9sono validi.

Spiegazione:

Provalo 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