iOS 11 a un bug qui fait que le résultat de 1 + 2 + 3 est 24 . Ceci est lié à la vitesse d'animation, mais de toute façon:

La tâche est de faire 1 + 2 + 3 == 24. Mais seulement ça. Vous devez donc fournir une fonction qui additionne correctement la plupart des séquences, mais renvoie 24quand les arguments sont 1, 2et 3dans n’importe quel ordre.

Exemple d'entrées:

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'entrée peut être dans n'importe quel format tant que votre code accepte un nombre quelconque d'arguments.

• La prise en charge des nombres négatifs n'est pas requise (tous les nombres non négatifs doivent fonctionner, y compris 0)
• Nous supposons une entrée correcte

Différences par rapport à une autre question similaire: "Qu'est-ce que vous obtenez lorsque vous multipliez 6 par 9? (42)" :

• Dans ce cas, votre fonction doit accepter un nombre quelconque d'arguments. La vieille question précise exactement 2.
• Dans ce cas, l'ordre n'a pas d'importance, alors que l'ancienne question spécifiait que cet ordre 6 9était requis et 9 6devait être évalué correctement.

MATL , 11 à 10 octets

St3:X=6*+s

Essayez-le en ligne! ou vérifier tous les cas de test

Explication

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

Os{3LQi4*

Explication:

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.

Essayez-le en ligne!

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

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

-12 octets grâce à @ OlivierGrégoire .
-31 octets grâce à @Nevay .

Explication:

Essayez ici.

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

Preuve (inefficace) que seuls [1,2,3](dans n'importe quel ordre) seront les résultats possibles lorsque pis 0b1110( p==14) et que la somme est inférieure à 6 ou inférieure ( s<7): Essayez-le ici.

p==14( 0b1110) Évalue à vrai ssi les valeurs d'entrée modulo 32 couvrent les valeurs 1, 2et 3et ne contiennent pas d' autres valeurs ( p|=1<<i) (chaque valeur doit se produire 1+ fois). La somme des entrées qui correspond p==14sera plus grande que 6pour toute entrée sauf 1,2,3( s=a*1+b*2+c*3+u*32avec a>0,b>0,c>0,u>=0).
_@Nevay

Vieux 71 octets répondent:

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

Preuve que pour trois nombres naturels non nuls donnés, seuls [1,2,3](dans un ordre quelconque) auront une somme égale à son produit ( 1+2+3 == 1*2*3) (avec une somme positive):
lorsque la somme est égale au produit de Leo Kurlandchik & Andrzej Nowicki

(Inefficace) preuve que seulement [1,2,3](dans n'importe quel ordre) et [0,0,0]sera les résultats possibles avec des nombres non négatifs et une longueur de 3: Essayez-le ici.
Ainsi s*4deviendra 6*4 = 24pour [1,2,3], et 0*4 = 0pour [0,0,0].

Gelée , 8 octets

3R⁼Ṣ4*×S

Essayez-le en ligne!

MATL , 13 octets

stGp=18*Gda*+

Essayez-le en ligne!

Il est deux octets plus long que l'autre réponse MATL, mais il utilise une approche complètement différente (et une OMI plus intéressante), j'ai donc pensé que cela valait la peine d'être publié.

Explication:

Cette solution utilise le fait que:

La somme et le produit d'un tableau à trois éléments ne sont égaux que si le tableau est une permutation de 1,2,3.

Cela prend l'entrée, calcule la somme set la duplique t. Il vérifie ensuite si la somme est égale au produit Gp=. Nous multiplions le booléen 1/0par 18 18*et vérifions s'il existe des valeurs non identiques dans le vecteur da*(encore une fois, multiplions par un booléen any(diff(x)). Nous multiplions ensuite les deux et ajoutons le dernier nombre à la somme initiale.

Une explication pas à pas:

Supposons que l'entrée est [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 octets

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

Essayez-le en ligne!

Utilise une autre méthode d’ajout de 18 si l’entrée triée consiste [1, 2, 3]à battre l’ autre réponse Python d’un octet.

Haskell , 37 octets

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

Essayez-le en ligne!

Nous utilisons l'appariement de motifs pour attraper le cas exceptionnel.

Haskell n'a pas de tri intégré. L'égalité 2^a+2^b+2^c==14n'est satisfaite que par [a,b,c]une permutation de [1,2,3]parmi des entiers non négatifs. Un plus court a+b+c=a*b*cfonctionne presque, mais est satisfait [0,0,0], et l'ajout du contrôle le ,a>0rend plus long d'un octet.

Octave , 34 octets

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

Essayez-le en ligne!

ou

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

Essayez-le en ligne!

ou

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

Ceci est plus courte que l'approche utilisation des autres: @(x){24,sum(x)}{2-isequal(sort(x),1:3)}.

Explication:

Il prend la somme du vecteur et ajoute 18 si le vecteur trié est égal à 1,2,3. Cela donnera 6+18=24si le vecteur est une permutation de 1,2,3, et juste la somme du vecteur sinon.

PHP, 116 octets

C’est ma première tentative de défi de golf, et c’est PHP, un langage qui, apparemment, craint en jouant au golf puisque je le vois rarement ici, alors ... heu, j’ai essayé?

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

Remarque: je n'ai pas inclus le commentaire dans le décompte.

Ungolfed

Ce n'est rien de spécial 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 vous voulez tester cela avec PHPFiddle et non sur console, vous pouvez évidemment le remplacer $ipar tout ce que vous voulez.

Merci à Olivier Grégoire qui m'a fait connaître la combinaison de cordes [0,3,3]qui est revenue 24 fois avant et m'a également aidé à économiser quelques caractères en stockant le array_sumet en le retournant au lieu d'exécuter à nouveau la fonction.

R, 47 octets 34 octets 36 octets

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

Essayez-le en ligne!

Faites la somme des entrées et ajoutez 18 si le jeu d’entrées est 1: 3.
Merci à @mlt pour avoir joué 11 octets au golf. Merci à @ Ayb4btu pour avoir identifié une erreur avec le code survolé

Javascript ES6, 39 octets

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

Réponse précédente

Javascript ES6, 66 octets

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

L'essayer

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

Rapide, 67 octets

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

Pourrait le rendre à 27 octets avec des extensions sur [Int], mais ce serait tricher :(

Mathematica, 28 octets

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

Essayez-le en ligne!

J, 17 octets

-6 octets grâce à Frowny Frog

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

Faites la somme de tous les nombres +/et multipliez le résultat par (pseudocode) 1 + 3*(is123 ? 1 : 0). Autrement dit, renvoyez les résultats inchangés, sauf si la liste triée est 1 2 3dans ce cas, nous multiplions le résultat par 4.

Essayez-le en ligne!

réponse originale

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

Vérifiez si l'entrée triée est 1 2 3- si oui, invoquez la fonction constante 24 ( 24"_); sinon, retournez la somme+/

Essayez-le en ligne!

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

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

Essayez-le en ligne!

+18 pour using System.Linq;

Lua , 116 81 octets

-7 octets grâce à Jonathan

Prend les entrées en tant qu'arguments de ligne de commande

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)

Essayez-le en ligne!

Explication:

Fonctionne en créant un tableau fragmenté Set en ajoutant des zéros dans les index correspondant aux valeurs en entrée. Si les paramètres sont 3, 4, 7définis, le tableau fragmenté n'aura que des nombres à ces index. Avec ce tableau, nous obtenons sa longueur avec l'opérateur #qui compte depuis l'index 1jusqu'au plus haut index qui a une valeur. Si cette longueur est exactement identique 3, cela signifie qu'il y avait des éléments dans la position 1, 2et 3c'est ce que nous sommes. à la recherche de. La longueur du tableau fragmenté sera toujours comprise entre 0et Noù Nest le nombre de paramètres. Il suffit donc de vérifier si la longueur du tableau de paramètres et du tableau fragmenté est correcte 3.

R , 55 45 54 49 57 54 48 octets

Sauvegardé de nombreux octets et solutions incorrectes grâce à Ayb4btu.

Enregistré 3 9 octets grâce à Giuseppe. Je continue à apprendre de nouvelles façons d’abuser du fait que F==0.

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

Essayez-le en ligne!

L'autre réponse R a gagné à la fin.

C (gcc) , 136 131 125 97 91 octets

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

Essayez-le en ligne!

Retina , 21 octets

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

Essayez-le en ligne!

Les entrées sont séparées par des sauts de ligne, mais la suite de tests utilise la séparation par virgule pour plus de commodité.

Explication

O`

Trier les chiffres (lexicographique, en fait, mais nous ne se soucient que le cas où les entrées sont 1, 2, 3dans un certain ordre, où cela ne fait pas de différence).

^1¶2¶3$
24

Si l'entrée est 1,2,3(dans un certain ordre), remplacez-la par 24.

.+
$*

Convertissez chaque nombre en unaire.

1

Comptez le nombre de 1s, ce qui ajoute les nombres unaires et les reconvertit en décimal.

Haskell , 44 octets

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

Essayez-le en ligne!

Les permutations de [1,2,3]sont les seules partitions de ce 6produit 6, sauf 6elle-même. (Cela suppose que les entrées sont non négatives, ce qui semble être le cas pour tous les cas de test… j'ai demandé à l'OP à ce sujet.)

PL / SQL - 135 123 octets

En supposant que i soit une entrée de tableau entier de toute taille:

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 octets

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

Essayez-le en ligne!

Notez que l'objet fonction créé est utilisable à la compilation. Les tests sont donc effectués par le compilateur sans qu'il soit nécessaire d'exécuter un programme.

Explication:

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

Preuve que les seuls non négatifs i...pour lesquels (-i&...)est égal à -4 et à (~i*...)-24 sont les permutations de 1, 2, 3:

Nous observons tout d' abord que depuis -0= 0, le cas échéant i= 0alors (-i&...) = 0, si nous concluons que tous les isont positifs.

Maintenant, notez que dans le complément à 2, -iéquivaut à ~(i - 1)et ~iéquivaut à -(i + 1). En appliquant la règle de De Morgan, nous trouvons que (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), donc ((i - 1) | ...) = 3; de même, est -1 ** n * ((i + 1) * ...) = -24donc nétrange et ((i + 1) * ...) = 24.

Les facteurs premiers de 24 sont 2 ** 3 * 3, donc n<= 4. Si n= 1, on a i - 1 = 3et i + 1 = 24, donc n= 3. Ecrivez le iwlog comme a <= b <= c, alors clairement a= 1 sinon >> (a + 1)(b + 1)(c + 1)27. Aussi c<= 4 comme sinon (a - 1)|(b - 1)|(c - 1)> = 4. cne peut pas être 4 car 5 n'est pas un facteur de 24, donc c<= 3. Ensuite, pour satisfaire à (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2 selon les besoins.

Coque , 9 octets

?K24Σ=ḣ3O

Essayez-le en ligne!

Explication

?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

Solution précédente

Donne le mauvais résultat à [2,2], et probablement d'autres entrées aussi, mais c'était plus intéressant.

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

Essayez-le en ligne!

Pushy , 12 octets

gF3RFx?18;S#

Essayez-le en ligne!

Cela fonctionne en triant les entrées et, si elle est égale à [1, 2, 3], en ajoutant 18. Ensuite, la somme est calculée et imprimée, il est ajouté 24 et le résultat est 18, et la réponse normale autrement.

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

?qS3SK24s

Vérifiez tous les cas de test.

Python 2 , 41 39 octets

-1 octet grâce à caird

-1 par inspiration de la réponse de FlipTack

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

Essayez-le en ligne!

Solution alternative de 39 octets

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

Gelée , 10 à 9 octets

Ṣ24S⁼?3R¤

Essayez-le en ligne!

-1 octet grâce à Erik

Alternative (par M. Xcoder ), également pour 9 octets:

3R⁼Ṣ×18+S

Essayez-le en ligne!

Comment ça marche

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

Une approche différente de l’autre réponse Pyth.

*sQ^4qS3S

Explication:

Un port de ma réponse en 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

Essayez-le en ligne!

PowerShell , 44 octets

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

Essayez-le en ligne!

Algorithme similaire aux réponses Python et JavaScript. Prend les entrées sous forme de tableau littéral $a. Puis, somme tout de suite $a, formant l’opérateur de gauche du +.

La main droite est le diff(alias pour Compare-Object) de 1,2,3et $a- ceci est un tableau vide si elles sont égales, ou un tableau non vide des différents éléments s'ils ne sont pas égaux - enfermés dans un booléen-not. Ainsi, s’ils sont égaux, le tableau vide (une valeur de Falsey) devient $true.

C'est ensuite multiplié par 18ce qui jette implicitement $trueà 1et $falseà 0. Donc, le côté droit sera 18si les tableaux sont les mêmes, et 0sinon. Cela donne le résultat correct de 24si le tableau en entrée est 1,2,3dans une permutation, et la somme du tableau en entrée dans le cas contraire.

Kotlin , 46 44 octets

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

Essayez-le en ligne!

Édite

• M. Xcoder -2 octets