Étonnamment, nous n’avons pas encore lancé le défi «Trouver le chiffre le plus élevé», mais je pense que c’est un peu trop trivial.

Étant donné l'entrée d'un entier non négatif, retourne le chiffre unique le plus élevé (c'est-à-dire non répété) trouvé dans l'entier. S'il n'y a pas de chiffres uniques, votre programme peut tout faire (comportement indéfini).

L'entrée peut être prise sous la forme d'un entier unique, d'une chaîne ou d'une liste de chiffres.

Cas de test

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

C'est du code-golf, donc le moins d'octets dans chaque langue gagne!

05AB1E , 4 3 octets

Sauvé 1 octet grâce à M. Xcoder notifiant qu'une entrée de liste de chiffres est valide.

¢ÏM

Essayez-le en ligne!

Explication

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

Python 3 , 40 octets

2 octets sauvés grâce à movatica .

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

Essayez-le en ligne!

42 octets

Fonctionne pour les types de paramètres String et list of digits. Lance une erreur sans chiffres uniques, genre d'abus de cette spécification:

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

Essayez-le en ligne!

Explication

• lambda i: - Déclare une fonction lambda avec une chaîne ou une liste de paramètres de chiffres i.
• max(...) - Trouve la valeur maximale du générateur.
• x for x in i- Itère parmi les caractères / chiffres de i.
• if i.count(x)<2 - Vérifie si le chiffre est unique.

Alice , 15 octets

/&.sDo
\i-.tN@/

Essayez-le en ligne!

Explication

/...
\.../

Il s'agit d'un cadre simple pour le code linéaire qui fonctionne entièrement en mode ordinal (ce qui signifie que ce programme fonctionne complètement avec le traitement de chaîne). Le code linéaire déplié est alors juste:

i..DN&-sto@

Ce qu'il fait:

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 octets

O`.
(.)\1+

!`.$

Essayez-le en ligne!

Explication

O`.

Triez les chiffres.

(.)\1+

Supprimer les chiffres répétés.

!`.$

Récupère le dernier chiffre (maximum).

Charbon de bois , 18 12 octets

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

Essayez-le en ligne! (Lien vers la version commentée)

N'imprime rien si aucune solution n'est trouvée. L'astuce est que la forboucle imprime chaque numéro unique de la chaîne d'entrée, mais sans déplacer le curseur, la valeur continue ainsi à se réimprimer jusqu'à ce que la solution finale soit trouvée.

La version précédente imprimait les caractères de A à Z lorsqu'aucune solution n'était trouvée, d'où les commentaires:

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

Essayez-le en ligne! (Lien vers la version commentée)

Coque , 7 octets

→fo¬hgO

Essayez-le en ligne! (Suite de tests, se bloque sur le dernier cas de test car il n'a pas de chiffres uniques)

Il s'agit d'une composition de fonctions dans un style sans points (les arguments ne sont mentionnés explicitement nulle part). Prend les entrées et retourne les sorties sous forme de chaîne, ce qui équivaut à Husk à une liste de caractères.

Explication

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 vérification de la longueur 1 est effectuée en prenant la tête de la liste (tous les éléments sauf le dernier) et en la niant (les listes vides sont fausses, les listes non vides sont la vérité).

Haskell, 37 octets

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

Essayez-le en ligne!

Comment ça marche:

  [  |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 octets

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

Une fonction anonyme qui prend une liste de chiffres, sous forme d'entiers ou de chaînes de caractères uniques. Il précalcule ysous forme d'argument facultatif pour éviter d'utiliser des accolades pour le corps de la fonction. Renvoie le chiffre sous forme de chaîne. Cela prend une approche légèrement différente de l'autre réponse R et finit par être le plus petit peu plus court! on dirait que mon commentaire était faux après tout ...

tablecalcule les occurrences de chaque élément de la liste, names(table(x))en xtant que valeurs uniques dans (en tant que chaînes). Puisque les chiffres sont heureusement classés par le même lexicographe que numériquement, nous pouvons toujours utiliser max.

Essayez-le en ligne!

JavaScript (ES6), 46 41 40 octets

Prend l'entrée sous forme de chaîne. Renvoie RangeError s'il n'y a pas de chiffres uniques.

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

-7 octets grâce à Rick Hitchcock

-1 octet grâce à Shaggy

Cas de test

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 octets

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

Ne fonctionne que pour les listes de chiffres. L'affaire Edge '990' fonctionne bien :)

Essayez-le en ligne!

Brachylog , 8 octets

ọtᵒtᵍhth

Essayez-le en ligne!

Explication

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

Husk , 9 à 8 octets

Merci à Leo d’avoir suggéré une solution légèrement plus nette au même nombre d’octets.

▲‡ȯf=1`#

Essayez-le en ligne!

Explication

  ȯ       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 octets

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

merci @Martin Ender

voici l'approche de Martin sur ma réponse

Mathematica, 35 octets

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

R, 45 43 octets

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

Essayez-le en ligne!

Prend l'entrée en tant que vecteur d'entiers. Trouve les éléments dupliqués, les supprime et prend le maximum. (Retourne -Infavec un avertissement s'il n'y a pas de maximum unique.)

Edité dans une fonction anonyme par commentaire

Ruby , 42 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 10 caractères = 19 octets

Méthode: multipliez les éléments qui apparaissent plusieurs fois par zéro, puis définissez l'élément le plus élevé.

⌈/×∘(1=≢)⌸

⌸ pour chaque élément unique et ses index dans l'argument:

 × multiplier l'élément unique

 ∘(… ) Avec:

  1= le booléen pour savoir si on est égal à

  ≢ le décompte des indices (combien de fois l'élément unique se produit)

⌈/ le max de cela

Essayez-le en ligne!

APL (Dyalog Classic) , 15 octets

⌈/×∘(1=≢)⎕U2338

Essayez-le en ligne!

Identique à ce qui précède, mais utilise ⎕U2338au lieu de ⌸.

Bash + coreutils, 30 28 octets

-2 octets grâce à Digital Trauma

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

Essayez-le en ligne!

Bash + coreutils, 20 octets

sort|uniq -u|tail -1

Essayez-le en ligne!

Si l'entrée est donnée sous forme de liste de chiffres, un par ligne, nous pouvons ignorer l'étape de repliement. Cela ressemble à de la triche cependant.

Python 2 , 39 octets

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

Essayez-le en ligne!

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

using System.Linq;

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

Essayez-le en ligne!

Merci @CarlosAlejo

JavaScript (ES6), 52 50 octets

Prend la saisie sous forme de liste de chiffres. Renvoie 0s'il n'y a pas de chiffres uniques.

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

Cas de test

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 octets

Prend les entrées sous forme de tableau de chiffres.

k@¬èX ÉÃrw

Essaye-le

Explication

     :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 octets

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

Essayez-le en ligne!

-6 octets grâce à la perspicacité de @ KevinCruijssen!

APL (Dyalog) , 14 octets

-2 grâce à Two Night.

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

⌈/ le plus grand des

⊢ les arguments

× multiplié par

1=(… ) Le booléen pour chacun où on est égal

 +/ la somme des rangées de

 ∘.=⍨ leur table d'égalité

Essayez-le en ligne!

PHP , 40 octets

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

Essayez-le en ligne!

PHP , 42 octets

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

Essayez-le en ligne!

Java (JDK) , 67 octets

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

Essayez-le en ligne!

Mathematica, 42 octets

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

F # , 88 octets

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

Essayez-le en ligne!

Une approche améliorée dès mon premier effort entraîne moins d'octets.

Points d'intérêt: fstet sndrenvoient les premier et deuxième éléments d'un tuple, respectivement.

Gelée , 9 octets

ṢŒrṪỊ$ÐfṀ

Essayez-le en ligne!

Pyth, 6 octets

eS.m/Q

Suite de tests

Explication:

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 octets

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

Essayez-le en ligne!