iOS 11 có một lỗi khiến kết quả của 1 + 2 + 3 là 24 . Điều này có liên quan đến tốc độ hoạt hình, nhưng dù sao:

Nhiệm vụ là thực hiện 1 + 2 + 3 == 24. Nhưng chỉ có thế. Vì vậy, bạn nên cung cấp một chức năng tổng kết một cách chính xác nhất trình tự nhưng lợi nhuận 24khi đối số 1, 2và 3trong bất kỳ thứ tự.

Ví dụ đầu vào:

1 2 => 3
3 4 => 7
1 2 3 4 5 6 7 8 9 => 45
3 2 1 => 24
2 1 3 => 24
1 1 => 2
1 2 3 => 24
40 2 => 42
1 2 2 4 => 9
1 2 3 4 1 2 3 => 16
1 => 1
1 23 => 24
0 1 2 => 3
3 2 3 => 8

Đầu vào có thể ở bất kỳ định dạng nào miễn là mã của bạn chấp nhận bất kỳ số lượng đối số nào.

• Hỗ trợ cho các số âm không bắt buộc (tất cả các số không âm được yêu cầu để hoạt động, bao gồm 0)
• Chúng tôi giả sử đầu vào chính xác

Sự khác biệt với một câu hỏi tương tự khác: "Bạn nhận được gì khi nhân 6 với 9? (42)" :

• Trong trường hợp này, hàm của bạn được yêu cầu chấp nhận bất kỳ số lượng đối số. Câu hỏi cũ chỉ định chính xác 2.
• Trong trường hợp này, thứ tự không thành vấn đề, trong khi câu hỏi cũ chỉ định rằng thứ tự đó 6 9là bắt buộc và 9 6cần được đánh giá chính xác.

MATL , 11 10 byte

St3:X=6*+s

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

        % implicit input [3,1,2]
S       % sort
        % STACK: [1,2,3]
t       % duplicate elements
3:      % push range 1..3
        % STACK: [1,2,3], [1,2,3], [1,2,3]
X=      % true if arrays are numerically equal
        % STACK: [1,2,3], 1
6*+     % multiply result of comparison by 6 and add to the original array
        % STACK: [7,8,9]
s       % sum
        % (implicit) convert to string and display

05AB1E , 9 byte

Os{3LQi4*

Giải trình:

Os{         Get the sum of the input, and then get the sorted input list
     Qi     If it is equal to...
   3L       [1, 2, 3]
       4*   Then multiply the sum by four.

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

Java 8, 109 106 101 90 75 74 71 66 byte

a->{int s=0,p=0;for(int i:a){s+=i;p|=1<<i;}return s<7&p==14?24:s;}

-12 byte nhờ @ OlivierGrégoire .
-31 byte nhờ @Nevay .

Giải trình:

Hãy thử nó ở đây.

a->{                  // Method with integer-array parameter and boolean return-type
  int s=0,            //  Sum-integer, starting at 0
      p=1;            //  Product-integer, starting at 1
  for(int i:a){       //  Loop over the input-array
    s+=i;             //   Add current item to sum
    p|=1<<i;          //   Take 1 bitwise left-shifted with `i`, and bitwise-OR it with `p`
  }                   //  End of loop
  return p==14        //  If `p` is now exactly 14 (`0b1110`)
    &s<7?             //  and the sum is 6 or lower:
     24               //   Return 24
    :                 //  Else:
     s;               //   Return the sum
}                     // End of method

(Không hiệu quả) chứng minh rằng chỉ có [1,2,3](theo thứ tự) sẽ được kết quả tốt khi plà 0b1110( p==14) và tổng là dưới 6 hoặc thấp hơn ( s<7): Hãy thử nó ở đây.

p==14( 0b1110) Trả về true khi và chỉ khi các giá trị đầu vào theo modulo 32 bìa các giá trị 1, 2và 3và không chứa các giá trị khác ( p|=1<<i) (mỗi giá trị có thể xảy ra 1+ lần). Tổng số đầu vào khớp p==14sẽ lớn hơn 6bất kỳ đầu vào nào ngoại trừ 1,2,3( s=a*1+b*2+c*3+u*32với a>0,b>0,c>0,u>=0).
_@Nayay

Câu trả lời cũ 71 byte :

a->{int s=0,p=1;for(int i:a){s+=i;p*=i;}return a.length==3&p==s?s*4:s;}

Chứng minh rằng với ba số tự nhiên khác không, chỉ [1,2,3](theo bất kỳ thứ tự nào) sẽ có tổng bằng với sản phẩm của nó ( 1+2+3 == 1*2*3) (với tổng dương):
Khi tổng bằng với sản phẩm của Leo Kurlandchik & Andrzej Nowicki

(Không hiệu quả) chứng minh rằng chỉ [1,2,3](theo bất kỳ thứ tự nào) và [0,0,0]sẽ là kết quả có thể có với các số không âm và độ dài 3: Hãy thử tại đây.
Vì vậy, s*4sẽ trở thành 6*4 = 24cho [1,2,3], và 0*4 = 0cho [0,0,0].

Thạch , 8 byte

3R⁼Ṣ4*×S

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

MATL , 13 byte

stGp=18*Gda*+

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

Nó dài hơn hai byte so với câu trả lời MATL khác, nhưng nó sử dụng một cách tiếp cận hoàn toàn khác (và IMO thú vị hơn), vì vậy tôi cho rằng nó đáng để đăng.

Giải trình:

Giải pháp này sử dụng thực tế rằng:

Tổng và tích của một mảng có ba phần tử chỉ bằng nhau nếu mảng là hoán vị của 1,2,3.

Cái này lấy đầu vào, tính tổng svà nhân đôi nó t. Sau đó, nó kiểm tra nếu tổng bằng sản phẩm Gp=. Chúng tôi nhân boolean 1/0với 18 18*và kiểm tra xem có các giá trị không giống nhau trong vectơ không da*(một lần nữa, nhân với một boolean any(diff(x)). Sau đó, chúng tôi nhân hai số cuối với số ban đầu.

Từng bước giải thích:

Giả sử đầu vào là [1, 2, 3]:

s                              % Implicit input, calculate the sum
                               % 6
 t                             % Duplicate the sum:
                               % 6, 6
  G                            % Grab input
                               % 6, 6, [1,2,3]
   p                           % Calculate the product
                               % 6, 6, 6
    =                          % Check if the last two elements are equal
                               % 6, 1 (true)
     18*                       % Push 18, multiply by the last number
                               % 6, 18
        G                      % Grab input
                               % 6, 18, [1,2,3]
         d                     % Calculate the difference between each element
                               % 6, 18, [1,1]
          a                    % any non zero elements?
                               % 6, 18, 1 (true)
           *                   % Multiply last two numbers
                               % 6, 18
            +                  % Add numbers. Result: 24

Python 2 , 39 byte

lambda*a:sum(a)+18*(sorted(a)==[1,2,3])

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

Sử dụng một phương pháp thay thế thêm 18 nếu đầu vào được sắp xếp là [1, 2, 3]để đánh bại câu trả lời Python khác bằng một byte.

Haskell , 37 byte

f[a,b,c]|2^a+2^b+2^c==14=24
f l=sum l

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

Chúng tôi sử dụng khớp mẫu để bắt trường hợp đặc biệt.

Haskell không có phân loại tích hợp. Bình đẳng chỉ 2^a+2^b+2^c==14được thỏa mãn bởi [a,b,c]một hoán vị [1,2,3]giữa các số nguyên không âm. Một ngắn hơn a+b+c=a*b*cgần như hoạt động, nhưng được thỏa mãn bởi [0,0,0], và việc thêm kiểm tra ,a>0làm cho nó dài hơn 1 byte.

Octave , 34 byte

@(x)sum(x)+isequal(sort(x),1:3)*18

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

hoặc là

@(x)(s=sum(x))+18*~(s-6|prod(x)-6)

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

hoặc là

@(x)(s=sum(x))+18*~(s-prod(x)|s-6)

Điều này ngắn hơn cách tiếp cận người khác sử dụng : @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Giải trình:

Nó lấy tổng của vectơ và thêm 18 nếu vectơ được sắp xếp bằng 1,2,3. Điều này sẽ đưa ra 6+18=24nếu vectơ là hoán vị 1,2,3và chỉ là tổng của vectơ nếu không.

PHP, 116 byte

Đây là lần thử đầu tiên của tôi tại một thử thách chơi gôn, VÀ đó là PHP, một ngôn ngữ dường như rất tệ khi chơi golf vì tôi hiếm khi thấy nó ở đây, vì vậy ... uhm, tôi đã thử chưa?

<?php
//call as var/www/html/cg_ios.php --'1 2 3 4 5'
$i=$argv[1];$a=(explode(' ',$i));echo((($b=array_sum($a))==6&&count($a)==3&&in_array(3,$a)&&!in_array(0,$a)?24:$b));

Lưu ý: Tôi không bao gồm các bình luận vào bytecount.

Bị đánh cắp

Không có gì đặc biệt tbh:

$i=$argv[1];             //Read the input from the command line
$a=array_filter($c=explode(' ',$i)) //Split the input string into an array, use Whitespace as delimiter
                         //also, remove all 0 from the array, since they are not important at all
echo(                    //print the result
    ($b=array_sum($a) == 6  //If The SUM of the Array is 6 ...
        &&               //... AND ...
    (count($c) == 3)     //... the array has exactly 3 values ...
        &&               //... AND ...
    in_array(3,$a)       // ... the array contains the value 3 ...
        &&               // ... AND ...  
    !in_array(0,$a)      //... the array contains no zeros
        ?
    24                   //print 24
        :
    $b));     //print the sum of the array values we saved earlier

Nếu bạn muốn kiểm tra điều này trong PHPFiddle chứ không phải trên bàn điều khiển, rõ ràng bạn có thể thay thế $ibằng bất cứ thứ gì bạn muốn.

Cảm ơn Olivier Grégoire, người đã cho tôi biết về tổ hợp chuỗi [0,3,3]đã trả về 24 trước đó và cũng giúp tôi lưu một vài ký tự bằng cách lưu trữ array_sumvà trả lại thay vì chạy lại chức năng.

R, 47 byte 34 byte 36 byte

x=scan();all(sort(x)==1:3)*18+sum(x)

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

Tính tổng đầu vào và thêm 18 nếu bộ đầu vào là 1: 3.
Cảm ơn @mlt vì đã chơi golf 11 byte. Cảm ơn @ Ayb4btu vì đã xác định lỗi với mã quá mức

Javascript ES6, 39 byte

Cảm ơn @Herman Lauenstein

a=>a.sort()=="1,2,3"?24:eval(a.join`+`)

f=a=>a.sort()=="1,2,3"?24:eval(a.join`+`)

console.log(f([1,2,3]));
console.log(f([1,2,3,4]));

Câu trả lời trước

Javascript ES6, 66 byte

a=>(n=[1,2,3],a.every(_=>n.includes(_))?24:a.reduce((x,y)=>x+y,0))

Thử nó

f=a=>(n=[1,2,3],a.every(_=>n.includes(_))?24:a.reduce((x,y)=>x+y,0))

console.log(f([1,2,3]));
console.log(f([1,3,2]));
console.log(f([1,2,3,4]));

Swift, 67 byte

func z(i: [Int])->Int{return i.sorted()==[1,2,3] ?24:i.reduce(0,+)}

Có thể làm cho nó tới 27 byte với các phần mở rộng trên [Int], nhưng đó sẽ là gian lận :(

Toán học, 28 byte

If[Sort@#=={1,2,3},24,Tr@#]&

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

J, 17 byte

-6 byte nhờ Frowny Frog

+/*1+3*1 2 3-:/:~

Tính tổng tất cả các số +/và nhân kết quả với (mã giả) 1 + 3*(is123 ? 1 : 0). Đó là, trả về kết quả không thay đổi trừ khi danh sách được sắp xếp là1 2 3 trong trường hợp chúng ta nhân kết quả với 4.

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

câu trả lời gốc

+/`(24"_)@.(1 2 3-:/:~)

Kiểm tra xem đầu vào được sắp xếp là 1 2 3- nếu có, gọi hàm hằng 24 ( 24"_); nếu không, trả lại tổng+/

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

C # (.NET Core) , 57 + 18 = 75 byte

a=>a.OrderBy(x=>x).SequenceEqual(new[]{1,2,3})?24:a.Sum()

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

+18 cho using System.Linq;

Lua , 116 81 byte

-7 byte nhờ Jonathan

Đưa đầu vào làm đối số dòng lệnh

Z=0S={}for i=1,#arg do
j=arg[i]+0S[j]=0Z=Z+j
end
print(#S>2 and#arg<4 and 24or Z)

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

Giải trình:

Hoạt động bằng cách tạo một mảng thưa thớt Svà thêm các số 0 trong các chỉ mục tương ứng với các giá trị đầu vào. Nếu tham số là 3, 4, 7mảng thưa thớt sẽ chỉ có số tại các chỉ số đó. Với mảng đó, chúng tôi có được nó dài với các nhà điều hành #mà đếm từ chỉ số 1lên đến chỉ số cao hơn mà có một giá trị trong nó, nếu chiều dài này là chính xác 3, nó có nghĩa là đã có yếu tố ở vị trí này 1, 2và 3mà là những gì chúng tôi tìm kiếm. Độ dài của mảng thưa thớt sẽ luôn nằm giữa 0và Nđâu Nlà số lượng tham số. Vì vậy, chúng ta chỉ cần kiểm tra xem độ dài của cả mảng tham số và mảng thưa là 3.

R , 55 45 54 49 57 54 48 byte

Đã lưu nhiều byte và giải pháp không chính xác nhờ Ayb4btu.

Đã lưu 3 9 byte nhờ Giuseppe. Tôi tiếp tục học những cách mới để lạm dụng thực tế đó F==0.

"if"((s=sum(x<-scan()))-prod(x)|sum(x|1)-3,s,24)

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

Câu trả lời R khác đã giành chiến thắng cuối cùng.

C (gcc) , 136 131 125 97 91 byte

i,r,t;main(c,v)char**v;{for(;c-->1;)i=atoi(v[c]),r+=i,t|=1<<i;printf("%d",r<7&t==14?24:r);}

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

Võng mạc , 21 byte

O`
^1¶2¶3$
24
.+
$*
1

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

Đầu vào được phân tách theo dòng, nhưng bộ kiểm tra sử dụng phân tách bằng dấu phẩy để thuận tiện.

Giải trình

O`

Sắp xếp các con số (thứ tự từ điển, trên thực tế, nhưng chúng tôi chỉ quan tâm đến những trường hợp đó, đầu vào là 1, 2, 3theo một trật tự, nơi mà không tạo sự khác biệt).

^1¶2¶3$
24

Nếu đầu vào là 1,2,3(theo một số thứ tự), thay thế nó bằng 24.

.+
$*

Chuyển đổi từng số để unary.

1

Đếm số lượng 1s, thêm các số đơn nguyên và chuyển đổi chúng thành số thập phân.

Haskell , 44 byte

f a|sum a==6,product a==6,a<[6]=24|1<2=sum a

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

Các hoán vị [1,2,3]là các phân vùng duy nhất của 6sản phẩm của họ 6, 6tự chặn . (Điều này giả định rằng các đầu vào là không âm, dường như là trường hợp cho tất cả các trường hợp thử nghiệm, tôi đã hỏi OP về điều này.)

PL / SQL - 135 123 byte

Giả sử i là đầu vào mảng số nguyên có kích thước bất kỳ:

if (select sum(s) = exp(sum(ln(s))) from unnest(i) s) then
    return 24;
else
    return (select sum(s) from unnest(i) s);
end if;

C ++ 17, 56 54 byte

[](auto...i){return(-i&...)+4|(~i*...)+24?(i+...):24;}

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

Lưu ý rằng đối tượng hàm được tạo có thể sử dụng được tại thời gian biên dịch, do đó các kiểm tra được trình biên dịch thực hiện mà không phải chạy chương trình.

Giải trình:

[]             // Callable object with empty closure,
(auto...i)     // deduced argument types,
{              // and deduced return type
  return       //
      (-i&...) //   If the fold over the bitwise AND of the negation of each argument
    +4|        // is unequal to -4, or
      (~i*...) //   if the product of the bitwise complements of the arguments
    +24?       // is unequal to -24, then
      (i+...): //   return the sum of the arguments, otherwise
      24;}     //   return 24.

Bằng chứng cho thấy các chỉ số không âm i...mà (-i&...)bằng -4 và (~i*...)tương đương -24 là các hoán vị của 1, 2, 3:

Trước tiên chúng tôi quan sát rằng vì -0= 0, nếu có i= 0sau đó (-i&...) = 0, vì vậy chúng tôi kết luận rằng tất cả iđều dương.

Bây giờ, lưu ý rằng trong phần bù của 2, -itương đương ~(i - 1)và ~itương đương với -(i + 1). Áp dụng quy tắc của De Morgan, chúng tôi thấy rằng (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), vì vậy ((i - 1) | ...) = 3; tương tự, -1 ** n * ((i + 1) * ...) = -24như vậy nlà kỳ quặc và ((i + 1) * ...) = 24.

Các thừa số nguyên tố của 24 là 2 ** 3 * 3, vì vậy n<= 4. Nếu n= 1, chúng ta có i - 1 = 3và i + 1 = 24, vì vậy n= 3. Viết iwlog dưới dạng a <= b <= c, sau đó rõ ràng a= 1 nếu không (a + 1)(b + 1)(c + 1)> = 27. Ngoài ra c<= 4 là mặt khác (a - 1)|(b - 1)|(c - 1)> = 4. ckhông thể là 4 vì 5 không phải là hệ số của 24, vì vậy c<= 3. Sau đó, để thỏa mãn (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2 theo yêu cầu.

Husk , 9 byte

?K24Σ=ḣ3O

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

Giải trình

?K24Σ=ḣ3O
        O    Sort the input
?    =ḣ3     If it is equal to [1,2,3]:
 K24           Return 24
             Else:
    Σ          Return the sum of the input

Giải pháp trước

Cung cấp kết quả sai cho [2,2], và có lẽ các đầu vào khác cũng vậy, nhưng nó thú vị hơn.

?ṁD→E§eΠΣ
     §eΠΣ    Build a two-element list with the product and sum of the input
?   E        If the two elements are equal:
             (true for any permutation of [1,2,3] and the list [0,0,0]
 ṁD            Double both elements and sum them
               (This is 4 times the sum: 24 for permutations of [1,2,3], 0 for [0,0,0])
             Else:
   →          Return the last element (the sum)

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

Pushy , 12 byte

gF3RFx?18;S#

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

Điều này hoạt động bằng cách sắp xếp đầu vào và, nếu nó bằng [1, 2, 3], nối thêm 18. Sau đó, tổng được tính và in, thu được 24 là 18 được thêm vào và câu trả lời bình thường khác.

         \ Implicit: Input on stack.
g        \ Sort input ascendingly
F3RF     \ On auxiliary stack, push range(3) -> [1, 2, 3]
x?       \ If the stacks are equal:
  18     \    Append 18 to the input
;
S#       \ Print sum of input.

Bình , 9 byte

?qS3SK24s

Xác nhận tất cả các trường hợp thử nghiệm.

Con trăn 2 , 41 39 byte

-1 byte nhờ caird

-1 theo cảm hứng từ câu trả lời của FlipTack

lambda*a:sum(a)*4**(sorted(a)==[1,2,3])

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

Giải pháp thay thế 39 byte

lambda*a:sum(a)<<2*(sorted(a)==[1,2,3])

Thạch , 10 9 byte

Ṣ24S⁼?3R¤

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

-1 byte nhờ Erik

Thay thế (bởi Mr. Xcoder ), cũng cho 9 byte:

3R⁼Ṣ×18+S

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

Làm thế nào nó hoạt động

Ṣ24S⁼?3R¤ - Main link. Argument: l (list)

Ṣ         - Sort
     ?    - Ternary if statement
    ⁼     -  Condition: Is l equal to...
      3R¤ -    [1, 2, 3]
 24       -  If condition: Return 24          
   S      -  Else: Return the sum of the list

Bình thường , 9 byte

Aproach khác nhau từ câu trả lời Pyth khác.

*sQ^4qS3S

Giải trình:

Một cổng từ câu trả lời Python của tôi

*sQ^4qS3SQ  # Full program (Q at the end is implicit and represents the input)

*           # A * B where A and B are the next two lines
  sQ        # Sum elements of input
  ^4        # 4 to the power of:
    qS3SQ   # Compares sorted input to [1, 2, 3] and returns 0 or 1

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

PowerShell , 44 byte

param($a)($a-join'+'|iex)+18*!(diff(1..3)$a)

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

Thuật toán tương tự với câu trả lời Python và JavaScript. Đưa đầu vào như một mảng theo nghĩa đen $a. Sau đó, ngay lập tức tổng $ahợp lại với nhau, tạo thành toán tử bên trái của+ .

Bên tay phải là diff(bí danh Compare-Object) của 1,2,3và $a- đây là một mảng trống nếu chúng bằng nhau hoặc một mảng không trống của các mục khác nhau nếu chúng không bằng nhau - được đặt trong Boolean-không. Vì vậy, nếu chúng bằng nhau, điều đó làm cho mảng trống (giá trị falsey) thành $true.

Đó là sau đó nhân 18mà ngầm phôi $trueđể 1và $falseđể 0. Vì vậy, phía bên tay phải sẽ là 18nếu các mảng giống nhau, và 0nếu không. Điều đó cho kết quả chính xác 24nếu mảng đầu vào có 1,2,3bất kỳ hoán vị nào và tổng của mảng đầu vào khác.

Kotlin , 46 44 byte

if(i.sorted()==listOf(1,2,3))24 else i.sum()

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

Chỉnh sửa

• Ông Xcoder -2 byte