Você receberá uma string. Ele conterá 9 números inteiros exclusivos de 0 a 9. Você deve retornar o número inteiro ausente. A string ficará assim:

123456789
 > 0

134567890
 > 2

867953120
 > 4

Python 2 , 18 16 bytes

^{+ beleza graças a @Sarge Borsch}

`99066**2`.strip

Experimente online!

99066**2 é apenas uma maneira mais curta de gerar uma string que contém 0 ~ 9

Python , 22 bytes

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

Experimente online!

Uma solução aritmética. Interpreta a sequência de entrada como hexadecimal, a nega e pega o módulo de resultado 15.

APL (Dyalog) , 4 bytes

Função derivada

⎕D∘~

⎕D D igits

∘ (vincula um argumento esquerdo à seguinte função diádica para criar uma função monádica)

~ exceto [o argumento]

Experimente online!

Trem de funções

⎕D~⊢

⎕D D igits

~ exceto

⊢ o argumento certo

Experimente online!

Programa explícito

⎕D~⍞

⎕D D igits

~ exceto

⍞ entrada de caracteres

Experimente online!

Flacidez cerebral , 48 38 36 + 3 = 39 bytes

10 bytes salvos graças ao DJMcMayhem!

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

Experimente online!

Explicação

A soma de todos os dígitos do Ascii é 525. Este programa resume a entrada e a subtrai de 525 para obter o dígito ausente.

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

Pressionará 525. Isso tira vantagem do fato de que sabemos que haverá 9 elementos de entrada para começar. Isso significa que é []avaliado como 9, o que nos permite obter grandes números como 525 rapidamente.

Em seguida, temos o pouco:

                             [{{}}]

que somará as entradas e subtrairá do total.

Haskell , 24 23 bytes

(477-).sum.map fromEnum

Experimente online! Uso: (477-).sum.map fromEnum $ "123456890". 477 é a soma dos códigos de caracteres dos dígitos 1 a 9, excluindo 0. Esta função anônima calcula 477 menos a soma de todos os códigos de caracteres para encontrar o que está faltando.

Transformar os dígitos dos caracteres em ints é um byte a mais:

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

Experimente online!

Gelatina , 3 bytes

ØDḟ

Simplesmente filtra ( ḟ) a sequência de entrada de "0123456789" ( ØD).

Experimente online!

Ruby, 14

Soma os códigos ascii e subtrai de 48 * 9 + 45

->s{477-s.sum}

Use assim

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

puts f["123456789"]

JavaScript (ES6), 26

Edite 1 byte de salvar thx @Neil, com um truque muito mais inteligente

Xoring todos os valores de 1 a 9 fornece 1. Xor 1 mais uma vez e o resultado é 0. Portanto, se algum valor único estiver ausente, o resultado será o valor ausente.

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

Teste

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 Agradecimentos ao pôr do sol básico
-2 Agradecimentos a Martin Ender

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

1

Experimente online!

Substitua todos os dígitos por tantos se _5 1s:

.
$*_5$*

Remover todas as _s e uma 1para cada um:

+`_1|1_ 

Conte o número de 1s restantes:

1

05AB1E , 6 bytes

45¹SO-

Experimente online!

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

Porta da resposta Python do @ xnor, exceto que o JavaScript tem apenas um operador restante em vez de um módulo, portanto, não posso fazê-lo em uma única etapa. Editar: salvou 6 bytes graças a @Arnauld.

Brainfuck, 17 15 bytes

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

Experimente aqui . Esta solução funciona apenas no Brainfuck padrão (células de 8 bits), pois depende da embalagem.

É um dia raro em que Brainfuck pode realmente competir, mas esse desafio acabou de se alinhar com as especificações do BF muito bem!

Em vez de detalhar essa resposta, eu gostaria de passar pelas iterações que fiz, porque acho que seria mais compreensível (e mais interessante).
Nota: esta solução é inspirada principalmente pela resposta Brain-Flak do Wheat Wizard .

Explicação

Etapa 1, 26 bytes

Em sua resposta, Wheat Wizard apontou que a soma dos valores ASCII de 0-9 soma a 525. E como o Brainfuck padrão tem apenas uma noção de [0,255], isso torna o valor 525% 256 = 13 . Ou seja, subtrair os valores ASCII da entrada de 13 fornece o dígito ausente.

A primeira versão deste programa foi:
1. Coloque 13 na primeira célula
2. Insira entradas na segunda célula
3. Subtraia a segunda célula da primeira célula
4. Salte para 2 se houver entradas restantes
5. Imprima a primeira célula

E aqui está o código para a solução simples:

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

Etapa 2, 19 bytes

Como apontado em sua resposta, como sabemos que a entrada terá exatamente o comprimento 9, podemos usar esse valor como uma constante e eliminar essa longa sequência de + no início.
Também não importa em que ponto adicionamos 13 (obrigado, propriedade comutativa!), Portanto, misturamos isso com as etapas de subtração e impressão.

,        #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 foi a minha resposta original para esse problema, mas podemos fazer melhor.

Etapa 3, 17 bytes

Curiosamente, a resposta anterior funciona mesmo se começarmos com um + em vez de um,

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

Brainfuck exigiu algo em uma célula para iniciar um loop. Ingenuamente, adicionamos mais 4 no final, quando poderia ter sido em outros lugares.

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

Com alguns truques de loop totalmente intencionais (leia-se: tentativa e erro), iniciar o programa com a - leva a dois resultados interessantes:

1. Um é adicionado à segunda célula (economizando 1 byte no final).
2. Os loops são executados um tempo extra, totalizando 10 em vez de 9 (economizando mais 1 byte).

1 + 10 + 2 = 13, e terminamos com a resposta original.

Olhando para trás, é provavelmente uma redação excessiva para um programa tão simples do Brainfuck.

Etapa 4, 15 bytes

Depois de pensar um pouco mais nessa solução, consegui cortar 2 bytes.

Eu queria esclarecer algo sobre a etapa anterior:
o sinal de menos para inserir o loop efetivamente adiciona 1, mas o que realmente está fazendo é subtrair 255 da segunda célula (resultando em 1).

É óbvio em retrospecto, mas subtrair 1 da primeira célula é o mesmo que adicionar 1 à segunda célula (porque tudo na primeira célula é subtraído da segunda célula).

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

Consegui remover o "> + <" adicionando um "-" no início do primeiro loop. Ele precisa ir até lá, e não onde estava o "> + <", porque o programa repetirá infinitamente.

Oitava , 22 bytes

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

Experimente online!

Mathematica, 25 bytes

477-Tr@ToCharacterCode@#&

Função pura pegando uma string como entrada e retornando um número inteiro. O Mathematica tem nomes longos de comando e reluta em converter entre seqüências de caracteres e números inteiros, o que o torna particularmente ruim nesse desafio. O melhor que pude encontrar foi o algoritmo da resposta Ruby da Level River St , que calcula com base no total dos códigos ASCII da string de entrada; no Mathematica, isso usa apenas um nome de comando longo.

PHP, 27

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

usa o truque da resposta de Rod para gerar uma string contendo todos os dígitos e remove todos os dígitos, exceto o que está faltando.

PHP, 41

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

Este usa xor porque ainda não o vi.

Bash + coreutils, 19 bytes

Encontrei uma solução bash mais curta , que usa uma abordagem interessante de soma de verificação:

sum -s|dc -e524?--P

Experimente online!

Explicação:

O sumcomando imprime uma soma de verificação e uma contagem de blocos. Não conheço muitos detalhes, mas o uso da opção -s(algoritmo System V) tornará a soma de verificação igual à soma ASCII de cada código de caractere de entrada. Como tal, a soma de verificação permanece constante quando a ordem dos mesmos caracteres de entrada é alterada.

Dado 867953120como caso de teste (último exemplo), eis como o script funciona:

• sum -ssaídas 473 1. Se nenhum número inteiro estivesse faltando, a soma de verificação teria sido 525.
• dc -e524?empurra 524 e depois a entrada do tubo. A pilha é: 1 473 524. A idéia é subtrair a soma de verificação de 525, mas como a soma gera 1 também, preciso trabalhar com ela.
• --P. Após a aplicação dos dois subtracções (524- (473-1)), a pilha é: 52. Com 'P', imprimo o caractere com esse código ASCII:, 4o dígito ausente.

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

Receio que não seja muito curto.

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-

Experimente 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

Inclui +1 para -r

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

Experimente online!

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

Braquilog (2), 5 bytes

ẹ:Ị↔x

Experimente online!

Provavelmente deve ser mais curto (ainda estou confuso sobre o porquê disso ẹser necessário), mas é o melhor que posso fazer.

Explicação

ẹ:Ị↔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 comum, 47 bytes

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

Ungolfed:

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

Explicação:

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

Isso percorre os caracteres s, converte-os em dígitos e os adiciona. O dígito-char-p, convenientemente, retorna o número do caractere como seu valor "verdadeiro", para que possa ser usado como teste ou conversão.

(- 45 ...)

Subtrair de 45 devolve o dígito que estava faltando na entrada.

Cubix , 18 bytes

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

Expandido

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

Experimente aqui

Usa o mesmo tipo de método que essa resposta à prova de balas .

Crie o valor -525 na pilha pressionando 5, 2, concatenar, pressionar 5, concatenar e negar.
Em seguida, obtenha repetidamente a entrada e adicione até o final da entrada ser atingido.
Remova a última entrada, negue (faça positivo) o último resultado da adição, produza o caractere e interrompa.

O motivo para trabalhar de -525 em diante é que a saída de caracteres é atingida para cada iteração de entrada. Como o valor é negativo, nada é produzido até que o loop seja encerrado e o valor negativo seja positivo.

PHP, 37 bytes

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

Bash (+ utilitários), 22, 19 bytes

• Use em seqvez de expansão entre chaves, -3 bytes (Thx @Riley!)

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

Teste

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

Experimente Online!

Planilhas Google, 39 33 bytes

A entrada é inserida na célula A1.

Código:

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

Economizou 6 bytes graças a Steve Kass.

Código anterior:

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

Resultado:

Entre 98, 14 12 bytes

Salvei 1 byte, movendo o programa para 1 linha e 1 byte, fazendo um cálculo melhor

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

Experimente online!

Explicação

A soma dos valores ASCII varia de 477 a 468, dependendo do número que está faltando. Subtraindo isso de 7, obtemos o intervalo -470 a -461. Ao modificar esse número por 10, obtemos o intervalo de 0 a 9, que 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

A razão pela qual eu uso os valores ASCII em vez de receber uma entrada inteira é porque o &comando no Try it Online é interrompido no EOF (mesmo que ele deva reverter o IP). Mas ~funciona corretamente.

Programa Antigo , 14 bytes

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

A soma dos valores ASCII de todos os 10 dígitos é 525. Subtraindo a soma dos dígitos fornecidos de 525, obtemos o valor ASCII do caractere ausente.

#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$_}

Experimente online!

Recebe entrada $n, constrói um intervalo 0..9(ou seja, 0, 1, 2 ... 9) e usa uma Where-Objectcláusula (the |?{...}) para extrair o número que regex -notmatch. Isso é deixado no pipeline, a produção está implícita.

Röda , 28 bytes

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

Experimente online!

Pyth, 5 bytes

-jkUT

tente!

explicação

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

"-jUT" também funciona, mas produz novas linhas para cada int.

05AB1E , 5 bytes

žhISK

Experimente online!

Explicação

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