iOS 11'in 1 + 2 + 3 sonuçlarının 24 olmasını sağlayan bir hata var . Bu, animasyon hızı ile ilgilidir, ama yine de:

Görev yapmaktır 1 + 2 + 3 == 24. Ama sadece bu. Böylece doğru en dizileri ama döner toplayan bir işlevi vermelidir 24argümanlar olduğunda 1, 2ve 3herhangi bir sırada.

Örnek girişler:

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

Giriş, kodunuz herhangi bir sayıda argümanı kabul ettiği sürece herhangi bir biçimde olabilir.

• Negatif sayılar için destek gerekli değildir (0 içeren tüm negatif numaraların çalışması gerekir)
• Doğru girdi kabul ediyoruz

Başka bir benzer sorudan farklılıklar : "6'yı 9 ile çarptığınızda ne elde edersiniz? (42)" :

• Bu durumda, işlevin herhangi bir sayıda argümanı kabul etmesi gerekir . Eski soru tam olarak 2 belirtir.
• Bu durumda sipariş önemli değil, eski soru bu siparişin 6 9gerekli olduğunu ve 9 6doğru bir şekilde değerlendirilmesi gerektiğini belirtirken .

Matl , 11 10 bayt

St3:X=6*+s

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın

açıklama

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

Os{3LQi4*

Açıklama:

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.

Çevrimiçi deneyin!

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

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

@ OlivierGrégoire sayesinde 12 bayt . @Nevay
sayesinde -31 bayt .

Açıklama:

Burada dene.

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

Sadece (verimsiz) geçirmez [1,2,3](herhangi bir sırayla) olası sonuçları olacak zaman polduğu 0b1110( p==14) ve toplamı 6 veya daha düşük (altındadır s<7): Burada deneyin.

p==14( 0b1110Giriş değerleri 32 kapak değerleri modulo IFF) doğru olarak değerlendirilir 1, 2ve 3ve diğer bir değer (içerir p|=1<<i) (her bir değer 1+ kez ortaya vardır). Giriş toplamı maçlar bu p==14daha büyük olacaktır 6dışında herhangi bir giriş için 1,2,3( s=a*1+b*2+c*3+u*32ile a>0,b>0,c>0,u>=0).
_@Nevay

Eski 71 baytlık cevap:

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

Verilen sıfır olmayan doğal sayılardan [1,2,3]herhangi biri için , yalnızca (herhangi bir sıra ile) ürününe ( 1+2+3 == 1*2*3) (pozitif bir toplamla) eşit bir toplamı olacağını kanıtlayın :
Toplam, ürün Leo Kurlandchik & Andrzej Nowicki'ye eşit olduğunda

(Verimsiz) sadece [1,2,3](herhangi bir sıra ile) ve [0,0,0]negatif olmayan sayılar ve 3 uzunluğuyla olası sonuçlar olacağını ispatlar : Burada deneyin.
Yani s*4irade olur 6*4 = 24için [1,2,3], ve 0*4 = 0için [0,0,0].

Jöle , 8 bayt

3R⁼Ṣ4*×S

Çevrimiçi deneyin!

MATL , 13 bayt

stGp=18*Gda*+

Çevrimiçi deneyin!

Diğer MATL cevaplarından iki byte daha uzun, ama tamamen farklı (ve IMO daha ilginç) bir yaklaşım kullanıyor, bu yüzden göndermeye değer olduğunu düşündüm.

Açıklama:

Bu çözüm şu gerçeği kullanır:

Üç elemanlı bir dizinin toplamı ve ürünü, sadece dizi bir permütasyon ise eşit olur 1,2,3.

Bu girdiyi alır, toplamı hesaplar sve kopyalar t. Daha sonra toplamın ürüne eşit olup olmadığını kontrol eder Gp=. Boole'yi 1/018 ile çarpıyoruz 18*ve vektörde aynı olmayan değerlerin olup olmadığını kontrol ediyoruz da*(yine, bir boole ile any(diff(x))çarpın. Sonra, son toplamı eklemek için iki sayıyı çarpın.

Adım adım açıklama:

Girdiyi varsayalım [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 bayt

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

Çevrimiçi deneyin!

Sıralanan giriş, diğer Python cevabını bir byte [1, 2, 3]ile yenmek için 18 alternatif bir yöntem kullanır .

Haskell , 37 bayt

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

Çevrimiçi deneyin!

İstisnai durumu yakalamak için kalıp eşleme kullanıyoruz.

Haskell'de yerleşik sıralama yoktur. Eşitlik 2^a+2^b+2^c==14yalnızca negatif olmayan tamsayılar arasındaki [a,b,c]bir permütasyonla karşılanır [1,2,3]. Daha kısa bir süre a+b+c=a*b*cneredeyse işe yarar, ancak memnun kalır [0,0,0]ve kontrolün eklenmesi ,a>0onu 1 bayt daha uzun yapar.

Oktav , 34 bayt

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

Çevrimiçi deneyin!

veya

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

Çevrimiçi deneyin!

veya

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

Bu yaklaşım, diğerleri kullanım daha kısadır: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Açıklama:

Vektörün toplamını alır ve sıralanan vektör eşitse 18 ekler 1,2,3. Bu 6+18=24, vektörün bir permütasyonu olup olmadığını ve eğer değilse, 1,2,3sadece vektörün toplamını verir.

PHP, 116 bayt

Bu benim ilk defa bir golf mücadelesinde girişimdi ve AND, burada nadiren gördüğümden beri golf oynamak için berbat görünen bir dil.

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

Not: Yorumu bayt sayımına dahil etmedim.

Ungolfed

Özel bir şey değil, 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

Bunu PHPFiddle'da ve konsolda değil test etmek istiyorsanız, kesinlikle $iistediğiniz bir şeyle değiştirebilirsiniz .

Beni daha [0,3,3]önce 24 döndüren ve aynı zamanda birkaç karakterden tasarruf etmeme yardımcı olan array_sumve işlevi tekrar çalıştırmak yerine geri getirerek geri döndüren tel kombinasyonundan haberdar olan Olivier Grégoire sayesinde .

R, 47 bayt 34 bayt 36 bayt

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

Çevrimiçi deneyin!

Girişi toplayın ve giriş 1: 3 ise 18 ekleyin.
11 byte kapalı golf için @mlt teşekkürler. Aşırı kodlanmış kodla ilgili bir hatayı tanımlayan @ Ayb4btu'ya teşekkürler

Javascript ES6, 39 bayt

@Herman Lauenstein sayesinde

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

Önceki cevap

Javascript ES6, 66 bayt

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

Dene

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 Bayt

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

[Int] uzantısına sahip 27 byte'a ulaşabilir, ancak bu aldatma olur :(

Mathematica, 28 bayt

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

Çevrimiçi deneyin!

J, 17 bayt

Frowny Frog sayesinde -6 bayt

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

Tüm sayıları +/toplayın ve sonucu (pseudocode) ile çarpın 1 + 3*(is123 ? 1 : 0). Diğer bir deyişle, sıralanan liste olmadığı sürece sonuçları değiştiririz 1 2 3; bu durumda sonucu 4 ile çarparız.

Çevrimiçi deneyin!

orijinal cevap

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

Sıralanan giriş olup olmadığını kontrol edin 1 2 3- evet ise, sabit fonksiyon 24 ( 24"_); değilse, toplamı döndür+/

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

İçin +18 using System.Linq;

Lua , 116 81 bayt

Jonathan sayesinde -7 bayt

Komut satırı argümanları olarak girdi alır

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)

Çevrimiçi deneyin!

Açıklama:

Seyrek bir dizi oluşturarak Sve giriş değerlerine karşılık gelen endekslere sıfır ekleyerek çalışır. Parametreler 3, 4, 7seyrekse, sadece bu endekslerde sayılar olacaktır. O dizide ile, operatör ile 's uzunluğu almak #indeksinden sayar 1bu uzunluk tam olarak ise, içinde bir değere sahip yüksek endekse kadar 3, bu pozisyonda unsurların bulunduğunu demektir 1, 2ve 3wich bizler ne aramak. Seyrek dizinin uzunluğu daima parametre sayısı 0ile Nnerede arasında olacaktır N. Bu yüzden sadece hem parametre dizisinin hem de seyrek dizinin uzunluğunun olup olmadığını kontrol etmeliyiz 3.

R , 55 45 54 49 57 54 48 bayt

Ayb4btu sayesinde birçok bayt ve yanlış çözüm kurtarıldı.

Giuseppe sayesinde 3 9 bayt kaydedildi . Bu gerçeği kötüye kullanmanın yeni yollarını öğrenmeye devam ediyorum F==0.

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

Çevrimiçi deneyin!

Diğer R cevabı sonunda kazandı.

C (gcc) , 136 131 125 97 91 bayt

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

Çevrimiçi deneyin!

Retina , 21 bayt

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

Çevrimiçi deneyin!

Giriş satır besleme ile ayrılmıştır, ancak test paketi rahatlık için virgülle ayırma kullanır.

açıklama

O`

Sıralama sayılar (sözlük sırasında, aslında, ama biz sadece durumda önem girdiler olduklarını 1, 2, 3bir fark yapmaz bazı sırayla, içinde).

^1¶2¶3$
24

Giriş 1,2,3(bir sırada) ise, 24 ile değiştirin.

.+
$*

Her sayıyı birliğe dönüştürün.

1

1Tekli sayıları ekleyen ve tekrar ondalık sayıya dönüştüren s sayısını sayın .

Haskell , 44 bayt

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

Çevrimiçi deneyin!

Permütasyon [1,2,3]sadece bölümleri vardır 6kimin ürünüdür 6engelleme, 6kendisini. (Bu, girdilerin negatif olmadığını varsayar, bu da tüm test durumları için geçerli gibi görünüyor… OP'den bunu sordum.)

PL / SQL - 135 123 Bayt

İ'nin herhangi bir boyutta bir tamsayı dizi girişi olduğunu varsayalım:

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 bayt

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

Çevrimiçi deneyin!

Oluşturulan işlev nesnesinin derleme zamanında kullanılabildiğini unutmayın; bu nedenle testler bir program çalıştırmak zorunda kalmadan derleyici tarafından gerçekleştirilir.

Açıklama:

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

-4'e eşit ve -24'e eşit i...olan yalnızca olumsuz olmayanların aşağıdakilerin izinleri olduğunun kanıtı :(-i&...)(~i*...)1, 2, 3

Biz ilk beri bu gözlemlemek -0= 0Varsa i= 0o (-i&...) = 0biz sonuçlandırmak, böylece tüm bu iolumlu.

Şimdi, 2'nin tamamlayıcısında, -ieşdeğer ~(i - 1)ve ~ieşdeğer olduğuna dikkat edin -(i + 1). De Morgan'ın kuralını uygulayarak, bunu (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), yani ((i - 1) | ...) = 3; benzer şekilde, -1 ** n * ((i + 1) * ...) = -24çok ngarip ve ((i + 1) * ...) = 24.

24 asal faktörlerdir 2 ** 3 * 3, yani n<= 4. Eğer n= 1, elimizdeki i - 1 = 3ve i + 1 = 24böylece n= 3. Yaz iolarak wlog a <= b <= cardından açıkça aaksi takdirde = 1 (a + 1)(b + 1)(c + 1)> Ayrıca = 27'e c<= 4 olarak Aksi halde (a - 1)|(b - 1)|(c - 1)> = 4. 4 colamaz çünkü 5, 24 faktörü değildir, yani c<= 3. (a - 1)|(b - 1)|(c - 1) = 3Gerektiğinde c = 3, b = 2 değerini karşılamak için.

Kabuğu , 9 bayt

?K24Σ=ḣ3O

Çevrimiçi deneyin!

açıklama

?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

Önceki çözüm

[2,2] 'ye yanlış sonuç verir ve muhtemelen başka girdilere de sahiptir, ancak daha ilginçti.

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

Çevrimiçi deneyin!

Pushy , 12 bayt

gF3RFx?18;S#

Çevrimiçi deneyin!

Bu girdiyi sıralayarak çalışır ve eğer eşitse [1, 2, 3]18 eklenir. Sonra toplam hesaplanır ve yazdırılır, sonuç 24'e 18 eklenir ve normal cevap aksi takdirde olur.

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

?qS3SK24s

Tüm test durumlarını doğrulayın.

Python 2 , 41 39 bayt

Caird sayesinde -1 bayt

-1 FlipTack'in yanıtından ilham alarak

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

Çevrimiçi deneyin!

Alternatif 39 baytlık çözüm

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

Jöle , 10 9 bayt

Ṣ24S⁼?3R¤

Çevrimiçi deneyin!

Erik sayesinde -1 bayt

Alternatif ( Bay Xcoder tarafından ), ayrıca 9 bayt için:

3R⁼Ṣ×18+S

Çevrimiçi deneyin!

Nasıl çalışır

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

Diğer Pyth cevabından farklı bir yaklaşım.

*sQ^4qS3S

Açıklama:

Python cevabımdan bir port

*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

Çevrimiçi deneyin!

PowerShell , 44 bayt

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

Çevrimiçi deneyin!

Python ve JavaScript cevaplarına benzer bir algoritma. Hazır bilgi dizisi olarak girdi alır $a. Sonra hemen $abirlikte toplar, bu da sol el operatörünü oluşturur +.

Sağ taraf diff(ve alias için Compare-Object) 1,2,3ve $a- eşittirlerse boş bir dizidir veya eşit değilse boş bir dizidir - Boolean-not değil. Yani, eğer eşitlerse, bu boş diziyi (bir falsey değeri) içine alır $true.

Yani o çarpılır 18örtülü atmalarını hangi $trueetmek 1ve $falsekarşı 0. Dolayısıyla, sağ taraf 18, diziler aynıysa ve 0aksi takdirde olacaktır. Bu 24, giriş dizisinin 1,2,3herhangi bir permütasyonda olup olmadığının ve aksi takdirde giriş dizisinin toplamının doğru sonucunu verir .

Kotlin , 46 44 bayt

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

Çevrimiçi deneyin!

Düzenlemeler

• Bay Xcoder -2 bayt