Intro

Un amico ha posto questa domanda oggi in un modo leggermente diverso: "Può un singolo comando [Python] determinare il più grande di alcuni numeri interi E che non sono uguali?".

Anche se non abbiamo trovato il modo di farlo all'interno delle definizioni ragionevoli di "un singolo comando", ho pensato che potesse essere un problema divertente per il golf.

 Sfida

" Restituisce il più grande di un elenco di numeri interi se e solo se non sono tutti uguali. "

Più specificamente:

Data una stringa contenente solo un elenco di numeri interi separati da virgola:

• Se sono tutti uguali, non restituisce / restituisce nulla
• Altrimenti, restituisce / genera il più grande

Regole

• L' input deve essere una stringa contenente solo un elenco di numeri interi separati da virgola
• L' output deve essere o nulla (nessun output di alcun tipo), oppure l'elemento più grande dall'input, rappresentato com'è nell'input

Le voci possono essere un programma completo o solo una funzione, purché tu fornisca un modo per testarle!

ipotesi

• Supponiamo che gli elementi dell'elenco di input possano essere più di una cifra ma non più grandi di (2 ³² - 1)
• Supponiamo che l'elenco di input non contenga più di un milione di elementi
• Supponiamo che l'input non includerà valori negativi
• Supponiamo che l'input non sarà mai vuoto

^{A scanso di equivoci, la spiegazione della sfida fornita subito dopo "Più specificamente" sostituirà la dichiarazione della sfida sopra di essa ("Restituisci il più grande ...").}

 Esempi

(1) Tutti uguali:

Input: 1,1
Output:

(2) diverso:

Input: 1,2
Output: 2

(3) Zero !:

Input: 0,0,0,0,0,0,0,1,0,0
Output: 1

(4) Casuale:

Input: 7,3,8,4,8,3,9,4,6,1,3,7,5
Output: 9

(5) Numeri più grandi, elenco più grande:

Input: 627,3894,863,5195,7789,5269,8887,3262,1448,3192
Output: 8887

Esempi aggiuntivi:

(6) Tutti uguali, elenco più grande:

Input: 7,7,7,7,7,7,7,7,7
Output:

(7) Tutti uguali, elenco più grande, numeri più grandi:

Input: 61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976,61976
Output:

(8) Non uguale, elenco più grande, numeri più grandi:

Input: 96185,482754,96185,96185,96185,96185,96185,96185,7,96185,96185,96185,96185,96185,96185,96185,96185,96185,96185,96185,96185,96185,96185,96185,96185,961185,96185,96185,96185
Output: 961185

punteggio

Questo è code-golf, quindi vince il codice con il minor numero di byte!

R , 50 37 byte

-33 byte grazie a digEmAll! -13 byte grazie a rturnbull!

x=scan(se=",");if(any(diff(x)))max(x)

Provalo online!

MathGolf , 5 byte

è▀s╞╙

Provalo online!

Spiegazione

è      Read whole input as int array
 ▀     Get unique elements
  s    Sort list
   ╞   Discard from left of array
    ╙  Get maximum of list

Questo funziona perché sia ​​l'operatore massimo che lo scarto dall'operatore sinistro non fanno nulla per gli elenchi vuoti. Bene, l'operatore max rimuove l'elenco e non inserisce nulla per elenchi vuoti.

Potrebbe essere di 4 byte se l'input potrebbe essere considerato come un elenco.

Perl 6 , 26 23 22 byte

-1 byte grazie a nwellnhof

{.max if .Set>1}o&EVAL

Provalo online!

Restituisce uno slip vuoto se tutto è uguale.

Spiegazione

                o&EVAL  # Eval the string to a list of integers
{              }         # Pass to code block
 .max            # Return the max
      if .Set>1  # If the list converted to a set has more than one element

Gelatina , 4 byte

ḟṀE?

Un programma completo che accetta l'input come argomento della riga di comando (non quotato) che stampa l'output richiesto

(Si noti che si occupa di: input vuoto come , input singolo elemento 7e input di elementi multipli come 7,8,7come le specifiche sembrano richiedere attualmente.)

Provalo online!

Come?

ḟṀE? - Full program: if one argument is present it is evaluated using Python
     -                 so 7,8,7 -> [7,8,7], while 7 -> 7
ḟṀE? - Main Link: list or integer OR no argument (in which case an implicit argument of 0)
   ? - if...
  E  - ...condition: all equal? (for any integer E yields 1 since the argument is
     -                           treated as a list like [integer])
ḟ    - ...then: filter discard (since it's undefined the right argument is implicitly 
     -                          equal to the left; both are treated as lists, so this
     -                          yields an empty list)
 Ṁ   - ...else: maximum (again an integer is treated as a list)
     - implicit print (Jelly's representation of an empty list is an empty string
     -                 furthermore no newline is printed in either case)

APL (Dyalog Classic) , 6 byte

⍪⌈/~⌊/

Provalo online!

un treno che calcola il massimo ( ⌈/) senza ( ~) il minium ( ⌊/) trasformato in una matrice ( ⍪)

se l'input contiene solo un elemento distinto, ⌈/~⌊/sarà vuoto e ⍪restituirà una matrice 0 × 1 che viene visualizzata come nulla

in caso contrario, ⌈/~⌊/sarà un vettore a 1 elemento e ⍪sarà una matrice 1x1 (visivamente indistinguibile da uno scalare) che contiene il massimo

CJam , 16 13 byte

q',/:iL|$1>W>

Provalo online!

Python 2 , 37 byte

output su stderr (debug su tio).

a=input();m=max(a);m>min(a)>exit(`m`)

Provalo online!

Python 2 , 42 41 byte

a=input();print('',max(a))[len(set(a))>1]

Provalo online!

Haskell , 77 75 61 byte

f.read.('[':).(++"]")    
f a=[0|any(/=a!!0+0)a]>>show(maximum a)

Provalo online!

('[':).(++"]")prende una stringa (ad es. "1,2,1,3") e la racchiude tra parentesi quadre ( "[1,2,1,3]"). Quindi readtrasforma la stringa in un elenco di numeri interi ( [1,2,1,3]).

La funzione futilizza questo suggerimento per un condizionale più breve se uno dei risultati è l'elenco vuoto. any(/=a!!0+0)acontrolla se l'elenco acontiene elementi non uguali al suo primo elemento a!!0. ( +0È necessario in modo tale che readsappia che deve cercare un elenco di numeri.) Se tutti gli elementi sono uguali, questo test risulta Falsee la stringa vuota viene restituita. In caso contrario show(maximum a), viene restituito il massimo dell'elenco convertito in una stringa.

Rosso, 81 byte

x: split input","forall x[x/1: load x/1]sort x: unique x if 1 <>length? x[last x]

Come la soluzione R, un grosso pezzo di codice gestisce la stringa di input "1,1,2,44,1". Se possiamo averlo come blocco, ad esempio:, x: [1 1 2 44 1]allora possiamo farlo in 41 byte:

sort x: unique x if 1 <>length? x[last x]

APL (Dyalog Unicode) , 12 byte

Programma completo. Richiede la stringa da stdin.

{1≠≢∪⍵:⌈/⍵}⎕

Provalo online!

⎕ richiedere e valutare l'espressione (le virgole concatenano i numeri in un elenco)

{... } applica la seguente lambda anonima ( ⍵è l'argomento; l'elenco dei numeri):

 1≠ [if] 1 è diverso da ...

 ≢ il conteggio di ...

 ∪ i numeri univoci in ...

 ⍵ la lista

 : poi

 ⌈/ ritorna il massimo attraverso (lit. riduzione massima) ...

 ⍵ la lista

 [else: non fare nulla]

JavaScript (Node.js) , 49/53 byte

La mia versione originale utilizzando .every(), 53 byte

Una funzione che restituisce '' non viene considerata come uscita? Sicuramente questo può essere migliorato su ...

s=>(a=s.split`,`).every(e=>a[0]==e)?'':Math.max(...a)

Provalo online!

Versione migliorata utilizzando Set()da Shaggy , 49 byte

s=>new Set(a=s.split`,`).size>1?Math.max(...a):``

Provalo online!

Neim , 4 byte

𝐐𝐎Ξ𝐠

Spiegazione:

  Ξ   If
𝐐    all elements are equal
  𝐎  not
      then
   𝐠  get greatest element

Provalo online!

Ottava , 28 byte

Restituisce il massimo (un numero, che è una matrice 1x1) o una matrice vuota (1x0).

@(a)max(a)(1+all(a(1)==a):1)

Provalo online!

Japt, 16 byte

Questo sarebbe 9 se non per il formato di input inutilmente rigoroso, 7 se lanciare un errore conta come non produrre nulla.

Presuppone che la stringa contenga almeno 2 numeri interi.

q, mn
â ÊÉ?Urw:P

Provalo

Lisp comune, 102 byte

(lambda(x &aux(c(read-from-string(concatenate'string"#.`("x")"))))(or(apply'= c)(princ(apply'max c))))

Provalo online!

La dimensione è dovuta principalmente all'immissione dei dati; con input come un elenco regolare, la lunghezza si riduce a 46 byte:

(lambda(x)(or(apply'= x)(princ(apply'max x))))

XPath 3.1, 54 byte

con la stringa di input come elemento di contesto:

let$t:=tokenize(.,',')!xs:int(.)return max($t)[$t!=$t]

Potrebbe essere ridotto di un carattere se si consente al contesto di associare un prefisso più corto di "xs" allo spazio dei nomi dello schema XML.

Spiegazione: accetta la stringa di input, tokenizza su "," separatore, si applica xs:int()a ciascun token per convertire in un numero intero, calcola il massimo della sequenza, genera il massimo a condizione che il predicato $t!=$tsia vero. Se A e B sono sequenze, allora A!=Bè vero se esiste una coppia di elementi (a da A, b da B) tale che a!=b.

Se l'input può essere fornito come una sequenza di numeri interi $ s anziché come una stringa separata da virgola, la soluzione si riduce a

max($s)[$s!=$s]

(15 byte - che potrebbe essere la soluzione più breve in un linguaggio che non è stato progettato per brevità)

NOTA : questo non soddisfa il requisito "rappresentato com'è nell'input" - se c'è un numero intero con zeri iniziali o un segno più nell'input, questi andranno persi. Sospetto che sia vero anche per molte altre soluzioni.

K4 , 38 35 byte

{$[1=#:t:?:(7h$","\:x)-48;;*:t@>t]}

Casi test:

q)k){$[1=#:t:?:(7h$","\:x)-48;;*:t@>t]}"1,2,4,4"
,4
q)k){$[1=#:t:?:(7h$","\:x)-48;;*:t@>t]}"4,4,4,4"
q)
q)k){$[1=#:t:?:(7h$","\:x)-48;;*:t@>t]}"7,3,8,4,8,3,9,4,6,1,3,7,5"
,9
q)k){$[1=#:t:?:(7h$","\:x)-48;;*:t@>t]}"7,7,7,7,7,7,7,7,7,7,7,7,7"
q)

Non sono molto fluente in nessuna delle k varianti disponibili su TiO, quindi nessun esempio online disponibile, proverò a trovarne uno però

Spiegazione

Se ti stai chiedendo perché determinate operazioni vengano eseguite prima di altre, K4 non ha la precedenza dell'operatore, ma interpreta da destra a sinistra (anche se puoi usare le parentesi come precedenza). Espressioni separate da punti e virgola.

   $[expr;`True;`False] is the conditional format

{$[1=#:t:?:(7h$","\:x)-48;;*:t@>t]}
               ","\:x                 //split string on commas
            7h$                       //cast strings to long
                      -48             //they'll be from ascii format, so compensate
         ?:                           //get distinct list      
       t:                             //set list to variable t        
     #:                               //get count of t
   1=                                 //check if count t = 1
                         ;;           //return nothing if true
                             t@>t  //if false, sort t descending
                           *:         //return first value

Probabilmente si può giocare a golf più in basso, non un fan di dover usare quella funzione di fortuna massima alla fine.

EDIT: se le virgole nell'output sono un problema, può essere risolto con altri due byte:

q)k){$[1=#:t:?:(7h$","\:x)-48;;*:,/t@>t]}"1,2,4,4"
4
                                 ,/                 //joins the single element lists into one

Prendendo il totale a 40 37, ma la virgola prima del numero significa semplicemente che è un singolo elenco di elementi rispetto a un atomo.

PHP (<= 5.6) 64 74 byte

 echo array_count_values($a=split(',',$argn))[$m=max($a)]==count($a)?'':$m;

Esegui come pipe -nRo testalo online

splitè stato rimosso in PHP7, ma dato che ho dovuto aggiungere 10 per risolvere alcuni problemi, valeva la pena usarlo invece explodeche in questo caso è approssimativamente equivalente.

Japt -hF , 8 byte

q, ün Åc

Provalo

-3 byte se l'input potrebbe essere preso come un array.

05AB1E , 9 8 byte

',¡ZsËiõ

-1 byte grazie a @Cowabunghole .

Provalo online o verifica tutti i casi di test .

Spiegazione:

',¡        '# Split the (implicit) input by ","
   Z        # Push the maximum (without popping the list)
    s       # Swap so the list is at the top of the stack again
     Ëi     # If all elements are equal:
       õ    #  Push an empty string ""
            # (Implicitly output the top of the stack to STDOUT as result)

Python 2 , 44 byte

k=eval(input())
if~-len(set(k)):print max(k)

Provalo online!

Ohm v2 , 9 byte

Ul1E?Oq¿↑

Provalo online! Spiegazione:

Ul1E?Oq¿↑
U         Uniquify input
 l        Get length
  1E      Push whether length is equak to 1
    ?Oq   If so immediately quit
       ¿↑ Else print maximum

Carbone , 15 byte

≔Ｉ⪪Ｓ,θ¿›⌈θ⌊θＩ⌈θ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔Ｉ⪪Ｓ,θ

Dividi l'input tra virgole e trasmetti ciascun valore in numero intero.

¿›⌈θ⌊θ

Verifica se il valore massimo è maggiore del valore minimo.

Ｉ⌈θ

In tal caso, eseguire il cast del valore massimo per stringa e stampa.

Mathematica, 43 byte

If[!Equal@@#,Max@#]&@@#~ImportString~"CSV"&

Funzione pura. Accetta una stringa separata da virgola come input e restituisce un numero o Null. Credo che questo sia valido, in quanto Nullnon viene visualizzato graficamente:

C (gcc) , 91 byte

M(s)char*s;{long m=atol(s),o,l=0;for(;s=strchr(s,44);o<0?m-=o:0)l|=o=m-atol(++s);s=l?m:-1;}

Provalo online!

Degolf

M(s)char*s;{
    long m=atol(s),o,l=0; // Read the first integer from string
    for(;s=strchr(s,44); // Advance pointer to next ','
           o<0?m-=o:0) // End of loop: if difference <0, deduct from max, increasing it to new max.
        l|=o=m-atol(++s); // Read next number, and subtract it from current max. 
                          // Bitwise-OR the difference into the l-variable
    s=l?m:-1; // End of function: if l is non-zero, there were at least two different values.
              // Return -1 if l is zero, otherwise the max value.
}

Pyth, 7 byte

Itl{QeS

Provalo online!
Tutti i casi di test (codice leggermente diverso per una migliore formattazione dell'output)

Poiché Pyth si basa su Python, l'input dell'utente viene sempre interpretato come una stringa, che può quindi essere passata eval(). Tutti i programmi Pyth vengono eseguiti automaticamente Q=eval(input())come prima istruzione.

Itl{QeS  | Full code
Itl{QeSQ | with implicit variables filled
---------+-------------------------------
I        | If
 t       | one less than
  l      | the length of
   {Q    | the deduplicated input
         | is truthy (!=0),
         | print
     e   | the last element of
      SQ | the sorted input

Java (JDK) , 101 byte

d->{long m=0,c=-1,b;for(var s:d.split(",")){b=new Long(s);c=c<0|c==b?b:0;m=b>m?b:m;}return c>0?"":m;}

Provalo online!

spiegato

d->{                            // Function taking a String input
    long m=0,c=-1,b;            // Initialise variables
    for(var s:d.split(",")){    // Split by comma and loop over elements
        b=new Long(s);          // Parse String to Long
        c=c<0                   // If c<0 (i.e. this is the first element)
            |c==b               // ...or c is equal to the current element
            ?b                  // Set c to the current element (all elements are the same so far
            :0;                 // Otherwise set c to zero to denote that list is not all same element  
        m=b>m?b:m;              // Set m to max of b and m
    }
    return c>0?""               // If c is not zero then all elements are the same, return nothing
                 :m;            // Else return max element
}

Soluzione bonus!

Nonostante i miei migliori sforzi non sono riuscito a ottenere questa soluzione usando regex e Stream a meno di 105 byte, ma mi è piaciuta molto la sua eleganza, quindi ho dovuto menzionarlo onorariamente;

d->d.matches("(.+?)(,\\1)+")?"":java.util.Arrays.stream(d.split(",")).map(Long::new).reduce(0L,Long::max)

MATL , 15 9 byte

U&=?}1MX>

Provalo online!
Test multipli

Sto solo cercando di evitare che le mie costolette MATL diventino troppo arrugginite!

modificare : dopo tutto arrugginito; salvato 6 byte, grazie a @LuisMendo.

Spiegazione

U     % str2num - automatically parses comma-separated strings
&=?   % Are all the values equal? 
}     % if not
1M    % Get the numeric matrix again on the stack
X>    % And find its maximum value.

Pip , 13 byte

a^:',MXaRMMNa

Provalo online!

Utilizza l'approccio della soluzione APL di ngn :

     MNa  Minimum of the list
  aRM     Remove it from the list
MX        Take the max of the remaining elements

I primi 5 byte a^:', dividono la stringa di input tra virgole.

Soluzioni alternative a 13 byte:

I!$=Ya^',PMXy
a^:',$=a?uMXa