iOS 11 hat einen Fehler , der das Ergebnis von 1 + 2 + 3 zu 24 macht . Dies hängt mit der Animationsgeschwindigkeit zusammen, aber trotzdem:

Die Aufgabe ist es zu machen 1 + 2 + 3 == 24. Aber nur das. So sollten Sie eine Funktion zur Verfügung stellen , die korrekt summiert die meisten Sequenzen kehrt aber 24wenn die Argumente sind 1, 2und 3in beliebiger Reihenfolge.

Beispieleingaben:

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

Die Eingabe kann in einem beliebigen Format erfolgen, solange Ihr Code eine beliebige Anzahl von Argumenten akzeptiert.

• Unterstützung für negative Zahlen ist nicht erforderlich (alle nicht negativen Zahlen müssen funktionieren, einschließlich 0)
• Wir gehen von einer korrekten Eingabe aus

Unterschiede zu einer ähnlichen Frage: "Was bekommen Sie, wenn Sie 6 mit 9 multiplizieren? (42)" :

• In diesem Fall muss Ihre Funktion eine beliebige Anzahl von Argumenten akzeptieren . Die alte Frage gibt genau 2 an.
• In diesem Fall spielt die Reihenfolge keine Rolle, während die alte Frage angibt, dass die Reihenfolge 6 9erforderlich ist und 9 6korrekt ausgewertet werden sollte.

MATL , 11 10 Bytes

St3:X=6*+s

Probieren Sie es online! oder überprüfen Sie alle Testfälle

Erläuterung

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

Os{3LQi4*

Erläuterung:

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.

Probieren Sie es online!

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

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

-12 Bytes dank @ OlivierGrégoire .
-31 Bytes dank @Nevay .

Erläuterung:

Probieren Sie es hier aus.

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

(Ineffiziente) den Nachweis dafür , dass nur [1,2,3](in beliebiger Reihenfolge) werden die möglichen Ergebnisse, wenn pist 0b1110( p==14) und die Summe unter 6 oder niedriger ( s<7): es hier probieren.

p==14( 0b1110) Den Wert true iff die Eingangswerte modulo 32 Abdeckung der Werte 1, 2und 3und enthalten keine anderen Werte ( p|=1<<i) (jeder Wert hat 1+ Zeiten auftreten). Die Summe der übereinstimmenden Eingaben p==14ist größer als 6für alle Eingaben außer 1,2,3( s=a*1+b*2+c*3+u*32mit a>0,b>0,c>0,u>=0).
_@Nevay

Alte 71 Bytes Antwort:

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

Beweis, dass für alle drei gegebenen natürlichen Zahlen ungleich Null nur [1,2,3](in beliebiger Reihenfolge) eine Summe gleich ihrem Produkt ( 1+2+3 == 1*2*3) (mit einer positiven Summe) vorliegt :
Wenn die Summe gleich dem Produkt von Leo Kurlandchik & Andrzej Nowicki ist

(Ineffizienter) Beweis, dass nur [1,2,3](in beliebiger Reihenfolge) und [0,0,0]die möglichen Ergebnisse mit nicht negativen Zahlen und einer Länge von 3: Versuchen Sie es hier.
So s*4wird Wille 6*4 = 24für [1,2,3]und 0*4 = 0für [0,0,0].

Gelee , 8 Bytes

3R⁼Ṣ4*×S

Probieren Sie es online!

MATL , 13 Bytes

stGp=18*Gda*+

Probieren Sie es online!

Es ist zwei Bytes länger als die andere MATL-Antwort, aber es verwendet einen völlig anderen (und IMO interessanteren) Ansatz, so dass ich dachte, dass es sich lohnt, etwas zu posten.

Erläuterung:

Diese Lösung nutzt die Tatsache, dass:

Die Summe und das Produkt eines Arrays mit drei Elementen sind nur dann gleich, wenn das Array eine Permutation von ist 1,2,3.

Dies nimmt die Eingabe, berechnet die Summe sund dupliziert sie t. Anschließend wird geprüft, ob die Summe mit dem Produkt übereinstimmt Gp=. Wir multiplizieren den Booleschen Wert 1/0mit 18 18*und prüfen, ob der Vektor nicht identische Werte enthält da*(multiplizieren Sie erneut mit einem Booleschen Wert any(diff(x)). Dann multiplizieren wir die beiden , indem wir die letzte Zahl zur ursprünglichen Summe addieren.

Eine schrittweise Erklärung:

Angenommen, die Eingabe lautet [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 Bytes

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

Probieren Sie es online!

Verwendet eine alternative Methode zum Hinzufügen von 18, wenn die sortierte Eingabe [1, 2, 3]die andere Python-Antwort um ein Byte schlagen soll .

Haskell , 37 Bytes

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

Probieren Sie es online!

Wir verwenden Pattern Matching, um den Ausnahmefall einzufangen.

In Haskell ist keine Sortierung integriert. Die Gleichheit 2^a+2^b+2^c==14wird nur durch [a,b,c]eine Permutation von [1,2,3]nicht negativen ganzen Zahlen erfüllt . Ein kürzerer a+b+c=a*b*cWert funktioniert fast, ist aber zufrieden [0,0,0], und das Anhängen des Schecks verlängert ,a>0ihn um 1 Byte.

Oktave , 34 Bytes

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

Probieren Sie es online!

oder

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

Probieren Sie es online!

oder

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

Dies ist kürzer als der Ansatz andere Verwendung: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Erläuterung:

Es nimmt die Summe des Vektors und addiert 18, wenn der sortierte Vektor gleich ist 1,2,3. Dies gibt an, 6+18=24ob der Vektor eine Permutation von ist 1,2,3, und wenn nicht, nur die Summe des Vektors.

PHP, 116 Bytes

Dies ist mein erster Versuch, eine Golf-Herausforderung zu meistern, UND es ist PHP, eine Sprache, die anscheinend schlecht fürs Golfen ist, da ich sie hier selten sehe. Also ... ähm, ich habe es versucht?

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

Hinweis: Ich habe den Kommentar nicht in den bytecount aufgenommen.

Ungolfed

Es ist nichts Besonderes.

$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

Wenn Sie dies in PHPFiddle und nicht auf der Konsole testen möchten, können Sie es natürlich durch $ialles ersetzen, was Sie möchten .

Vielen Dank an Olivier Grégoire, der mich auf die zuvor zurückgegebene String-Kombination aufmerksam gemacht hat [0,3,3]und mir dabei geholfen hat, ein paar Zeichen zu sparen, indem er die gespeichert array_sumund zurückgegeben hat, anstatt die Funktion erneut auszuführen .

R, 47 Bytes 34 Bytes 36 Bytes

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

Probieren Sie es online!

Summieren Sie die Eingabe und addieren Sie 18, wenn der Eingabesatz 1: 3 ist.
Vielen Dank an @mlt für das Golfen mit 11 Bytes. Vielen Dank an @ Ayb4btu für die Identifizierung eines Fehlers mit dem überladenen Code

Javascript ES6, 39 Bytes

Danke an @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]));

Vorherige Antwort

Javascript ES6, 66 Bytes

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

Versuch es

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

Schnell, 67 Bytes

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

Könnte es auf 27 Bytes mit Erweiterungen auf [Int] schaffen, aber das wäre Betrug :(

Mathematica, 28 Bytes

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

Probieren Sie es online!

J, 17 Bytes

-6 Bytes dank Frowny Frog

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

Summiere alle Zahlen +/und multipliziere das Ergebnis mit (Pseudocode) 1 + 3*(is123 ? 1 : 0). Das heißt, die Ergebnisse werden unverändert zurückgegeben, es sei denn, die sortierte Liste ist. 1 2 3In diesem Fall multiplizieren wir das Ergebnis mit 4.

Probieren Sie es online!

ursprüngliche Antwort

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

Überprüfen Sie, ob die sortierte Eingabe lautet. 1 2 3Wenn ja, rufen Sie die Konstantenfunktion 24 ( 24"_) auf. Wenn nicht, geben Sie die Summe zurück+/

Probieren Sie es online!

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

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

Probieren Sie es online!

+18 für using System.Linq;

Lua , 116 81 Bytes

-7 Bytes dank Jonathan

Übernimmt Eingaben als Befehlszeilenargumente

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)

Probieren Sie es online!

Erläuterung:

Erstellt ein Array Smit geringer Dichte und fügt den Indizes, die den Eingabewerten entsprechen, Nullen hinzu. Wenn die Parameter 3, 4, 7dünn sind, enthält das Array nur Zahlen an diesen Indizes. Mit diesem Array, bekommen wir es Länge mit dem Betreiber #, der zählt vom Index 1bis zu dem höheren Index, der einen Wert in sich hat, wenn diese Länge genau ist 3, bedeutet dies , dass es Elemente in der Lage 1, 2und 3weicht ist , was wir sind Auf der Suche nach. Die Länge des dünnen Arrays liegt immer zwischen 0und Nwo Nist die Anzahl der Parameter. Wir müssen also nur prüfen, ob die Länge des Parameter-Arrays und des Sparse-Arrays gleich ist 3.

R , 55 45 54 49 57 54 48 Bytes

Dank Ayb4btu konnten viele Bytes und falsche Lösungen eingespart werden.

3 9 Bytes dank Giuseppe gespeichert . Ich lerne immer wieder neue Wege, um diese Tatsache zu missbrauchen F==0.

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

Probieren Sie es online!

Die andere R-Antwort hat am Ende gewonnen.

C (gcc) , 136 131 125 97 91 Bytes

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

Probieren Sie es online!

Netzhaut , 21 Bytes

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

Probieren Sie es online!

Die Eingabe erfolgt durch Zeilenvorschub getrennt, die Testsuite verwendet jedoch aus Bequemlichkeitsgründen die Kommatrennung.

Erläuterung

O`

Ordnen Sie die Zahlen (lexikographisch, eigentlich, aber wir kümmern uns nur um den Fall , dass die Eingänge sind 1, 2, 3in einer bestimmten Reihenfolge, sofern dies keinen Unterschied macht).

^1¶2¶3$
24

Wenn die Eingabe 1,2,3(in einer bestimmten Reihenfolge) ist, ersetzen Sie sie durch 24.

.+
$*

Wandle jede Zahl in eine unäre um.

1

Zählen Sie die Anzahl von 1s, wodurch die unären Zahlen addiert und in Dezimalzahlen umgewandelt werden.

Haskell , 44 Bytes

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

Probieren Sie es online!

Die Permutationen [1,2,3]sind die einzigen Partitionen , 6deren Produkt 6, abgesehen von 6selbst. (Dies setzt voraus, dass die Eingaben nicht negativ sind, was für alle Testfälle der Fall zu sein scheint. Ich habe das OP danach gefragt.)

PL / SQL - 135 123 Bytes

Angenommen, i ist ein Integer-Array-Eingang beliebiger Größe:

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 Bytes

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

Probieren Sie es online!

Beachten Sie, dass das erstellte Funktionsobjekt zur Kompilierungszeit verwendet werden kann, sodass die Tests vom Compiler ausgeführt werden, ohne dass ein Programm ausgeführt werden muss.

Erläuterung:

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

Beweis, dass der einzige Nichtnegativ, i...für den (-i&...)-4 und (~i*...)-24 gleich sind, die Permutationen von 1, 2, 3:

Wir beobachten dies zuerst seit -0= 0, wenn überhaupt i= 0dann (-i&...) = 0, und schließen daraus, dass alle ipositiv sind.

Beachten Sie nun, dass in 2's Komplement, -iäquivalent zu ~(i - 1)und ~iäquivalent zu ist -(i + 1). Wenn wir die Regel von De Morgan anwenden, finden wir, dass (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), also ((i - 1) | ...) = 3; ähnlich, -1 ** n * ((i + 1) * ...) = -24so nist ungerade und ((i + 1) * ...) = 24.

Die Primfaktoren von 24 sind 2 ** 3 * 3, also n<= 4. Wenn n= 1, haben wir i - 1 = 3und i + 1 = 24, also n= 3. Schreiben Sie das iwlog als a <= b <= c, dann klar a= 1 als sonst (a + 1)(b + 1)(c + 1)> = 27. Auch c<= 4 als andernfalls ist (a - 1)|(b - 1)|(c - 1)> = 4. ckann nicht 4 sein, da 5 kein Faktor von 24 ist, also c<= 3. (a - 1)|(b - 1)|(c - 1) = 3Um dann c = 3 zu erfüllen , ist b = 2, wie erforderlich.

Schale , 9 Bytes

?K24Σ=ḣ3O

Probieren Sie es online!

Erläuterung

?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

Vorherige Lösung

Gibt das falsche Ergebnis an [2,2] und wahrscheinlich auch an andere Eingaben, aber es war interessanter.

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

Probieren Sie es online!

Aufdringlich , 12 Bytes

gF3RFx?18;S#

Probieren Sie es online!

Dies funktioniert, indem die Eingabe sortiert und, wenn sie gleich [1, 2, 3]ist, an 18 angehängt wird. Dann wird die Summe berechnet und gedruckt, wobei 24 an 18 angehängt wird und ansonsten die normale Antwort.

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

?qS3SK24s

Überprüfen Sie alle Testfälle.

Python 2 , 41 39 Bytes

-1 Byte dank caird

-1 durch Inspiration von FlipTacks Antwort

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

Probieren Sie es online!

Alternative 39-Byte-Lösung

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

Gelee , 10 9 Bytes

Ṣ24S⁼?3R¤

Probieren Sie es online!

-1 Byte danke an Erik

Alternative (von Mr. Xcoder ), auch für 9 Bytes:

3R⁼Ṣ×18+S

Probieren Sie es online!

Wie es funktioniert

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

Anderer Ansatz als die andere Pyth-Antwort.

*sQ^4qS3S

Erläuterung:

Ein Port aus meiner Python-Antwort

*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

Probieren Sie es online!

PowerShell , 44 Byte

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

Probieren Sie es online!

Ähnlicher Algorithmus wie bei den Python- und JavaScript-Antworten. Übernimmt die Eingabe als Literal-Array $a. Dann summieren sich sofort die Zahlen $a, die der linke Operator des +.

Die rechte Hand ist der diff(Alias ​​für Compare-Object) von 1,2,3und $a- dies ist entweder ein leeres Array, wenn sie gleich sind, oder ein nicht leeres Array der verschiedenen Elemente, wenn sie nicht gleich sind - eingeschlossen in ein Boolesches-Nicht. Wenn sie also gleich sind, wird das leere Array (ein falscher Wert) zu $true.

Das wird dann multipliziert, 18womit implizit $truenach 1und $falsenach geworfen wird 0. Die rechte Seite ist also, 18wenn die Arrays identisch sind, und 0ansonsten. Dies ergibt das korrekte Ergebnis, 24wenn sich das Eingabearray 1,2,3in irgendeiner Permutation befindet, und ansonsten die Summation des Eingabearrays.

Kotlin , 46 44 Bytes

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

Probieren Sie es online!

Bearbeitungen

• Mr. Xcoder -2 Bytes