Surpreendentemente, ainda não tivemos um desafio simples de "encontrar o dígito mais alto", mas acho que isso é um pouco trivial demais.

Dada a entrada de um número inteiro não negativo, retorne o dígito único mais alto (isto é, não repetido) encontrado no número inteiro. Se não houver dígitos únicos, seu programa poderá fazer qualquer coisa (comportamento indefinido).

A entrada pode ser tomada como um único número inteiro, uma sequência ou uma lista de dígitos.

Casos de teste

12         -> 2
0          -> 0
485902     -> 9
495902     -> 5
999999     -> Anything
999099     -> 0
1948710498 -> 7

Isso é código-golfe, e o menor número de bytes em cada idioma vence!

05AB1E , 4 3 bytes

Economizou 1 byte graças ao Sr. Xcoder notificando que uma lista de dígitos é uma entrada válida.

¢ÏM

Experimente online!

Explicação

¢     # count occurrences of each digit in input
 Ï    # keep only the digits whose occurrences are true (1)
  M   # push the highest

Python 3 , 40 bytes

Economizou 2 bytes graças à movatica .

lambda i:max(x*(i.count(x)<2)for x in i)

Experimente online!

42 bytes

Funciona para os tipos de parâmetros String e lista de dígitos. Lança um erro sem dígitos únicos, tipo de abuso dessa especificação:

lambda i:max(x for x in i if i.count(x)<2)

Experimente online!

Explicação

• lambda i: - Declara uma função lambda com uma sequência de caracteres ou lista de dígitos i.
• max(...) - Encontra o valor máximo do gerador.
• x for x in i- Repete os caracteres / dígitos de i.
• if i.count(x)<2 - Verifica se o dígito é único.

Alice , 15 bytes

/&.sDo
\i-.tN@/

Experimente online!

Explicação

/...
\.../

Essa é uma estrutura simples para código linear que opera inteiramente no modo Ordinal (o que significa que este programa funciona completamente através do processamento de cadeias). O código linear desdobrado é então apenas:

i..DN&-sto@

O que faz:

i    Read all input as a string.
..   Make two copies.
D    Deduplicate the characters in the top copy.
N    Get the multiset complement of this deduplicated string in the input.
     This gives us a string that only contains repeated digits (with one
     copy less than the original, but the number of them doesn't matter).
&-   Fold string subtraction over this string, which means that each of
     the repeated digits is removed from the input.
s    Sort the remaining digits.
t    Split off the last digit.
o    Print it.
@    Terminate the program.

Retina , 16 bytes

O`.
(.)\1+

!`.$

Experimente online!

Explicação

O`.

Classifique os dígitos.

(.)\1+

Remova os dígitos repetidos.

!`.$

Busque o último dígito (máximo).

Carvão , 18 12 bytes

Ｆχ¿⁼№θＩι¹ＰＩι

Experimente online! (Link para a versão detalhada)

Não imprime nada se nenhuma solução for encontrada. O truque é que o forloop imprime todos os números únicos na string de entrada, mas sem mover o cursor, o valor continua sendo impresso novamente até que a solução final seja encontrada.

A versão anterior imprimiu os caracteres de A a Z quando nenhuma solução foi encontrada, daí os comentários:

ＡααＦχＡ⎇⁼№θＩι¹Ｉιααα

Experimente online! (Link para a versão detalhada)

Casca , 7 bytes

→fo¬hgO

Experimente online! (Conjunto de testes, falha no último caso de teste, pois não possui dígitos únicos)

Essa é uma composição de funções no estilo sem ponto (os argumentos não são mencionados explicitamente em nenhum lugar). Recebe e retorna a saída como uma string, que em Husk é equivalente a uma lista de caracteres.

Explicação

Test case: "1948710498"

      O    Sort:                             "0114478899"
     g     Group consecutive equal elements: ["0","11","44","7","88","99"]
 fo¬h      Keep only those with length 1*:   ["0","7"]
→          Take the last element:            "7"

* A verificação do comprimento 1 é feita pegando o cabeçalho da lista (todos os elementos, exceto o último) e negando-o (listas vazias são falsas, listas não vazias são verdadeiras).

Haskell, 37 bytes

f s=maximum[x|x<-s,[x]==filter(==x)s]

Experimente online!

Como funciona:

  [  |x<-s   ]          -- loop x through the input string s
    x                   -- and keep the x where
     [x]==filter(==x)s  -- all x extracted from s equal a singleton list [x]
maximum                 -- take the maximum of all the x

R , 41 bytes

function(x,y=table(x))max(names(y[y==1]))

Uma função anônima que recebe uma lista de dígitos, como números inteiros ou seqüências de caracteres únicas. Ele precomputa ycomo argumento opcional para evitar o uso de chaves para o corpo da função. Retorna o dígito como uma sequência. Isso leva uma abordagem um pouco diferente da outra resposta R e acaba sendo um pouquinho menor! parece que meu comentário estava errado, afinal ...

tablecalcula as ocorrências de cada elemento na lista, com names(table(x))os valores exclusivos em x(como seqüências de caracteres). Felizmente, como os dígitos são ordenados da mesma forma lexicograficamente e numericamente, ainda podemos usá-lo max.

Experimente online!

JavaScript (ES6), 46 41 40 bytes

Recebe a entrada como uma sequência. Retorna RangeError se não houver dígitos únicos.

s=>f=(i=9)=>s.split(i).length-2?f(--i):i

-7 bytes graças a Rick Hitchcock

-1 byte graças a Shaggy

Casos de teste

let f =

s=>g=(i=9)=>s.split(i).length-2?g(--i):i


console.log(f("12")())         // 2
console.log(f("0")())          // 0
console.log(f("485902")())     // 9
console.log(f("495902")())     // 5
//console.log(f("999999")())   // RangeError
console.log(f("999099")())     // 0
console.log(f("1948710498")()) // 7

Python 3, 40 bytes

lambda i:max(x+9-9*i.count(x)for x in i)

Funciona apenas para listas de dígitos. O case '990' da borda funciona bem :)

Experimente online!

Braquilog , 8 bytes

ọtᵒtᵍhth

Experimente online!

Explicação

Example input: 495902

ọ          Occurences:    [[4,1],[9,2],[5,1],[0,1],[2,1]]
 tᵒ        Order by tail: [[0,1],[2,1],[4,1],[5,1],[9,2]]
   tᵍ      Group by tail: [[[0,1],[2,1],[4,1],[5,1]],[[9,2]]]
     h     Head:          [[0,1],[2,1],[4,1],[5,1]]
      t    Tail:          [5,1]
       h   Head:          5

Casca , 9 8 bytes

Agradecemos a Leo por sugerir uma solução um pouco mais limpa na mesma contagem de bytes.

▲‡ȯf=1`#

Experimente online!

Explicação

  ȯ       Compose the following thre functions into one binary function.
      `#  Count the occurrences of the right argument in the left.
    =1    Check equality with 1. This gives 1 (truthy) for values that 
          appear uniquely in the right-hand argument.
   f      Select the elements from the right argument, where the function
          in the left argument is truthy.
          Due to the composition and partial function application this
          means that the first argument of the resulting function actually
          curries `# and the second argument is passed as the second
          argument to f. So what we end up with is a function which selects
          the elements from the right argument that appear uniquely in
          the left argument.
 ‡        We call this function by giving it the input for both arguments.
          So we end up selecting unique digits from the input.
▲         Find the maximum.  

Mathematica, 41 bytes

(t=9;While[DigitCount[#][[t]]!=1,t--];t)&

obrigado @Martin Ender

aqui está a abordagem de Martin na minha resposta

Mathematica, 35 bytes

9//.d_/;DigitCount[#][[d]]!=1:>d-1&

R, 45 43 bytes

function(x)max(setdiff(x,x[duplicated(x)]))

Experimente online!

Recebe entrada como um vetor de números inteiros. Localiza os elementos duplicados, remove-os e utiliza o máximo. (Retorna -Infcom um aviso se não houver um máximo exclusivo.)

Editado em uma função anônima por comentário

Ruby , 42 bytes

->x{(?0..?9).select{|r|x.count(r)==1}[-1]}

Experimente online!

APL (Dyalog Unicode) , 10 caracteres = 19 bytes

Método: multiplique elementos que ocorrem várias vezes por zero e depois ajuste o elemento mais alto.

⌈/×∘(1=≢)⌸

⌸ para cada elemento exclusivo e seus índices no argumento:

 × multiplique o elemento único

 ∘(… ) Com:

  1= o booleano para saber se um é igual a

  ≢ a contagem de índices (quantas vezes o elemento único ocorre)

⌈/ o máximo disso

Experimente online!

APL (Dyalog Classic) , 15 bytes

⌈/×∘(1=≢)⎕U2338

Experimente online!

Idêntico ao anterior, mas usa em ⎕U2338vez de ⌸.

Bash + coreutils, 30 28 bytes

-2 bytes graças ao Digital Trauma

fold -1|sort|uniq -u|tail -1

Experimente online!

Bash + coreutils, 20 bytes

sort|uniq -u|tail -1

Experimente online!

Se a entrada for dada como uma lista de dígitos, um por linha, podemos pular o estágio de dobra. Isso parece trapaça.

Python 2 , 39 bytes

lambda l:max(1/l.count(n)*n for n in l)

Experimente online!

C # (.NET Core) , 27 97 86 58 57 75 bytes

using System.Linq;

n=>n.GroupBy(i=>i).Where(i=>i.Count()<2).Max(i=>i.Key)-48

Experimente online!

Obrigado @CarlosAlejo

JavaScript (ES6), 52 50 bytes

Recebe a entrada como uma lista de dígitos. Retorna 0se não houver dígitos únicos.

s=>s.reduce((m,c)=>m>c|s.filter(x=>x==c)[1]?m:c,0)

Casos de teste

let f =

s=>s.reduce((m,c)=>m>c|s.filter(x=>x==c)[1]?m:c,0)

console.log(f([1,2]))                 // 2
console.log(f([0]))                   // 0
console.log(f([4,8,5,9,0,2]))         // 9
console.log(f([4,9,5,9,0,2]))         // 5
console.log(f([9,9,9,9,9,9]))         // (0)
console.log(f([9,9,9,0,9,9]))         // 0
console.log(f([1,9,4,8,7,1,0,4,9,8])) // 7

Japonês , 12 11 10 bytes

Recebe a entrada como uma matriz de dígitos.

k@¬èX ÉÃrw

Teste-o

Explicação

     :Implicit input of array U.
k    :Filter the array to the elements that return false when...
@    :Passed through a function that...
¬    :Joins U to a string and...
èX   :Counts the number of times the current element (X) appears in the string...
É    :Minus 1.
     :(The count of unique digits will be 1, 1-1=0, 0=false)
à   :End function.
r    :Reduce by...
w    :Getting the greater of the current element and the current value.
     :Implicit output of resulting single digit integer.

Java (OpenJDK 8) , 89 85 79 bytes

a->{int i=10,x[]=new int[i];for(int d:a)x[d]++;for(;i-->0&&x[i]!=1;);return i;}

Experimente online!

-6 bytes graças à visão de @ KevinCruijssen!

APL (Dyalog) , 14 bytes

-2 graças aTwiNight.

⌈/⊢×1=(+/∘.=⍨)

⌈/ o maior de

⊢ os argumentos

× multiplicado por

1=(… ) O booleano para cada um onde é igual

 +/ a linha soma de

 ∘.=⍨ sua tabela de igualdade

Experimente online!

PHP , 40 bytes

<?=array_flip(count_chars($argn))[1]-48;

Experimente online!

PHP , 42 bytes

<?=chr(array_flip(count_chars($argn))[1]);

Experimente online!

Java (JDK) , 67 bytes

s->{int i=9;for(s=" "+s+" ";s.split(i+"").length!=2;i--);return i;}

Experimente online!

Mathematica, 42 bytes

Max@Position[RotateRight@DigitCount@#,1]-1&

F # , 88 bytes

let f i=Seq.countBy(fun a->a)i|>Seq.maxBy(fun a->if snd a>1 then 0 else int(fst a))|>fst

Experimente online!

Uma abordagem aprimorada do meu primeiro esforço resulta em menos bytes.

Pontos de interesse: fste sndretorne o primeiro e o segundo elementos de uma tupla, respectivamente.

Geléia , 9 bytes

ṢŒrṪỊ$ÐfṀ

Experimente online!

Pitão, 6 bytes

eS.m/Q

Suíte de teste

Explicação:

eS.m/Q
eS.m/QbQ    Implicit variable introduction
  .m   Q    Find all minimal elements of the input by the following function:
    /Qb     Number of appearances in the input
eS          Take the maximum element remaining.

Perl 5 , 59 bytes

for$x(split//,<>){$d[$x]++};for($x=11;--$d[--$x];){}print$x

Experimente online!