iOS 11 ha un bug che rende il risultato di 1 + 2 + 3 a 24 . Questo è legato alla velocità dell'animazione, ma comunque:

Il compito è fare 1 + 2 + 3 == 24. Ma solo quello. Quindi, è necessario fornire una funzione che riassume correttamente la maggior parte delle sequenze, ma restituisce 24quando gli argomenti sono 1, 2e 3in qualsiasi ordine.

Input di esempio:

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

L'input può essere in qualsiasi formato purché il codice accetti un numero qualsiasi di argomenti.

• Non è necessario il supporto per i numeri negativi (per funzionare sono necessari tutti i numeri non negativi, incluso 0)
• Assumiamo un input corretto

Differenze da un'altra domanda simile: "Cosa ottieni quando moltiplichi 6 per 9? (42)" :

• In questo caso la tua funzione è tenuta ad accettare un numero qualsiasi di argomenti. La vecchia domanda specifica esattamente 2.
• In questo caso l'ordine non ha importanza, mentre la vecchia domanda specificava che l'ordine 6 9è necessario e 9 6deve essere valutato correttamente.

MATL , 11 10 byte

St3:X=6*+s

Provalo online! o verifica tutti i casi di test

Spiegazione

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

Spiegazione:

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.

Provalo 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 grazie a @ OlivierGrégoire .
-31 byte grazie a @Nevay .

Spiegazione:

Provalo qui.

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

(Inefficiente) prova che solo [1,2,3](in qualsiasi ordine) saranno i possibili risultati quando pè 0b1110( p==14) e la somma è inferiore a 6 o inferiore ( s<7): provalo qui.

p==14( 0b1110) Valuta true se e solo se i valori di ingresso modulo 32 di copertura dei valori 1, 2e 3e non contengono altri valori ( p|=1<<i) (ciascun valore deve avvenire 1+ volte). La somma dell'input corrispondente p==14sarà maggiore di 6per qualsiasi input tranne 1,2,3( s=a*1+b*2+c*3+u*32con a>0,b>0,c>0,u>=0).
_@Nevay

Risposta di vecchi 71 byte :

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

Prova che per ogni tre numeri naturali diversi da zero, solo [1,2,3](in qualsiasi ordine) avrà una somma pari al suo prodotto ( 1+2+3 == 1*2*3) (con una somma positiva):
quando la somma è uguale al prodotto di Leo Kurlandchik & Andrzej Nowicki

(Inefficiente) prova che solo [1,2,3](in qualsiasi ordine) e [0,0,0]saranno i possibili risultati con numeri non negativi e una lunghezza di 3: provalo qui.
Così s*4diventerà 6*4 = 24per [1,2,3]e 0*4 = 0per [0,0,0].

Gelatina , 8 byte

3R⁼Ṣ4*×S

Provalo online!

MATL , 13 byte

stGp=18*Gda*+

Provalo online!

È due byte più lungo dell'altra risposta MATL, ma utilizza un approccio completamente diverso (e IMO più interessante), quindi ho pensato che valesse la pena pubblicare.

Spiegazione:

Questa soluzione utilizza il fatto che:

La somma e il prodotto di un array con tre elementi sono uguali solo se l'array è una permutazione di 1,2,3.

Questo prende l'input, calcola la somma se la duplica t. Quindi controlla se la somma è uguale al prodotto Gp=. Moltiplichiamo il valore booleano 1/0per 18 18*e controlliamo se ci sono valori non identici nel vettore da*(di nuovo, moltiplica per un valore booleano any(diff(x)). Quindi moltiplichiamo i due e aggiungiamo l'ultimo numero alla somma originale.

Una spiegazione dettagliata:

Supponiamo che l'input sia [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])

Provalo online!

Utilizza un metodo alternativo per aggiungere 18 se l'ingresso ordinato deve [1, 2, 3]battere l' altra risposta Python di un byte.

Haskell , 37 byte

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

Provalo online!

Usiamo il pattern matching per catturare il caso eccezionale.

Haskell non ha l'ordinamento incorporato. L'uguaglianza 2^a+2^b+2^c==14è soddisfatta solo da [a,b,c]una permutazione [1,2,3]tra numeri interi non negativi. Un corto a+b+c=a*b*cfunziona quasi, ma è soddisfatto [0,0,0]e accodando il controllo ,a>0lo allunga di 1 byte.

Ottava , 34 byte

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

Provalo online!

o

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

Provalo online!

o

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

Questo è più corta delle altre approccio uso: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Spiegazione:

Prende la somma del vettore e aggiunge 18 se il vettore ordinato è uguale a 1,2,3. Questo darà 6+18=24se il vettore è una permutazione di 1,2,3, e solo la somma del vettore in caso contrario.

PHP, 116 byte

Questo è il mio primo tentativo in una sfida di golf, ed è PHP, un linguaggio che apparentemente fa schifo al golf poiché lo vedo raramente qui, quindi ... uhm, ci ho provato?

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

Nota: non ho incluso il commento nel bytecount.

Ungolfed

Non è niente di speciale:

$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

Se vuoi testarlo in PHPFiddle e non su console, puoi ovviamente sostituirlo $icon qualsiasi cosa tu voglia.

Grazie a Olivier Grégoire che mi ha fatto conoscere la combinazione di stringhe [0,3,3]che era tornata prima 24 e mi ha anche aiutato a salvare alcuni caratteri memorizzando array_sume restituendo quello invece di eseguire nuovamente la funzione.

R, 47 byte 34 byte 36 byte

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

Provalo online!

Sommare l'input e aggiungere 18 se il set di input è 1: 3.
Grazie a @mlt per giocare a golf con 11 byte. Grazie a @ Ayb4btu per l'identificazione di un errore con il codice overgolf

Javascript ES6, 39 byte

Grazie a @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]));

Risposta precedente

Javascript ES6, 66 byte

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

Provalo

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

Rapido, 67 byte

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

Potrebbe arrivare a 27 byte con estensioni su [Int], ma sarebbe barare :(

Mathematica, 28 byte

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

Provalo online!

J, 17 byte

-6 byte grazie a Frowny Frog

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

Somma tutti i numeri +/e moltiplica il risultato per (pseudocodice) 1 + 3*(is123 ? 1 : 0). Cioè, restituisce i risultati invariati a meno che l'elenco ordinato non sia, 1 2 3nel qual caso moltiplichiamo il risultato per 4.

Provalo online!

risposta originale

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

Controlla se l'ingresso ordinato è 1 2 3- se sì, invoca la funzione costante 24 ( 24"_); in caso contrario, restituire la somma+/

Provalo online!

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

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

Provalo online!

+18 per using System.Linq;

Lua , 116 81 byte

-7 byte grazie a Jonathan

Accetta input come argomenti della riga di comando

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)

Provalo online!

Spiegazione:

Funziona creando una matrice sparsa Se aggiungendo zero negli indici corrispondenti ai valori di input. Se i parametri sono 3, 4, 7la matrice sparsa avrà solo numeri in quegli indici. Con tale matrice, otteniamo la sua lunghezza con l'operatore #che conta dall'indice 1fino all'indice superiore che ha un valore in esso, se questa lunghezza è esattamente 3, significa che ci sono stati gli elementi in posizione 1, 2e 3goduto è ciò che siamo cercando. La lunghezza della matrice sparsa sarà sempre tra 0e Ndove Nè il numero di parametri. Quindi non ci resta che verificare se la lunghezza sia dell'array di parametri sia dell'array sparse 3.

R , 55 45 54 49 57 54 48 byte

Salvataggio di molti byte e soluzioni errate grazie ad Ayb4btu.

Salvato 3 9 byte grazie a Giuseppe. Continuo a imparare nuovi modi per abusare del fatto F==0.

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

Provalo online!

L'altra risposta R ha vinto alla fine.

C (gcc) , 136 131 125 97 97 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);}

Provalo online!

Retina , 21 byte

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

Provalo online!

L'input è separato dalla linea di alimentazione, ma la suite di test utilizza la separazione virgola per comodità.

Spiegazione

O`

Ordina i numeri (lessicografico, in realtà, ma si preoccupano solo il caso che gli ingressi sono 1, 2, 3in un certo ordine, in cui questo non fa la differenza).

^1¶2¶3$
24

Se l'ingresso è 1,2,3(in un certo ordine), sostituirlo con 24.

.+
$*

Converti ogni numero in unario.

1

Contare il numero di 1s, che aggiunge i numeri unari e li converte in decimali.

Haskell , 44 byte

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

Provalo online!

Le permutazioni di [1,2,3]sono le uniche partizioni del 6cui prodotto è 6, salvo 6se stesso. (Ciò presuppone che gli input non siano negativi, il che sembra essere il caso di tutti i casi di test ... ho chiesto all'OP di questo.)

PL / SQL - 135 123 byte

Supponendo i come input di array interi di qualsiasi dimensione:

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

Provalo online!

Si noti che l'oggetto funzione creato è utilizzabile al momento della compilazione, quindi i test vengono eseguiti dal compilatore senza dover eseguire un programma.

Spiegazione:

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

Prova che l'unico non negativo i...per il quale è (-i&...)uguale a -4 e (~i*...)uguale a -24 sono le permutazioni di 1, 2, 3:

Prima osserviamo che da -0= 0, se presente i= 0allora (-i&...) = 0, quindi concludiamo che tutti isono positivi.

Ora, nota che nel complemento di 2, -iè equivalente a ~(i - 1)ed ~iè equivalente a -(i + 1). Applicando la regola di De Morgan, troviamo che (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), quindi ((i - 1) | ...) = 3; allo stesso -1 ** n * ((i + 1) * ...) = -24modo, così nè strano e ((i + 1) * ...) = 24.

I fattori primi di 24 sono 2 ** 3 * 3, quindi n<= 4. Se n= 1, abbiamo i - 1 = 3e i + 1 = 24, quindi n= 3. Scrivi il iwlog come a <= b <= c, quindi chiaramente a= 1 come altrimenti (a + 1)(b + 1)(c + 1)> = 27. Anche c<= 4 come altrimenti (a - 1)|(b - 1)|(c - 1)> = 4. cnon può essere 4 poiché 5 non è un fattore 24, quindi c<= 3. Quindi soddisfare (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2 come richiesto.

Buccia , 9 byte

?K24Σ=ḣ3O

Provalo online!

Spiegazione

?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

Soluzione precedente

Fornisce il risultato sbagliato a [2,2], e probabilmente anche altri input, ma è stato più interessante.

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

Provalo online!

Pushy , 12 byte

gF3RFx?18;S#

Provalo online!

Funziona ordinando l'input e, se è uguale [1, 2, 3], aggiungendo 18. Quindi, la somma viene calcolata e stampata, dando 24 è 18 è stato aggiunto e la risposta normale altrimenti.

         \ 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

Verifica tutti i casi di test.

Python 2 , 41 39 byte

-1 byte grazie a caird

-1 per ispirazione dalla risposta di FlipTack

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

Provalo online!

Soluzione alternativa a 39 byte

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

Gelatina , 10 9 byte

Ṣ24S⁼?3R¤

Provalo online!

-1 byte grazie a Erik

Alternativa (di Mr. Xcoder ), anche per 9 byte:

3R⁼Ṣ×18+S

Provalo online!

Come funziona

Ṣ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

Approccio diverso dall'altra risposta Pyth.

*sQ^4qS3S

Spiegazione:

Una porta dalla mia risposta 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

Provalo online!

PowerShell , 44 byte

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

Provalo online!

Algoritmo simile alle risposte Python e JavaScript. Accetta input come un array letterale $a. Quindi si somma immediatamente $ainsieme, che costituisce l'operatore sinistro del +.

La mano destra è diff(alias per Compare-Object) di 1,2,3e $a- questa è una matrice vuota se sono uguali, o una matrice non vuota dei diversi elementi se non sono uguali - racchiusa in un non booleano. Quindi, se sono uguali, ciò rende l'array vuoto (un valore di falso) in $true.

Questo viene poi moltiplicato per il 18quale cast implicitamente $trueverso 1e $falseverso 0. Quindi il lato destro sarà 18se gli array sono uguali e in caso 0contrario. Ciò fornisce il risultato corretto 24se l'array di input è 1,2,3in qualsiasi permutazione e altrimenti la somma dell'array di input.

Kotlin , 46 44 byte

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

Provalo online!

Le modifiche

• Sig. Xcoder -2 byte