Sorprendentemente, no hemos tenido un simple "encontrar el dígito más alto" desafío todavía, pero creo que es un poco demasiado trivial.

Dada la entrada de un entero no negativo, devuelve el dígito único más alto (es decir, no repetido) encontrado en el entero. Si no hay dígitos únicos, su programa puede hacer cualquier cosa (comportamiento indefinido).

La entrada se puede tomar como un entero entero, una cadena o una lista de dígitos.

Casos de prueba

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

Este es el código de golf, por lo que gana menos bytes en cada idioma .

05AB1E , 4 3 bytes

Se guardó 1 byte gracias al Sr. Xcoder que notificó que una lista de dígitos es una entrada válida.

¢ÏM

Pruébalo en línea!

Explicación

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

Python 3 , 40 bytes

Guardado 2 bytes gracias a movatica .

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

Pruébalo en línea!

42 bytes

Funciona tanto para String como para tipos de parámetros de lista de dígitos. Lanza un error sin dígitos únicos, tipo de abusos de esa especificación:

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

Pruébalo en línea!

Explicación

• lambda i: - Declara una función lambda con una cadena o una lista de dígitos parámetro i.
• max(...) - Encuentra el valor máximo del generador.
• x for x in i- Itera a través de los caracteres / dígitos de i.
• if i.count(x)<2 - Comprueba si el dígito es único.

Alice , 15 bytes

/&.sDo
\i-.tN@/

Pruébalo en línea!

Explicación

/...
\.../

Este es un marco simple para código lineal que opera completamente en modo Ordinal (lo que significa que este programa funciona completamente a través del procesamiento de cadenas). El código lineal desplegado es simplemente:

i..DN&-sto@

Que hace:

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+

!`.$

Pruébalo en línea!

Explicación

O`.

Ordenar los dígitos.

(.)\1+

Eliminar dígitos repetidos.

!`.$

Obtenga el último dígito (máximo).

Carbón , 18 12 bytes

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

Pruébalo en línea! (Enlace a la versión detallada)

No imprime nada si no se encuentra una solución. El truco es que el forbucle imprime cada número único en la cadena de entrada, pero sin mover el cursor, por lo tanto, el valor sigue reimprimiéndose hasta que se encuentra la solución final.

La versión anterior imprimió los caracteres de la A a la Z cuando no se encontró una solución, de ahí los comentarios:

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

Pruébalo en línea! (Enlace a la versión detallada)

Casco , 7 bytes

→fo¬hgO

Pruébalo en línea! (Conjunto de pruebas, se bloquea en el último caso de prueba ya que no tiene dígitos únicos)

Esta es una composición de funciones en estilo libre de puntos (los argumentos no se mencionan explícitamente en ninguna parte). Toma la entrada y devuelve la salida como una cadena, que en Husk es equivalente a una lista de caracteres.

Explicación

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"

* La verificación de la longitud 1 se realiza tomando el encabezado de la lista (todos los elementos excepto el último) y negándolo (las listas vacías son falsas, las listas no vacías son verdaderas).

Haskell, 37 bytes

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

Pruébalo en línea!

Cómo 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]))

Una función anónima que toma una lista de dígitos, ya sea como enteros o cadenas de caracteres individuales. Precalcula ycomo argumento opcional para evitar el uso de llaves para el cuerpo de la función. Devuelve el dígito como una cadena. ¡Esto toma un enfoque ligeramente diferente al de la otra respuesta R y termina siendo el más pequeño! Parece que mi comentario fue incorrecto después de todo ...

tablecalcula las ocurrencias de cada elemento en la lista, con names(table(x))los valores únicos en x(como cadenas). Dado que, afortunadamente, los dígitos se ordenan de la misma forma lexicográfica que numérica, aún podemos usarlos max.

Pruébalo en línea!

JavaScript (ES6), 46 41 40 bytes

Toma la entrada como una cadena. Devuelve RangeError si no hay dígitos únicos.

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

-7 bytes gracias a Rick Hitchcock

-1 byte gracias a Shaggy

Casos de prueba

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)

Solo funciona para listas de dígitos. El caso de borde '990' funciona bien :)

Pruébalo en línea!

Brachylog , 8 bytes

ọtᵒtᵍhth

Pruébalo en línea!

Explicación

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

Casco , 9 8 bytes

Gracias a Leo por sugerir una solución un poco más ordenada con el mismo número de bytes.

▲‡ȯf=1`#

Pruébalo en línea!

Explicación

  ȯ       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)&

gracias @Martin Ender

aquí está el enfoque de Martin en mi respuesta

Mathematica, 35 bytes

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

R, 45 43 bytes

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

Pruébalo en línea!

Toma la entrada como un vector de enteros. Encuentra los elementos duplicados, los elimina y toma el máximo. (Regresa -Infcon una advertencia si no hay un máximo único).

Editado en una función anónima por comentario

Ruby , 42 bytes

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

Pruébalo en línea!

APL (Dyalog Unicode) , 10 caracteres = 19 bytes

Método: multiplique elementos que ocurren varias veces por cero y luego multa el elemento más alto.

⌈/×∘(1=≢)⌸

⌸ para cada elemento único y sus índices en el argumento:

 × multiplicar el elemento único

 ∘(... ) con:

  1= el booleano para saber si uno es igual a

  ≢ el recuento de índices (cuántas veces se produce el elemento único)

⌈/ el máximo de eso

Pruébalo en línea!

APL (Dyalog Classic) , 15 bytes

⌈/×∘(1=≢)⎕U2338

Pruébalo en línea!

Idéntico a lo anterior, pero utiliza en ⎕U2338lugar de ⌸.

Bash + coreutils, 30 28 bytes

-2 bytes gracias a Digital Trauma

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

Pruébalo en línea!

Bash + coreutils, 20 bytes

sort|uniq -u|tail -1

Pruébalo en línea!

Si la entrada se proporciona como una lista de dígitos, uno por línea, podemos omitir la etapa de plegado. Sin embargo, eso se siente como hacer trampa.

Python 2 , 39 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Gracias @CarlosAlejo

JavaScript (ES6), 52 50 bytes

Toma la entrada como una lista de dígitos. Devuelve 0si no hay dígitos únicos.

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

Casos de prueba

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

Japt , 12 11 10 bytes

Toma la entrada como una matriz de dígitos.

k@¬èX ÉÃrw

Pruébalo

Explicación

     :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;}

Pruébalo en línea!

-6 bytes gracias a la idea de @ KevinCruijssen!

APL (Dyalog) , 14 bytes

-2 gracias aTwiNight.

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

⌈/ el más grande de

⊢ los argumentos

× multiplicado por

1=(... ) el booleano para cada uno donde uno es igual

 +/ la fila suma de

 ∘.=⍨ su tabla de igualdad

Pruébalo en línea!

PHP , 40 bytes

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

Pruébalo en línea!

PHP , 42 bytes

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

Pruébalo en línea!

Java (JDK) , 67 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Un enfoque mejorado desde mi primer esfuerzo, resulta en menos bytes.

Puntos de interés: fsty snddevolver el primer y el segundo elemento de una tupla respectivamente.

Jalea , 9 bytes

ṢŒrṪỊ$ÐfṀ

Pruébalo en línea!

Pyth, 6 bytes

eS.m/Q

Banco de pruebas

Explicación:

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

Pruébalo en línea!