Se le dará una cadena. Contendrá 9 enteros únicos de 0-9. Debe devolver el entero que falta. La cadena se verá así:

123456789
 > 0

134567890
 > 2

867953120
 > 4

Python 2 , 18 16 bytes

^{+ belleza gracias a @Sarge Borsch}

`99066**2`.strip

Pruébalo en línea!

99066**2 es solo una forma más corta de generar una cadena que contiene 0 ~ 9

Python , 22 bytes

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

Pruébalo en línea!

Una solución aritmética. Interpreta la cadena de entrada como hexadecimal, la niega y toma el resultado módulo 15.

APL (Dyalog) , 4 bytes

Función derivada

⎕D∘~

⎕D D igits

∘ (vincula un argumento izquierdo a la siguiente función diádica para crear una función monádica)

~ excepto [el argumento]

Pruébalo en línea!

Tren de funciones

⎕D~⊢

⎕D D igits

~ excepto

⊢ el argumento correcto

Pruébalo en línea!

Programa explícito

⎕D~⍞

⎕D D igits

~ excepto

⍞ entrada de caracteres

Pruébalo en línea!

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

¡10 bytes guardados gracias a DJMcMayhem!

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

Pruébalo en línea!

Explicación

La suma de todos los dígitos en Ascii es 525. Este programa resume la entrada y la resta de 525 para obtener el dígito faltante.

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

Empujará 525. Esto aprovecha el hecho de que sabemos que habrá 9 elementos de entrada para empezar. Esto significa que se []evalúa a 9, lo que nos permite llegar rápidamente a grandes cantidades como 525.

A continuación tenemos el bit:

                             [{{}}]

que resumirá las entradas y las restará del total.

Haskell , 24 23 bytes

(477-).sum.map fromEnum

Pruébalo en línea! Uso: (477-).sum.map fromEnum $ "123456890". 477 es la suma de los códigos de caracteres de los dígitos del 1 al 9, excluyendo 0. Esta función anónima calcula 477 menos la suma de todos los códigos de caracteres de dígitos para encontrar el que falta.

Convertir los dígitos de caracteres en caracteres es un byte más largo:

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

Pruébalo en línea!

Jalea , 3 bytes

ØDḟ

Simplemente filtra ( ḟ) la cadena de entrada de "0123456789" ( ØD).

Pruébalo en línea!

Rubí, 14

Suma los códigos ascii y resta de 48 * 9 + 45

->s{477-s.sum}

Usar así

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

puts f["123456789"]

JavaScript (ES6), 26

Editar 1 byte guardar thx @Neil, con un truco mucho más inteligente

Xoring todos los valores del 1 al 9 da 1. Xor 1 una vez más y el resultado es 0. Entonces, si falta un valor único, el resultado será el valor faltante.

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

Prueba

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 Gracias a Basic Sunset
-2 Gracias a Martin Ender

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

1

Pruébalo en línea!

Reemplace cada dígito con esa cantidad de _sy 5 1s:

.
$*_5$*

Elimine todos los _sy a 1para cada uno:

+`_1|1_ 

Cuente el número de 1s restantes:

1

05AB1E , 6 bytes

45¹SO-

Pruébalo en línea!

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

JavaScript (ES6), 31 29 28 22 bytes

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

Puerto de la respuesta de Python de @ xnor, excepto que JavaScript solo tiene un operador restante en lugar de un operador de módulo, por lo que no puedo hacerlo en un solo paso. Editar: Guardado 6 bytes gracias a @Arnauld.

Brainfuck, 17 15 bytes

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

Pruébalo aquí . Esta solución funciona solo en Brainfuck estándar (celdas de 8 bits), ya que depende de la envoltura.

Es un día raro cuando Brainfuck puede competir, ¡pero este desafío se alineó bastante bien con la especificación BF!

En lugar de desglosar esta respuesta, me gustaría revisar las iteraciones que hice, porque creo que sería más comprensible (y más interesante).
Nota: esta solución está inspirada en gran medida por la respuesta Brain-Flak de Wheat Wizard .

Explicación

Paso 1, 26 bytes

En su respuesta, Wheat Wizard señaló que la suma de los valores ASCII de 0-9 suma a 525. Y como Brainfuck estándar solo tiene una noción de [0,255], esto hace que el valor sea 525% 256 = 13 . Es decir, restando los valores ASCII de la entrada de 13 le da el dígito faltante.

La primera versión de este programa fue:
1. Poner 13 en la primera celda
2. Tomar entradas en la segunda celda
3. Restar la segunda celda de la primera celda
4. Saltar a 2 si quedan entradas
5. Imprimir la primera celda

Y aquí está el código para la solución simple:

+++++++++++++ #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  

Paso 2, 19 bytes

Como se señaló en su respuesta, dado que sabemos que la entrada tendrá exactamente la longitud 9, podemos usar ese valor como una constante y eliminar esa larga cadena de + al principio.
Tampoco importa en qué momento agreguemos 13 (¡gracias, propiedad conmutativa!), Por lo que lo mezclaremos con los pasos de resta e impresión.

,        #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

Esta fue mi respuesta original a este problema, pero podemos hacerlo mejor.

Paso 3, 17 bytes

Curiosamente, la respuesta anterior funciona incluso si comenzamos con un + en lugar de un,

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

Brainfuck requería algo en una celda para comenzar un ciclo. Ingenuamente agregamos ese 4 extra al final, cuando podría haber ido a otros lugares.

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

Con algunos trucos de bucle totalmente intencionales (léase: prueba y error), comenzar el programa con un - lleva a dos resultados interesantes:

1. Uno se agrega a la segunda celda (guardando 1 byte al final).
2. Los bucles se ejecutan una vez más, totalizando 10 en lugar de 9 (ahorrando otro 1 byte).

1 + 10 + 2 = 13, y terminamos con la respuesta original.

Mirando hacia atrás, esto es probablemente una crítica excesiva para un programa Brainfuck tan simple.

Paso 4, 15 bytes

Después de pensar un poco más en esta solución, pude cortar 2 bytes.

Quería aclarar algo sobre el paso anterior:
el signo negativo para ingresar al bucle efectivamente agrega 1, pero lo que en realidad está haciendo es restar 255 de la segunda celda (lo que resulta en 1).

Es obvio en retrospectiva, pero restar 1 de la primera celda es lo mismo que sumar 1 a la segunda celda (porque todo en la primera celda se resta de la segunda celda).

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

Pude eliminar el "> + <" agregando un "-" al comienzo del primer bucle. Tiene que ir allí, y no donde estaba el "> + <", porque de lo contrario el programa se repetirá infinitamente.

Octava , 22 bytes

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

Pruébalo en línea!

Mathematica, 25 bytes

477-Tr@ToCharacterCode@#&

Función pura que toma una cadena como entrada y devuelve un entero. Mathematica tiene nombres de comando largos y es reacio a convertir entre cadenas y enteros, lo que lo hace particularmente malo en este desafío. Lo mejor que pude encontrar fue el algoritmo de la respuesta Ruby de Level River St , que realiza un cálculo basado en el total de los códigos ASCII de la cadena de entrada; en Mathematica, esto usa solo un nombre de comando largo.

PHP, 27

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

usa el truco de la respuesta de Rod para generar una cadena que contiene todos los dígitos y luego elimina todos los dígitos excepto el que falta.

PHP, 41

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

Este usa xor porque aún no lo he visto.

Bash + coreutils, 19 bytes

Encontré una solución bash más corta , que utiliza un enfoque interesante de suma de comprobación:

sum -s|dc -e524?--P

Pruébalo en línea!

Explicación:

El sumcomando imprime una suma de verificación y un conteo de bloques. No conozco muchos detalles, pero el uso de la opción -s(algoritmo del Sistema V) hará que la suma de verificación sea igual a la suma ASCII de cada código de caracteres de entrada. Como tal, la suma de comprobación permanece constante cuando cambia el orden de los mismos caracteres de entrada.

Dado 867953120como caso de prueba (último ejemplo), así es como funciona el script:

• sum -ssalidas 473 1. Si no faltara un entero, la suma de verificación habría sido 525.
• dc -e524?empuja 524 y luego la entrada de la tubería. La pila es: 1 473 524. La idea es restar la suma de verificación de 525, pero como la suma también produce 1, necesito trabajar con ella.
• --P. Después de aplicar los dos sustracciones (524- (473-1)), la pila es: 52. Con 'P' imprimo el carácter con ese código ASCII: 4el dígito que falta.

Fortran 95, 146128 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

No muy corto, me temo.

Sin golf:

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-

Pruébalo en línea!

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

Incluye +1 para -r

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

Pruébalo en línea!

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

Brachylog (2), 5 bytes

ẹ:Ị↔x

Pruébalo en línea!

Podría decirse que debería ser más corto (todavía estoy confundido sobre por qué ẹes necesario), pero esto es lo mejor que puedo hacer.

Explicación

ẹ:Ị↔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

Lisp común, 47 bytes

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

Sin golf:

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

Explicación:

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

Esto recorre los caracteres s, los convierte en dígitos y los agrega. Digit-char-p, convenientemente, devuelve el número de char como su valor "verdadero", para que pueda usarse como prueba o conversión.

(- 45 ...)

Restar 45 devuelve el dígito que faltaba en la entrada.

Cubix , 18 bytes

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

Expandido

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

Pruébalo aquí

Utiliza el mismo tipo de método que esta respuesta mental .

Cree el valor -525 en la pila presionando 5, 2, concatenar, empujar 5, concatenar y negar.
Luego, obtenga repetidamente la entrada y agregue hasta que se llegue al final de la entrada.
Elimine la última entrada, niegue (haga positivo) el último resultado agregado, muestre el carácter y pare.

La razón para trabajar desde -525 en adelante es que la salida de caracteres se alcanza para cada iteración de entrada. Como el valor es negativo, no se emite nada hasta que se sale del bucle y el valor negativo se vuelve positivo.

PHP, 37 bytes

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

Bash (+ utilidades), 22, 19 bytes

• Use en seqlugar de expansión de llaves, -3 bytes (Thx @Riley!)

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

Prueba

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

¡Pruébelo en línea!

Hojas de cálculo de Google, 39 33 bytes

La entrada se ingresa en la celda A1.

Código:

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

Guardado 6 bytes gracias a Steve Kass.

Código anterior:

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

Resultado:

Befunge 98, 14 12 bytes

Ahorré 1 byte moviendo el programa a 1 línea y 1 byte haciendo mejores matemáticas

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

Pruébalo en línea!

Explicación

La suma de los valores ASCII varía de 477 a 468, según el número que falta. Al restar esto de 7, obtenemos el rango -470 a -461. Al modificar este número por 10, obtenemos el rango 0 - 9, que luego podemos imprimir.

~+;       ;#    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

La razón por la que uso los valores ASCII en lugar de tomar la entrada entera es porque el &comando en Probar en línea se detiene en EOF (aunque debería revertir la IP). El ~funciona correctamente, sin embargo.

Programa anterior , 14 bytes

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

La suma de los valores ASCII de los 10 dígitos es 525. Al restar la suma de los dígitos dados de 525, obtenemos el valor ASCII del carácter faltante.

#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 bytes

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

Pruébalo en línea!

Toma entrada $n, construye un rango 0..9(es decir, 0, 1, 2 ... 9), luego usa una Where-Objectcláusula (the |?{...}) para extraer el número que hace regex -notmatch. Eso queda en la tubería, la salida es implícita.

Röda , 28 bytes

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

Pruébalo en línea!

Pyth, 5 bytes

-jkUT

¡intentalo!

explicación

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

"-jUT" también funciona, pero produce nuevas líneas para cada int.

05AB1E , 5 bytes

žhISK

Pruébalo en línea!

Explicación

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