Trova la cifra univoca più alta

33

Sorprendentemente non abbiamo ancora avuto una semplice sfida "trova la cifra più alta", ma penso che sia un po ' troppo banale.

Dato input di un numero intero non negativo, restituisce la cifra univoca più alta (ovvero non ripetuta) trovata nell'intero. Se non ci sono cifre univoche, il programma può fare qualsiasi cosa (comportamento indefinito).

L'input può essere preso come un singolo numero intero, una stringa o un elenco di cifre.

Casi test

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

Si tratta di code-golf quindi vince il minor numero di byte in ogni lingua !

code-golf  number  integer 
— Skidsdev
fonte
2
Possiamo invece prendere input come stringa?
— Kritixi Lithos,
3
Dato l'ultimo caso di test, penso che siamo costretti a prendere l'input come una stringa ... (gli zeri iniziali non possono essere rappresentati in numeri interi)
— Leo,
@Leo che è stato il mio cattivo in realtà, fondamentalmente ha schiacciato i numeri sulla mia tastiera, non ha notato lo zero iniziale. Ma sì, l'input può essere preso come una stringa
— Skidsdev,
25
@Adám "comportamento indefinito" generalmente significa che puoi fare qualsiasi cosa, incluso evocare orrori senza nome dal vuoto se questo salva byte.
— Martin Ender,
22
@MartinEnder infatti eliminerò felicemente il 50% dei tuoi byte se il tuo codice convoca con successo cthulhu in assenza di cifre univoche;)
— Skidsdev

Risposte:

16

05AB1E , 4 3 byte

Salvato 1 byte grazie a Mr. Xcoder che notifica che un elenco di cifre è un input valido.

¢ÏM

Provalo online!

Spiegazione

¢     # count occurrences of each digit in input
 Ï    # keep only the digits whose occurrences are true (1)
  M   # push the highest
— Emigna
fonte
Aspetta così in 05AB1E, 2non è vero; solo 1? : o
— HyperNeutrino,
@HyperNeutrino: Corretto!
— Emigna,
2
Sembra molto utile e molto fastidioso ... È interessante: o: D
— HyperNeutrino,
@HyperNeutrino: spesso è utile, ma può essere uno svantaggio quando la sfida dice che restituisce un valore di verità , quando molte lingue possono restituire qualsiasi numero intero positivo o forse anche una stringa non vuota.
— Emigna,
Un barrato sul numero per non è facile da vedere!
— MrZander,
15

Python 3 , 40 byte

Salvato 2 byte grazie a movatica .

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

Provalo online!

42 byte

Funziona sia per String che per l'elenco dei tipi di parametri delle cifre. Genera un errore per nessuna cifra univoca, tipo di abusi di quella specifica:

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

Provalo online!

Spiegazione

  • lambda i: - Dichiara una funzione lambda con una stringa o un elenco di cifre parametro i.
  • max(...) - Trova il valore massimo del generatore.
  • x for x in i- Scorre i caratteri / le cifre di i.
  • if i.count(x)<2 - Verifica se la cifra è unica.
— Mr. Xcoder
fonte
40 byte:lambda i:max(x*(i.count(x)<2)for x in i)
— movatica,
1
@movatica Grazie!
— Mr. Xcoder
8

Alice , 15 byte

/&.sDo
\i-.tN@/

Provalo online!

Spiegazione

/...
\.../

Questo è un semplice framework per il codice lineare che funziona interamente in modalità Ordinale (il che significa che questo programma funziona completamente attraverso l'elaborazione delle stringhe). Il codice lineare spiegato è quindi solo:

i..DN&-sto@

Cosa fa:

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
fonte
-1, non " evoca orrori senza nome dal vuoto " se non ci sono cifre uniche. ;) (Leggi: +1, ottima risposta come sempre.)
— Kevin Cruijssen,
1
@KevinCruijssen Ho provato, ma non ha salvato i byte. Forse Dark potrebbe essere una lingua più appropriata ...
— Martin Ender,
7

Carbone , 18 12 byte

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

Provalo online! (Link alla versione dettagliata)

Non stampa nulla se non viene trovata alcuna soluzione. Il trucco è che il forciclo stampa ogni numero univoco nella stringa di input, ma senza spostare il cursore, quindi il valore continua a ristampare se stesso fino a trovare la soluzione finale.

La versione precedente stampava i caratteri dalla A alla Z quando non veniva trovata alcuna soluzione, quindi i commenti:

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

Provalo online! (Link alla versione dettagliata)

— Charlie
fonte
3
È un comportamento indefinito interessante :)
— Emigna,
Mi sembra finlandese: D
— fedorqui,
2
@fedorqui piacere di vederti qui! Sì, ma Charcoal è più facile da imparare rispetto a Jelly o O5AB1E, ed è più divertente da usare nei giochi di arte ASCII. :-)
— Charlie,
7

Buccia , 7 byte

→fo¬hgO

Provalo online! (Suite di test, si arresta in modo anomalo sull'ultimo caso di test poiché non ha cifre univoche)

Questa è una composizione di funzioni in stile privo di punti (gli argomenti non sono menzionati esplicitamente da nessuna parte). Accetta input e restituisce output come stringa, che in Husk equivale a un elenco di caratteri.

Spiegazione

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"

* Il controllo per la lunghezza 1 viene eseguito prendendo la testa dell'elenco (tutti gli elementi tranne l'ultimo) e annullandolo (gli elenchi vuoti sono falsi, gli elenchi non vuoti sono veritieri).

— Leo
fonte
7

Haskell, 37 byte

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

Provalo online!

Come funziona:

  [  |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
— Nome del modello
fonte
7

R , 41 byte

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

Una funzione anonima che accetta un elenco di cifre, come numeri interi o stringhe di singoli caratteri. Si precompone ycome argomento facoltativo per evitare l'uso di parentesi graffe per il corpo della funzione. Restituisce la cifra come stringa. Questo ha un approccio leggermente diverso dall'altra risposta R e finisce per essere il più piccolo un po 'più corto! sembra che il mio commento ci sia stato dopo tutto sbagliato ...

tablecalcola le occorrenze di ciascun elemento nell'elenco, con names(table(x))i valori univoci in x(come stringhe). Dato che per fortuna le cifre sono ordinate lessicograficamente come numericamente, possiamo ancora utilizzarle max.

Provalo online!

— Giuseppe
fonte
Bello! Non mi aspettavo che fare qualcosa tablesarebbe stato più breve (in più non ricordo mai come mettermi namesal lavoro).
— agosto
1
<2per un altro byte. Non ci dovrebbe mai essere uno zero nei conteggi.
— MickyT,
1
y=table(scan());max(names(y[y<2]))è più breve di alcuni byte.
— JAD,
6

JavaScript (ES6), 46 41 40 byte

Accetta l'input come stringa. Restituisce RangeError se non ci sono cifre univoche.

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

-7 byte grazie a Rick Hitchcock

-1 byte grazie a Shaggy

Casi test

Mostra snippet di codice

— Oki
fonte
Rimuovere l'avviso per 39 byte: (s,i=9)=>s.split(i).length-2?f(s,--i):i. È possibile evitare l'overflow dello stack per 42 byte: (s,i=9)=>s.split(i).length-2?i&&f(s,--i):i.
— Rick Hitchcock,
Salvare un byte con curry: s=>g=(i=9)=>s.split(i).length-2?g(--i):ie quindi chiamarlo conf("12")()
— Shaggy il
5

Python 3, 40 byte

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

Funziona solo per elenchi di cifre. Il caso limite "990" funziona bene :)

Provalo online!

— Alex Varga
fonte
Benvenuti in PPCG! Sembra che tu abbia tutto a posto :)
— Stephen,
4

Brachylog , 8 byte

ọtᵒtᵍhth

Provalo online!

Spiegazione

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
— Fatalize
fonte
4

Husk, 9 8 bytes

Thanks to Leo for suggesting a slightly neater solution at the same byte count.

▲‡ȯf=1`#

Try it online!

Explanation

  ȯ       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
fonte
1
¬← could be more simply =1, same bytecount though :)
— Leo
1
@Leo Ah yeah, I was too lazy to test whether the currying would work without parentheses. I need to trust more in the type inference. ;)
— Martin Ender
4

Mathematica, 41 bytes

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

thanks @Martin Ender

here is Martin's approach on my answer

Mathematica, 35 bytes

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

R, 45 43 bytes

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

Try it online!

Takes input as a vector of integers. Finds the duplicated elements, removes them, and takes the maximum. (Returns -Inf with a warning if there is no unique maximum.)

Edited into an anonymous function per comment

— aPaulT
fonte
max(x[!duplicated(x)]) is quite a bit shorter, but this is a great answer. I knew the way I was going to do it was not this good. Also you can remove the f= from the beginning, as anonymous functions are perfectly valid answers. Also, you can use TIO to test your functions if you use this format: Try it online!
— Giuseppe
Thanks! I think the 'duplicated' function doesn't count the first occurrence of a duplicate element so your version wouldn't quite work
— aPaulT
ah, good point. I almost never use duplicated but I actually thought up another, shorter answer!
— Giuseppe
3

Ruby, 42 bytes

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

Try it online!

— G B
fonte
Ruby ties Python :)
— Mr. Xcoder
Because 42 is always the answer. :-)
— G B
5
@GB Or is it: ->x{x.chars.select{|r|x.count(r)<2}.max}
— Martin Ender
1
That would be 2 bytes shorter and ruin the whole thing. :-)
— G B
3

APL (Dyalog Unicode), 10 chars = 19 bytes

Method: multiply elements that occur multiple times by zero, and then fine the highest element.

⌈/×∘(1=≢)⌸

⌸ for each unique element and its indices in the argument:

 × multiply the unique element

 ∘(…) with:

  1= the Boolean for whether one is equal to

  ≢ the tally of indices (how many times the unique element occurs)

⌈/ the max of that

Try it online!

APL (Dyalog Classic), 15 bytes

⌈/×∘(1=≢)⎕U2338

Try it online!

Identical to the above, but uses ⎕U2338 instead of ⌸.

— Adám
fonte
3

Bash + coreutils, 30 28 bytes

-2 bytes thanks to Digital Trauma

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

Try it online!

Bash + coreutils, 20 bytes

sort|uniq -u|tail -1

Try it online!

If input is given as a list of digits, one per line, we can skip the fold stage. That feels like cheating though.

— Riley
fonte
Replace grep -o . with fold -1 to save 2 bytes. I agree that an input integer given as a list of digits is stretching the rules too far.
— Digital Trauma
+1 just because it is bash
— Anush
3

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

Try it online!

Thanks @CarlosAlejo

— kakkarot
fonte
This does not work with "1948710498" as input (returns "9" instead of "7"), and you must add using System.Linq; to the byte count.
— Charlie
@CarlosAlejo Oops! Sorry! Just now read the specifications fully. Will edit the solution soon.
— kakkarot
Edited. Are there any optimisations I can make?
— kakkarot
Sure: try using OrderBy(...).Last() instead of .OrderByDescending(...).First(), for instance. Or even better, change your last part with .Max(i=>i.Key) after the Where clause.
— Charlie
@CarlosAlejo Thanks! Edited.
— kakkarot
2

JavaScript (ES6), 52 50 bytes

Takes input as a list of digits. Returns 0 if there are no unique digits.

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

Test cases

Show code snippet

— Arnauld
fonte
2

Japt, 12 11 10 bytes

Takes input as an array of digits.

k@¬èX ÉÃrw

Test it

Explanation

     :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.
— Shaggy
fonte
2

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

Try it online!

-6 bytes thanks to @KevinCruijssen's insight!

— Olivier Grégoire
fonte
1
You can replace return i>0?i:0; with return i;. The output will be -1 for test case [9,9,9,9,9,9], but that is fine with the challenge: "If there are no unique digits, your program can do anything (undefined behavior).".
— Kevin Cruijssen
Indeed, I can since the current revision. Before I couldn't because of the test case 0. It's something I oversaw in the previous golf! :)
— Olivier Grégoire
2

APL (Dyalog), 14 bytes

-2 thanks toTwiNight.

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

⌈/ the largest of

⊢ the arguments

× multiplied by

1=(…) the Boolean for each where one equals

 +/ the row sums of

 ∘.=⍨ their equality table

Try it online!

— Adám
fonte
Since 0 is never the highest unique digit except for 0 itself, you can save 1 byte using × instead of /⍨, then save another byte converting that into a train
— TwiNight
@TwiNight Nice! Thank you.
— Adám
1

Mathematica, 42 bytes

Max@Position[RotateRight@DigitCount@#,1]-1&
— J42161217
fonte
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

Try it online!

An improved approach from my first effort, results in less bytes.

Points of interest: fst and snd return the first and second elements of a tuple respectively.

1

Pyth, 6 bytes

eS.m/Q

Test suite

Explanation:

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.