iOS 11 tiene un error que hace que el resultado de 1 + 2 + 3 sea 24 . Esto está relacionado con la velocidad de la animación, pero de todos modos:

La tarea es hacer 1 + 2 + 3 == 24. Pero solo eso. Por lo tanto, debe proporcionar una función que sume correctamente la mayoría de las secuencias pero que regrese 24cuando los argumentos son 1, 2y 3en cualquier orden.

Entradas de ejemplo:

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

La entrada puede estar en cualquier formato siempre que su código acepte cualquier número de argumentos.

• No se requiere soporte para números negativos (se requiere que todos los números no negativos funcionen, eso incluye 0)
• Asumimos entrada correcta

Diferencias con otra pregunta similar: "¿Qué obtienes cuando multiplicas 6 por 9? (42)" :

• En este caso, se requiere que su función acepte cualquier número de argumentos. La vieja pregunta especifica exactamente 2.
• En este caso, el orden no importa, mientras que la pregunta anterior especificaba que el orden 6 9es obligatorio y 9 6debe evaluarse correctamente.

MATL , 11 10 bytes

St3:X=6*+s

Pruébalo en línea! o verificar todos los casos de prueba

Explicación

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

Explicación:

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.

Pruébalo en línea!

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 gracias a @ OlivierGrégoire .
-31 bytes gracias a @Nevay .

Explicación:

Pruébalo aquí

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

Prueba (ineficiente) de que solo [1,2,3](en cualquier orden) serán los posibles resultados cuando pes 0b1110( p==14) y la suma es inferior a 6 o inferior ( s<7): Pruébelo aquí.

p==14( 0b1110) Evalúa a verdadero si y sólo si los valores de entrada módulo 32 de la cubierta de los valores 1, 2y 3y no contienen otros valores ( p|=1<<i) (cada valor tiene que ocurrir 1+ veces). La suma de la entrada que coincida p==14será mayor que 6para cualquier entrada excepto 1,2,3( s=a*1+b*2+c*3+u*32con a>0,b>0,c>0,u>=0).
_@Nevay

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

Prueba de que para tres números naturales distintos de cero, solo [1,2,3](en cualquier orden) tendrá una suma igual a su producto ( 1+2+3 == 1*2*3) (con una suma positiva):
cuando la suma es igual al producto de Leo Kurlandchik & Andrzej Nowicki

Prueba (ineficiente) de que solo [1,2,3](en cualquier orden) y [0,0,0]serán los resultados posibles con números no negativos y una longitud de 3: Pruébelo aquí.
Entonces la s*4voluntad se convierte 6*4 = 24para [1,2,3]y 0*4 = 0para [0,0,0].

Jalea , 8 bytes

3R⁼Ṣ4*×S

Pruébalo en línea!

MATL , 13 bytes

stGp=18*Gda*+

Pruébalo en línea!

Es dos bytes más largo que la otra respuesta de MATL, pero utiliza un enfoque completamente diferente (e IMO más interesante), así que pensé que valía la pena publicarlo.

Explicación:

Esta solución utiliza el hecho de que:

La suma y el producto de una matriz con tres elementos solo son iguales si la matriz es una permutación de 1,2,3.

Esto toma la entrada, calcula la suma sy la duplica t. Luego verifica si la suma es igual al producto Gp=. Multiplicamos el booleano 1/0por 18, 18*y verificamos si hay valores no idénticos en el vector da*(nuevamente, multiplicamos por un booleano any(diff(x)). Luego multiplicamos los dos y sumamos el último número a la suma original.

Una explicación paso a paso:

Suponga que la entrada es [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])

Pruébalo en línea!

Utiliza un método alternativo para agregar 18 si la entrada ordenada es [1, 2, 3]para vencer a la otra respuesta de Python por un byte.

Haskell , 37 bytes

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

Pruébalo en línea!

Utilizamos la coincidencia de patrones para captar el caso excepcional.

Haskell no tiene clasificación incorporada. La igualdad 2^a+2^b+2^c==14se satisface solo por [a,b,c]una permutación [1,2,3]entre enteros no negativos. Un más corto a+b+c=a*b*ccasi funciona, pero está satisfecho [0,0,0], y agregar el cheque lo ,a>0hace 1 byte más largo.

Octava , 34 bytes

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

Pruébalo en línea!

o

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

Pruébalo en línea!

o

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

Esto es más corto que el enfoque de otros uso: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Explicación:

Toma la suma del vector y agrega 18 si el vector ordenado es igual a 1,2,3. Esto dará 6+18=24si el vector es una permutación de 1,2,3, y solo la suma del vector si no.

PHP, 116 bytes

Este es mi primer intento en un desafío de golf, y es PHP, un lenguaje que aparentemente apesta en el golf ya que rara vez lo veo aquí, así que ... uhm, ¿lo intenté?

<?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: No incluí el comentario en el bytecount.

Sin golf

No es nada especial 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

Si desea probar esto en PHPFiddle y no en la consola, obviamente puede reemplazarlo $icon cualquier cosa que desee.

Gracias a Olivier Grégoire, que me hizo consciente de la combinación de cadenas [0,3,3]que devolvió 24 antes y también me ayudó a guardar algunos caracteres almacenando array_sumy devolviendo eso en lugar de ejecutar la función nuevamente.

R, 47 bytes 34 bytes 36 bytes

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

Pruébalo en línea!

Sume la entrada y agregue 18 si el conjunto de entrada es 1: 3.
Gracias a @mlt por jugar golf en 11 bytes. Gracias a @ Ayb4btu por identificar un error con el código sobredotado

Javascript ES6, 39 bytes

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

Respuesta anterior

Javascript ES6, 66 bytes

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

Intentalo

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

Rápido, 67 bytes

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

Podría llegar a 27 bytes con extensiones en [Int], pero eso sería trampa :(

Mathematica, 28 bytes

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

Pruébalo en línea!

J, 17 bytes

-6 bytes gracias a Frowny Frog

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

Suma todos los números +/y multiplica el resultado por (pseudocódigo) 1 + 3*(is123 ? 1 : 0). Es decir, devolver los resultados sin cambios a menos que la lista ordenada sea 1 2 3en cuyo caso multiplicamos el resultado por 4.

Pruébalo en línea!

respuesta original

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

Compruebe si la entrada ordenada es 1 2 3: en caso afirmativo, invoque la función constante 24 ( 24"_); si no, devuelva la suma+/

Pruébalo en línea!

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

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

Pruébalo en línea!

+18 para using System.Linq;

Lua , 116 81 bytes

-7 bytes gracias a Jonathan

Toma datos como argumentos de línea 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)

Pruébalo en línea!

Explicación:

Funciona creando una matriz dispersa Sy agregando ceros en los índices correspondientes a los valores de entrada. Si los parámetros son 3, 4, 7la matriz dispersa solo tendrá números en esos índices. Con esa matriz, obtenemos su longitud con el operador #que cuenta desde el índice 1hasta el índice más alto que tiene un valor, si esta longitud es exactamente 3, significa que había elementos en la posición 1, 2y 3que es lo que estamos buscando. La longitud de la matriz dispersa siempre estará entre 0y Ndónde Nestá el número de parámetros. Entonces, solo tenemos que verificar si la longitud de la matriz de parámetros y la matriz dispersa es 3.

R , 55 45 54 49 57 54 48 bytes

Guardado muchos bytes y soluciones incorrectas gracias a Ayb4btu.

Guardado 3 9 bytes gracias a Giuseppe. Sigo aprendiendo nuevas formas de abusar del hecho de que F==0.

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

Pruébalo en línea!

La otra respuesta R ganó al 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);}

Pruébalo en línea!

Retina , 21 bytes

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

Pruébalo en línea!

La entrada está separada por salto de línea, pero el conjunto de pruebas utiliza la separación por comas para mayor comodidad.

Explicación

O`

Ordenar los números (lexicográfico, en realidad, sino que sólo se preocupan por el caso de que las entradas son 1, 2, 3en algún orden, donde eso no hace una diferencia).

^1¶2¶3$
24

Si la entrada es 1,2,3(en algún orden), reemplácela con 24.

.+
$*

Convierte cada número a unario.

1

Cuente el número de 1s, que agrega los números unarios y los convierte de nuevo a decimal.

Haskell , 44 bytes

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

Pruébalo en línea!

Las permutaciones de [1,2,3]son las únicas particiones de 6cuyo producto es 6, salvo en 6sí mismo. (Esto supone que las entradas no son negativas, lo que parece ser el caso para todos los casos de prueba ... Le he preguntado al OP sobre esto).

PL / SQL: 135 123 bytes

Suponiendo que i como una entrada de matriz entera de cualquier tamaño:

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

Pruébalo en línea!

Tenga en cuenta que el objeto de función creado se puede utilizar en tiempo de compilación, por lo que el compilador realiza las pruebas sin tener que ejecutar un programa.

Explicación:

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

Prueba de que lo único no negativo i...para el que (-i&...)es igual a -4 y (~i*...)igual a -24 son las permutaciones de 1, 2, 3:

Primero observamos que dado que -0= 0, si existe i= 0entonces (-i&...) = 0, concluimos que todos ison positivos.

Ahora, tenga en cuenta que en el complemento de 2, -ies equivalente a ~(i - 1), y ~ies equivalente a -(i + 1). Aplicando la regla de De Morgan, encontramos que (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), entonces ((i - 1) | ...) = 3; de manera similar, -1 ** n * ((i + 1) * ...) = -24también nes extraño y ((i + 1) * ...) = 24.

Los factores primos de 24 son 2 ** 3 * 3, entonces n<= 4. Si n= 1, tenemos i - 1 = 3y i + 1 = 24, entonces n= 3. Escribe el iwlog como a <= b <= c, entonces claramente a= 1 como lo contrario (a + 1)(b + 1)(c + 1)> = 27. También c<= 4 como de lo contrario (a - 1)|(b - 1)|(c - 1)> = 4. cno puede ser 4 ya que 5 no es un factor de 24, entonces c<= 3. Luego, para satisfacer (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2 según se requiera.

Casco , 9 bytes

?K24Σ=ḣ3O

Pruébalo en línea!

Explicación

?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

Solución previa

Da el resultado incorrecto a [2,2], y probablemente otras entradas también, pero fue más interesante.

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

Pruébalo en línea!

Pushy , 12 bytes

gF3RFx?18;S#

Pruébalo en línea!

Esto funciona clasificando la entrada y, si es igual a [1, 2, 3], agregando 18. Luego, se calcula e imprime la suma, se agrega 24 y 18, y la respuesta normal de lo contrario.

         \ 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

Verifique todos los casos de prueba.

Python 2 , 41 39 bytes

-1 byte gracias a caird

-1 por inspiración de la respuesta de FlipTack

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

Pruébalo en línea!

Solución alternativa de 39 bytes

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

Jalea , 10 9 bytes

Ṣ24S⁼?3R¤

Pruébalo en línea!

-1 byte gracias a Erik

Alternativa (por Mr. Xcoder ), también para 9 bytes:

3R⁼Ṣ×18+S

Pruébalo en línea!

Cómo 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

Pyth , 9 bytes

Enfoque diferente de la otra respuesta de Pyth.

*sQ^4qS3S

Explicación:

Un puerto de mi respuesta de 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

Pruébalo en línea!

PowerShell , 44 bytes

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

Pruébalo en línea!

Algoritmo similar a las respuestas de Python y JavaScript. Toma la entrada como una matriz literal $a. Luego se suman de inmediato $a, lo que forma el operador izquierdo de +.

La mano derecha es el diff(alias para Compare-Object) de 1,2,3y $a: esta es una matriz vacía si son iguales o una matriz no vacía de los diferentes elementos si no son iguales, encerrada en un booleano. Entonces, si son iguales, eso convierte la matriz vacía (un valor de falsey) en $true.

Eso luego se multiplica por lo 18que implícitamente arroja $truehacia 1y $falsehacia 0. Entonces, el lado derecho será 18si las matrices son iguales, y de lo 0contrario. Eso da el resultado correcto de 24si la matriz de entrada está 1,2,3en alguna permutación, y la suma de la matriz de entrada de lo contrario.

Kotlin , 46 44 bytes

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

Pruébalo en línea!

Ediciones

• Sr. Xcoder -2 bytes