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) ตรวจสอบการจริง IFF ค่าการป้อนข้อมูลแบบโมดูโล 32 ปกค่า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)
_@Nevay

คำตอบเก่า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/0ด้วย 18 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])

ลองออนไลน์!

ใช้วิธีอื่นในการเพิ่ม 18 ถ้าอินพุตที่เรียงไว้[1, 2, 3]จะเอาชนะคำตอบ Python อื่น ๆด้วยไบต์

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

หมายเหตุ: ฉันไม่ได้รวมความคิดเห็นไว้ใน bytecount

Ungolfed

มันไม่มีอะไรพิเศษเลย:

$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สิ่งที่คุณต้องการได้อย่างชัดเจน

ขอบคุณ Olivier Grégoireที่ทำให้ฉันตระหนักถึงการรวมกันของสตริง[0,3,3]ที่กลับมา 24 ก่อนหน้านี้และยังช่วยฉันประหยัดสองสามตัวอักษรโดยการจัดเก็บarray_sumและกลับมาที่แทนที่จะใช้ฟังก์ชั่นอีกครั้ง

R, 47 ไบต์ 34 ไบต์ 36 ไบต์

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

ลองออนไลน์!

รวมอินพุตและเพิ่ม 18 ถ้าชุดอินพุตเป็น 1: 3
ขอบคุณ @mlt สำหรับการเล่นกอล์ฟขนาด 11 ไบต์ ขอบคุณ @ Ayb4btu สำหรับการระบุข้อผิดพลาดด้วยรหัส overgolfed

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

Swift, 67 ไบต์

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

สามารถเพิ่มเป็น 27 ไบต์ด้วยส่วนขยายใน [Int] แต่นั่นอาจเป็นการโกง :(

Mathematica ขนาด 28 ไบต์

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

ลองออนไลน์!

J, 17 ไบต์

-6 ไบต์ขอบคุณ Frowny Frog

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

สรุปตัวเลขทั้งหมด+/และคูณผลมาจาก 1 + 3*(is123 ? 1 : 0)(pseudocode) นั่นคือส่งคืนผลลัพธ์ที่ไม่เปลี่ยนแปลงเว้นแต่ว่ารายการที่เรียงลำดับจะเป็น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, 7sparse array จะมีตัวเลขที่ดัชนีเหล่านั้นเท่านั้น กับอาร์เรย์ที่เราได้รับมันยาวกับผู้ประกอบการ#ที่นับจากดัชนี1ถึงดัชนีที่สูงที่มีค่าในนั้นหากความยาวตรงนี้เป็น3ก็หมายความว่ามีองค์ประกอบในตำแหน่ง1, 2และ3ชคือสิ่งที่เรากำลัง กำลังมองหา. ความยาวของอาร์เรย์จะกระจัดกระจายอยู่ระหว่าง0และNที่ไหนNคือจำนวนพารามิเตอร์ 3ดังนั้นเราก็ต้องตรวจสอบว่าความยาวของทั้งอาร์เรย์พารามิเตอร์และอาร์เรย์เบาบางคือ

R , 55 45 54 49 57 54 48 ไบต์

บันทึกจำนวนมากและการแก้ปัญหาที่ไม่ถูกต้องขอบคุณ Ayb4btu

บันทึกแล้ว3 9 ไบต์ขอบคุณ Giuseppe 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

ลองออนไลน์!

อินพุตถูกคั่นด้วย linefeed แต่ชุดทดสอบใช้การคั่นด้วยเครื่องหมายจุลภาคเพื่อความสะดวก

คำอธิบาย

O`

เรียงลำดับตัวเลข (lexicographically จริง แต่เราจะดูแลเกี่ยวกับกรณีที่ปัจจัยการผลิตที่มี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.

พิสูจน์ว่า nonnegative เท่านั้นi...ที่(-i&...)เท่ากับ -4 และ(~i*...)เท่ากับ -24 เป็นวิธีเรียงสับเปลี่ยนของ1, 2, 3:

ครั้งแรกที่เราสังเกตว่าตั้งแต่-0= 0ถ้ามีi= 0แล้ว(-i&...) = 0ดังนั้นเราจึงสรุปได้ว่าทุกคนที่iเป็นบวก

ตอนนี้ทราบว่าใน 2 ส่วนประกอบ, -iเทียบเท่ากับ~(i - 1)และเป็นเทียบเท่า~i -(i + 1)การใช้กฎของมอร์แกนเดอเราพบว่า(-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 = 3และi + 1 = 24ดังนั้น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 ตามต้องการ

Husk , 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)

ลองออนไลน์!

เร่งความเร็ว 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

ทางเลือก (โดยMr. 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 ไบต์

aproach ที่แตกต่างจากคำตอบ 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 จะเข้าเป็น $aarray แล้วทันทีสรุปร่วมกันซึ่งเป็นผู้ประกอบการทางด้านซ้ายมือของ$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 ไบต์