iOS 11 ma błąd, który powoduje, że wynikiem 1 + 2 + 3 jest 24 . Jest to związane z prędkością animacji, ale w każdym razie:

Zadanie polega na wykonaniu 1 + 2 + 3 == 24. Ale tylko to. Powinieneś więc zapewnić funkcję, która poprawnie sumuje większość sekwencji, ale zwraca, 24gdy argumenty są 1, 2i 3w dowolnej kolejności.

Przykładowe dane wejściowe:

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

Dane wejściowe mogą mieć dowolny format, o ile kod akceptuje dowolną liczbę argumentów.

• Obsługa liczb ujemnych nie jest wymagana (wszystkie nieujemne liczby muszą działać, w tym 0)
• Zakładamy prawidłowe dane wejściowe

Różnice w stosunku do innego podobnego pytania: „Co otrzymujesz, mnożąc liczbę 6 przez 9? (42)” :

• W takim przypadku twoja funkcja musi zaakceptować dowolną liczbę argumentów. Stare pytanie określa dokładnie 2.
• W tym przypadku kolejność nie ma znaczenia, podczas gdy stare pytanie określało, że kolejność 6 9jest wymagana i 9 6powinna być poprawnie oceniona.

MATL , 11 10 bajtów

St3:X=6*+s

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe

Wyjaśnienie

        % 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 bajtów

Os{3LQi4*

Wyjaśnienie:

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.

Wypróbuj online!

Java 8, 109 106 101 90 75 74 71 66 bajtów

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

-12 bajtów dzięki @ OlivierGrégoire .
-31 bajtów dzięki @Nevay .

Wyjaśnienie:

Wypróbuj tutaj.

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

(Niewystarczający) dowód, że tylko [1,2,3](w dowolnej kolejności) możliwe wyniki będą, gdy pjest 0b1110( p==14), a suma jest mniejsza niż 6 lub niższa ( s<7): Wypróbuj tutaj.

p==14( 0b1110) Zwraca wartość prawda IFF wartości wejściowe modulo 32 pokrywy wartości 1, 2a 3i nie zawierają żadnych innych wartości ( p|=1<<i) (każda wartość musi nastąpić 1+ razy). Suma dopasowanych danych wejściowych p==14będzie większa niż 6dla danych wejściowych z wyjątkiem 1,2,3( s=a*1+b*2+c*3+u*32z a>0,b>0,c>0,u>=0).
_@Nevay

Stara 71 bajtów odpowiedź:

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

Dowód, że dla dowolnych trzech podanych niezerowych liczb naturalnych tylko [1,2,3](w dowolnej kolejności) będzie miała sumę równą jej iloczynowi ( 1+2+3 == 1*2*3) (z sumą dodatnią):
Gdy suma jest równa iloczynowi Leo Kurlandchika i Andrzeja Nowickiego

(Nieefektywny) dowód, że tylko [1,2,3](w dowolnej kolejności) i [0,0,0]będą możliwe wyniki z liczbami nieujemnymi i długością 3: Wypróbuj tutaj.
Tak s*4stanie się 6*4 = 24dla [1,2,3]i 0*4 = 0dla [0,0,0].

Galaretka , 8 bajtów

3R⁼Ṣ4*×S

Wypróbuj online!

MATL , 13 bajtów

stGp=18*Gda*+

Wypróbuj online!

To dwa bajty dłuższe niż druga odpowiedź MATL, ale używa zupełnie innego (i bardziej interesującego IMO) podejścia, więc pomyślałem, że warto to opublikować.

Wyjaśnienie:

To rozwiązanie wykorzystuje fakt, że:

Suma i iloczyn tablicy z trzema elementami są równe tylko wtedy, gdy tablica jest permutacją 1,2,3.

To pobiera dane wejściowe, oblicza sumę si powiela ją t. Następnie sprawdza, czy suma jest równa iloczynowi Gp=. Mnożymy wartość logiczną 1/0przez 18 18*i sprawdzamy, czy w wektorze nie ma identycznych wartości da*(ponownie, mnożymy przez wartość logiczną any(diff(x)). Następnie mnożymy te dwa, dodając ostatnią liczbę do oryginalnej sumy.

Wyjaśnienie krok po kroku:

Załóżmy, że dane wejściowe to [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 bajtów

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

Wypróbuj online!

Używa alternatywnej metody dodawania 18, jeśli posortowane dane wejściowe [1, 2, 3]mają pokonać bajt drugiej odpowiedzi w języku Python .

Haskell , 37 bajtów

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

Wypróbuj online!

Używamy dopasowywania wzorów, aby uchwycić wyjątkowy przypadek.

Haskell nie ma wbudowanego sortowania. Równość 2^a+2^b+2^c==14jest spełniona tylko przez [a,b,c]permutację [1,2,3]między liczbami całkowitymi nieujemnymi. Krótszy a+b+c=a*b*cprawie działa, ale jest spełniony [0,0,0], a dołączenie czeku ,a>0powoduje, że jest on o 1 bajt dłuższy.

Oktawa , 34 bajty

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

Wypróbuj online!

lub

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

Wypróbuj online!

lub

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

Jest krótsza niż podejście inni korzystają: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Wyjaśnienie:

Pobiera sumę wektora i dodaje 18, jeśli posortowany wektor jest równy 1,2,3. To da, 6+18=24jeśli wektor jest permutacją 1,2,3, a tylko suma wektora, jeśli nie.

PHP, 116 bajtów

To jest moja pierwsza próba gry w golfa, ORAZ to PHP, język, który najwyraźniej jest do bani w golfa, ponieważ rzadko go tu widzę, więc ... uhm, próbowałem?

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

Uwaga: Nie dodałem komentarza do bajtu.

Nie golfił

To nic specjalnego 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

Jeśli chcesz to przetestować w PHPFiddle, a nie na konsoli, możesz oczywiście zastąpić $iwszystko, co chcesz.

Podziękowania dla Oliviera Grégoire'a, który uświadomił mi kombinację ciągów, [0,3,3]która zwróciła wcześniej 24, a także pomógł mi zaoszczędzić kilka znaków, przechowując array_sumi zwracając to zamiast ponownie uruchamiać funkcję.

R, 47 bajtów 34 bajty 36 bajtów

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

Wypróbuj online!

Zsumuj dane wejściowe i dodaj 18, jeśli zestaw danych wejściowych to 1: 3.
Dzięki @mlt za grę w golfa z 11 bajtów. Dzięki @ Ayb4btu za zidentyfikowanie błędu w przerobionym kodzie

JavaScript ES6, 39 bajtów

Dzięki @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]));

Poprzednia odpowiedź

JavaScript ES6, 66 bajtów

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

Spróbuj

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

Szybki, 67 bajtów

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

Mógłby dojść do 27 bajtów z rozszerzeniami na [Int], ale byłoby to oszustwo :(

Mathematica, 28 bajtów

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

Wypróbuj online!

J, 17 bajtów

-6 bajtów dzięki Frowny Frog

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

Zsumuj wszystkie liczby +/i pomnóż wynik przez (pseudokod) 1 + 3*(is123 ? 1 : 0). Oznacza to, że zwracaj wyniki bez zmian, chyba że posortowana lista jest 1 2 3w takim przypadku mnożymy wynik przez 4.

Wypróbuj online!

oryginalna odpowiedź

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

Sprawdź, czy posortowane dane wejściowe są 1 2 3- jeśli tak, wywołaj funkcję stałą 24 ( 24"_); jeśli nie, zwróć sumę+/

Wypróbuj online!

C # (.NET Core) , 57 + 18 = 75 bajtów

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

Wypróbuj online!

+18 dla using System.Linq;

Lua , 116 81 bajtów

-7 bajtów dzięki Jonathanowi

Pobiera dane wejściowe jako argumenty wiersza poleceń

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)

Wypróbuj online!

Wyjaśnienie:

Działa poprzez tworzenie rzadkiej tablicy Si dodawanie zer do indeksów odpowiadających wartościom wejściowym. Jeśli parametrami są 3, 4, 7rzadkie tablice, będą miały tylko liczby przy tych indeksach. Dzięki tej tablicy otrzymujemy jej długość wraz z operatorem, #który zlicza od indeksu 1do wyższego indeksu, który ma w sobie wartość, jeśli ta długość jest dokładnie 3, oznacza to, że były pozycje w pozycji 1, 2i 3tym właśnie jesteśmy szukam. Długość rzadkiej tablicy będzie zawsze pomiędzy 0i Ngdzie Njest liczba parametrów. Musimy więc tylko sprawdzić, czy długość zarówno tablicy parametrów, jak i tablicy rzadkiej wynosi 3.

R , 55 45 54 49 57 54 48 bajtów

Zaoszczędzono wiele bajtów i niepoprawne rozwiązania dzięki Ayb4btu.

Zaoszczędzono 3 9 bajtów dzięki Giuseppe. Uczę się nowych sposobów na nadużywanie tego faktu F==0.

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

Wypróbuj online!

Druga odpowiedź R wygrała w końcu.

C (gcc) , 136 131 125 97 91 bajtów

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

Wypróbuj online!

Retina , 21 bajtów

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

Wypróbuj online!

Dane wejściowe są oddzielone od linii, ale dla wygody zestaw testów używa separacji przecinków.

Wyjaśnienie

O`

Sortowanie numerów (leksykograficznie, faktycznie, ale tylko dbają o sprawy, że wejścia są 1, 2, 3w jakimś celu, a jeżeli nie ma znaczenia).

^1¶2¶3$
24

Jeśli dane wejściowe są 1,2,3(w określonej kolejności), zamień je na 24.

.+
$*

Konwertuj każdą liczbę na jednoargumentową.

1

Policz liczbę 1s, która dodaje liczby jednostkowe i konwertuje je z powrotem na dziesiętne.

Haskell , 44 bajty

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

Wypróbuj online!

Permutacje [1,2,3]są jedynymi partycjami, 6których produktem jest 6, z wyjątkiem 6samego siebie. (Zakłada się, że dane wejściowe są nieujemne, co wydaje się dotyczyć wszystkich przypadków testowych… Zapytałem o to OP).

PL / SQL - 135 123 bajtów

Zakładając, że jako dane wejściowe tablicy liczb całkowitych o dowolnym rozmiarze:

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 bajty

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

Wypróbuj online!

Zauważ, że utworzony obiekt funkcji jest użyteczny w czasie kompilacji, więc testy są wykonywane przez kompilator bez konieczności uruchamiania programu.

Wyjaśnienie:

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

Dowodem na to, że jedynymi nieujemnymi, i...dla których (-i&...)jest równa -4 i (~i*...)jest równa -24, są permutacje 1, 2, 3:

Najpierw obserwujemy, że skoro -0= 0, jeśli w ogóle i= 0wtedy (-i&...) = 0, to dochodzimy do wniosku, że wszystkie isą dodatnie.

Teraz zauważ, że w uzupełnieniu 2 -ijest równoważne ~(i - 1)i ~irównoważne -(i + 1). Stosując regułę De Morgana, stwierdzamy, że (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), więc ((i - 1) | ...) = 3; Podobnie -1 ** n * ((i + 1) * ...) = -24, więc njest nieparzysta i ((i + 1) * ...) = 24.

Pierwszymi czynnikami 24 są 2 ** 3 * 3, więc n<= 4. Jeśli n= 1, mamy i - 1 = 3i i + 1 = 24, więc n= 3. Napisz ilog jako a <= b <= c, a następnie wyraźnie a= 1 jak inaczej (a + 1)(b + 1)(c + 1)> = 27. Również c<= 4 jako w przeciwnym razie (a - 1)|(b - 1)|(c - 1)> = 4. cnie może być 4, ponieważ 5 nie jest współczynnikiem 24, więc c<= 3. Następnie, aby spełnić (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2 zgodnie z wymaganiami.

Łuska , 9 bajtów

?K24Σ=ḣ3O

Wypróbuj online!

Wyjaśnienie

?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

Poprzednie rozwiązanie

Daje zły wynik [2,2] i prawdopodobnie również inne dane wejściowe, ale było to bardziej interesujące.

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

Wypróbuj online!

Pushy , 12 bajtów

gF3RFx?18;S#

Wypróbuj online!

Działa to poprzez sortowanie danych wejściowych i, jeśli jest ono równe [1, 2, 3], dopisywanie 18. Następnie suma jest obliczana i drukowana, uzyskując 24 to 18, a normalna odpowiedź w przeciwnym razie.

         \ 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 bajtów

?qS3SK24s

Sprawdź wszystkie przypadki testowe.

Python 2 , 41 39 bajtów

-1 bajt dzięki Cairnowi

-1 według inspiracji z odpowiedzi FlipTack

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

Wypróbuj online!

Alternatywne rozwiązanie 39 bajtów

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

Galaretka , 10 9 bajtów

Ṣ24S⁼?3R¤

Wypróbuj online!

-1 bajt dzięki Erikowi

Alternatywa (autorstwa pana Xcodera ), również dla 9 bajtów:

3R⁼Ṣ×18+S

Wypróbuj online!

Jak to działa

Ṣ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 bajtów

Inne podejście od drugiej odpowiedzi Pyth.

*sQ^4qS3S

Wyjaśnienie:

Port z mojej odpowiedzi w Pythonie

*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

Wypróbuj online!

PowerShell , 44 bajty

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

Wypróbuj online!

Algorytm podobny do odpowiedzi na Python i JavaScript. Pobiera dane wejściowe jako tablicę literalną $a. Następnie natychmiast sumuje się $arazem, co tworzy lewy operator operatora +.

Prawa ręka to diff(pseudonim Compare-Object) 1,2,3i $a- jest to pusta tablica, jeśli są równe, lub niepusta tablica różnych elementów, jeśli nie są równe - ujęta w wartość logiczną. Jeśli więc są równe, to tworzy pustą tablicę (wartość falsey) $true.

To jest następnie mnożone przez 18niejawnie przesyłane $truedo 1i $falsedo 0. Więc prawa strona będzie, 18jeśli tablice są takie same i 0inaczej. To daje poprawny wynik, 24jeśli tablica wejściowa jest 1,2,3w dowolnej permutacji, a sumowanie tablicy wejściowej w przeciwnym razie.

Kotlin , 46 44 bajtów

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

Wypróbuj online!

Edycje

• Pan Xcoder -2 bajty