介绍

今天，一位朋友以稍微不同的方式提出了这个问题：“单个[Python]命令可以确定某些整数中的最大值，并且它们不相等吗？”。

虽然我们在“单个命令”的合理定义内没有找到实现此目的的方法，但我认为打高尔夫球可能是一个有趣的问题。

 挑战

“ 如果并且都不都是整数，则返回整数列表中的最大值。 ”

进一步来说：

给定一个仅包含逗号分隔的整数列表的字符串：

• 如果它们相等，则什么也不返回/输出
• 否则，返回/输出最大

规则

• 的输入必须是仅包含整数的逗号分隔的列表的字符串
• 该输出必须是没有（任何种类的输出），否则最大的元素从输入，表示它是在输入

条目可以是完整程序，也可以只是一个功能，只要您提供一些测试方法即可！

假设条件

• 假设输入列表元素可以超过一位，但不超过（2 ³² − 1）
• 假设输入列表中的元素不超过一百万
• 假设输入将不包含负值
• 假设输入永远不会为空

^{为避免疑问，紧接在“更具体地”之后给出的对挑战的解释应取代其上方的挑战声明（“返回最大的……”）。}

 例子

（1）全部相等：

Input: 1,1
Output:

（2）不同：

Input: 1,2
Output: 2

（3）零！：

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

（4）随机：

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

（5）更大的数字，更大的列表：

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

其他示例：

（6）所有相等的较大列表：

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

（7）所有相等，更大的列表，更大的数字：

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）不相等，清单较大，数字较大：

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

计分

这是code-golf，因此具有最短字节数的代码将获胜！

R，50 37字节

-33字节感谢digEmAll！-13字节感谢rturnbull！

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

在线尝试！

MathGolf，5个字节

è▀s╞╙

在线尝试！

说明

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

之所以可行，是因为max运算符和左运算符的丢弃都不会对空列表做任何事情。好吧，max运算符删除列表，不为空列表推送任何内容。

如果可以将输入作为列表，则可以为4个字节。

Perl 6的，26个23 22字节

-1字节感谢nwellnhof

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

在线尝试！

如果所有条件均相等，则返回空清单。

说明

                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

果冻，4 字节

ḟṀE?

接受输入作为命令行参数（不带引号）的完整程序，它将打印所需的输出

（请注意，它处理以下内容：空输入（如），单项输入（如）7和多项输入（如7,8,7规范当前似乎需要的输入。）

在线尝试！

怎么样？

ḟṀ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个字节

⍪⌈/~⌊/

在线尝试！

一列计算最大值（⌈/）而没有（~）最小值（⌊/）变成矩阵（⍪）的火车

如果输入仅包含一个不同的元素，⌈/~⌊/则将为空，⍪并返回一个0×1的矩阵，该矩阵不显示任何内容

否则，⌈/~⌊/将是一个包含1个元素的向量，并且⍪将是一个包含最大值的1x1矩阵（在视觉上与标量没有区别）

CJam，16 13字节

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

在线尝试！

Python 2，37个字节

输出到stderr（在tio上调试）。

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

在线尝试！

Python 2中，42 41个字节

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

在线尝试！

Haskell，77 75 61字节

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

在线尝试！

('[':).(++"]")接受一个字符串（例如"1,2,1,3"）并将其括在方括号（"[1,2,1,3]"）中。然后read将字符串转换为整数列表（[1,2,1,3]）。

如果结果之一是空列表，则该函数f使用此技巧来缩短条件。any(/=a!!0+0)a检查列表是否a包含任何不等于其第一个元素的元素a!!0。（+0需要这样，以便read知道它必须查找数字列表。）如果所有元素都相等，则此测试结果False并返回空字符串。否则show(maximum a)，将返回转换为字符串的列表的最大值。

红色，81字节

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

像R解决方案一样，代码的很大一部分正在处理输入字符串“ 1、2、44、1”。如果我们可以将其作为一个块，例如：x: [1 1 2 44 1]，则可以以41个字节为单位：

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

APL（Dyalog Unicode），12个字节

完整程序。提示输入来自stdin的字符串。

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

在线尝试！

⎕ 提示并评估表达式（逗号将数字连接到列表中）

{… } 应用以下匿名lambda（⍵是参数；数字列表）：

 1≠ [如果] 1与…不同

 ≢ …的理货

 ∪ …中的唯一数字

 ⍵ 名单

 : 然后

 ⌈/ 返回最大跨度（照明最大减少量）…

 ⍵ 名单

 [其他：什么都不做]

JavaScript（Node.js），49/53字节

我的原始版本使用.every()，53个字节

返回“”的函数是否算作无输出？当然可以在...上改善

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

在线尝试！

Shaggy使用Set()的改进版本，49字节

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

在线尝试！

Neim，4个字节

𝐐𝐎Ξ𝐠

说明：

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

在线尝试！

八度，28字节

返回最大值（一个数字，它是一个1x1矩阵）或一个空（1x0）矩阵。

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

在线尝试！

Japt，16个字节

如果不是不必要的严格输入格式，则为9；如果抛出错误，则为7。

假设字符串包含至少2个整数。

q, mn
â ÊÉ?Urw:P

尝试一下

Common Lisp，102字节

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

在线尝试！

大小主要是由于输入数据所致；使用常规列表输入时，长度减少到46个字节：

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

XPath 3.1，54个字节

输入的字符串作为上下文项：

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

如果允许上下文将比“ xs”短的前缀绑定到XML Schema名称空间，则可以减少一个字符。

说明：取输入字符串，在“，”分隔符上标记化，应用于xs:int()每个标记以转换为整数，计算序列的最大值，在谓词$t!=$t为true的情况下输出最大值。如果A和B是序列，则A!=B当存在一对项（来自A的a，来自B的b）时，则为true a!=b。

如果可以将输入提供为整数$ s的序列而不是逗号分隔的字符串，则解决方案可简化为

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

（15字节-可能不是出于简短目的而专门设计的语言中最短的解决方案）

注意：这不能满足“在输入中表示”的要求-如果输入中存在带前导零或加号的整数，则这些将丢失。我怀疑其他许多解决方案也是如此。

K4，38 35个字节

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

测试用例：

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)

我不太熟悉TiO上可用的k个变体中的任何一个，因此没有在线示例可用，我会尽力提出一个

说明

如果您想知道为什么某些操作要先于其他操作执行，那么K4没有运算符优先级，而是从右向左进行解释（尽管您可以将括号用作优先级）。用分号分隔的表达式。

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

可能可以打得更多，而不是最后不得不使用该临时最大功能的爱好者。

编辑：如果输出中的逗号有问题，可以用另外两个字节修复它：

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

总数达到40 37，但是数字前的逗号只是意味着它是单个元素列表，而不是原子。

PHP（<= 5.6）64 74字节

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

作为管道运行-nR或在线测试

split已在PHP7中删除，但由于我不得不添加10个以解决一些问题，因此值得使用，而不是explode在这种情况下大致等效。

Japt -hF，8字节

q, ün Åc

尝试一下

-3 如果输入可以作为数组，则为字节。

05AB1E，9 8 字节

',¡ZsËiõ

-1个字节感谢@Cowabunghole。

在线尝试或验证所有测试用例。

说明：

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

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

在线尝试！

欧姆v2，9个字节

Ul1E?Oq¿↑

在线尝试！ 说明：

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

木炭，15字节

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

在线尝试！链接是详细版本的代码。说明：

≔Ｉ⪪Ｓ,θ

将输入拆分为逗号，并将每个值转换为整数。

¿›⌈θ⌊θ

测试最大值是否大于最小值。

Ｉ⌈θ

如果是这样，则将最大值转换为字符串并打印。

Mathematica，43个字节

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

纯功能。以逗号分隔的字符串作为输入，并返回数字或Null。我认为这是有效的，因为Null没有图形显示：

C（gcc），91字节

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

在线尝试！

德戈尔夫

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个字节

Itl{QeS

在线尝试！
所有测试用例（略有不同的代码以实现更好的输出格式）

由于Pyth基于Python，因此用户输入始终会解释为字符串，然后可以通过进行传递eval()。所有Pyth程序都会自动Q=eval(input())作为第一条指令运行。

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字节

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

在线尝试！

讲解

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
}

奖励解决方案！

尽管尽了最大的努力，我仍然无法使用正则表达式和Streams将此解决方案的字节数减少到105个字节以下，但是我真的很喜欢它的优雅，因此不得不提一个荣誉。

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

MATL，15 9字节

U&=?}1MX>

在线尝试！
多个测试用例

只是为了防止我的MATL砍变得太生锈！

编辑：毕竟生锈；@LuisMendo，节省了6个字节。

说明

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.

点，13字节

a^:',MXaRMMNa

在线尝试！

使用ngn的APL解决方案中的方法：

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

前5个字节 a^:',以逗号分隔输入字符串。

备用13字节解决方案：

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