Intro

Un ami a posé cette question aujourd'hui d'une manière légèrement différente - "Une seule commande [Python] peut-elle déterminer le plus grand de certains entiers ET qu'ils ne sont pas égaux?".

Bien que nous n'ayons pas trouvé un moyen de le faire dans les définitions raisonnables de "une seule commande", je pensais que cela pourrait être un problème amusant pour le golf.

 Défi

" Renvoie le plus grand d'une liste d'entiers si et seulement si ils ne sont pas tous égaux. "

Plus précisement:

Étant donné une chaîne contenant uniquement une liste d'entiers séparés par des virgules:

• S'ils sont tous égaux, rien ne retourne / ne sort
• Sinon, retour / sortie le plus grand

Règles

• L' entrée doit être une chaîne contenant uniquement une liste d'entiers séparés par des virgules
• La sortie doit être soit rien (aucune sortie d'aucune sorte), soit le plus grand élément de l'entrée, représenté tel qu'il est dans l'entrée

Les entrées peuvent être un programme complet ou simplement une fonction, à condition que vous fournissiez un moyen de les tester!

Hypothèses

• Supposons que les éléments de la liste d'entrée peuvent comporter plus d'un chiffre mais pas plus de (2 ³² - 1)
• Supposons que la liste d'entrée ne comporte pas plus d'un million d'éléments
• Supposons que l'entrée n'inclura pas de valeurs négatives
• Supposons que l'entrée ne sera jamais vide

^{Pour éviter tout doute, l'explication de la contestation donnée juste après "Plus spécifiquement" remplacera l'énoncé de la contestation ci-dessus ("Renvoyer le plus grand ...").}

 Exemples

(1) Tous égaux:

Input: 1,1
Output:

(2) Différent:

Input: 1,2
Output: 2

(3) Zéro!:

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

(4) Aléatoire:

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

(5) Plus grands nombres, plus grande liste:

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

Exemples supplémentaires:

(6) Toutes égales, liste plus grande:

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

(7) Tous égaux, liste plus grande, nombres plus grands:

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) Pas égal, liste plus grande, plus grands nombres:

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

Notation

C'est le cas code-golf, donc le code avec le plus petit nombre d'octets gagne!

R , 50 37 octets

-33 octets grâce à digEmAll! -13 octets grâce à rturnbull!

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

Essayez-le en ligne!

MathGolf , 5 octets

è▀s╞╙

Essayez-le en ligne!

Explication

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

Cela fonctionne parce que l'opérateur max et le rejet de l'opérateur gauche ne font rien pour les listes vides. Eh bien, l'opérateur max supprime la liste et ne pousse rien pour les listes vides.

Il peut s'agir de 4 octets si l'entrée peut être considérée comme une liste.

Perl 6 , 26 23 22 octets

-1 octet grâce à nwellnhof

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

Essayez-le en ligne!

Renvoie une fiche vide si tout est égal.

Explication

                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

Gelée , 4 octets

ḟṀE?

Un programme complet acceptant l'entrée comme argument de ligne de commande (sans guillemets) qui imprime la sortie requise

(Notez qu'il traite de: l'entrée vide comme , l'entrée d'article unique comme 7et l'entrée d'article multiple comme 7,8,7comme la spécification semble actuellement exiger.)

Essayez-le en ligne!

Comment?

ḟṀ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 octets

⍪⌈/~⌊/

Essayez-le en ligne!

un train calculant le maximum ( ⌈/) sans ( ~) le minium ( ⌊/) transformé en matrice ( ⍪)

si l'entrée ne contient qu'un seul élément distinct, ⌈/~⌊/sera vide et⍪ renverra une matrice 0 × 1 qui restitue comme rien

autrement, ⌈/~⌊/ sera un vecteur à 1 élément et ce ⍪sera une matrice 1x1 (visuellement indiscernable d'un scalaire) qui contient le maximum

CJam , 16 13 octets

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

Essayez-le en ligne!

Python 2 , 37 octets

sorties vers stderr (débogage sur tio).

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

Essayez-le en ligne!

Python 2 , 42 41 octets

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

Essayez-le en ligne!

Haskell , 77 75 61 octets

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

Essayez-le en ligne!

('[':).(++"]")prend une chaîne (par exemple "1,2,1,3") et la place entre crochets chars ( "[1,2,1,3]"). alorsreadTransforme la chaîne en une liste d'entiers ( [1,2,1,3]).

La fonction futilise cette astuce pour un conditionnel plus court si l'un des résultats est la liste vide. any(/=a!!0+0)avérifie si la liste acontient un élément différent de son premier élément a!!0. (Le +0est nécessaire de telle sorte qu'il readsache qu'il doit rechercher une liste de nombres.) Si tous les éléments sont égaux, ce test aboutit Falseet la chaîne vide est renvoyée. Sinon show(maximum a), c'est le maximum de la liste convertie en chaîne, qui est retourné.

Rouge, 81 octets

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

Comme la solution R, une énorme partie du code gère la chaîne d'entrée "1,1,2,44,1". Si nous pouvons avoir cela comme un bloc, par exemple:, x: [1 1 2 44 1]alors nous pouvons le faire en 41 octets:

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

APL (Dyalog Unicode) , 12 octets

Programme complet. Demande la chaîne de stdin.

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

Essayez-le en ligne!

⎕ demander et évaluer l'expression (les virgules concaténent les nombres dans une liste)

{… } Appliquer le lambda anonyme suivant (⍵ est l'argument; la liste des nombres):

 1≠ [si] 1 est différent de…

 ≢ le décompte de…

 ∪ les numéros uniques dans…

 ⍵ la liste

 : ensuite

 ⌈/ renvoyer le max à travers (lit. réduction max)…

 ⍵ la liste

 [sinon: ne rien faire]

JavaScript (Node.js) , 49/53 octets

Ma version originale utilisant .every() , 53 octets

Une fonction renvoyant '' ne compte-t-elle pas comme sortie? Bien sûr, cela peut être amélioré ...

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

Essayez-le en ligne!

Version améliorée utilisant Set()par Shaggy , 49 octets

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

Essayez-le en ligne!

Neim , 4 octets

𝐐𝐎Ξ𝐠

Explication:

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

Essayez-le en ligne!

Octave , 28 octets

Renvoie le maximum (un nombre, qui est une matrice 1x1) ou une matrice vide (1x0).

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

Essayez-le en ligne!

Japt, 16 octets

Ce serait 9 si ce n'est pour le format d'entrée inutilement strict, 7 si lancer une erreur ne compte pour rien.

Suppose que la chaîne contient au moins 2 entiers.

q, mn
â ÊÉ?Urw:P

Essayez-le

Lisp commun, 102 octets

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

Essayez-le en ligne!

La taille est principalement due à la saisie des données; avec une entrée en liste régulière, la longueur est réduite à 46 octets:

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

XPath 3.1, 54 octets

avec la chaîne d'entrée comme élément de contexte:

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

Peut être réduit d'un caractère si vous autorisez le contexte à lier un préfixe plus court que «xs» à l'espace de noms du schéma XML.

Explication: prend la chaîne d'entrée, effectue un jeton sur le séparateur ",", s'applique xs:int()à chaque jeton à convertir en entier, calcule le maximum de la séquence, génère le maximum à condition que le prédicat $t!=$tsoit vrai. Si A et B sont des séquences, alors A!=Bc'est vrai si il y a une paire d'éléments (a de A, b de B) tels quea!=b .

Si l'entrée peut être fournie sous la forme d'une séquence d'entiers $ s plutôt que d'une chaîne séparée par des virgules, la solution se réduit à

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

(15 octets - ce qui pourrait bien être la solution la plus courte dans un langage qui n'est pas conçu pour être concis)

REMARQUE : cela ne satisfait pas l'exigence "représentée telle qu'elle est dans l'entrée" - s'il y a un entier avec des zéros en tête ou un signe plus dans l'entrée, ceux-ci seront perdus. Je soupçonne que c'est également le cas pour de nombreuses autres solutions.

K4 , 38 35 octets

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

Cas de 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)

Je ne parle pas couramment les k variantes disponibles sur TiO, donc aucun exemple en ligne n'est disponible, je vais essayer d'en trouver une

Explication

Si vous vous demandez pourquoi certaines opérations sont effectuées avant d'autres, K4 n'a pas de priorité d'opérateur, il interprète plutôt de droite à gauche (bien que vous puissiez utiliser des parenthèses pour la priorité). Expressions séparées par des points-virgules.

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

Peut probablement être joué plus bas, pas fan de devoir utiliser cette fonction max de fortune à la fin.

EDIT: Si les virgules en sortie sont un problème, il peut être corrigé avec deux octets supplémentaires:

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

Prendre le total à 40 37, mais la virgule avant le nombre signifie simplement qu'il s'agit d'une liste d'éléments unique par opposition à un atome.

PHP (<= 5,6) 64 74 octets

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

Exécuter en tant que pipe avec -nRou tester en ligne

splita été supprimé en PHP7, mais comme j'ai dû en ajouter 10 pour résoudre quelques problèmes, cela valait la peine d'être utilisé au lieu de explodece qui est à peu près équivalent dans ce cas.

Japt -hF , 8 octets

q, ün Åc

Essayez-le

-3 octets si l'entrée peut être considérée comme un tableau.

05AB1E , 9 8 octets

',¡ZsËiõ

-1 octet grâce à @Cowabunghole .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

',¡        '# 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 octets

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

Essayez-le en ligne!

Ohm v2 , 9 octets

Ul1E?Oq¿↑

Essayez-le en ligne! Explication:

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

Fusain , 15 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

≔Ｉ⪪Ｓ,θ

Divisez l'entrée sur des virgules et convertissez chaque valeur en entier.

¿›⌈θ⌊θ

Testez si la valeur maximale est supérieure à la valeur minimale.

Ｉ⌈θ

Si c'est le cas, convertissez la valeur maximale en chaîne et imprimez.

Mathematica, 43 octets

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

Fonction pure. Prend une chaîne séparée par des virgules en entrée et retourne un nombre ou Null. Je crois que cela est valide, car il Nulln'est pas affiché graphiquement:

C (gcc) , 91 octets

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

Essayez-le en ligne!

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 octets

Itl{QeS

Essayez-le en ligne!
Tous les cas de test (code légèrement différent pour un meilleur formatage de sortie)

Comme Pyth est basé sur Python, l'entrée utilisateur est toujours interprétée comme une chaîne, qui peut ensuite être transmise eval(). Tous les programmes Pyth s'exécutent automatiquementQ=eval(input()) comme leur première instruction.

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 octets

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

Essayez-le en ligne!

Expliqué

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
}

Solution bonus!

Malgré tous mes efforts, je n'ai pas pu obtenir cette solution en utilisant des expressions rationnelles et des flux à moins de 105 octets, mais j'ai vraiment aimé son élégance, j'ai donc dû lui donner une mention honorifique;

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

MATL , 15 9 octets

U&=?}1MX>

Essayez-le en ligne!
Plusieurs cas de test

J'essaie juste d'empêcher mes côtelettes MATL de devenir trop rouillées!

Éditer : rouillé après tout; sauvé 6 octets, grâce à @LuisMendo.

Explication

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 octets

a^:',MXaRMMNa

Essayez-le en ligne!

Utilise l'approche de la solution APL de ngn :

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

Les 5 premiers octets a^:',divisent la chaîne d'entrée par des virgules.

Solutions alternatives à 13 octets:

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