Introdução

Um amigo fez essa pergunta hoje de uma maneira um pouco diferente - "Um único comando [Python] pode determinar o maior de alguns números inteiros E que eles não são iguais?".

Embora não tenhamos encontrado uma maneira de fazer isso dentro das definições razoáveis de "um único comando", achei que poderia ser um problema divertido para o golfe.

 Desafio

" Retorna a maior de uma lista de números inteiros se e somente se eles não forem todos iguais. "

Mais especificamente:

Dada uma sequência que contém apenas uma lista de números inteiros separados por vírgula:

• Se todos forem iguais, nada retornará / produzirá.
• Caso contrário, retorne / produza o maior

Regras

• A entrada deve ser uma sequência que contenha apenas uma lista de números inteiros separados por vírgula
• A saída deve ser nada (nenhuma saída de qualquer tipo) ou o maior elemento da entrada, representado como está na entrada

As entradas podem ser um programa completo ou apenas uma função, desde que você ofereça uma maneira de testá-las!

Premissas

• Suponha que os elementos da lista de entrada possam ter mais de um dígito, mas não maiores que (2 ³² - 1)
• Suponha que a lista de entrada não tenha mais que um milhão de elementos
• Suponha que a entrada não inclua valores negativos
• Suponha que a entrada nunca estará vazia

^{Para evitar dúvidas, a explicação do desafio dada logo após "Mais especificamente" substituirá a declaração do desafio acima dele ("Devolver o maior ...").}

 Exemplos

(1) Todos iguais:

Input: 1,1
Output:

(2) Desigual:

Input: 1,2
Output: 2

(3) Zero !:

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

(4) Aleatório:

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

(5) números maiores, lista maior:

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

Exemplos adicionais:

(6) Todos iguais, lista maior:

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

(7) Todos iguais, lista maior, números maiores:

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) Diferente, lista maior, números maiores:

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

Pontuação

Esta é code-golf, portanto, o código com o menor número de bytes vitórias!

R , 50 bytes 37

-33 bytes graças ao digEmAll! -13 bytes graças ao rturnbull!

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

Experimente online!

MathGolf , 5 bytes

è▀s╞╙

Experimente online!

Explicação

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

Isso funciona porque o operador máximo e o descarte do operador esquerdo não fazem nada para listas vazias. Bem, o operador max remove a lista e não empurra nada para listas vazias.

Pode ter 4 bytes se a entrada puder ser tomada como uma lista.

Perl 6 , 26 23 22 bytes

-1 byte graças a nwellnhof

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

Experimente online!

Retorna um recibo vazio se tudo for igual.

Explicação

                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 bytes

ḟṀE?

Um programa completo que aceita a entrada como um argumento de linha de comando (sem aspas) que imprime a saída necessária

(Observe que ele trata de: entrada vazia como , entrada de item único e entrada de 7vários itens como7,8,7 como a especificação atualmente parece exigir).

Experimente online!

Quão?

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

⍪⌈/~⌊/

Experimente online!

um trem calculando o máximo ( ⌈/) sem ( ~) o minium ( ⌊/) transformado em uma matriz (⍪ )

se a entrada contiver apenas um elemento distinto, ⌈/~⌊/ela estará vazia e⍪ retornará uma matriz 0 × 1 que é renderizada como nada

caso contrário, ⌈/~⌊/será um vetor de 1 elemento e ⍪será uma matriz 1x1 (visualmente indistinguível de um escalar) que contenha o máximo

CJam , 16 13 bytes

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

Experimente online!

Python 2 , 37 bytes

produz para stderr (depuração no tio).

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

Experimente online!

Python 2 , 42 41 bytes

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

Experimente online!

Haskell , 77 75 61 bytes

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

Experimente online!

('[':).(++"]")pega uma string (por exemplo "1,2,1,3") e a coloca entre colchetes ( "[1,2,1,3]"). Em seguida, readtransforma a string em uma lista de números inteiros ( [1,2,1,3]).

A função fusa essa dica para uma condicional mais curta se um dos resultados for a lista vazia. any(/=a!!0+0)averifica se a lista acontém algum elemento que não seja igual ao seu primeiro elemento a!!0. (O +0é necessário para que readele saiba que precisa procurar uma lista de números.) Se todos os elementos forem iguais, esse teste resultará Falsee a sequência vazia será retornada. Caso contrário show(maximum a), esse é o máximo da lista convertida em uma sequência de caracteres, é retornada.

Vermelho, 81 bytes

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

Como a solução R, grande parte do código está lidando com a string de entrada "1,1,2,44,1". Se pudermos ter isso como um bloco, por exemplo:, x: [1 1 2 44 1]então podemos fazê-lo em 41 bytes:

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

APL (Dyalog Unicode) , 12 bytes

Programa completo. Solicita a string do stdin.

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

Experimente online!

⎕ solicitar e avaliar a expressão (vírgulas concatenam os números em uma lista)

{… } Aplique a seguinte lambda anônima ( ⍵é o argumento; a lista de números):

 1≠ [se] 1 é diferente de…

 ≢ a contagem de ...

 ∪ os números únicos em…

 ⍵ a lista

 : então

 ⌈/ retornar o máximo através (lit. max redução)…

 ⍵ a lista

 [mais: não faça nada]

JavaScript (Node.js) , 49/53 bytes

Minha versão original usando .every(), 53 bytes

Uma função retornando '' conta como sem saída? Claro que isso pode ser melhorado ...

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

Experimente online!

Versão melhorada usando Set()por Salsicha , 49 bytes

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

Experimente online!

Neim , 4 bytes

𝐐𝐎Ξ𝐠

Explicação:

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

Experimente online!

Oitava , 28 bytes

Retorna a matriz máxima (um número, que é uma matriz 1x1) ou uma matriz vazia (1x0).

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

Experimente online!

Japonês, 16 bytes

Isso seria 9, se não fosse o formato de entrada desnecessariamente estrito, 7 se o lançamento de um erro não conta como resultado.

Assume que a sequência contém pelo menos 2 números inteiros.

q, mn
â ÊÉ?Urw:P

Tente

Lisp comum, 102 bytes

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

Experimente online!

O tamanho é principalmente devido à entrada dos dados; com a entrada como uma lista regular, o comprimento é reduzido para 46 bytes:

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

XPath 3.1, 54 bytes

com a sequência de entrada como o item de contexto:

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

Pode ser reduzido por um caractere se você permitir que o contexto vincule um prefixo menor que "xs" ao espaço para nome do Esquema XML.

Explicação: pega a sequência de entrada, tokeniza no separador ",", aplica xs:int()- se a cada token para converter em um número inteiro, calcula o máximo da sequência, gera o máximo desde que o predicado $t!=$tseja verdadeiro. Se A e B são sequências, então A!=Bé verdade se houver um par de itens (a de A, b de B) que sejam a!=b.

Se a entrada puder ser fornecida como uma sequência de números inteiros $ s em vez de uma sequência separada por vírgula, a solução será reduzida para

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

(15 bytes - que pode muito bem ser a solução mais curta em um idioma que não é projetado especificamente para fins de concisão)

NOTA : isso não atende ao requisito "representado como está na entrada" - se houver um número inteiro com zeros à esquerda ou um sinal de mais na entrada, eles serão perdidos. Eu suspeito que isso também seja verdade em muitas outras soluções.

K4 , 38 bytes 35

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

Casos de teste:

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)

Não sou muito fluente em nenhuma das k variantes disponíveis no TiO; portanto, nenhum exemplo on-line está disponível. Tentarei criar uma.

Explicação

Se você está se perguntando por que certas operações são executadas antes de outras, o K4 não tem precedência de operador; em vez disso, interpreta da direita para a esquerda (embora você possa usar parênteses para precedência). Expressões separadas por ponto e vírgula.

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

Provavelmente, você pode jogar mais, não é um fã de ter que usar essa função improvisada no final.

EDIT: Se as vírgulas na saída são um problema, ele pode ser corrigido com mais dois bytes:

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

Levando o total para 40 37, mas a vírgula antes do número significa simplesmente que é uma lista de elementos únicos em oposição a um átomo.

PHP (<= 5,6) 64 74 bytes

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

Executar como tubo -nRou testá-lo on - line

splitfoi removido no PHP7, mas como eu tive que adicionar 10 para corrigir alguns problemas, valeu a pena usá-lo em vez do explodeque é aproximadamente equivalente nesse caso.

Japonês -hF , 8 bytes

q, ün Åc

Tente

-3 bytes se a entrada puder ser tomada como uma matriz.

05AB1E , 9 8 bytes

',¡ZsËiõ

-1 byte graças a @Cowabunghole .

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Try it online!

Ohm v2, 9 bytes

Ul1E?Oq¿↑

Try it online! Explanation:

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

Charcoal, 15 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

≔Ｉ⪪Ｓ,θ

Divida a entrada por vírgulas e converta cada valor para inteiro.

¿›⌈θ⌊θ

Teste se o valor máximo é maior que o valor mínimo.

Ｉ⌈θ

Nesse caso, converta o valor máximo para string e print.

Mathematica, 43 bytes

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

Função pura. Pega uma string separada por vírgula como entrada e retorna um número ou Null. Eu acredito que isso é válido, pois Nullnão é exibido graficamente:

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

Experimente 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.
}

Pitão, 7 bytes

Itl{QeS

Experimente online!
Todos os casos de teste (código ligeiramente diferente para melhor formatação da saída)

Como o Pyth é baseado no Python, a entrada do usuário é sempre interpretada como uma string, que pode ser transmitida eval(). Todos os programas Pyth são executados automaticamenteQ=eval(input()) como sua primeira instrução.

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

Experimente online!

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
}

Solução bônus!

Apesar dos meus melhores esforços, não consegui obter essa solução usando regex e Streams com menos de 105 bytes, mas eu realmente gostei da sua elegância, por isso tive que fazer uma menção honrosa;

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

MATL , 15 9 bytes

U&=?}1MX>

Experimente online!
Múltiplos casos de teste

Apenas tentando impedir que minhas costeletas do MATL fiquem enferrujadas!

Edit : enferrujado, afinal; salvou 6 bytes, graças a @LuisMendo.

Explicação

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 bytes

a^:',MXaRMMNa

Experimente online!

Usa a abordagem da solução APL da ngn :

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

Os primeiros 5 bytes a^:',dividem a sequência de entrada em vírgulas.

Soluções alternativas de 13 bytes:

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