Défi

Étant donné un nombre entier divisible par 9 et un chiffre manquant, recherchez le chiffre manquant.

Le chiffre manquant peut être représenté par n'importe quel caractère autre que les chiffres 0-9 tant qu'il est cohérent.

Si le chiffre manquant peut être 0 ou 9, affichez quelque chose pour le signifier.

Supposons que l'utilisateur est suffisamment intelligent pour ne mettre qu'un seul chiffre manquant et un seul numéro, etc.

Cas de test

Dans les cas de test, le chiffre manquant est représenté par un point d'interrogation

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

Python , 21 octets

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

Essayez-le en ligne!

J'avais l'habitude Ide représenter un chiffre manquant.

Alice , 12 octets

/o&
\i@/+R9%

Essayez-le en ligne!

Affiche 0si le résultat peut être 0 ou 9.

Explication

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

Sorties 9 si pourrait être 0 ou 9.

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

Japt, 7 octets

J'ai essayé quelques solutions, mais la plus courte était similaire à la plupart des autres, sauf que nous n'avons pas besoin de remplacer la ?au début.

Peut prendre n'importe quel caractère non numérique comme chiffre manquant. Sorties 0lorsque la solution peut être celle ou 9.

¬x*J u9

Essayez-le

Explication

Saisie implicite de chaîne U. ¬se divise en un tableau de caractères individuels, xréduit le tableau en ajoutant en ignorant tous les éléments non numériques, *Jmultiplie chaque élément par -1 et u9obtient le module positif du résultat.

JavaScript (ES6), 18 octets

Attend a +comme chiffre manquant. Retours 9pour 0 ou 9 .

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

Cas de 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 octets

Une sortie de 0signifie que le résultat peut être 0 ou 9 .

þSO(9%

Essayez-le en ligne! ou comme suite de tests

Explication

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

Python 2 , 44 41 35 octets

^{-6 octets grâce à RiaD}

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

Essayez-le en ligne!

Utilisateurs ]pour chiffre manquant.
Affiche 0si le chiffre manquant peut être 0 ou 9.

Pyth, 9 7 octets

%_s-Qd9

Utilise l'espace comme délimiteur et renvoie 0 si le résultat peut être 0 ou 9.

Essayez-le en ligne

Explication

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

Prolog (SWI) , 59 octets

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

Essayez-le en ligne!

Ouais pour la programmation logique!

Explication

D'abord, nous faisons un prédicat *, qui tient lorsqu'il est appliqué à zéro et à la liste vide. Notre prédicat est également valable lorsque le début de la liste est compris entre 0 et 9 et lorsque nous ajoutons le chiffre de début mod 9, le prédicat est conservé.

Nous définissons ensuite +être juste ce prédicat avec 0comme premier argument. C'est-à-dire que nous voulons que la somme numérique soit un multiple de 9.

Prolog fait tout le gros travail pour trouver des solutions pour nous.

Befunge-93 , 16 octets

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

Essayez-le en ligne!

Une version en ligne de la réponse Befunge de James Holderness qui parvient à raser deux octets. Cela comprime essentiellement le code sur une seule ligne, inverse la direction et profite du fait que Befunge ne saute pas à la fin de la ligne. Il m'a suggéré de poster une réponse séparée avec une explication. Le code prend un * comme représentant le chiffre manquant et renvoie un 9 pour 0 ou 9.

Comment ça marche

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

* (Valeur ASCII 42) a été choisi comme caractère manquant car il contrebalance la valeur initiale du chiffre, 3.

LaTeX, plusieurs octets ( 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, illisible ( 348 334 octets)

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

\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

Seul l'espace est autorisé comme chiffre inconnu dans ce code.

J , ₁₄ 12 octets

-2 octets grâce à @BolceBussiere

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

Honnêtement, je ne sais pas pourquoi "."0interprète ?comme 0, mais il le fait sur mon interprète et sur TIO, donc je ne vais pas le remettre en question. (Mise à jour: voir les commentaires pour une explication pourquoi).

Cette approche prend très simplement la somme des chiffres, la nie en soustrayant de 9 et la prend modulo 9.

Essayez-le en ligne!

Gelée , 11 9 6 octets

|0SN%9

Explication

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

Une sortie de 0 signifie que le résultat peut être 0 ou 9.

Essayez-le en ligne!

Enregistré 2 octets grâce à M. Xcoder . Lors de l'utilisation de chaque quick ( €) pendant l'évaluation, la division du nombre en chiffres était redondante.

Enregistré 3 octets grâce à Dennis . Peut être bit à bit OU l'entrée avec 0 au lieu d'analyser manuellement l'entrée comme un nombre tout en supprimant les zéros et les non-chiffres en tête.

Swift , 51 octets

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

Essayez-le en ligne!

Befunge-93 (PyFunge) , 22 21 octets

Je me suis rendu compte que je n'avais pas besoin d'utiliser ?pour représenter le chiffre absent, alors j'en ai utilisé un qui est un multiple de 9 après avoir soustrait 48: x
Cela m'a permis de jouer au golf sur le 3+, mais cela ne m'a permis d'économiser qu'un octet en raison de la longueur du première ligne avant le conditionnel :(

Un port de mon Befunge-98 Réponse:
5 plus d' octets afin de vérifier si nous avons atteint EOF,
1 octet supplémentaire pour pousser 48 ( "0"vs '0),
1 octet supplémentaire pour imprimer la réponse avec .@,
et 1 octet supplémentaire , parce que la seconde ligne a un espace
pour un total de 8 octets supplémentaires.

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

Essayez-le en ligne!

Affiche 0si le chiffre manquant peut être 0 ou 9.

Cela ne fonctionne que dans l'interpréteur PyFunge pour les raisons expliquées ci-dessous.

Explication

Une grande partie de cette explication est copiée de mon explication Befunge-98 , car ce programme est très similaire à celui-ci. _{^{fiche sans vergogne}}

Dans la première ligne du programme, nous additionnons les chiffres, y compris le x, qui est traité comme un 72 en raison de sa valeur ASCII. Cependant, la somme sera la même une fois que nous aurons modifié par 9, donc ce n'est pas pertinent.

~: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 nous venons de modifier par 9, nous nous retrouverions avec le mauvais chiffre, parce que nous voulons 9 - (sum % 9). Cependant, nous pouvons faire mieux que 9\-, ce qui soustrait le reste de 9: si nous rendons la somme négative avant de modifier par 9, nous obtiendrons un résultat positif, équivalent à celui 9 - (sum % 9)de certains interprètes. C'est ce qui nous oblige à utiliser les interprètes PyFunge pour Befunge 93 et ​​98, car c'est le seul sur TIO à le faire. Les autres nous donnent une valeur entre -8 et 8 au lieu de 0 et 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 octets

J'ai réalisé que je n'avais pas besoin d'utiliser ?pour représenter le chiffre absent, alors j'en ai utilisé un qui est un multiple de 9 après avoir soustrait 48: x
Cela m'a permis de jouer au golf 3+.

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

Essayez-le en ligne!

Utilise un xcomme chiffre manquant, car sa valeur ASCII est divisible par 9 après avoir soustrait 48 (et c'est bien car il est couramment utilisé comme variable en mathématiques).

Sorties via le code de sortie (car qun octet est plus court que .@)
Sorties 0si le chiffre manquant peut être 0 ou 9.

Cela ne fonctionne que dans l'interpréteur PyFunge pour les raisons expliquées ci-dessous.

Explication

Dans la première ligne du programme, nous additionnons les chiffres, y compris le x, qui est traité comme un 72 en raison de sa valeur ASCII. Cependant, la somme sera la même une fois que nous aurons modifié par 9, donc ce n'est pas pertinent.

#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 nous venons de modifier par 9, nous nous retrouverions avec le mauvais chiffre, parce que nous voulons 9 - (sum % 9). Cependant, nous pouvons faire mieux que 9\-, ce qui soustrait le reste de 9: si nous rendons la somme négative avant le modding de 9, nous obtiendrons un résultat positif, équivalent à9 - (sum % 9) de certains interprètes . C'est ce qui nous oblige à utiliser les interprètes PyFunge pour Befunge 93 et ​​98, car c'est le seul sur TIO à le faire. Les autres nous donnent une valeur comprise entre -8 et 8 au lieu de 0 et 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

Rubis , 22 octets

Les usages ' (tout caractère dont la distance 0est divisible par "0" fera l'affaire, y compris 0lui-même).

Une sortie de 0signifie soit 0ou 9.

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

Essayez-le en ligne!

Explication

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

Rubis , 46 , 41 octets

-5 grâce à @Unihedron

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

Essayez-le en ligne!

Befunge-93, 28 27 19 18 octets

Le mérite doit être attribué à Mistah Figgins , dont la réponse PyFunge m'a montré que vous n'aviez pas besoin d'une vérification spéciale pour le caractère manquant, si vous vous êtes simplement assuré que la valeur ASCII était un multiple de neuf.

Remerciements supplémentaires à Jo King qui a montré que vous n'aviez pas besoin de convertir complètement les caractères en leur équivalent numérique et que vous pouviez simplement soustraire 3 pour obtenir une valeur relative à la base 9 (ASCII 0moins 3 est 45, un multiple de 9) .

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

Essayez-le en ligne!

Pour que cela fonctionne, vous devez utiliser le caractère * du chiffre manquant (il y en a d'autres qui pourraient également fonctionner, mais c'est le plus beau).

Les sorties 9si le chiffre manquant peut être 0 ou 9.

Explication

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.

Essentiellement, nous calculons la somme de tous les chiffres, plus 45 par chiffre (qui sera finalement annulé lorsque nous modifions avec 9). Cette somme est soustraite de 3 (notre total de départ) et 39 autres sont soustraits par le chiffre manquant (ASCII* moins trois). Encore une fois, 3 moins 39 est un multiple de 9, il est donc annulé lorsque nous modifions avec 9.

Donc, à la fin, nous calculons la somme négative de tous les chiffres, mod 9, plus 9, c'est-à-dire

9 - (digitsum % 9)

Et cela nous donne le chiffre manquant.

Befunge-98 (PyFunge) , 8 octets

#q~3--9%

Essayez-le en ligne!

Sorties via code de sortie. Comme avec la réponse de Mistah Figgin , cela ne fonctionne qu'avec Pyfunge, où un nombre négatif mod 9 devient positif. Utilise un x comme chiffre manquant.

PowerShell , 40 octets

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

Essayez-le en ligne! ou vérifier tous les cas de test

Prend l'entrée comme '123x'dans $a. Construit une plage 0vers 9et utilise Where-Object(ici abrégé comme |?) pour extraire les entiers qui correspondent à la clause. La clause prend $a, effectue une regex -replacepour remplacer le xpar le chiffre actuel $_et obtient le mod 9 avec %9. Ainsi, si 9 se divise également, ce sera zéro. Nous prenons le booléen-pas de celui-ci, qui rend les zéros véridiques et tout le reste falsey, de sorte que satisfait la clause Where-Object. Ces résultats sont laissés sur le pipeline et la sortie est implicite.

Haskell , 35 octets

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

Essayez-le en ligne!

Rétine , 35 34 25 octets

Si le ?peut être 0 or 9, est représenté par le résultat 9.

.
$*
1{9}

^
9$*;
+`;1

.

Essayez-le en ligne

Explication

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

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

Essayez-le en ligne!

Peu importe quel caractère signifie le chiffre manquant tant qu'il ne s'agit pas d'un chiffre.

Tcl, 53 octets

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

Comme pour les autres réponses, cela est raccourci en ne disant pas explicitement «0 ou 9».
Au lieu de cela, un résultat de «9» signifie 0 ou 9.

Essayez-le en ligne!

Explication

Cela fonctionne assez simplement. Il utilise une expression régulière pour:

• diviser l'argument en chiffres individuels
• éliminer tout point d' interrogation non numérique
• entrelacer les chiffres avec des signes plus

Il évalue ensuite 9 - (sum_of_digits mod 9) pour arriver à une valeur finale en 1..9, ce qu'il fait alors puts.

Le 0 (in 0$argv) de tête est requis au cas où le point d'interrogation apparaît en premier dans l'entrée; un signe plus en tête dans la séquence transformée n'est pas un problème pour expr.

Pyth , 8 octets

%_iz19 9

Essayez-le en ligne!

Utilise Iau lieu de ?.

• Convertir en base 19.
• Nier.
• Modulo 9.

APL (Dyalog) , 13 octets

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

Essayez-le en ligne!

Le chiffre manquant est ⍬.

brainfuck , 50 octets

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

Essayez-le en ligne!

Imprime un 9 pour 0 ou 9. Le caractère manquant est représenté par:

Comment ça marche

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

Le caractère manquant doit être un caractère ayant un mod 9 de 4, +3 car nous soustrayons 3 des chiffres normaux et +1 pour l'initialisation du total à 1.

En remarque, il y a beaucoup d'inefficacité dans le code pour le golf, car chaque chiffre réinitialise le total 5 fois chacun, plutôt qu'une seule fois parfois si je soustrais 48 au lieu de 3.

> <> , 35 33 25 21 15 octets

Une sortie de 0signifie que le résultat peut être 0 ou 9 .

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

Essayez-le en ligne!

6 octets enregistrés grâce à Jo King en utilisant 'pour représenter les chiffres manquants.

Java 8, 36 34 octets

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

Renvoie 9lorsque les deux 0et 9sont valides.

Explication:

Essayez-le en ligne.

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