Giới thiệu

Một người bạn đã đặt ra câu hỏi này ngày hôm nay theo một cách hơi khác - "Lệnh [Python] có thể xác định số lớn nhất trong số các số nguyên VÀ chúng không bằng nhau không?".

Mặc dù chúng tôi đã không tìm ra cách để làm điều này trong các định nghĩa hợp lý về "một lệnh duy nhất", tôi nghĩ rằng nó có thể là một vấn đề thú vị đối với golf.

 Thử thách

" Trả về số lớn nhất trong danh sách các số nguyên if-and-only-if chúng không bằng nhau. "

Cụ thể hơn:

Cho một chuỗi chỉ chứa danh sách các số nguyên được phân tách bằng dấu phẩy:

• Nếu tất cả đều bằng nhau, trả lại / đầu ra không có gì
• Khác, trả lại / đầu ra lớn nhất

Quy tắc

• Đầu vào phải là một chuỗi chỉ chứa danh sách các số nguyên được phân tách bằng dấu phẩy
• Đầu ra phải là không có gì (không có đầu ra dưới bất kỳ hình thức nào), hoặc phần tử lớn nhất từ ​​đầu vào, được biểu thị như ở đầu vào

Các mục có thể là một chương trình đầy đủ hoặc chỉ là một chức năng, miễn là bạn cung cấp một số cách để kiểm tra chúng!

Giả định

• Giả sử các phần tử danh sách đầu vào có thể nhiều hơn một chữ số nhưng không lớn hơn (2 ³² - 1)
• Giả sử danh sách đầu vào có không quá một triệu phần tử
• Giả sử đầu vào sẽ không bao gồm các giá trị âm
• Giả sử đầu vào sẽ không bao giờ trống

^{Để tránh nghi ngờ, lời giải thích về thử thách được đưa ra ngay sau "Cụ thể hơn" sẽ thay thế tuyên bố về thử thách phía trên nó ("Trả lại số tiền lớn nhất ...").}

 Ví dụ

(1) Tất cả bằng nhau:

Input: 1,1
Output:

(2) Không giống nhau:

Input: 1,2
Output: 2

(3) Không!:

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

(4) Ngẫu nhiên:

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

(5) Số lượng lớn hơn, danh sách lớn hơn:

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

Ví dụ khác:

(6) Tất cả bằng nhau, danh sách lớn hơn:

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

(7) Tất cả bằng nhau, danh sách lớn hơn, số lớn hơn:

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) Không bằng nhau, danh sách lớn hơn, số lớn hơn:

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

Chấm điểm

Đây là code-golf, vì vậy mã có số byte ngắn nhất sẽ thắng!

R , 50 37 byte

-33 byte nhờ digEmAll! -13 byte nhờ rturnbull!

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

Hãy thử trực tuyến!

MathGolf , 5 byte

è▀s╞╙

Hãy thử trực tuyến!

Giải trình

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

Điều này hoạt động vì cả toán tử tối đa và loại bỏ từ toán tử trái không làm gì cho danh sách trống. Chà, toán tử max loại bỏ danh sách và không đẩy được gì cho danh sách trống.

Nó có thể là 4 byte nếu đầu vào có thể được lấy làm danh sách.

Perl 6 , 26 23 22 byte

-1 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Trả về một phiếu trống nếu mọi thứ đều bằng nhau.

Giải trình

                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

Thạch , 4 byte

ḟṀE?

Một chương trình đầy đủ chấp nhận đầu vào dưới dạng đối số dòng lệnh (không trích dẫn) in ra đầu ra cần thiết

(Lưu ý rằng nó liên quan đến: đầu vào trống như , đầu vào một mục thích 7và nhiều đầu vào giống 7,8,7như thông số kỹ thuật dường như hiện đang yêu cầu.)

Hãy thử trực tuyến!

Làm sao?

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

⍪⌈/~⌊/

Hãy thử trực tuyến!

một chuyến tàu tính toán tối đa ( ⌈/) không có ( ~) minium ( ⌊/) biến thành ma trận ( ⍪)

nếu đầu vào chỉ chứa một phần tử riêng biệt, ⌈/~⌊/sẽ trống và ⍪sẽ trả về ma trận 0 × 1, kết xuất là không có gì

mặt khác, ⌈/~⌊/sẽ là vectơ 1 phần tử và nó ⍪sẽ là ma trận 1x1 (không thể phân biệt trực quan với vô hướng) có chứa tối đa

CJam , 16 13 byte

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

Hãy thử trực tuyến!

Python 2 , 37 byte

đầu ra cho thiết bị lỗi chuẩn (gỡ lỗi trên tio).

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

Hãy thử trực tuyến!

Python 2 , 42 41 byte

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

Hãy thử trực tuyến!

Haskell , 77 75 61 byte

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

Hãy thử trực tuyến!

('[':).(++"]")lấy một chuỗi (ví dụ "1,2,1,3") và đặt nó trong ký tự ngoặc ( "[1,2,1,3]"). Sau đó readbiến chuỗi thành một danh sách các số nguyên ( [1,2,1,3]).

Hàm fsử dụng mẹo này cho một điều kiện ngắn hơn nếu một trong các kết quả là danh sách trống. any(/=a!!0+0)akiểm tra xem danh sách acó chứa bất kỳ phần tử nào không bằng phần tử đầu tiên của nó không a!!0. ( +0Cần thiết để readbiết rằng nó phải tìm danh sách các số.) Nếu tất cả các phần tử đều bằng nhau, kết quả kiểm tra này Falsesẽ được trả về và chuỗi trống được trả về. Mặt khác show(maximum a), đó là mức tối đa của danh sách được chuyển đổi thành một chuỗi, được trả về.

Màu đỏ, 81 byte

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

Giống như giải pháp R, một đoạn mã lớn đang xử lý chuỗi đầu vào "1,1,2,44,1". Nếu chúng ta có thể có khối đó dưới dạng một khối, ví dụ : x: [1 1 2 44 1], thì chúng ta có thể làm điều đó trong 41 byte:

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

APL (Dyalog Unicode) , 12 byte

Chương trình đầy đủ. Lời nhắc cho chuỗi từ stdin.

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

Hãy thử trực tuyến!

⎕ nhắc và đánh giá biểu thức (dấu phẩy ghép các số vào danh sách)

{... } áp dụng lambda sau vô danh ( ⍵là lập luận; danh sách các số):

 1≠ [nếu] 1 khác với

 ≢ kiểm đếm của đào

 ∪ những con số độc nhất vô nhị

 ⍵ danh sách

 : sau đó

 ⌈/ trả lại mức tối đa (giảm tối đa)

 ⍵ danh sách

 [khác: không làm gì]

JavaScript (Node.js) , 49/53 byte

Phiên bản gốc của tôi sử dụng .every(), 53 byte

Hàm trả về '' có được tính là không có đầu ra không? Chắc chắn điều này có thể được cải thiện khi ...

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

Hãy thử trực tuyến!

Phiên bản được cải thiện Set()bằng Shaggy , 49 byte

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

Hãy thử trực tuyến!

Neim , 4 byte

𝐐𝐎Ξ𝐠

Giải trình:

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

Hãy thử trực tuyến!

Octave , 28 byte

Trả về giá trị tối đa (một số, là ma trận 1x1) hoặc ma trận trống (1x0).

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

Hãy thử trực tuyến!

Japt, 16 byte

Đây sẽ là 9 nếu không phải là định dạng đầu vào nghiêm ngặt không cần thiết, 7 nếu ném lỗi được tính là không xuất ra gì.

Giả sử chuỗi chứa ít nhất 2 số nguyên.

q, mn
â ÊÉ?Urw:P

Thử nó

Lisp thông thường, 102 byte

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

Hãy thử trực tuyến!

Kích thước chủ yếu là do nhập dữ liệu; với đầu vào là một danh sách thông thường, độ dài giảm xuống còn 46 byte:

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

XPath 3.1, 54 byte

với chuỗi đầu vào là mục ngữ cảnh:

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

Có thể giảm một ký tự nếu bạn cho phép bối cảnh liên kết tiền tố ngắn hơn "xs" với không gian tên Lược đồ XML.

Giải thích: lấy chuỗi đầu vào, mã thông báo trên dấu phân tách ",", áp dụng xs:int()cho mỗi mã thông báo để chuyển đổi thành số nguyên, tính tối đa của chuỗi, đưa ra giá trị tối đa được cung cấp là vị ngữ $t!=$t. Nếu A và B là các chuỗi, thì A!=Bđúng là có một cặp vật phẩm (a từ A, b từ B) sao cho a!=b.

Nếu đầu vào có thể được cung cấp dưới dạng một chuỗi các số nguyên $ s chứ không phải là một chuỗi được phân tách bằng dấu phẩy thì giải pháp giảm xuống còn

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

(15 byte - có thể là giải pháp ngắn nhất trong ngôn ngữ không được thiết kế cho mục đích ngắn gọn)

LƯU Ý : điều này không thỏa mãn yêu cầu "được biểu thị như trong đầu vào" - nếu có một số nguyên có số 0 đứng đầu hoặc dấu cộng trong đầu vào, những số này sẽ bị mất. Tôi nghi ngờ điều đó cũng đúng với nhiều giải pháp khác.

K4 , 38 35 byte

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

Các trường hợp thử nghiệm:

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)

Tôi không rành về bất kỳ biến thể k nào có sẵn trên TiO, vì vậy không có ví dụ trực tuyến nào có sẵn, tôi sẽ cố gắng đưa ra một biến thể

Giải trình

Nếu bạn đang tự hỏi tại sao một số thao tác nhất định được thực hiện trước các thao tác khác, K4 không có quyền ưu tiên của toán tử, thay vào đó, nó diễn giải từ phải sang trái (mặc dù bạn có thể sử dụng dấu ngoặc đơn cho quyền ưu tiên). Biểu hiện tách biệt bởi dấu chấm phẩy.

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

Có lẽ có thể bị đánh golf nhiều hơn, không phải là một fan hâm mộ của việc phải sử dụng chức năng tối đa tạm thời đó vào cuối.

EDIT: Nếu dấu phẩy trong đầu ra là một vấn đề, nó có thể được sửa với hai byte nữa:

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

Lấy tổng số là 40 37, nhưng dấu phẩy trước số chỉ đơn giản có nghĩa là đó là một danh sách thành phần duy nhất trái ngược với nguyên tử.

PHP (<= 5.6) 64 74 byte

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

Chạy như ống với -nRhoặc kiểm tra trực tuyến

splitđã bị xóa trong PHP7, nhưng vì tôi phải thêm 10 để khắc phục một số vấn đề, nó đáng để sử dụng thay vì explodetương đương trong trường hợp này.

Japt -hF , 8 byte

q, ün Åc

Thử nó

-3 byte nếu đầu vào có thể được lấy dưới dạng một mảng.

05AB1E , 9 8 byte

',¡ZsËiõ

-1 byte nhờ @Cowabunghole .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Hãy thử trực tuyến!

Ohm v2 , 9 byte

Ul1E?Oq¿↑

Hãy thử trực tuyến! Giải trình:

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

Than , 15 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔Ｉ⪪Ｓ,θ

Tách đầu vào trên dấu phẩy và chuyển từng giá trị thành số nguyên.

¿›⌈θ⌊θ

Kiểm tra xem giá trị tối đa lớn hơn giá trị tối thiểu.

Ｉ⌈θ

Nếu vậy thì truyền giá trị tối đa cho chuỗi và in.

Toán học, 43 byte

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

Chức năng thuần túy. Lấy một chuỗi được phân tách bằng dấu phẩy làm đầu vào và trả về một số hoặc Null. Tôi tin rằng điều này là hợp lệ, vì Nullnó không được hiển thị bằng đồ họa:

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

Hãy thử trực tuyến!

Thuốc khử trùng

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

Bình thường, 7 byte

Itl{QeS

Hãy thử trực tuyến!
Tất cả các trường hợp thử nghiệm (mã hơi khác nhau để định dạng đầu ra tốt hơn)

Vì Pyth dựa trên Python, đầu vào của người dùng luôn được hiểu là một chuỗi, sau đó có thể được truyền qua eval() . Tất cả các chương trình Pyth tự động chạy Q=eval(input())như hướng dẫn đầu tiên của họ.

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

Hãy thử trực tuyến!

Giải thích

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
}

Giải pháp thưởng!

Mặc dù đã cố gắng hết sức nhưng tôi không thể có được giải pháp này bằng cách sử dụng regex và Stream xuống dưới 105 byte, nhưng tôi thực sự thích sự thanh lịch của nó nên đã phải đề cập đến nó một cách vinh dự;

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

MATL , 15 9 byte

U&=?}1MX>

Hãy thử trực tuyến!
Nhiều testcase

Chỉ cần cố gắng để giữ cho sườn MATL của tôi không bị gỉ!

Biên tập : gỉ sau tất cả; đã lưu 6 byte, nhờ @LuisMendo.

Giải trình

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

Hãy thử trực tuyến!

Sử dụng cách tiếp cận từ giải pháp APL của ngn :

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

5 byte đầu tiên a^:', phân tách chuỗi đầu vào trên dấu phẩy.

Các giải pháp 13 byte thay thế:

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