Sie erhalten eine Zeichenfolge. Es enthält 9 eindeutige Ganzzahlen von 0 bis 9. Sie müssen die fehlende Ganzzahl zurückgeben. Die Zeichenfolge sieht folgendermaßen aus:

123456789
 > 0

134567890
 > 2

867953120
 > 4

Python 2 , 18 16 Bytes

^{+ Schönheit dank @Sarge Borsch}

`99066**2`.strip

Probieren Sie es online!

99066**2 Dies ist nur eine kürzere Möglichkeit, eine Zeichenfolge zu generieren, die 0 bis 9 enthält

Python , 22 Bytes

lambda s:-int(s,16)%15

Probieren Sie es online!

Eine arithmetische Lösung. Interpretiert die Eingabezeichenfolge als hexadezimal, negiert sie und nimmt das Ergebnis Modulo 15.

APL (Dyalog) , 4 Bytes

Abgeleitete Funktion

⎕D∘~

⎕D D igits

∘ (Verknüpft ein linkes Argument mit der folgenden dyadischen Funktion, um eine monadische Funktion zu erstellen.)

~ außer [das Argument]

Probieren Sie es online!

Funktionszug

⎕D~⊢

⎕D D igits

~ außer

⊢ das richtige argument

Probieren Sie es online!

Explizites Programm

⎕D~⍞

⎕D D igits

~ außer

⍞ Zeicheneingabe

Probieren Sie es online!

Brain-Flak , 48 38 36 + 3 = 39 Bytes

10 Bytes gespart dank DJMcMayhem!

((([]())[]{}){()()({}[()])}{}[{{}}])

Probieren Sie es online!

Erläuterung

Die Summe aller Ziffern in Ascii ist 525. Dieses Programm summiert die Eingabe und subtrahiert sie von 525, um die fehlende Ziffer zu erhalten.

((([]())[]{}){()()({}[()])}{}      )

Will push 525. Dies nutzt die Tatsache aus, dass wir wissen, dass es zunächst 9 Eingabeelemente geben wird. Dies bedeutet, dass der []Wert 9 ergibt, wodurch wir schnell zu großen Zahlen wie 525 gelangen können.

Als nächstes haben wir das bisschen:

                             [{{}}]

Dadurch werden die Eingaben summiert und von der Gesamtsumme subtrahiert.

Haskell , 24 23 Bytes

(477-).sum.map fromEnum

Probieren Sie es online! Verbrauch: (477-).sum.map fromEnum $ "123456890". 477 ist die Summe der Zeichencodes der Ziffern 1 bis 9 mit Ausnahme von 0. Diese anonyme Funktion berechnet 477 abzüglich der Summe aller Ziffernzeichencodes, um den fehlenden zu finden.

Das Umwandeln der Zeichen in Ints dauert ein Byte länger:

(45-).sum.map(read.pure)
foldl(\a b->a-read[b])45

Probieren Sie es online!

Gelee , 3 Bytes

ØDḟ

Filtert ( ḟ) einfach die Eingabezeichenfolge aus "0123456789" ( ØD).

Probieren Sie es online!

Rubin, 14

Summiert die ASCII-Codes und subtrahiert von 48 * 9 + 45

->s{477-s.sum}

Verwenden Sie wie folgt

f=->s{477-s.sum}

puts f["123456789"]

JavaScript (ES6), 26

Bearbeiten Sie 1 Byte und speichern Sie @Neil mit einem viel intelligenteren Trick

Das Xoring aller Werte von 1 bis 9 ergibt 1. Oder 1 noch einmal und das Ergebnis ist 0. Wenn also ein einzelner Wert fehlt, ist das Ergebnis der fehlende Wert.

s=>eval([1,...s].join`^`)

Prüfung

f=s=>eval([1,...s].join`^`)

function go() {

  var i=I.value;
  O.textContent = f(i)
}  

go()

<input oninput='go()' value='012987653' id=I>
<pre id=O></pre>

Retina , 27 21 19 Bytes

-6 Dank an Basic Sunset
-2 Dank an Martin Ender

.
$*_5$*
+`_1|1_

1

Probieren Sie es online!

Ersetze jede Ziffer mit so vielen _s und 5 1s:

.
$*_5$*

Entfernen Sie alle _s und a 1für jedes:

+`_1|1_ 

Zähle die Anzahl der 1verbleibenden s:

1

05AB1E , 6 Bytes

45¹SO-

Probieren Sie es online!

45     # Push 45
  ¹    # push input
   S   # Split
    O  # Sum
     - # Subtract (45 - sum)

JavaScript (ES6), 31 29 28 22 Byte

s=>(15-`0x${s}`%15)%15

Port von @ xnors Python-Antwort, außer dass JavaScript nur einen Restoperator anstelle eines Modulo-Operators hat, daher kann ich das nicht in einem einzigen Schritt tun. Bearbeiten: 6 Bytes dank @Arnauld gespeichert.

Gehirnfick, 17 15 Bytes

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

Probieren Sie es hier aus . Diese Lösung funktioniert nur mit Standard-Brainfuck (8-Bit-Zellen), da es sich um ein Wrapping handelt.

Es ist ein seltener Tag, an dem Brainfuck tatsächlich antreten kann, aber diese Herausforderung stimmte einfach ziemlich gut mit der BF-Spezifikation überein!

Anstatt diese Antwort direkt aufzuschlüsseln, möchte ich die Iterationen durchgehen, die ich gemacht habe, weil ich denke, dass dies verständlicher (und interessanter) wäre.
Hinweis: Diese Lösung ist weitgehend von der Brain-Flak-Antwort von Wheat Wizard inspiriert .

Erläuterung

Schritt 1, 26 Bytes

In seiner Antwort wies Wheat Wizard darauf hin, dass sich die Summe der ASCII-Werte von 0-9 zu 525 summiert. Und da Standard-Brainfuck nur einen Begriff von [0,255] hat, ergibt dies den Wert 525% 256 = 13 . Das heißt, wenn Sie die ASCII-Werte der Eingabe von 13 subtrahieren, erhalten Sie die fehlende Ziffer.

Die erste Version dieses Programms war:
1. Setzen Sie 13 in die erste Zelle
2. Nehmen Sie Eingaben in die zweite Zelle
3. Subtrahieren Sie die zweite Zelle von der ersten Zelle
4. Springen Sie zu 2, wenn noch Eingaben vorhanden sind
5. Drucken Sie die erste Zelle

Und hier ist der Code für die einfache Lösung:

+++++++++++++ #Set the first cell to 13  
>,            #Take inputs into the second cell  
[[<->-],]     #Subtract the second cell from the first cell and repeat until inputs are over  
<.            #Print the first cell  

Schritt 2, 19 Bytes

Wie in seiner Antwort ausgeführt, können wir, da wir wissen, dass die Eingabe genau die Länge 9 hat, diesen Wert als Konstante verwenden und diese lange Zeichenfolge von + gleich am Anfang entfernen.
Es ist auch egal, zu welchem ​​Zeitpunkt wir 13 addieren (danke, kommutative Eigenschaft!), Also mischen wir es mit den Schritten Subtraktion und Drucken.

,        #Take input to enter the loop
[[->-<], #Subtract the first cell from the second cell 
>+<]     #Add 1 for each input; totaling 9
>++++    #Add the missing 4 to make 13
.        #And print

Dies war meine ursprüngliche Antwort auf dieses Problem, aber wir können es besser machen.

Schritt 3, 17 Bytes

Interessanterweise funktioniert die vorherige Antwort auch dann, wenn wir mit einem + anstelle von einem beginnen.

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

Brainfuck benötigte etwas in einer Zelle, um eine Schleife zu beginnen. Wir haben diese zusätzlichen 4 am Ende naiv hinzugefügt, wenn es an anderen Orten gegangen sein könnte.

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

Mit etwas völlig absichtlich (sprich: Versuch und Irrtum) Schleife Tricks, Anfahren des Programm mit einem - führt zu zwei interessanten Ergebnissen:

1. Man wird zur zweiten Zelle hinzugefügt (1 Byte am Ende speichern).
2. Die Schleifen werden ein weiteres Mal ausgeführt, insgesamt 10 statt 9 (wobei ein weiteres Byte eingespart wird).

1 + 10 + 2 = 13, und wir erhalten die ursprüngliche Antwort.

Rückblickend ist dies wahrscheinlich ein übermäßiger Aufschub für solch ein einfaches Brainfuck-Programm.

Schritt 4, 15 Bytes

Nachdem ich ein bisschen mehr über diese Lösung nachgedacht hatte, konnte ich 2 Bytes abschneiden.

Ich wollte etwas über den vorherigen Schritt klarstellen:
Das Minus zum Eingeben der Schleife addiert effektiv 1, aber was es tatsächlich tut, ist das Subtrahieren von 255 von der zweiten Zelle (was zu 1 führt).

Rückblickend ist es offensichtlich, aber das Subtrahieren von 1 von der ersten Zelle ist dasselbe wie das Addieren von 1 zu der zweiten Zelle (weil alles in der ersten Zelle von der zweiten Zelle subtrahiert wird).

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

Ich konnte das "> + <" durch Hinzufügen eines "-" am Anfang der ersten Schleife entfernen. Es muss dorthin gehen und nicht dorthin, wo das "> + <" war, da das Programm ansonsten eine Endlosschleife ausführt.

Oktave , 22 Bytes

@(x)setdiff('0':'9',x)

Probieren Sie es online!

Mathematica, 25 Bytes

477-Tr@ToCharacterCode@#&

Reine Funktion, die einen String als Eingabe nimmt und eine Ganzzahl zurückgibt. Mathematica hat lange Befehlsnamen und zögert, zwischen Zeichenfolgen und Ganzzahlen zu konvertieren, was es bei dieser Herausforderung besonders schlimm macht. Das Beste, was ich finden konnte, war der Algorithmus aus Level River Sts Ruby-Antwort , der eine Berechnung basierend auf der Summe der ASCII-Codes der Eingabezeichenfolge durchführt. In Mathematica wird nur ein langer Befehlsname verwendet.

PHP, 27

<?=trim(32043**2,$argv[1]);

verwendet den Trick aus Rods Antwort , um eine Zeichenfolge zu generieren, die alle Ziffern enthält, und entfernt dann alle Ziffern mit Ausnahme der fehlenden.

PHP, 41

for($b=1;$i<9;$b^=$argv[1][$i++]);echo$b;

Dieser benutzt xor, weil ich es noch nicht gesehen habe.

Bash + Coreutils, 19 Bytes

Ich habe eine kürzere Bash-Lösung gefunden, die einen interessanten Prüfsummenansatz verwendet:

sum -s|dc -e524?--P

Probieren Sie es online!

Erläuterung:

Der sumBefehl gibt eine Prüfsumme und eine Blockanzahl aus. Ich kenne nicht viele Details, aber bei Verwendung der Option -s(System V-Algorithmus) entspricht die Prüfsumme der ASCII-Summe jedes eingegebenen Zeichencodes. Somit bleibt die Prüfsumme konstant, wenn sich die Reihenfolge der gleichen Eingabezeichen ändert.

Gegeben 867953120als Testfall (letztes Beispiel), hier ist , wie das Skript funktioniert:

• sum -sAusgänge 473 1. Wenn keine ganze Zahl fehlte, wäre die Prüfsumme 525 gewesen.
• dc -e524?drückt 524 und dann den Pipe-Eingang. Der Stapel ist: 1 473 524. Die Idee ist, die Prüfsumme von 525 zu subtrahieren, aber da die Summe auch 1 ergibt, muss ich damit arbeiten.
• --P. Nach dem Auftragen der zwei Subtraktionen (524- (473-1)), ist der Stapel: 52. Mit 'P' gebe ich das Zeichen mit diesem ASCII-Code aus: 4die fehlende Ziffer.

Fortran 95, 146 128 Bytes

function m(s)
character(len=10)::s,t
t='0123456789'
do j=1,10
k=0
do i=1,9
if(s(i:i)==t(j:j))k=1
end do
if(k==0)m=j-1
end do
end

Nicht sehr kurz, fürchte ich.

Ungolfed:

integer function m(s)
    implicit none

    character(len=9)::s
    character(len=10)::t
    integer:: i, j, k

    t='0123456789'
    do j=1,10
        k=0
        do i=1,9
            if (s(i:i) == t(j:j)) k=1
        end do
        if (k==0) m=j-1
    end do

end function m

CJam , 5 Bytes

A,sq-

Probieren Sie es online!

A,     e# The range from 0 to 9: [0 1 2 3 4 5 6 7 8 9]
  s    e# Cast to a string: "0123456789"
   q   e# The input
    -  e# Remove all characters from the range that are in the input
       e# Implicit output

GNU sed , 36 Bytes

Beinhaltet +1 für -r

s/$/0123456789/
:
s/(.)(.*)\1/\2/
t

Probieren Sie es online!

s/$/0123456789/ # Append 0123456789
:               # Start loop
s/(.)(.*)\1/\2/ # remove a duplicate character
t               # loop if something changed

Brachylog (2), 5 Bytes

ẹ:Ị↔x

Probieren Sie es online!

Sollte wohl kürzer sein (ich bin immer noch verwirrt, warum das ẹnotwendig ist), aber das ist das Beste, was ich tun kann.

Erläuterung

ẹ:Ị↔x
ẹ      Split the input into a list of characters
 :Ị    Pair that list with the string "0123456789"
   ↔x  Remove all elements of the list from the string

Common Lisp, 47 Bytes

(lambda(s)(- 45(reduce'+ s :key'digit-char-p)))

Ungolfed:

(lambda (s) (- 45 (reduce '+ s :key 'digit-char-p)))

Erklärung:

(reduce '+ s :key 'digit-char-p)

Dies durchläuft die Zeichen in einer Schleife s, konvertiert sie in Ziffern und fügt sie hinzu. Digit-char-p gibt die Nummer des Zeichens günstigerweise als "wahren" Wert zurück, sodass es als Test oder Konvertierung verwendet werden kann.

(- 45 ...)

Subtrahieren von 45 gibt die Ziffer zurück, die in der Eingabe fehlte.

Cubix , 18 Bytes

5v&;52/ni?@.>!&oW+

Erweitert

    5 v
    & ;
5 2 / n i ? @ .
> ! & o W + . .
    . .
    . .

Probieren Sie es hier aus

Verwendet die gleiche Art von Verfahren , wie diese Gehirn-Flakfeuer Antwort.

Erstellen Sie den Wert -525 auf dem Stapel, indem Sie 5, 2, verketten, 5, verketten und negieren drücken.
Holen Sie sich dann wiederholt die Eingabe und fügen Sie sie hinzu, bis das Ende der Eingabe erreicht ist.
Entfernen Sie die letzte Eingabe, negieren Sie das letzte Additionsergebnis (machen Sie es positiv), geben Sie das Zeichen aus und halten Sie an.

Der Grund für die Arbeit von -525 bis ist, dass die Zeichenausgabe bei jeder Eingabe-Iteration getroffen wird. Da der Wert negativ ist, wird nichts ausgegeben, bis die Schleife verlassen und der negative Wert positiv gemacht wird.

PHP, 37 Bytes

<?=45-array_sum(str_split($argv[1]));

Bash (+ Dienstprogramme), 2219 Bytes

• Verwenden Sie seqanstelle der geschweiften Klammer -3 Bytes (Thx @Riley!)

seq 0 9|tr -d \\n$1 

Prüfung

$seq 0 9|tr -d \\n123456789
0

Probieren Sie es online!

Google Sheets, 39 33 Bytes

Die Eingabe wird in die Zelle eingegeben A1.

Code:

=REGEXEXTRACT(4&2^29,"[^"&A1&"]")

6 Bytes gespart dank Steve Kass.

Vorheriger Code:

=REGEXEXTRACT("0123456789","[^"&A1&"]")

Ergebnis:

Befunge 98, 14 12 Bytes

Ich habe 1 Byte gespart, indem ich das Programm auf 1 Zeile verschoben habe, und 1 Byte, indem ich etwas besser rechnete

~+;@.%a--7;#

Probieren Sie es online!

Erläuterung

Die Summe der ASCII-Werte reicht von 477 bis 468, je nachdem, welche Zahl fehlt. Durch Subtrahieren von 7 erhalten wir den Bereich -470 bis -461. Durch Modifizieren dieser Zahl um 10 erhalten wir den Bereich 0 - 9, den wir dann drucken können.

~+;       ;#    Sums the ASCII values of all characters to stdIn
~          #    The # doesn't skip over the ~ because it's on the end of a line
~               Once EOF is hit, the ~ reverses the IP's direction
          ;#    Jump the ; that was used before
       --7      Subtract the sum from 7 (really just 0 - (sum - 7))
     %a         Mod it by 10
   @.           Print and exit

Der Grund, warum ich die ASCII-Werte verwende, anstatt eine Ganzzahleingabe zu verwenden, ist, dass der &Befehl in Try it Online bei EOF angehalten wird (obwohl die IP umgekehrt werden sollte). Das ~funktioniert aber einwandfrei.

Altes Programm , 14 Bytes

#v~+
@>'i5*--,

Die Summe der ASCII-Werte aller 10 Stellen ist 525. Durch Subtrahieren der Summe der angegebenen Stellen von 525 erhalten wir den ASCII-Wert des fehlenden Zeichens.

#v~+         Sums the ASCII values of all characters on stdIn
             Moves to the next line when this is done
 >'i5*       Pushes 525 (105 * 5)
      --     Subtracts the sum from 525
@       ,    Prints and exits

PowerShell , 30 Byte

param($n)0..9|?{$n-notmatch$_}

Probieren Sie es online!

Nimmt Eingaben entgegen $n, erstellt einen Bereich 0..9(dh 0, 1, 2 ... 9) und verwendet dann eine Where-ObjectKlausel (the |?{...}), um die Zahl zu ermitteln, die Regex ausführt -notmatch. Das bleibt in der Pipeline, die Ausgabe ist implizit.

Röda , 28 Bytes

{(_/"")|ord _|sum|chr 525-_}

Probieren Sie es online!

Pyth, 5 Bytes

-jkUT

Versuch es!

Erläuterung

-jkUT
    T   # 10
   U    # The unary range of ten: [0,1,..,9]
 jk     # join that on the empty string
-       # set minus

"-jUT" funktioniert auch ein bisschen, erzeugt aber Zeilenumbrüche für jeden Int.

05AB1E , 5 Bytes

žhISK

Probieren Sie es online!

Erläuterung

žh     # from the string "0123456789"
    K  # remove
  IS   # each digit of the input