Implemente la calculadora iOS 11

43

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.
Hauleth
fuente
23
Además, iOS 11 no funciona así. Debería ser así en su lugar. ( explicación del código )
user202729
3
@ user202729 La pregunta probablemente esté inspirada en iOS 11. No creo que el OP le pida que la replique por completo.
Okx
2
@Okx exactamente. Esto es por diversión, no para implementarlo del 1 al 1. Por supuesto, esto podría cambiarse a la propuesta del usuario 202729, pero si lo desea, puede crear un nuevo desafío con dicha tarea.
Hauleth
3
¿Son enteras las entradas?
xnor
99
Una razón por la que este es un desafío hermoso es por la propiedad vinculada a la cual esta combinación de números es muy especial. La otra razón por la que este es un hermoso desafío es que se burla de Apple por priorizar (su idea de) UX sobre la funcionalidad.
NH.

Respuestas:

11

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
Cinaski
fuente
11

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!

Okx
fuente
11

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

Kevin Cruijssen
fuente
7

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
Stewie Griffin
fuente
6

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.

FlipTack
fuente
sorted(a)==[1,2,3]puede convertirse set(a)=={1,2,3}en guardar 3 bytes.
mypetlion
1
@mypetlion Desafortunadamente, eso sería cierto para listas con duplicados como[1, 2, 3, 3]
FlipTack
Woops Pensé que estábamos restringidos a exactamente 3 entradas.
mypetlion
6

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.

xnor
fuente
4

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.

Stewie Griffin
fuente
4

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.

YU NO TRABAJAS
fuente
Bienvenido al sitio, y buen primer post!
caird coinheringaahing
¿Qué pasa con los valores de entrada [0, 3, 3]? Además, ¿no puede guardar el resultado array_sum($a)en una variable y reutilizarlo?
Olivier Grégoire
@ OlivierGrégoire Eso también está arreglado ahora, obviamente me perdí ese caso. Probablemente podría pensar en una mejor solución, esto es, incluso para mis estándares, realmente ... desordenado.
NO TRABAJAS
Falta código de golf $ en argv [1]
manassehkatz-Reinstate Monica
4

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

marca
fuente
3

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

Weedoze
fuente
58 bytes:a=>(Array.sort(a).join()=="1,2,3"?24:a.reduce((x,y)=>x+y))
Okx
a.sort()=="1,2,3"trabajos.
Neil
39 bytes: a=>a.sort()=="1,2,3"?24:eval(a.joinBT+BT)(reemplace BT con backticks)
Herman L
3

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 :(

Dominik Bucher
fuente
1
Bienvenido al sitio! Esta es una competencia de código de golf, por favor, ¿puede codificar tanto como sea posible? Además, no conozco Swift, pero si estoy en lo correcto, esto guarda la entrada en una variable, que no está permitida. Sin embargo, puede convertir esto en una función.
caird coinheringaahing
1
Golfed un poco: func z(i:[Int]){print(i.sorted()==[1,2,3] ?24:i.reduce(0,+))}.
Sr. Xcoder
1
O 55 bytes (-12): {$0.sorted()==[1,2,3] ?24:$0.reduce(0,+)}as([Int])->Intcomo las reglas estándar permiten funciones anónimas. Puedes ver cómo funciona aquí .
Sr. Xcoder
@ Mr.Xcoder, puede omitir el casting y agregarlo a la constante f que está declarando. o pon el tipo dentro del cierre y te deshaces de as:)
Dominik Bucher
2
+1 para Swift. ¿Es este el código fuente original de la calculadora iOS?
GB
2

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!

Jonás
fuente
Realmente no sé J, pero ¿puedo 1 2 3i.3?
Uriel
@Uriel, i.3produce 0 1 2, por lo que tendría que hacer lo 1+i.3que no ahorra caracteres pero es menos claro.
Jonás
bien, olvidé que J está indexado 0
Uriel
[:+/8"0^:(1 2 3-:/:~)
FrownyFrog
+/@,[*3*1 2 3-:/:~
FrownyFrog
2

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.

Felipe Nardi Batista
fuente
1
80 bytes
Kevin Cruijssen
No viste nada (edité mi comentario, ya que aún no habían
pasado
Sí, acabo de encontrar el mismo defecto en mi propia respuesta. Lo arreglé usando array-length == 3 AND A == S AND S> 0. Pero supongo que comprobar la longitud de #argsLua es demasiado pesado. En ese caso, puede retroceder a su respuesta de 90 bytes, supongo ... :(
Kevin Cruijssen
83 bytes
Jonathan S.
@JonathanS. agradable
Felipe Nardi Batista
2

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.

BLT
fuente
Falla para [0,0,0]: devuelve en 24lugar de 0.
Olivier Grégoire
Aparentemente me perdí 'no negativo' y 'puede ser un solo número' en la especificación. Espere.
BLT
c(1,1,2,3)regresa en 28lugar de7
Ayb4btu
@ Ayb4btu Gracias, buena captura.
BLT
1
x=scan();s=sum(x);"if"(s-prod(x)|s-6|length(x)-3,s,24)es 54 bytes intercambiando la condición y usando en |lugar de &para que podamos restar.
Giuseppe
2

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!

cleblanc
fuente
1

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.

Martin Ender
fuente
Por curiosidad, según su explicación, entiendo que la línea final cuenta todas las ocurrencias del partido (todas las 1s en este caso). ¿Retina siempre hace esto para una sola línea final? ¿O también es posible contar todos los 1s en algún punto intermedio, y luego continuar con el resultado para hacer otra cosa (que usa dos líneas nuevamente para las acciones de reemplazo)? Además, otra pregunta relacionada: ¿qué funciones en Retina requieren solo una línea? El sorting ( O`) es uno de ellos, y el otro también funciona; pero cualquier otro? Solo trato de entender a Retina un poco más. :)
Kevin Cruijssen
1
@KevinCruijssen Sí, puede usar una etapa de emparejamiento (contando) en algún lugar en el medio, pero tendrá que marcarla explícitamente como una etapa de emparejamiento con M`. Es solo si hay una sola línea final que Retina establece por defecto en Mpunto de anclaje en lugar de Replace. AGMTSson todas las etapas de una sola línea, Res de dos líneas, Oy Dson una o dos líneas, dependiendo de si el $se utiliza la opción (lo que les convierte en tipo / deduplicate- por etapas). No dude en enviarme un ping en la sala de chat Retina si tiene más preguntas: chat.stackexchange.com/rooms/41525/retina
Martin Ender
1

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

Lynn
fuente
43 bytes.
Totalmente humano
1

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;
Leo Vesque
fuente
Bienvenido a PPCG! ¿Podría intentar jugar golf eliminando todos los espacios adicionales, incluso si hace que la respuesta sea ilegible (siempre y cuando se compile)?
Olivier Grégoire
1

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.

ecatmur
fuente
1

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!

León
fuente
Esto da 24 por 2,2
recursivo
@recursive en realidad da 16, pero tienes razón. Y probablemente esto también dé resultados incorrectos para algunos arreglos más largos ... Maldición, necesito cambiar a una solución aburrida
Leo
0

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.
FlipTack
fuente
0

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
caird coinheringaahing
fuente
Puedes hacerlo Ṣ24S⁼?3R¤por 9 bytes.
Erik the Outgolfer
O también 3R⁼Ṣ×18+Spara 9 bytes.
Sr. Xcoder
0

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!

Felipe Nardi Batista
fuente
0

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.

AdmBorkBork
fuente
0

Kotlin , 46 44 bytes

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

Pruébalo en línea!

Ediciones

jrtapsell
fuente
¿Podría usar listOf(1,2,3)para guardar 2 bytes? No conozco a Kotlin, así que no estoy seguro.
Sr. Xcoder