Trouver le chiffre unique le plus élevé

33

É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!

code-golf number integer

— Skidsdev
source

2

Pouvons-nous prendre l’entrée sous forme de chaîne à la place?

— Kritixi Lithos

3

Compte tenu du dernier cas de test, je pense que nous sommes obligés de prendre les entrées sous forme de chaîne ... (les zéros de gauche ne peuvent pas être représentés sous forme d'entiers)

— Leo

@Leo c'était mon mauvais, en gros, écrasé les chiffres sur mon clavier, n'a pas remarqué le zéro de tête. Mais oui, l'entrée peut être considérée comme une chaîne

— Skidsdev Le

25

@ Adám "comportement indéfini" signifie généralement que vous pouvez faire n'importe quoi, y compris appeler des horreurs sans nom depuis le vide si cela enregistre des octets.

— Martin Ender

22

@MartinEnder en fait, je supprimerai volontiers 50% de vos octets si votre code appelle avec succès cthulhu s'il n'y a pas de chiffres uniques;)

— Skidsdev Le

Réponses:

16

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

— Emigna
source

Attends donc dans 05AB1E, 2n’est pas la vérité; seulement 1? : o

— HyperNeutrino

@ HyperNeutrino: Correct!

— Emigna

2

Cela semble à la fois très utile et très gênant ... C'est intéressant: o: D

— HyperNeutrino

@HyperNeutrino: Cela s'avère souvent utile, mais cela peut être un inconvénient lorsque le défi dit de renvoyer une valeur de vérité , lorsque beaucoup de langues peuvent renvoyer un entier positif ou même une chaîne non vide.

— Emigna

Un barré sur le numéro n'est pas facile à voir!

— MrZander

15

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.

— M. Xcoder
source

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

— movatica

1

@ Movatica Merci!

— M. Xcoder

8

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.

— Martin Ender
source

-1, ne "fait pas appel à des horreurs sans nom du vide " s'il n'y a pas de chiffres uniques. ;) (Lire: +1, bonne réponse, comme toujours.)

— Kevin Cruijssen Le

1

@ KevinCruijssen J'ai essayé, mais cela n'a pas économisé d'octets. Peut -être que Dark pourrait être une langue plus appropriée ...

— Martin Ender

7

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).

— Martin Ender
source

Dommage que la déduplication ne soit pas utile ici :(

— CalculatriceFeline

7

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)

— Charlie
source

3

C'est un comportement indéfini intéressant :)

— Emigna Le

Cela me semble finlandais: D

— fedorqui

2

@fedorqui ravi de vous voir ici! Oui, mais le charbon de bois est plus facile à apprendre que Jelly ou O5AB1E, et il est plus amusant à utiliser dans les jeux ASCII-art. :-)

— Charlie

7

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é).

— Leo
source

7

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

— nimi
source

7

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!

— Giuseppe
source

Agréable! Je ne m'attendais pas à ce que quelque chose tablesoit plus court (en plus, je ne me souviens jamais comment aller namesau travail).

— aPaulT

1

<2pour un autre octet. Il ne devrait jamais y avoir de zéro dans les comptes.

— MickyT

1

y=table(scan());max(names(y[y<2]))est quelques octets plus court.

— JAD

6

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

Afficher l'extrait de code

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

Développer l'extrait

— OK je
source

Retirez l'alerte pour 39 octets: (s,i=9)=>s.split(i).length-2?f(s,--i):i. Vous pouvez éviter le débordement de pile pour 42 octets: (s,i=9)=>s.split(i).length-2?i&&f(s,--i):i.

— Rick Hitchcock le

Économisez un octet en currying: s=>g=(i=9)=>s.split(i).length-2?g(--i):ipuis appelez-le avecf("12")()

— Shaggy le

5

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!

— Alex Varga
source

Bienvenue chez PPCG! On dirait que tu as tout compris :)

— Stephen

4

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

— Fataliser
source

4

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.

— Martin Ender
source

1

¬←pourrait être plus simplement =1, même bytecount cependant :)

— Leo

1

@Leo Ah ouais, j'étais trop paresseux pour vérifier si le curry fonctionnerait sans parenthèses. J'ai besoin de faire plus confiance à l'inférence de type. ;)

— Martin Ender Le

4

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&

— J42161217
source

4

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

— aPaulT
source

max(x[!duplicated(x)])est un peu plus court, mais c’est une excellente réponse. Je savais que j'allais faire, ce n'était pas si bon. Vous pouvez également supprimer le f=début, car les fonctions anonymes sont des réponses parfaitement valables. En outre, vous pouvez utiliser TIO pour tester vos fonctions si vous utilisez ce format: Essayez-le en ligne!

— Giuseppe

Merci! Je pense que la fonction 'dupliquée' ne compte pas la première occurrence d'un élément dupliqué et que votre version ne fonctionnerait donc pas très bien

— aPaulT

ah bon point. Je n’utilise presque jamais, duplicatedmais j’ai en fait pensé à une autre réponse plus courte!

— Giuseppe

3

Ruby , 42 octets

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

Essayez-le en ligne!

— GB
source

Ruby cravates Python :)

— M. Xcoder

Parce que 42 est toujours la réponse. :-)

— GB

5

@GB Ou est-ce:->x{x.chars.select{|r|x.count(r)<2}.max}

— Martin Ender le

1

Ce serait 2 octets plus court et gâcherait le tout. :-)

— GB

3

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 ⌸.

— Adam
source

3

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.

— Riley
source

Remplacez grep -o .par fold -1pour sauvegarder 2 octets. Je conviens qu’un nombre entier donné sous forme de liste de chiffres étire trop les règles.

— Trauma numérique

+1 juste parce que c'est bash

— Anush

3

Python 2 , 39 octets

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

Essayez-le en ligne!

— Xnor
source

J'ai apprécié ça, c'est génial!

— Anush

3

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

— Kakkarot
source

Cela ne fonctionne pas avec "1948710498" en entrée (renvoie "9" au lieu de "7") et vous devez ajouter using System.Linq;au nombre d'octets.

— Charlie le

@CarlosAlejo Oups! Désolé! Lisez tout à l'heure les spécifications. Va éditer la solution bientôt.

— kakkarot

Édité. Y a-t-il des optimisations que je peux faire?

— Kakkarot

Bien sûr: essayez d'utiliser OrderBy(...).Last()au lieu de .OrderByDescending(...).First(), par exemple. Ou mieux encore, changez votre dernière partie .Max(i=>i.Key)après la Whereclause.

— Charlie

@ CarlosAlejo Merci! Édité.

— Kakkarot

2

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

Afficher l'extrait de code

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

Développer l'extrait

— Arnauld
source

2

Japt , 12 11 10 octets

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

k@¬èX ÉÃrw

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.

— Hirsute
source

2

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!

— Olivier Grégoire
source

1

Vous pouvez remplacer return i>0?i:0;avec return i;. Le résultat sera -1 pour le scénario de test [9,9,9,9,9,9], mais le problème est résolu: " S'il n'y a pas de chiffres uniques, votre programme peut tout faire (comportement indéfini). ".

— Kevin Cruijssen

En effet, je peux depuis la révision en cours. Avant je ne pouvais pas à cause du cas de test 0. C'est quelque chose que j'ai supervisé dans le golf précédent! :)

— Olivier Grégoire Le

2

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!

— Adam
source

Puisque 0n'est jamais le chiffre unique le plus élevé sauf pour 0lui-même, vous pouvez enregistrer 1 octet en utilisant à la ×place de /⍨, puis enregistrez un autre octet convertissant celui-ci en train

— TwiNight le

@ Twiight Nice! Merci.

— Adám

2

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!

— Jörg Hülsermann
source

1

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

— Titus le

2

Java (JDK) , 67 octets

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

Essayez-le en ligne!

— Incarnation de l'ignorance
source

1

Mathematica, 42 octets

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

— J42161217
source

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.

1

Gelée , 9 octets

ṢŒrṪỊ$ÐfṀ

Essayez-le en ligne!

— Erik le golfeur
source

bien

— Leaky Nun

@ LeakyNun outgolfed, fils

— Skidsdev Le

@ Mayube mais l'algorithme de base est le même

— Leaky Nun

@ LeakyNun non, c'est assez différent.

— Steenbergh

Je @LeakyNun décidé de publier séparément ... essentiellement une grande différence est que , dans mon cas , je décide juste que pour garder, alors que Steenbergh prend quelques têtes ou quelque chose ...

— Erik le Outgolfer

1

Pyth, 6 octets

eS.m/Q

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.

— isaacg
source

1

Perl 5 , 59 octets

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

Essayez-le en ligne!

— Felix Palmen
source

Réduit à 40 octets: essayez-le en ligne! . (vous pouvez regarder le -Fdrapeau sur Perlrun si nécessaire)

— Dada

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.

Licensed under cc by-sa 3.0 with attribution required.