Herausforderung

Suchen Sie bei einer durch 9 teilbaren ganzen Zahl und einer fehlenden Stelle die fehlende Stelle.

Die fehlende Ziffer kann durch ein beliebiges anderes Zeichen als die Ziffern 0-9 dargestellt werden, sofern dies konsistent ist.

Wenn die fehlende Ziffer 0 oder 9 sein könnte, geben Sie etwas aus, um dies zu kennzeichnen.

Angenommen, der Benutzer ist intelligent genug, um nur eine fehlende Ziffer und eine Zahl usw. einzugeben.

Testfälle

In den Testfällen wird die fehlende Ziffer durch ein Fragezeichen dargestellt

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

Python , 21 Bytes

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

Probieren Sie es online!

Früher habe ich Ieine fehlende Ziffer dargestellt.

Alice , 12 Bytes

/o&
\i@/+R9%

Probieren Sie es online!

Gibt aus, 0ob das Ergebnis 0 oder 9 sein kann.

Erläuterung

/   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

Gibt 9 aus, wenn 0 oder 9 sein könnte.

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

Japt, 7 Bytes

Versuchte ein paar Lösungen, aber die kürzeste war ähnlich wie die meisten anderen, außer dass wir die ?am Anfang nicht ersetzen müssen .

Kann jedes nicht numerische Zeichen als fehlende Ziffer annehmen. Gibt aus, 0wann die Lösung das oder sein kann 9.

¬x*J u9

Versuch es

Erläuterung

Implizite Eingabe eines Strings U.¬Teilt sich in ein Array einzelner Zeichen, xverkleinert das Array, indem alle nicht numerischen Elemente ignoriert werden, *Jmultipliziert jedes Element mit -1 und u9erhält den positiven Modul des Ergebnisses.

JavaScript (ES6), 18 Byte

Erwartet eine +als fehlende Ziffer. Gibt 9für 0 oder 9 zurück .

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

Testfälle

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

Eine Ausgabe von 0bedeutet, dass das Ergebnis entweder 0 oder 9 sein kann .

þSO(9%

Probieren Sie es online! oder als Testsuite

Erläuterung

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

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

Probieren Sie es online!

Benutzer ]für fehlende Ziffer.
Gibt aus, 0ob die fehlende Ziffer 0 oder 9 sein könnte.

Pyth, 9 7 Bytes

%_s-Qd9

Verwendet Leerzeichen als Begrenzer und gibt 0 zurück, wenn das Ergebnis 0 oder 9 sein könnte.

Probieren Sie es online aus

Erläuterung

%_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.

Probieren Sie es online!

Yay für die logische Programmierung!

Erläuterung

Zuerst machen wir ein Prädikat * , das gilt, wenn es auf Null und die leere Liste angewendet wird. Unser Prädikat gilt auch, wenn der Listenanfang zwischen 0 und 9 liegt und wenn wir die führende Ziffer mod 9 hinzufügen, gilt das Prädikat.

Wir definieren dann, +nur dieses Prädikat zu sein0 als erstes Argument verwendet wird. Das heißt, wir wollen, dass die digitale Summe ein Vielfaches von 9 ist.

Prolog erledigt das Grunzen, um tatsächlich Lösungen für uns zu finden.

Befunge-93 , 16 Bytes

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

Probieren Sie es online!

Eine einzeilige Version von James Holderness 'Befunge-Antwort , die es schafft, zwei Bytes zu sparen . Dadurch wird der Code im Wesentlichen auf eine Zeile komprimiert, die Richtung umgekehrt und die Tatsache ausgenutzt, dass Befunge nicht am Zeilenende überspringt. Er schlug vor, dass ich eine separate Antwort mit einer Erklärung verfasse. Der Code nimmt ein * als Darstellung der fehlenden Ziffer und gibt eine 9 für entweder 0 oder 9 aus.

Wie es funktioniert

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-Wert 42) wurde als fehlendes Zeichen gewählt, da es dem Anfangswert der Ziffer 3 entgegenwirkt.

LaTeX, viele 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, unleserlich ( 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

In diesem Code ist nur Leerzeichen als unbekannte Ziffer zulässig.

J , _14-12 Bytes

-2 Bytes dank @BolceBussiere

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

Ich weiß ehrlich gesagt nicht warum "."0 interpretiert? als 0 aber dies geschieht auf meinem Interpreter und auf TIO, so dass ich es nicht in Frage stellen werde. (Update: Eine Erklärung dafür finden Sie in den Kommentaren.)

Dieser Ansatz nimmt sehr einfach die Summe der Ziffern, negiert sie durch Subtrahieren von 9 und nimmt sie modulo 9.

Probieren Sie es online!

Jelly , 11 9 6 Bytes

|0SN%9

Erläuterung

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

Eine Ausgabe von 0 bedeutet, dass das Ergebnis entweder 0 oder 9 sein kann.

Probieren Sie es online!

2 Bytes gespart dank Mr. Xcoder . Bei Verwendung von Each quick ( €) während der Auswertung wurde die Aufteilung der Nummer in Ziffern überflüssig.

3 Bytes gespart dank Dennis . Kann die Eingabe bitweise ODER mit 0 verknüpfen, anstatt die Eingabe manuell als Zahl zu analysieren, während führende Nullen und Nicht-Ziffern entfernt werden.

Schnell , 51 Bytes

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

Probieren Sie es online!

Befunge-93 (PyFunge) , 22 21 Bytes

Ich erkannte, dass ich nicht verwenden muss, um ?die abwesende Ziffer darzustellen, also verwendete ich eine, die ein Vielfaches von 9 ist, nachdem x
ich 48 subtrahiert hatte: Dies ließ mich das Golf spielen 3+, aber es sparte mir nur 1 Byte wegen der Länge des erste Zeile vor der Bedingung :(

Ein Port meiner Befunge-98-Antwort:
5 weitere Bytes, um zu überprüfen, ob wir EOF erreicht haben,
1 weiteres Byte, um 48 ( "0"vs '0) zu drücken ,
1 weiteres Byte, um die Antwort mit zu drucken .@,
und 1 weiteres Byte, weil das zweite Zeile hat Platz
für insgesamt 8 weitere Bytes.

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

Probieren Sie es online!

Gibt aus, 0ob die fehlende Ziffer 0 oder 9 sein könnte.

Dies funktioniert nur im PyFunge-Interpreter aus den nachfolgend erläuterten Gründen.

Erläuterung

Ein Großteil dieser Erklärung wurde aus meiner Befunge-98-Erklärung kopiert , da dieses Programm diesem sehr ähnlich ist. _{^{schamloser Stecker}}

In der ersten Zeile des Programms addieren wir die Ziffern, einschließlich des x, das aufgrund seines ASCII-Werts wie eine 72 behandelt wird. Die Summe wird jedoch dieselbe sein, sobald wir um 9 modifiziert haben. Dies ist also irrelevant.

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

Wenn wir nur um 9 modifizieren würden, würden wir mit der falschen Ziffer belassen, weil wir wollen 9 - (sum % 9). Wir können jedoch besser als 9\-, was den Rest von 9 abziehen würde: Wenn wir die Summe vor dem Modifizieren durch 9 negativ machen, erhalten wir ein positives Ergebnis, das 9 - (sum % 9)einigen Interpreten entspricht. Aus diesem Grund müssen wir die PyFunge-Interpreter für Befunge 93 und 98 verwenden, da dies der einzige von TIO ist, der dies ausführt. Die anderen geben uns einen Wert zwischen -8 und 8 anstelle von 0 und 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 bis 13 Bytes

Ich erkannte, dass ich nicht verwenden muss, um ?die abwesende Ziffer darzustellen, also verwendete ich eine, die ein Vielfaches von 9 ist, nachdem x
ich 48 subtrahiert hatte 3+.

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

Probieren Sie es online!

Verwendet eine x als fehlende Ziffer, da der ASCII-Wert nach Subtraktion von 48 durch 9 teilbar ist (und es ist schön, weil er in der Mathematik häufig als Variable verwendet wird).

Ausgabe über Exit-Code (weil qein Byte kürzer ist als .@)
Gibt aus, 0ob die fehlende Ziffer 0 oder 9 sein könnte.

Dies funktioniert nur im PyFunge-Interpreter aus den nachfolgend erläuterten Gründen.

Erläuterung

In der ersten Zeile des Programms addieren wir die Ziffern, einschließlich der x, die aufgrund ihres ASCII-Werts wie eine 72 behandelt werden. Die Summe wird jedoch dieselbe sein, sobald wir um 9 modifiziert haben. Dies ist also irrelevant.

#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

Wenn wir nur um 9 modifizieren würden, würden wir mit der falschen Ziffer belassen, weil wir wollen 9 - (sum % 9). Wir können jedoch besser als 9\-, was den Rest von 9 abziehen würde: Wenn wir die Summe vor der Modifikation durch 9 negativ machen, erhalten wir ein positives Ergebnis, das 9 - (sum % 9) einigen Interpreten entspricht . Aus diesem Grund müssen wir die PyFunge-Interpreter für Befunge 93 und 98 verwenden, da dies der einzige von TIO ist, der dies ausführt. Die anderen geben uns einen Wert zwischen -8 und 8 anstelle von 0 und 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

Verwendet '(jedes Zeichen, das einen Abstand zu hat0 durch "0" teilbar ist, reicht aus, einschließlich0 selbst).

Eine Ausgabe von 0 bedeutet entweder 0oder 9.

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

Probieren Sie es online!

Erläuterung

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 Danke an @Unihedron

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

Probieren Sie es online!

Befunge-93, 28 27 19 18 Bytes

Kredit muss zu gehen Mistah Figgins gehen , deren PyFunge-Antwort mir zeigte, dass Sie keine spezielle Prüfung für das fehlende Ziffernzeichen benötigen, wenn Sie nur sicherstellen, dass der ASCII-Wert ein Vielfaches von neun ist.

Zusätzlicher Dank geht an Jo King, der gezeigt hat, dass Sie die Zeichen nicht vollständig in ihre numerischen Äquivalente umwandeln müssen und einfach 3 subtrahieren können, um einen Wert zu erhalten, der relativ zur Basis 9 ist (ASCII 0minus 3 ist 45, ein Vielfaches von 9). .

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

Probieren Sie es online!

Damit dies funktioniert, sollten Sie den Charakter verwenden * für die fehlende Ziffer verwenden (es gibt andere, die ebenfalls funktionieren könnten, aber das ist das Schönste).

Gibt aus, 9ob die fehlende Ziffer 0 oder 9 sein könnte.

Erläuterung

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.

Im Wesentlichen berechnen wir die Summe aller Ziffern plus 45 pro Ziffer (was letztendlich gelöscht wird, wenn wir mit 9 modifizieren). Diese Summe wird von 3 (unserer Startsumme) abgezogen, und weitere 39 werden von der fehlenden Ziffer (ASCII) abgezogen* minus drei) . Auch hier ist 3 minus 39 ein Vielfaches von 9, also wird es aufgehoben, wenn wir mit 9 modifizieren.

Am Ende berechnen wir also die negative Summe aller Ziffern, Mod 9 plus 9, dh

9 - (digitsum % 9)

Und das gibt uns die fehlende Ziffer.

Befunge-98 (PyFunge) , 8 Bytes

#q~3--9%

Probieren Sie es online!

Ausgänge über Exit-Code. Wie bei Mistah Figgins Antwort funktioniert es nur bei Pyfunge, wo eine negative Zahl von Mod 9 positiv wird. Verwendet ein x als fehlende Ziffer.

PowerShell , 40 Byte

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

Probieren Sie es online! oder Überprüfen Sie alle Testfälle

Nimmt gerne Eingaben '123x'in $a. Konstruiert einen Bereich0 für 9und verwendetWhere-Object (hier abgekürzt als |?), um die Ganzzahlen zu ermitteln, die mit der Klausel übereinstimmen. Die Klausel nimmt an $a, führt einen regulären Ausdruck durch -replace, um den xdurch die aktuelle Ziffer zu ersetzen, $_und erhält den Mod 9 mit %9. Wenn sich also 9 gleichmäßig teilt, ist dies Null. Wir nehmen das Boolesche-Nicht davon, wodurch die Nullen wahr und alles andere falsch werden, so dass die Where-Object-Klausel erfüllt wird. Diese Ergebnisse verbleiben in der Pipeline und die Ausgabe ist implizit.

Haskell , 35 Bytes

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

Probieren Sie es online!

Retina , 35 34 25 Bytes

Wenn das ?möglich ist 0 or 9, wird das Ergebnis als angezeigt 9.

.
$*
1{9}

^
9$*;
+`;1

.

Probieren Sie es online aus

Erläuterung

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

Probieren Sie es online!

Es ist egal, welches Zeichen die fehlende Ziffer kennzeichnet, solange es sich nicht um eine Ziffer handelt.

Tcl, 53 Bytes

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

Wie bei anderen Antworten wird dies verkürzt, indem nicht explizit „0 oder 9“ gesagt wird.
Stattdessen bedeutet ein Ergebnis von „9“ entweder 0 oder 9.

Probieren Sie es online!

Erläuterung

Das funktioniert ganz einfach. Es verwendet einen regulären Ausdruck, um:

• Teilen Sie das Argument in einzelne Ziffern auf
• eliminieren Sie alle Fragezeichen Ziffern sind.
• Verschachteln Sie die Ziffern mit Pluszeichen

Es wertet dann 9 - (sum_of_digits mod 9) aus, um einen endgültigen Wert in 1..9 zu erhalten, den es dann puts .

Die führende 0 (in 0$argv) ist erforderlich, falls das Fragezeichen bei der Eingabe an erster Stelle steht. Ein vorangestelltes Pluszeichen in der transformierten Sequenz ist kein Problem für expr.

Pyth , 8 Bytes

%_iz19 9

Probieren Sie es online!

Verwendet Ianstelle von ?.

• In Basis 19 konvertieren.
• Negieren.
• Modulo 9.

APL (Dyalog) , 13 Bytes

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

Probieren Sie es online!

Die fehlende Ziffer ist ⍬.

Brainfuck , 50 Bytes

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

Probieren Sie es online!

Gibt eine 9 für 0 oder 9 aus. Ein fehlendes Zeichen wird dargestellt durch:

Wie es funktioniert

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

Das fehlende Zeichen muss ein Zeichen sein, das eine Mod 9 von 4, +3 hat, da wir 3 von den normalen Ziffern und +1 für die Initialisierung der Summe als 1 abziehen.

Als Randnotiz gibt es eine Menge Ineffizienz im Code für das Golfen, da jede Ziffer die Summe 5 Mal zurücksetzt, anstatt nur einmal, wenn ich 48 statt 3 subtrahiere.

> <> , 35 33 25 21 15 Bytes

Eine Ausgabe von 0bedeutet, dass das Ergebnis entweder 0 oder 9 sein kann .

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

Probieren Sie es online!

Dank Jo King wurden 6 Bytes eingespart, indem 'fehlende Ziffern dargestellt wurden.

Java 8, 36 34 Bytes

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

Gibt zurück, 9wenn beide 0und9 gültig sind.

Erläuterung:

Probieren Sie es online aus.

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