iOS 11 memiliki bug yang menjadikan hasil 1 + 2 + 3 menjadi 24 . Ini terkait dengan kecepatan animasi, tetapi bagaimanapun juga:

Tugasnya adalah membuat 1 + 2 + 3 == 24. Tapi hanya itu saja. Jadi, Anda harus menyediakan fungsi yang secara benar menjumlahkan sebagian besar urutan tetapi kembali 24ketika argumennya ada 1, 2dan 3dalam urutan apa pun.

Input contoh:

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

Input dapat dalam format apa pun selama kode Anda menerima sejumlah argumen.

• Dukungan untuk bilangan negatif tidak diperlukan (semua bilangan non-negatif diharuskan untuk bekerja, itu termasuk 0)
• Kami menganggap input yang benar

Perbedaan dari pertanyaan serupa lainnya: "Apa yang Anda dapatkan ketika Anda mengalikan 6 dengan 9? (42)" :

• Dalam hal ini fungsi Anda diperlukan untuk menerima setiap jumlah argumen. Pertanyaan lama menentukan dengan tepat 2.
• Dalam hal ini pesanan tidak masalah, sedangkan pertanyaan lama menentukan bahwa pesanan 6 9diperlukan dan 9 6harus dievaluasi dengan benar.

MATL , 11 10 byte

St3:X=6*+s

Cobalah online! atau verifikasi semua kasus uji

Penjelasan

        % 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*

Penjelasan:

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.

Cobalah online!

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 terima kasih kepada @ OlivierGrégoire .
-31 byte berkat @Nevay .

Penjelasan:

Coba di sini.

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

(Tidak efisien) bukti bahwa hanya [1,2,3](dalam urutan apapun) akan menjadi hasil yang mungkin saat pini 0b1110( p==14) dan jumlahnya di bawah 6 atau lebih rendah ( s<7): Cobalah sini.

p==14( 0b1110) mengevaluasi true jika nilai input modulo 32 menutupi nilai 1, 2dan 3dan tidak mengandung nilai lain ( p|=1<<i) (setiap nilai harus terjadi 1+ kali). Jumlah input yang cocok p==14akan lebih besar daripada 6input apa pun kecuali 1,2,3( s=a*1+b*2+c*3+u*32dengan a>0,b>0,c>0,u>=0).
_@Nay

Old 71 bytes menjawab:

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

Bukti bahwa untuk setiap tiga bilangan asli non-nol, hanya [1,2,3](dalam urutan apa pun) akan memiliki jumlah yang sama dengan produknya ( 1+2+3 == 1*2*3) (dengan jumlah positif):
Ketika jumlah tersebut sama dengan produk oleh Leo Kurlandchik & Andrzej Nowicki

(Tidak efisien) bukti bahwa hanya [1,2,3](dalam urutan apa pun) dan [0,0,0]akan menjadi hasil yang mungkin dengan angka non-negatif dan panjang 3: Coba di sini.
Jadi s*4akan menjadi 6*4 = 24untuk [1,2,3], dan 0*4 = 0untuk [0,0,0].

Jelly , 8 byte

3R⁼Ṣ4*×S

Cobalah online!

MATL , 13 byte

stGp=18*Gda*+

Cobalah online!

Ini dua byte lebih panjang dari jawaban MATL lainnya, tetapi menggunakan pendekatan yang sama sekali berbeda (dan IMO lebih menarik), jadi saya pikir itu layak posting.

Penjelasan:

Solusi ini menggunakan fakta bahwa:

Jumlah dan produk array dengan tiga elemen hanya sama jika array adalah permutasi 1,2,3.

Ini mengambil input, menghitung jumlah s, dan menggandakannya t. Kemudian memeriksa apakah jumlahnya sama dengan produk Gp=. Kami mengalikan boolean 1/0dengan 18,, 18*dan memeriksa apakah ada nilai-nilai tidak identik dalam vektor da*(sekali lagi, kalikan dengan boolean any(diff(x)). Kami kemudian mengalikan keduanya menambahkan angka terakhir ke jumlah asli.

Penjelasan langkah demi langkah:

Asumsikan inputnya adalah [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])

Cobalah online!

Menggunakan metode alternatif untuk menambahkan 18 jika input yang diurutkan adalah [1, 2, 3]untuk mengalahkan jawaban Python lainnya dengan byte.

Haskell , 37 byte

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

Cobalah online!

Kami menggunakan pencocokan pola untuk menangkap kasus luar biasa.

Haskell tidak memiliki penyortiran bawaan. Kesetaraan 2^a+2^b+2^c==14dipenuhi hanya dengan [a,b,c]permutasi di [1,2,3]antara bilangan bulat non-negatif. Yang lebih pendek a+b+c=a*b*champir berfungsi, tetapi dipenuhi oleh [0,0,0], dan menambahkan cek ,a>0membuatnya 1 byte lebih lama.

Oktaf , 34 byte

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

Cobalah online!

atau

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

Cobalah online!

atau

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

Ini lebih pendek dibandingkan dengan pendekatan lain penggunaan: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Penjelasan:

Dibutuhkan jumlah vektor, dan menambahkan 18 jika vektor yang diurutkan sama dengan 1,2,3. Ini akan memberikan 6+18=24jika vektor adalah permutasi 1,2,3, dan hanya jumlah vektor jika tidak.

PHP, 116 byte

Ini adalah upaya pertama saya untuk tantangan golf, DAN itu PHP, sebuah bahasa yang tampaknya payah di golf karena saya jarang melihatnya di sini, jadi ... uhm, saya mencoba?

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

Catatan: Saya tidak memasukkan komentar ke dalam bytecount.

Tidak disatukan

Bukan apa-apa tbh istimewa:

$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

Jika Anda ingin menguji ini dalam PHPFiddle dan bukan pada konsol, Anda dapat dengan jelas menggantinya $idengan apa pun yang Anda inginkan.

Terima kasih kepada Olivier Grégoire yang membuat saya menyadari kombinasi string [0,3,3]yang kembali 24 sebelumnya dan juga membantu saya menghemat beberapa karakter dengan menyimpan array_sumdan mengembalikannya alih-alih menjalankan fungsi lagi.

R, 47 byte 34 byte, 36 byte

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

Cobalah online!

Jumlah input dan tambahkan 18 jika set input adalah 1: 3.
Terima kasih kepada @mlt untuk bermain golf 11 byte. Terima kasih kepada @ Ayb4btu untuk mengidentifikasi kesalahan dengan kode overgolfed

Javascript ES6, 39 byte

Terima kasih kepada @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]));

Jawaban sebelumnya

Javascript ES6, 66 byte

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

Cobalah

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 Bytes

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

Bisa mencapai 27 byte dengan ekstensi di [Int], tapi itu akan curang :(

Mathematica, 28 byte

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

Cobalah online!

J, 17 byte

-6 byte berkat Frowny Frog

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

Jumlahkan semua angka +/dan gandakan hasilnya dengan (pseudocode) 1 + 3*(is123 ? 1 : 0). Artinya, kembalikan hasilnya tidak berubah kecuali daftar yang diurutkan 1 2 3dalam hal ini kita kalikan hasilnya dengan 4.

Cobalah online!

jawaban asli

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

Periksa apakah input yang diurutkan adalah 1 2 3- jika ya, aktifkan fungsi konstan 24 ( 24"_); jika tidak, kembalikan jumlahnya+/

Cobalah online!

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

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

Cobalah online!

+18 untuk using System.Linq;

Lua , 116 81 byte

-7 byte terima kasih kepada Jonathan

Mengambil input sebagai argumen baris perintah

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)

Cobalah online!

Penjelasan:

Bekerja dengan membuat array jarang Sdan menambahkan angka nol dalam indeks yang sesuai dengan nilai input. Jika parameter 3, 4, 7array jarang hanya akan memiliki angka di indeks tersebut. Dengan array itu, kita mendapatkan panjangnya dengan operator #yang dihitung dari indeks 1hingga indeks yang lebih tinggi yang memiliki nilai di dalamnya, jika panjang ini tepat 3, itu berarti bahwa ada elemen dalam posisi 1, 2dan 3yang adalah apa yang kita mencari. Panjang array jarang akan selalu di antara 0dan di Nmana Njumlah parameter. Jadi kita hanya perlu memeriksa apakah panjang array parameter dan array jarang 3.

R , 55 45 54 49 57 54 48 byte

Menyimpan banyak byte dan solusi yang salah berkat Ayb4btu.

Disimpan 3 9 byte berkat Giuseppe. Saya terus belajar cara-cara baru untuk menyalahgunakan fakta itu F==0.

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

Cobalah online!

Jawaban R lainnya menang pada akhirnya.

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

Cobalah online!

Retina , 21 byte

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

Cobalah online!

Input dipisahkan dengan linefeed, tetapi test suite menggunakan pemisahan koma untuk kenyamanan.

Penjelasan

O`

Sortir angka-angka (secara leksikografis, sebenarnya, tetapi kami hanya peduli pada kasus inputnya 1 , 2, 3dalam beberapa urutan, di mana itu tidak membuat perbedaan).

^1¶2¶3$
24

Jika inputnya 1,2,3(dalam urutan tertentu), ganti dengan 24.

.+
$*

Ubah setiap nomor menjadi unary.

1

Hitung jumlah 1s, yang menambahkan angka unary dan mengubahnya kembali menjadi desimal.

Haskell , 44 byte

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

Cobalah online!

Permutasi [1,2,3]adalah satu-satunya partisi 6yang produknya 6, kecuali 6itu sendiri. (Ini mengasumsikan input non-negatif, yang tampaknya menjadi kasus untuk semua kasus uji ... Saya sudah bertanya OP tentang ini.)

PL / SQL - 135 123 Bytes

Dengan asumsi saya sebagai input array integer dari berbagai ukuran:

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

Cobalah online!

Perhatikan bahwa objek fungsi yang dibuat dapat digunakan pada waktu kompilasi, sehingga pengujian dilakukan oleh kompiler tanpa harus menjalankan program.

Penjelasan:

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

Bukti bahwa satu-satunya nonnegatif i...yang (-i&...)sama dengan -4 dan (~i*...)sama dengan -24 adalah permutasi dari 1, 2, 3:

Kami pertama-tama mengamati bahwa sejak -0= 0, jika ada i= 0maka (-i&...) = 0, jadi kami menyimpulkan bahwa semua ipositif.

Sekarang, perhatikan bahwa dalam komplemen 2, -isama dengan ~(i - 1), dan ~isetara dengan -(i + 1). Menerapkan aturan De Morgan, kami menemukan bahwa (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), jadi ((i - 1) | ...) = 3; sama,, -1 ** n * ((i + 1) * ...) = -24jadi naneh dan ((i + 1) * ...) = 24.

Faktor prima dari 24 adalah 2 ** 3 * 3, jadi n<= 4. Jika n= 1, kita memiliki i - 1 = 3dan i + 1 = 24, jadi n= 3. Tuliskan iwlog sebagai a <= b <= c, lalu jelaskan a1 sebagai sebaliknya (a + 1)(b + 1)(c + 1)> = 27. Juga c<= 4 sebagai kalau tidak (a - 1)|(b - 1)|(c - 1)> = 4. ctidak bisa 4 karena 5 bukan faktor 24, jadi c<= 3. Kemudian untuk memenuhi (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2 seperti yang disyaratkan.

Sekam , 9 byte

?K24Σ=ḣ3O

Cobalah online!

Penjelasan

?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

Solusi sebelumnya

Memberikan hasil yang salah kepada [2,2], dan mungkin juga input lain, tetapi lebih menarik.

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

Cobalah online!

Pushy , 12 byte

gF3RFx?18;S#

Cobalah online!

Ini bekerja dengan mengurutkan input dan, jika sama dengan [1, 2, 3], menambahkan 18. Kemudian, jumlah dihitung dan dicetak, menghasilkan 24 adalah 18 ditambahkan, dan jawaban normal sebaliknya.

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

?qS3SK24s

Verifikasi semua kasus uji.

Python 2 , 41 39 byte

-1 byte terima kasih kepada caird

-1 berdasarkan inspirasi dari jawaban FlipTack

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

Cobalah online!

Alternatif solusi 39 byte

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

Jelly , 10 9 byte

Ṣ24S⁼?3R¤

Cobalah online!

-1 byte terima kasih kepada Erik

Alternatif (oleh Mr. Xcoder ), juga untuk 9 byte:

3R⁼Ṣ×18+S

Cobalah online!

Bagaimana itu bekerja

Ṣ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 byte

Perbedaan pendekatan dari jawaban Pyth lainnya.

*sQ^4qS3S

Penjelasan:

Sebuah port dari jawaban Python saya

*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

Cobalah online!

PowerShell , 44 byte

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

Cobalah online!

Algoritma serupa dengan jawaban Python dan JavaScript. Mengambil input sebagai array literal $a. Kemudian segera menjumlahkan $abersama, yang membentuk operator kiri +.

Tangan kanan adalah diff(alias untuk Compare-Object) dari 1,2,3dan $a- ini adalah array kosong jika sama, atau array tidak kosong dari item yang berbeda jika tidak sama - tertutup dalam Boolean-bukan. Jadi, jika mereka sama, itu membuat array kosong (nilai falsey) menjadi $true.

Itu kemudian dikalikan dengan 18mana secara implisit dilemparkan $trueke 1dan $falseke 0. Jadi sisi kanan adalah 18jika arraynya sama, dan 0sebaliknya. Itu memberikan hasil yang benar 24jika array input 1,2,3dalam permutasi apa pun, dan penjumlahan dari array input sebaliknya.

Kotlin , 46 44 byte

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

Cobalah online!

Suntingan

• Mr. Xcoder -2 byte