Introducción

Un amigo planteó esta pregunta hoy de una manera ligeramente diferente: "¿Puede un solo comando [de Python] determinar el mayor de algunos enteros Y que no son iguales?".

Si bien no encontramos una manera de hacerlo dentro de las definiciones razonables de "un solo comando", pensé que podría ser un problema divertido para el golf.

 Desafío

" Devuelve el mayor de una lista de enteros si-y-solo-si no son todos iguales " .

Más específicamente:

Dada una cadena que contiene solo una lista de enteros separados por comas:

• Si todos son iguales, no devuelve / genera nada
• De lo contrario, retorno / salida el mayor

Reglas

• La entrada debe ser una cadena que contenga solo una lista de enteros separados por comas
• La salida no debe ser nada (ninguna salida de ningún tipo) o el elemento más grande de la entrada, representado como está en la entrada

Las entradas pueden ser un programa completo o simplemente una función, ¡siempre que proporcione alguna forma de probarlas!

Supuestos

• Suponga que los elementos de la lista de entrada pueden tener más de un dígito pero no más de (2 ³² - 1)
• Suponga que la lista de entrada no tiene más de un millón de elementos.
• Suponga que la entrada no incluirá valores negativos
• Suponga que la entrada nunca estará vacía

^{Para evitar dudas, la explicación del desafío dada justo después de "Más específicamente" reemplazará la declaración del desafío que se encuentra arriba ("Devuelve el más grande ...").}

 Ejemplos

(1) Todos iguales:

Input: 1,1
Output:

(2) diferente:

Input: 1,2
Output: 2

(3) ¡Cero !:

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

(4) Aleatorio:

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

(5) Números más grandes, lista más grande:

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

Ejemplos adicionales:

(6) Todos iguales, lista más grande:

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

(7) Todos iguales, lista más grande, números más grandes:

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) No es igual, lista más grande, números más grandes:

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

Puntuación

Esto es code-golfasí, ¡entonces gana el código con el menor número de bytes!

R , 50 37 bytes

-33 bytes gracias a digEmAll! -13 bytes gracias a rturnbull!

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

Pruébalo en línea!

MathGolf , 5 bytes

è▀s╞╙

Pruébalo en línea!

Explicación

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

Esto funciona porque tanto el operador máximo como el descarte del operador izquierdo no hacen nada por las listas vacías. Bueno, el operador max elimina la lista y no introduce nada en las listas vacías.

Puede ser de 4 bytes si la entrada se puede tomar como una lista.

Perl 6 , 26 23 22 bytes

-1 byte gracias a nwellnhof

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

Pruébalo en línea!

Devuelve un recibo vacío si todo es igual.

Explicación

                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

Jalea , 4 bytes

ḟṀE?

Un programa completo que acepta la entrada como un argumento de línea de comando (sin comillas) que imprime la salida requerida

(Tenga en cuenta que se trata de: entrada vacía como , entrada de elemento único como 7y entrada de elemento múltiple 7,8,7como la especificación parece requerir actualmente).

Pruébalo en línea!

¿Cómo?

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

⍪⌈/~⌊/

Pruébalo en línea!

un tren que calcula el máximo ( ⌈/) sin ( ~) el mínimo ( ⌊/) convertido en una matriz ( ⍪)

si la entrada contiene solo un elemento distinto, ⌈/~⌊/estará vacía y ⍪devolverá una matriz 0 × 1 que se representa como nada

de lo contrario, ⌈/~⌊/será un vector de 1 elemento y ⍪será una matriz 1x1 (visualmente indistinguible de un escalar) que contiene el máximo

CJam , 16 13 bytes

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

Pruébalo en línea!

Python 2 , 37 bytes

salidas a stderr (depuración en tio).

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

Pruébalo en línea!

Python 2 , 42 41 bytes

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

Pruébalo en línea!

Haskell , 77 75 61 bytes

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

Pruébalo en línea!

('[':).(++"]")toma una cadena (p "1,2,1,3". ej. ) y la encierra en caracteres de paréntesis ( "[1,2,1,3]"). Luego readconvierte la cadena en una lista de enteros ( [1,2,1,3]).

La función futiliza este consejo para un condicional más corto si uno de los resultados es la lista vacía. any(/=a!!0+0)acomprueba si la lista acontiene algún elemento que no sea igual a su primer elemento a!!0. (Se +0necesita tal que readsepa que tiene que buscar una lista de números). Si todos los elementos son iguales, esta prueba da como resultado Falsey se devuelve la cadena vacía. De lo contrario show(maximum a), se devuelve el máximo de la lista convertida en una cadena.

Rojo, 81 bytes

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

Al igual que la solución R, una gran parte del código está manejando la cadena de entrada "1,1,2,44,1". Si podemos tener eso como un bloque, por ejemplo:, x: [1 1 2 44 1]entonces podemos hacerlo en 41 bytes:

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

APL (Dyalog Unicode) , 12 bytes

Programa completo Solicita una cadena desde stdin.

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

Pruébalo en línea!

⎕ solicitar y evaluar la expresión (las comas concatenan los números en una lista)

{... } aplique la siguiente lambda anónima ( ⍵es el argumento; la lista de números):

 1≠ [si] 1 es diferente de ...

 ≢ la cuenta de ...

 ∪ los números únicos en ...

 ⍵ la lista

 : luego

 ⌈/ devolver el máximo a través (lit. reducción máxima) ...

 ⍵ la lista

 [más: no hacer nada]

JavaScript (Node.js) , 49/53 bytes

Mi versión original usando .every() , 53 bytes

¿Una función que devuelve '' cuenta como sin salida? Claro que esto se puede mejorar ...

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

Pruébalo en línea!

Versión mejorada utilizando Set()por lanudo , 49 bytes

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

Pruébalo en línea!

Neim , 4 bytes

𝐐𝐎Ξ𝐠

Explicación:

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

Pruébalo en línea!

Octava , 28 bytes

Devuelve el máximo (un número, que es una matriz 1x1) o una matriz vacía (1x0).

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

Pruébalo en línea!

Japt, 16 bytes

Esto sería 9 si no fuera por el formato de entrada innecesariamente estricto, 7 si arrojar un error cuenta como no generar nada.

Asume que la cadena contiene al menos 2 enteros.

q, mn
â ÊÉ?Urw:P

Intentalo

Lisp común, 102 bytes

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

Pruébalo en línea!

El tamaño se debe principalmente a la entrada de datos; Con la entrada como una lista regular, la longitud se reduce a 46 bytes:

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

XPath 3.1, 54 bytes

con la cadena de entrada como elemento de contexto:

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

Podría reducirse en un carácter si permite que el contexto enlace un prefijo más corto que "xs" al espacio de nombres del esquema XML.

Explicación: toma la cadena de entrada, se tokeniza en el separador ",", se aplica xs:int()a cada token para convertirlo en un entero, calcula el máximo de la secuencia, emite el máximo siempre que el predicado $t!=$tsea ​​verdadero. Si A y B son secuencias, entonces A!=Bes cierto si hay un par de elementos (a de A, b de B) tales que a!=b.

Si la entrada se puede suministrar como una secuencia de enteros $ s en lugar de una cadena separada por comas, la solución se reduce a

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

(15 bytes, que bien podría ser la solución más corta en un lenguaje que no está diseñado específicamente para ser breve)

NOTA : esto no satisface el requisito "representado como está en la entrada": si hay un número entero con ceros a la izquierda o un signo más en la entrada, se perderán. Sospecho que eso también es cierto para muchas otras soluciones.

K4 , 38 35 bytes

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

Casos de prueba:

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)

No soy muy fluido en ninguna de las k variantes disponibles en TiO, por lo que no hay ejemplos en línea disponibles, aunque intentaré encontrar uno

Explicación

Si se pregunta por qué ciertas operaciones se realizan antes que otras, K4 no tiene precedencia de operador, sino que interpreta de derecha a izquierda (aunque puede usar paréntesis para precedencia). Expresiones separadas por punto y coma.

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

Probablemente se pueda jugar más, no un fanático de tener que usar esa función improvisada al final.

EDITAR: Si las comas en la salida son un problema, se puede arreglar con dos bytes más:

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

Tomando el total a 40 37, pero la coma antes del número simplemente significa que es una lista de elementos únicos en lugar de un átomo.

PHP (<= 5.6) 64 74 bytes

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

Ejecutar como tubería con -nRo probarlo línea

splitfue eliminado en PHP7, pero como tuve que agregar 10 para solucionar algunos problemas, valió la pena usarlo, en lugar de lo explodecual es más o menos equivalente en este caso.

Japt -hF , 8 bytes

q, ün Åc

Intentalo

-3 bytes si la entrada podría tomarse como una matriz.

05AB1E , 9 8 bytes

',¡ZsËiõ

-1 byte gracias a @Cowabunghole .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

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

Pruébalo en línea!

Ohm v2 , 9 bytes

Ul1E?Oq¿↑

Pruébalo en línea! Explicación:

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

Carbón de leña , 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔Ｉ⪪Ｓ,θ

Divida la entrada en comas y convierta cada valor a entero.

¿›⌈θ⌊θ

Pruebe si el valor máximo es mayor que el valor mínimo.

Ｉ⌈θ

Si es así, emita el valor máximo a cadena e imprima.

Mathematica, 43 bytes

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

Pura función. Toma una cadena separada por comas como entrada y devuelve un número o Null. Creo que esto es válido, ya Nullque no se muestra gráficamente:

C (gcc) , 91 bytes

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

Pruébalo en línea!

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 bytes

Itl{QeS

Pruébalo en línea!
Todos los casos de prueba (código ligeramente diferente para un mejor formato de salida)

Como Pyth se basa en Python, la entrada del usuario siempre se interpreta como una cadena, que luego se puede pasar eval(). Todos los programas Pyth se ejecutan automáticamente Q=eval(input())como su primera instrucción.

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 bytes

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

Pruébalo en línea!

Explicado

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
}

¡Solución extra!

A pesar de mis mejores esfuerzos, no pude obtener esta solución utilizando expresiones regulares y flujos de menos de 105 bytes, pero realmente me gustó su elegancia, así que tuve que darle una mención honorífica;

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

MATL , 15 9 bytes

U&=?}1MX>

Pruébalo en línea!
Múltiples casos de prueba

¡Solo trato de evitar que mis chuletas MATL se oxiden demasiado!

Editar : oxidado después de todo; guardado 6 bytes, gracias a @LuisMendo.

Explicación

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.

Pipa , 13 bytes

a^:',MXaRMMNa

Pruébalo en línea!

Utiliza el enfoque de la solución APL ngn :

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

Los primeros 5 bytes a^:',dividen la cadena de entrada en comas.

Soluciones alternativas de 13 bytes:

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