O iOS 11 possui um bug que faz com que o resultado de 1 + 2 + 3 seja 24 . Isso está relacionado à velocidade da animação, mas de qualquer maneira:

A tarefa é fazer 1 + 2 + 3 == 24. Mas só isso. Portanto, você deve fornecer uma função que resume corretamente a maioria das seqüências, mas retorna 24quando os argumentos são 1, 2e 3em qualquer ordem.

Exemplo de entradas:

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

A entrada pode estar em qualquer formato, desde que seu código aceite qualquer número de argumentos.

• Não é necessário suporte para números negativos (todos os números não negativos são necessários para o trabalho, incluindo 0)
• Assumimos entrada correta

Diferenças de outra pergunta semelhante: "O que você ganha quando multiplica 6 por 9? (42)" :

• Nesse caso, sua função é obrigada a aceitar qualquer número de argumentos. A pergunta antiga especifica exatamente 2.
• Nesse caso, a ordem não importa, enquanto a pergunta antiga especifica que a ordem 6 9é necessária e 9 6deve ser avaliada corretamente.

MATL , 11 10 bytes

St3:X=6*+s

Experimente online! ou verifique todos os casos de teste

Explicação

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

Explicação:

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.

Experimente 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 graças a @ OlivierGrégoire .
-31 bytes graças a @Nevay .

Explicação:

Experimente aqui.

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

Prova (ineficiente) de que apenas [1,2,3](em qualquer ordem) serão os resultados possíveis quando pfor 0b1110( p==14) e a soma for inferior a 6 ou inferior ( s<7): Experimente aqui.

p==14( 0b1110) Avalia a verdadeira sse os valores de entrada de módulo 32 de cobertura dos valores 1, 2e 3e não contêm outros valores ( p|=1<<i) (cada valor tem de ocorrer 1+ vezes). A soma da entrada que corresponder p==14será maior do que 6para qualquer entrada, exceto 1,2,3( s=a*1+b*2+c*3+u*32com a>0,b>0,c>0,u>=0).
_@Nevay

Resposta antiga de 71 bytes :

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

Prova de que para quaisquer três números naturais diferentes de zero, apenas [1,2,3](em qualquer ordem) terá uma soma igual ao seu produto ( 1+2+3 == 1*2*3) (com uma soma positiva):
Quando a soma é igual ao produto de Leo Kurlandchik e Andrzej Nowicki

(Ineficiente) prova que apenas [1,2,3](em qualquer ordem) e [0,0,0]serão os resultados possíveis com números não negativos e um comprimento de 3: Experimente aqui.
Então a s*4vontade se torna 6*4 = 24para [1,2,3]e 0*4 = 0para [0,0,0].

Gelatina , 8 bytes

3R⁼Ṣ4*×S

Experimente online!

MATL , 13 bytes

stGp=18*Gda*+

Experimente online!

É dois bytes mais longo que a outra resposta MATL, mas usa uma abordagem completamente diferente (e IMO mais interessante), então achei que vale a pena postar.

Explicação:

Esta solução usa o fato de que:

A soma e o produto de uma matriz com três elementos são iguais apenas se a matriz for uma permutação de 1,2,3.

Isso pega a entrada, calcula a soma se a duplica t. Em seguida, verifica se a soma é igual ao produto Gp=. Multiplicamos o booleano 1/0por 18, 18*e verifica se há valores não idênticos no vetor da*(novamente, multiplique por um booleano any(diff(x)). Depois multiplicamos os dois e adicionamos o último número à soma original.

Uma explicação passo a passo:

Suponha que a entrada seja [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])

Experimente online!

Usa um método alternativo de adicionar 18 se a entrada classificada [1, 2, 3]exceder a outra resposta Python por um byte.

Haskell , 37 bytes

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

Experimente online!

Usamos a correspondência de padrões para capturar o caso excepcional.

Haskell não tem classificação interna. A igualdade 2^a+2^b+2^c==14é satisfeita apenas por [a,b,c]uma permutação de [1,2,3]números inteiros não negativos. Um mais curto a+b+c=a*b*cquase funciona, mas é satisfeito [0,0,0]e, ao anexar a verificação, ,a>0fica 1 byte mais longo.

Oitava , 34 bytes

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

Experimente online!

ou

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

Experimente online!

ou

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

Esta é mais curto do que a abordagem de outro uso: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Explicação:

Ele pega a soma do vetor e adiciona 18 se o vetor classificado for igual a 1,2,3. Isso fornecerá 6+18=24se o vetor é uma permutação de 1,2,3e apenas a soma do vetor, se não.

PHP, 116 bytes

Esta é a minha primeira tentativa de desafio de golfe, e é PHP, uma linguagem que aparentemente é péssima no golfe, já que raramente a vejo aqui, então ... hum, eu tentei?

<?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: eu não incluí o comentário no bytecount.

Ungolfed

Não é nada de especial:

$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 você quiser testar isso no PHPFiddle e não no console, obviamente poderá substituir $ipor qualquer coisa que desejar.

Agradeço a Olivier Grégoire, que me informou sobre a combinação de cordas [0,3,3]que retornou 24 antes e também me ajudou a economizar alguns caracteres armazenando array_sume retornando isso em vez de executar a função novamente.

R, 47 bytes 34 bytes 36 bytes

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

Experimente online!

Soma a entrada e adicione 18 se o conjunto de entradas for 1: 3.
Graças a @mlt por jogar fora de 11 bytes. Obrigado a Ayb4btu por identificar um erro com o código sobrecarregado

Javascript ES6, 39 bytes

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

Resposta anterior

Javascript ES6, 66 bytes

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

Tente

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,+)}

Poderia chegar a 27 bytes com extensões em [Int], mas isso seria trapaça :(

Mathematica, 28 bytes

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

Experimente online!

J, 17 bytes

-6 bytes graças ao Frowny Frog

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

Soma todos os números +/e multiplique o resultado por (pseudocódigo) 1 + 3*(is123 ? 1 : 0). Ou seja, retorne os resultados inalterados, a menos que a lista classificada esteja 1 2 3nesse caso, multiplicando o resultado por 4.

Experimente online!

resposta original

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

Verifique se a entrada classificada é 1 2 3- se sim, chame a função constante 24 ( 24"_); caso contrário, retorne a soma+/

Experimente online!

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

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

Experimente online!

+18 para using System.Linq;

Lua , 116 81 bytes

-7 bytes graças a Jonathan

Recebe entrada como argumentos de linha de 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)

Experimente online!

Explicação:

Funciona criando uma matriz esparsa Se adicionando zeros nos índices correspondentes aos valores de entrada. Se os parâmetros forem 3, 4, 7a matriz esparsa, somente haverá números nesses índices. Com essa matriz, podemos obtê-lo de comprimento com o operador #que conta de índice 1até o índice mais elevado que tem um valor nela, se este comprimento é exatamente 3, isso significa que havia elementos na posição 1, 2e 3wich é o que nós somos procurando por. O comprimento da matriz esparsa será sempre entre 0e Nonde Nestá o número de parâmetros. Portanto, basta verificar se o comprimento da matriz de parâmetros e da matriz esparsa é 3.

R , 55 45 54 49 57 54 48 bytes

Economizou muitos bytes e soluções incorretas graças ao Ayb4btu.

Economizou 3 9 bytes graças a Giuseppe. Eu continuo aprendendo novas maneiras de abusar do fato disso F==0.

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

Experimente online!

A outra resposta R venceu no final.

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

Experimente online!

Retina , 21 bytes

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

Experimente online!

A entrada é separada por avanço de linha, mas o conjunto de testes usa separação por vírgula por conveniência.

Explicação

O`

Classificar os números (lexicographically, na verdade, mas que só se preocupam com o caso de que as entradas são 1, 2, 3de alguma forma, quando isso não faz diferença).

^1¶2¶3$
24

Se a entrada for 1,2,3(em alguma ordem), substitua-a por 24.

.+
$*

Converta cada número em unário.

1

Conte o número de 1s, que adiciona os números unários e os converte novamente em decimal.

Haskell , 44 bytes

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

Experimente online!

As permutações de [1,2,3]são as únicas partições de 6cujo produto está 6, exceto em 6si. (Isso pressupõe que as entradas não são negativas, o que parece ser o caso para todos os casos de teste ... perguntei ao OP sobre isso.)

PL / SQL - 135 123 bytes

Assumindo i como uma entrada de matriz inteira de qualquer tamanho:

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

Experimente online!

Observe que o objeto de função criado é utilizável em tempo de compilação; portanto, os testes são executados pelo compilador sem a necessidade de executar um programa.

Explicação:

[]             // 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 de que o único não negativo i...para o qual (-i&...)é igual a -4 e (~i*...)é igual a -24 são as permutações de 1, 2, 3:

Primeiro observamos que, como -0= 0, se houver i= 0então (-i&...) = 0, concluímos que todos isão positivos.

Agora, observe que no complemento de 2 -ié equivalente ~(i - 1)e ~ié equivalente a -(i + 1). Aplicando a regra de De Morgan, achamos que (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), então ((i - 1) | ...) = 3; Da mesma -1 ** n * ((i + 1) * ...) = -24forma n,, então, é estranho e ((i + 1) * ...) = 24.

Os fatores primos de 24 são 2 ** 3 * 3, então n<= 4. Se n= 1, temos i - 1 = 3e i + 1 = 24, então n= 3. Escreva o iwlog como a <= b <= c, então claramente a= 1 como contrário (a + 1)(b + 1)(c + 1)> = 27. Também c<= 4 como caso contrário, (a - 1)|(b - 1)|(c - 1)> = 4. cnão pode ser 4, pois 5 não é um fator de 24, então c<= 3. Então, para satisfazer (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2, conforme necessário.

Casca , 9 bytes

?K24Σ=ḣ3O

Experimente online!

Explicação

?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

Solução anterior

Dá o resultado errado para [2,2], e provavelmente outras entradas também, mas foi mais 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)

Experimente online!

Pushy , 12 bytes

gF3RFx?18;S#

Experimente online!

Isso funciona ordenando a entrada e, se for igual a [1, 2, 3], acrescentando 18. Em seguida, a soma é calculada e impressa, o rendimento de 24 é 18 foi acrescentado e a resposta normal, caso contrário.

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

Pitão , 9 bytes

?qS3SK24s

Verifique todos os casos de teste.

Python 2 , 41 39 bytes

-1 byte graças a caird

-1 por inspiração da resposta do FlipTack

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

Experimente online!

Solução alternativa de 39 bytes

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

Geléia , 10 9 bytes

Ṣ24S⁼?3R¤

Experimente online!

-1 byte graças a Erik

Alternativa (por Mr. Xcoder ), também para 9 bytes:

3R⁼Ṣ×18+S

Experimente online!

Como funciona

Ṣ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

Pitão , 9 bytes

Abordagem diferente da outra resposta de Pyth.

*sQ^4qS3S

Explicação:

Uma porta da minha resposta 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

Experimente online!

PowerShell , 44 bytes

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

Experimente online!

Algoritmo semelhante às respostas Python e JavaScript. Recebe a entrada como uma matriz literal $a. Em seguida, soma-se imediatamente $a, que forma o operador esquerdo do +.

O lado direito é o diff(apelido para Compare-Object) de 1,2,3e $a- este é um array vazio se eles forem iguais ou um array não vazio dos itens diferentes se não forem iguais - incluído em um Boolean-not. Então, se eles são iguais, isso transforma a matriz vazia (um valor de falsey) $true.

Isso é multiplicado pelo 18que implica implicitamente $truepara 1e $falsepara 0. Portanto, o lado direito será 18se as matrizes forem iguais e 0caso contrário. Isso fornece o resultado correto de 24se a matriz de entrada está 1,2,3em alguma permutação e a soma da matriz de entrada de outra forma.

Kotlin , 46 44 bytes

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

Experimente online!

Editar% s

• Mr. Xcoder -2 bytes