iOS 11有一个错误，使1 + 2 + 3的结果为24。这与动画速度有关，但是无论如何：

任务是制造1 + 2 + 3 == 24。但只有那样。所以，你应该提供正确总结大多数序列，但收益函数24时的参数是1，2和3以任何顺序。

输入示例：

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

输入可以采用任何格式，只要您的代码接受任意数量的参数即可。

• 不需要支持负数（必须使用所有非负数，包括0）
• 我们假设输入正确

与另一个类似问题的区别：“将6乘以9会得到什么？（42）”：

• 在这种情况下，您的函数需要接受任意数量的参数。老问题恰好指定了2。
• 在这种情况下，顺序无关紧要，而旧问题指定了顺序6 9是必需的，9 6应该正确评估。

MATL，11个10字节

St3:X=6*+s

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

说明

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

Os{3LQi4*

说明：

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.

在线尝试！

Java 8，109 106 101 90 75 74 71 66字节

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

-12个字节感谢@OlivierGrégoire。
-31个字节，感谢@Nevay。

说明：

在这里尝试。

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

（低效）证明只[1,2,3]（以任何顺序）将是可能的结果时，p是0b1110（p==14）和总和低于6或更低（s<7）：在这里尝试。

p==14（0b1110）如果输入值以模32为模，则计算结果为true 1，2并且3不包含其他值（p|=1<<i）（每个值必须出现1次以上）。匹配的输入总和p==14将大于6除1,2,3（s=a*1+b*2+c*3+u*32带有a>0,b>0,c>0,u>=0）以外的任何输入的总和。
_@内华

旧的71个字节的答案：

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

证明对于任何三个给定的非零自然数，仅[1,2,3]（按任何顺序）其和等于（1+2+3 == 1*2*3）（为正数）：
当和等于 Leo Kurlandchik和Andrzej Nowicki 的乘积时

（效率低下）证明只有[1,2,3]（以任意顺序）和[0,0,0]将是可能的结果，且结果为非负数且长度为3：在此处尝试。
因此，s*4将成为6*4 = 24对[1,2,3]，并0*4 = 0为[0,0,0]。

果冻，8字节

3R⁼Ṣ4*×S

在线尝试！

MATL，13字节

stGp=18*Gda*+

在线尝试！

它比另一个MATL答案长两个字节，但是它使用了完全不同的方法（并且IMO更有趣），所以我认为值得一提。

说明：

该解决方案使用以下事实：

仅当数组是的排列时，具有三个元素的数组的和和积才相等1,2,3。

这将接受输入，计算总和s，然后将其复制t。然后检查总和是否等于乘积Gp=。我们将布尔值乘以1/018，，18*并检查向量中是否存在不相同的值da*（再次，将其与布尔值any(diff(x))相乘。然后将两者相乘，将最后一个数字与原始和相加。

逐步说明：

假设输入为[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个字节

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

在线尝试！

如果排序后的输入[1, 2, 3]要比另一个Python答案好一个字节，则使用加18的替代方法。

Haskell，37个字节

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

在线尝试！

我们使用模式匹配来捕获特殊情况。

Haskell没有内置的排序功能。2^a+2^b+2^c==14仅通过在非负整数之间[a,b,c]进行排列即可满足该相等性[1,2,3]。较短的a+b+c=a*b*c几乎可以使用，但由可以满足要求[0,0,0]，并且附加检查,a>0会使长度增加1个字节。

八度，34字节

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

在线尝试！

要么

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

在线尝试！

要么

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

这比其他人使用的方法要短：@(x){24,sum(x)}{2-isequal(sort(x),1:3)}。

说明：

它取向量的总和，如果排序后的向量等于，则加18 1,2,3。6+18=24如果向量是的置换，则将给出1,2,3，如果不是，则仅给出向量的和。

PHP，116字节

这是我有史以来第一次尝试打高尔夫球，而PHP是一种语言，因为我在这里很少见到这种语言，所以它很吸引高尔夫，所以...嗯，我尝试过吗？

<?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));

注意：我没有在字节数中包含注释。

不打高尔夫球

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

如果要在PHPFiddle中而不是在控制台上进行测试，则显然可以替换$i为所需的任何内容。

感谢OlivierGrégoire，他使我意识到了[0,3,3]之前返回24 的字符串组合，还通过存储array_sum和返回而不是再次运行该函数帮助我节省了一些字符。

R，47字节 34字节 36字节

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

在线尝试！

对输入求和，如果输入集为1：3，则加18。
感谢@mlt打高尔夫球11个字节。感谢@ Ayb4btu使用过高的代码识别错误

Javascript ES6，39个字节

感谢@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]));

上一个答案

Javascript ES6，66字节

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

试试吧

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]));

迅捷，67字节

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

可以将其扩展为[Int]并扩展为27个字节，但这会欺骗:(

Mathematica，28个字节

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

在线尝试！

J，17个字节

-6字节归功于Frowny Frog

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

将所有数字求和，+/然后将结果乘以（伪代码）1 + 3*(is123 ? 1 : 0)。也就是说，除非排序列表是1 2 3在这种情况下，否则我们将结果乘以4，就不会返回任何结果。

在线尝试！

原始答案

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

检查排序后的输入是否为1 2 3-如果是，则调用常量函数24（24"_）; 如果不是，则返回总和+/

在线尝试！

C＃（.NET Core），57 + 18 = 75字节

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

在线尝试！

+18 using System.Linq;

的Lua，116个 81字节

-7字节感谢乔纳森

将输入作为命令行参数

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)

在线尝试！

说明：

通过创建稀疏数组S并在与输入值相对应的索引中添加零来工作。如果参数是3, 4, 7稀疏数组，则这些索引处只会有数字。有了这个数组，我们得到的长度#是从索引1开始到其中有值的更高索引的运算符的长度，如果这个长度正好是3，则意味着position中有元素1，2而3这就是我们要寻找。稀疏数组的长度将始终在之间0，N其中N参数的数量在哪里。因此，我们只需要检查parameters数组和sparse数组的长度是否均为3。

R，55 45 54 49 57 54 48字节

多亏了Ayb4btu，节省了许多字节和错误的解决方案。

感谢Giuseppe，节省了3 9个字节。我一直在学习滥用这种事实的新方法F==0。

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

在线尝试！

最后，另一个R答案获胜。

C（GCC） ，136个 131 125 97 91字节

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

在线尝试！

视网膜，21字节

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

在线尝试！

输入以换行分隔，但为了方便起见，测试套件使用逗号分隔。

说明

O`

排序号（字典顺序，实际上，但是我们只关心的情况下，该输入是1，2，3以某种顺序，其中不有所作为）。

^1¶2¶3$
24

如果输入是1,2,3（按某种顺序），则将其替换为24。

.+
$*

将每个数字转换为一元。

1

计算1s 的数量，这将一元数相加并将其转换回十进制。

Haskell，44个字节

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

在线尝试！

的排列[1,2,3]是6其乘积为的唯一分区6，除非6本身。（这假设输入是非负的，所有测试用例似乎都是这种情况。我已经问过OP这件事。）

PL / SQL - 135个 123字节

假设我是任意大小的整数数组输入：

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

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

在线尝试！

请注意，创建的函数对象可在编译时使用，因此测试由编译器执行，而无需运行程序。

说明：

[]             // 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.

证明了非负仅i...针对(-i&...)等于-4，(~i*...)等于-24是的排列1, 2, 3：

我们首先观察到既然-0= 0，如果有i= 0then (-i&...) = 0，那么我们得出结论，所有i都是正数。

现在，请注意2的补码-i等效于~(i - 1)，并且~i等效于-(i + 1)。应用De Morgan的规则，我们发现(-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1)，所以((i - 1) | ...) = 3; 类似地，-1 ** n * ((i + 1) * ...) = -24，所以n是奇数和((i + 1) * ...) = 24。

24的素数是2 ** 3 * 3，所以n<=4。如果n= 1，我们有i - 1 = 3and i + 1 = 24，so n=3。将iwlog 写为a <= b <= c，然后清楚地将a= 1表示，否则(a + 1)(b + 1)(c + 1)> =27。还将c<= 4表示为否则(a - 1)|(b - 1)|(c - 1)> =4。c不能为4，因为5不是24的因数，所以c<=3。然后要满足(a - 1)|(b - 1)|(c - 1) = 3c = 3，则b = 2是必需的。

外壳，9个字节

?K24Σ=ḣ3O

在线尝试！

说明

?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

先前的解决方案

将错误的结果提供给[2,2]，可能还会给出其他输入，但这更有趣。

?ṁ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)

在线尝试！

Pushy，12个字节

gF3RFx?18;S#

在线尝试！

这是通过对输入进行排序（如果等于[1, 2, 3]）后缀18 来进行的。然后，计算和打印总和，将后缀24 变成18，否则返回正常答案。

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

Pyth，9个字节

?qS3SK24s

验证所有测试用例。

Python 2中，41 39个字节

-1字节感谢caird

-1来自FlipTack的答案

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

在线尝试！

备用39字节解决方案

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

果冻，10 9字节

Ṣ24S⁼?3R¤

在线尝试！

-1字节感谢Erik

替代方案（由Xcoder先生完成），也适用于9个字节：

3R⁼Ṣ×18+S

在线尝试！

这个怎么运作

Ṣ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

Pyth，9个字节

与其他Pyth答案不同的方法。

*sQ^4qS3S

说明：

我的Python答案中的端口

*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

在线尝试！

PowerShell，44字节

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

在线尝试！

与Python和JavaScript答案相似的算法。将输入作为文字数组$a。然后立即求和$a，形成的左手运算符+。

右侧是diff（别名Compare-Object的）1,2,3和$a-这是一个空数组，如果它们相等，或不同的项目的一个非空数组，如果它们不相等-封闭在一个布尔不。因此，如果它们相等，则将空数组（假值）变成$true。

这是再乘以18含蓄地施放$true到1和$false到0。因此，18如果数组相同，则右侧为0否则，否则为右侧。24如果输入数组是否1,2,3处于任何排列中，则得出正确的结果，否则，将得出输入数组之和。

Kotlin，46 44字节

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

在线尝试！

编辑

• Xcoder先生 -2个字节