La dernière fois que j'ai essayé de trouver quelque chose de facile qui ne soit pas un doublon, c'était trop difficile. Donc, espérons que cette fois, les nouveaux arrivants pourront en faire de même.

Contribution:

Un tableau / liste avec des nombres entiers / décimaux. (Ou une chaîne représentant un tableau avec des nombres entiers / décimaux.)

Sortie:

Parcourez les nombres et appliquez les cinq opérandes mathématiques suivants dans cet ordre:

• Addition ( +);
• Soustraction ( −);
• Multiplication ( *ou ×ou ·);
• Division réelle / calculatrice ( /ou ÷);
• Exponentiation ( ^ou **).

(REMARQUE: Les symboles entre parenthèses sont simplement ajoutés à titre de clarification. Si votre langage de programmation utilise un symbole complètement différent de l'opération mathématique pour les opérations mathématiques, cela est tout à fait acceptable.)

Continuez jusqu'à ce que vous ayez atteint la fin de la liste, puis donnez le résultat de la somme.

Règles du challenge:

• Une exponentiation de 0 ( n ^ 0) devrait donner 1 (ceci s'applique également à 0 ^ 0 = 1).
• Il n'y a pas de scénario de test pour la division par 0 ( n / 0), vous n'avez donc pas à vous soucier de ce cas périphérique.
• Si le tableau ne contient qu'un seul nombre, nous le renvoyons comme résultat.

Règles générales:

• C'est du code-golf , donc la réponse la plus courte en octets est gagnante.
  Ne laissez pas les langues de code-golf vous décourager de poster des réponses avec des langues autres que le code de golf. Essayez de trouver une réponse aussi courte que possible à n'importe quel langage de programmation.
• Les règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés, programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.

Cas de test:

[1,2,3,4,5] -> 0
-> 1 + 2 = 3
  -> 3 - 3 = 0
    -> 0 * 4 = 0
      -> 0 / 5 = 0 

[5,12,23,2,4,4,2,6,7] -> 539
-> 5 + 12 = 17
  -> 17 - 23 = -6
    -> -6 * 2 = -12
      -> -12 / 4 = -3
        -> -3 ^ 4 = 81
          -> 81 + 2 = 83
            -> 83 - 6 = 77
              -> 77 * 7 -> 539

[-8,50,3,3,-123,4,17,99,13] -> -1055.356...
-> -8 + 50 = 42
  -> 42 - 3 = 39
    -> 39 * 3 = 117
      -> 117 / -123 = -0.9512...
        -> -0.9512... ^ 4 = 0.818...
          -> 0.818... + 17 = 17.818...
            -> 17.818... - 99 -> -81.181...
              -> -81.181... * 13 = -1055.356...

[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256
-> 2 + 2 = 4
  -> 4 - 2 = 2
    -> 2 * 2 = 4
      -> 4 / 2 = 2
        -> 2 ^ 2 = 4
          -> 4 + 2 = 6
            -> 6 - 2 = 4
              -> 4 * 2 = 8
                -> 8 / 2 = 4
                  -> 4 ^ 2 = 16
                    -> 16 + 2 = 18
                      -> 18 - 2 = 16
                        -> 16 * 2 = 32
                          -> 32 / 2 = 16
                            -> 16 ^ 2 = 256

[1,0,1,0,1,0] -> 1
-> 1 + 0 = 1
  -> 1 - 1 = 0
    -> 0 * 0 = 0
      -> 0 / 1 = 0
        -> 0 ^ 0 = 1

[-9,-8,-1] -> -16
  -> -9 + -8 = -17
    -> -17 - -1 = -16

[0,-3] -> -3
  -> 0 + -3 = -3

[-99] -> -99

Gelée , 13 octets

“+_×÷*”ṁṖ⁸żFV

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

Comment ça marche

“+_×÷*”ṁṖ⁸żFV  Main link. Argument: A (list of integers)

“+_×÷*”        Yield the list of operations as a string.
        Ṗ      Yield A popped, i.e., with its last element removed.
       ṁ       Mold; reshape the string as popped A.
               This repeats the characters of the string until it contains
               length(A)-1 characters.
         ⁸ż    Zipwith; pairs the integers of A with the corresponding characters.
           F   Flatten the result.
            V  Eval the resulting Jelly code.
               Jelly always evaluates left-to-right (with blatant disregard towards
               the order of operations), so this returns the desired result.

Javascript ES7 49 octets

a=>a.reduce((c,d,e)=>[c**d,c+d,c-d,c*d,c/d][e%5])

9 octets sauvés grâce à Dom Hastings, 6 autres sauvés grâce à Leaky Nun

Utilise le nouvel opérateur d'exponentiation.

Haskell, 76 65 64 62 octets

Merci à @ Damien pour la suppression de deux autres octets =)

f(u:v)=foldl(\x(f,y)->f x y)u(zip(v>>[(+),(-),(*),(/),(**)])v)

Ceci utilise le >>qui ici ajoute juste la liste [(+),...]à ses length vtemps. Le reste fonctionne toujours comme les anciennes versions.

Anciennes versions:

Ces solutions utilisent les listes infinies, comme cycle[...]répète simplement la liste donnée à l'infini. Ensuite, il obtient essentiellement zipla liste des nombres, et nous réduisons simplement fold( dans d’autres langues) la liste zippée via un lambda, qui applique les opérateurs à l’élément accumulateur / liste courante.

f(u:v)=foldl(\x(f,y)->f x y)u(zip(cycle[(+),(-),(*),(/),(**)])v)

f(u:v)=foldl(\x(y,f)->f x y)u(zip v(cycle[(+),(-),(*),(/),(**)]))

f l=foldl(\x(y,f)->f x y)(head l)(zip(drop 1l)(cycle[(+),(-),(*),(/),(**)]))

Pyke, 22 à 21 octets

lt5L%"+-*/^"L@\RJQ_XE

Essayez-le ici!

lt5L%                 -    map(len(input)-1, %5)
     "+-*/^"L@        -   map(^, "+-*/^"[<])
              \RJ     -  "R".join(^)
                    E - pyke_eval(^, V)
                 Q_X  -  splat(reversed(input))

Haskell, 61 octets

foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])

Crée une série de transformations dans une liste, comme dans [ajouter 1, ajouter 2, soustraire 3, ...], en commençant par 2 additions car nous commençons par 0 dans le repli. Ensuite, nous faisons ce que j'appelle le pli d'application de liste, ou foldl (flip id), qui applique une liste d'homomorphismes en série. Cela commence par zéro, ajoute la valeur initiale, puis effectue toutes les transformations calculées ci-dessus pour obtenir un résultat final.

Notez que (id d'inversion) est identique à (\ x y-> yx), juste plus court.

Exemple d'utilisation:

f = foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])
f [1,2,3,4,5] -- Is 0.0

TSQL 116 115 88 octets

Grâce à la suggestion de Ross Presser, j'ai pu jouer au golf jusqu'à 88 personnages.

-- In Try-it code, this must be DECLARE @y TABLE 
CREATE TABLE T(a real, i int identity)
INSERT T values(5),(12),(23),(2),(4),(4),(2),(6),(7)

DECLARE @ REAL SELECT @=CHOOSE(i%5+1,@/a,ISNULL(POWER(@,a),a),@+a,@-a,@*a)FROM T
PRINT @

Essayez-le en ligne

Pyth, 27 26 25 octets

.v+>tlQ*lQ"^c*-+":jdQ\-\_

Suite de tests.

Pyth utilise la notation préfixe: 1+2est écrit comme +1 2(espace nécessaire pour séparer les nombres).

Par conséquent, pour le premier cas de test, l'expression serait (((1+2)-3)*4)/5, qui dans la notation de préfixe serait écrite comme /*-+ 1 2 3 4 5.

En Pyth, la division float est à la cplace de /, elle devient donc c*-+ 1 2 3 4 5.

Aussi, en Pyth, -100est écrit comme à la _100place.

Par conséquent, pour le troisième cas de test, qui est ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), il devient: *-+^c*-+ _8 50 3 3 _123 4 17 99 13.

.v+>tlQ*lQ"^c*-+":jdQ\-\_
                  jdQ       Join input by space.
                 :   \-\_   Replace "-" with "_".
   >tlQ*lQ"^c*-+"           Generate the string "...^c*-+" of suitable length.
  +                         Join the two strings above.
.v                          Evaluate as a Pyth expression.

Histoire

• 33 octets: v:P+*lQ\(ssV+R\)Q*"+-*/p"lQ\p"**"
• 27 octets: .vs+_XUtQUQ"+-*c^"m:+;d\-\_
• 26 octets: .vs+_XUtQUQ"+-*c^":jdQ\-\_

En fait, 23 octets

;l"+-*/ⁿ"*@R':j':+'?o+ƒ

Essayez-le en ligne!

En réalité, utilise la notation postfixe pour les mathématiques et les opérateurs qui ne prennent jamais que deux arguments (tels que les opérateurs pour addition, soustraction, multiplication, division et exponentiation) ne font rien s’il n’ya qu’un seul élément sur la pile. Par conséquent, la conversion de l'entrée en code réel consiste simplement à inverser l'entrée, à la formater en tant que valeur numérique et à l'ajout des opérations. Ensuite, le code résultant peut être exécuté en donnant la sortie souhaitée.

Explication:

;l"+-*/ⁿ"*@R':j':+'?o+ƒ
;l"+-*/ⁿ"*               repeat the operations a number of times equal to the length of the input
                            (since extraneous operations will be NOPs, there's no harm in overshooting)
          @R             reverse the input
            ':j          join on ":" (make a string, inserting ":" between every pair of elements in the list)
               ':+       prepend a ":" (for the first numeric literal)
                  '?o    append a "?"
                           (this keeps the poor numeric parsing from trying to gobble up the first + as part of the numeric literal, since ? isn't interpreted as part of the literal, and is a NOP)
                     +   append the operations string
                      ƒ  cast as a function and call it

Exemple de code traduit pour la saisie 1,2,3,4,5:

:5:4:3:2:1?+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ

Julia, 53 50 octets

!x=(i=0;foldl((a,b)->(+,-,*,/,^)[i=i%5+1](a,b),x))

Essayez-le en ligne!

J, 40 octets

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)

Trouve le nombre de valeurs nécessaires pour utiliser un multiple de 5 opérateurs, que les pads avec les valeurs d'identité de ces opérateurs. Dans l'ordre, +0, -0, *1, %1 et ^1, ce qui peut être une valeur de bit 00111, ou 7 en base 10. Opère ensuite sur cette liste en passant en revue les opérateurs.

Usage

   f =: ^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)
   f 1 2 3 4 5
0
   f 5 12 23 2 4 4 2 6 7
539
   f _8 50 3 3 _123 4 17 99 13
_1055.36
   f 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
256
   f 1 0 1 0 1 0
1
   f _9 _8 _1
_16
   f 0 _3
_3
   f _99
_99

Explication

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#) Input: A
                                      #  Get length of A
                                    4+   Add four to it
                                  5|     Take it mod 5
                                5-       Find 5 minus its value, call it x
                           #&2           Create x copies of 2
                       7#:~              Convert 7 to base 2 and take the last x digits
                      ,                  Append those x digits to the end of A
                   |.@                   Reverse it, call it A'
^~                                       Power, reversed operators
    %~                                   Division, reversed operators
       *                                 Multiplication
         -~                              Subtraction, reversed operators
            +                            Addition
             /@                          Insert the previous operations, separated by `,
                                         into A' in order and cycle until the end
                                         Then evaluate the equation from right-to-left
                                         and return

Python 2, 81 67 64 octets

i=10
for n in input():exec'r%s=n'%'*+-*/*'[i::5];i=-~i%5
print r

L'entrée est un tableau de flotteurs. Testez-le sur Ideone .

Comment ça marche

'*+-*/*'[i::5]sélectionne chaque cinquième caractère de la chaîne, en commençant par celui de l' indice i , de sorte que ces rendements **si i = 0 ,+ si i = 1 , -si i = 2 , *si i = 3 et /si i = 4 . Puisque la chaîne a une longueur de 6 , l’expression générera une chaîne vide si i> 5 .

Nous initialisons la variable i à 10 . Pour chaque nombre n dans le tableau d'entrée, nous construisons la chaîne r<op>=nqui execs'exécute.

Initialement, i = 10 , <op>la chaîne vide l'est aussi , et il initialise r avec r+=n. Après chaque étape, nous incrémentons i modulo 5 avec i=-~i%5, de sorte que l'étape suivante récupère l'opérateur approprié.

Lorsque tous les nombres saisis ont été traités, nous imprimons r , qui contient la sortie souhaitée.

Matlab - 95 91 85 octets / Octave - 81 octets

L’entrée se présente sous cette forme a = ['1' '2' '3' '4' '5'];:, j’espère que cela est couvert par "chaîne représentant un tableau avec des entiers / décimales", sinon il y a 2 num2str nécessaires en plus.

Chaque résultat intermédiaire est imprimé sur console car cela me permet d'économiser des points-virgules. a(1)est exécuté pour que sa valeur soit ensuite sauvegardée dans ans. Aussi bien sûr en utilisantans du code est une mauvaise pratique.

b='+-*/^'
a(1)
for i=2:length(a)
  ['(',ans,')',b(mod(i-2,5)+1),a(i)]
end
eval(ans)

En octave, '+-*/^'(mod(i+2,5)+1) fonctionne également, ce qui économise encore 4 octets, merci Adám et Luis Mendo:

a(1)
for i=2:length(a)
  strcat('(',ans,')','+-*/^'(mod(i-2,5)+1),a(i))
end
eval(ans)

Changelog:

• Espaces supprimés si possible
• ajout de la solution Octave
• strcat () remplacé par []

Mathematica, 67 66 65 octets

Fold[{+##,#-#2,#2#,#/#2,If[#2==0,1,#^#2]}[[i++~Mod~5+1]]&,i=0;#]&

Simple Foldavec une variable icontenant l'index.

CJam, 18 octets

q~{"+-*/#"W):W=~}*

L'entrée est un tableau de flotteurs. Essayez-le en ligne!

Comment ça marche

q~                  Read and evaluate all input.
  {             }*  Reduce:
   "+-*/#"            Push the string of operators.
          W           Push W (initially -1).
           ):W        Increment and save in W.
              =       Retrieve the character at that index.
               ~      Evaluate.

R , 87 78 70 octets

i=0
Reduce(function(a,j)get(substr("+-*/^",i<<-i%%5+1,i))(a,j),scan())

Essayez-le en ligne!

Haskell - 74

f(x:xs)=foldl(\x(o,y)->o x y)x(zip(cycle[(+),(-),(*),(/),flip(^).floor])xs)

Cas de test:

λ> f[1,2,3,4,5] -> 0.0
λ> f[5,12,23,2,4,4,2,6,7] -> 539.0
λ> f[-8,50,3,3,-123,4,17,99,13] -> -1055.356943846277
λ> f [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256.0

Cela pourrait probablement être plus court; Le support de Haskell pour des listes infinies et des fonctions d'ordre supérieur rend la solution directe assez agréable, cependant. Une version de ^ :: Double -> Double -> Doubleserait plus intéressante pour le golf, mais je n’en ai pas trouvé. Heureusement, je n'avais pas besoin d'un lambda complet, style inutile alors rasé quelques octets.

PowerShell v2 +, 124 octets

param($n)$o=$n[0];if($y=$n.count-1){1..$y|%{$o=if(($x=$i++%5)-4){"$o"+'+-*/'[$x]+$n[$_]|iex}else{[math]::pow($o,$n[$_])}}}$o

Longtemps parce que PowerShell n'a pas d' opérateur ^ou **, nous devons donc comptabiliser un cas séparé et utiliser un appel .NET.

Prend l’entrée $nsous forme de tableau, définit notre sortie $ocomme premier chiffre. Nous vérifions ensuite .countle tableau, et tant qu'il est supérieur à celui que nous entrons dans le tableau if. Sinon, nous sautons le if.

Dans la ifboucle we, nous parcourons le tableau 1..$y|%{...}et chaque itération est réinitialisée $oà une nouvelle valeur, résultat d'une autre if/elseinstruction. Tant que notre compteur $i++n'est pas modulo-5 égal à 4 (c'est-à-dire que nous ne sommes pas chez l' ^opérateur), nous le prenons $oet le concaténons avec le symbole approprié '+-*/'[$x]et le nombre suivant dans le tableau en entrée $n[$_]. Nous transmettons cela à iex(alias pour Invoke-Expressionet similaire à eval), et cela est ré-enregistré dans $o. Si nous sommes sur l' ^opérateur, nous sommes dans le else, alors nous exécutons un [math]::Pow()appel, et ce résultat est ré-enregistré dans $o.

Dans les deux cas, nous sortons simplement $overs le pipeline et sortons, avec une sortie implicite.

Rouille, 123 , 117 octets

Réponse originale:

fn a(v:&[f32])->f32{v.iter().skip(1).enumerate().fold(v[0],|s,(i,&x)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

noms de méthodes stupides et longues ^^ ahh bien mieux

fn f(v:&[f32])->f32{v[1..].iter().zip(0..).fold(v[0],|s,(&x,i)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

non-golfé

fn f(values : &[f32]) -> f32 {
    values[1..].iter().zip(0..)
    .fold(values[0], |state,(&x,i)|
        match i%5 {
            0=>state+x,
            1=>state-x,
            2=>state*x,
            3=>state/x,
            _=>state.powf(x)
        }
    )
}

Perl 6 ,  70 68 65   62 octets

{$/=[(|(&[+],&[-],&[*],&[/],&[**])xx*)];.reduce: {$/.shift.($^a,$^b)}}
{(@_ Z |(&[+],&[-],&[*],&[/],&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{(@_ Z |(*+*,*-*,&[*],*/*,&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],*/*,&[**])xx*}

Explication:

-> *@_ {
  reduce
    -> $a, &b, $c { b($a,$c) },

    flat       # flatten list produced from zip
      zip
        @_,    # input

        slip(  # causes the list of operators to flatten into the xx list

          # list of 5 infix operators
          &infix:<+>, &infix:<->, &infix:<*>, &infix:</>, &infix:<**>

        ) xx * # repeat the list of operators infinitely
}

Techniquement, * + *c'est un lambda, mais c'est en fait la même chose que &[+]ce qui est court pour &infix:<+>l'ensemble des sous-routines qui gèrent l'addition numérique infixe.
Je n'ai pas utilisé que pour la multiplication ou exponentiation que les moyens de les écrire comme c'est au moins aussi longtemps que ce que j'ai ( *×*ou * * *et* ** * )

Tester:

Testez-le sur ideone.com
(après la mise à niveau vers une version de Rakudo datant d'un an et demi avant la sortie officielle des Perl 6 spectests )

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,2,3,4,5] => 0,
  [5,12,23,2,4,4,2,6,7] => 539,
  [-8,50,3,3,-123,4,17,99,13] => -1055.35694385, # -2982186493/2825761
  [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] => 256,
  [1,0,1,0,1,0] => 1,
  [-9,-8,-1] => -16,
  [0,-3] => -3,
  [-99] => -99,
);

plan +@tests;

my &code = {reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],&[/],&[**])xx*}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is code(@input), $expected, .gist
}

1..8
ok 1 - [1 2 3 4 5] => 0
ok 2 - [5 12 23 2 4 4 2 6 7] => 539
ok 3 - [-8 50 3 3 -123 4 17 99 13] => -1055.35694385
ok 4 - [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2] => 256
ok 5 - [1 0 1 0 1 0] => 1
ok 6 - [-9 -8 -1] => -16
ok 7 - [0 -3] => -3
ok 8 - [-99] => -99

Python 3, 88 93 octets

f=lambda x:eval('('*(len(x)-1)+'){}'.join(map(str,x)).format(*['+','-','*','/','**']*len(x)))

Cela a commencé par être beaucoup plus court, mais la priorité des opérateurs m'a alors vaincue et j'ai dû inclure beaucoup de parenthèses ...

Oracle PL / SQL, 275 254 octets

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

Les données doivent être insérées dans une table appelée Tavec une colonneN de typeNUMBER

Usage:

drop table t;
create table t (n number);
insert into t values (-8);
insert into t values (50);
insert into t values (3);
insert into t values (3);
insert into t values (-123);
insert into t values (4);
insert into t values (17);
insert into t values (99);
insert into t values (13);

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

Sortie:

-1055,356943846277162152071601242992595623

Version 275 octets:

declare r number;cursor c is select n,mod(rownum,5) r from t;begin for x in c loop if r is null then r:=x.n;else case x.r when 2 then r:=r+x.n;when 3 then r:=r-x.n;when 4 then r:=r*x.n;when 0 then r:=r/x.n;else r:=r**x.n; end case;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

Java 8, 173 172 167 138 137 118 113 octets

a->{double r=a[0],t;for(int i=1;i<a.length;r=new double[]{Math.pow(r,t),r+t,r-t,r*t,r/t}[i++%5])t=a[i];return r;}

Explication:

Essayez ici.

a->{                     // Method with double-array parameter and double return-type
  double r=a[0],         //  Result-double, starting at the first item of the input
         t;              //  Temp double
  for(int i=1;           //  Index-integer, starting at the second item
      i<a.length;        //  Loop over the input-array
      r=new double[]{    //    After every iteration, change `r` to:
         Math.pow(r,t),  //      If `i%5` is 0: `r^t`
         r+t,            //      Else-if `i%5` is 1: `r+t`
         r-t,            //      Else-if `i%5` is 2: `r-t`
         r*t,            //      Else-if `i%5` is 3: `r*t`
         r/t}[i++%5])    //      Else-if `i%5` is 4: `r/t`
                         //      And increase `i` by 1 afterwards with `i++`
    t=a[i];              //   Change `t` to the next item in the array
  return r;}             //  Return result-double

Quelques astuces peuvent réduire l'approche de @ Willmore de 23 à 174 octets (php 5.6 ou supérieur requis). La partie la plus économique consiste à supprimer les parenthèses inutiles (-10 octets).

fonction f ($ a) {while (compte ($ a)> 1) {$ l = tableau_shift ($ a); $ r = tableau_shift ($ a); tableau_unshift ($ a, ($ j = $ i ++% 5) ? ($ j == 1? $ l- $ r: ($ j == 2? $ l * $ r: ($ j == 3? $ l / $ r: $ l ** $ r))): $ l + $ r);} return end ($ a);}

Mais utiliser l' **opérateur au lieu de pow()permet également d'utilisereval un tableau pour les opérations; et avec encore quelques astuces ...

PHP> = 5.6, 82 octets

while(--$argc)eval('$x'.['/','**','+','-','*'][$i++?$i%5:2]."=$argv[$i];");echo$x;

prend la liste des paramètres de ligne de commande. Courez avec php -nr '<code>'ou essayez-le en ligne .

ancienne version, 161 157 151 145 144 140 137 137 117 octets

function f($a){while(count($a)>1)eval('$a[0]=array_shift($a)'.['+','-','*','/','**'][$i++%5].'$a[0];');return$a[0];}

Le golf le plus efficace a été obtenu en écrivant le résultat intermédiaire directement dans le premier élément, après avoir déplacé le résultat précédent du tableau.

panne

function f($a)
{
    while(count($a)>1)  // while array has more than one element ...
        eval('$a[0]='                           // future first element :=
            . 'array_shift($a)'                 // = old first element (removed)
            . ['+','-','*','/','**'][$i++%5]    // (operation)
            .'$a[0];'                           // new first element (after shift)
        );
    return$a[0];        // return last remaining element
}

suite de tests

$cases = array (
    0=>[1,2,3,4,5],
    539=>[5,12,23,2,4,4,2,6,7],
    '-1055.356...' => [-8,50,3,3,-123,4,17,99,13],
    256 => [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],
    1 => [1,0,1,0,1,0],
    -16 => [-9,-8,-1],
    -3 => [0, -3],
    -99 => [-99]
);
echo '<table border=1><tr><th>values</th><th>expected</th><th>actual result</th></tr>';
foreach ($cases as $expect=>$a)
{
    $result=f($a);
    echo "<tr><td>[", implode(',',$a),"]</td><td>$expect</td><td>$result</td></tr>";
}
echo '</table>';

PHP ,135 130 octets

Merci @titus, -5 octets, plus 0 cas correctif!

function f($z){return array_reduce($z,function($c,$x)use(&$i){eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');return$c;});};

Essayez-le en ligne!

Moins de golf:

function f( $t ) {
    return array_reduce( $t,
        function( $c, $x ) use( &$i ) {
            eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');
            return $c;
        }
    );
};

Était vraiment enraciné pour que array_reduce () travaille pour cela, mais nécessite trop de caractères pour battre le score PHP actuel le plus bas.

Le poster quand même au cas où quelqu'un aurait des suggestions!

Brachylog , 68 octets

hI,?bL,1:+:-:*:/:^b:L:I{bhv?t.|[O:L:I]h$(P,LbM,OhA,Lh:Ir:A&:M:Pr&.}.

C'est long… mais il n'utilise aucun prédicat d'évaluation.

Explication

• Prédicat principal

  hI,                                  Unify I with the first element of the input
     ?bL,                              L is the input minus the first element
         1:+:-:*:/:^b                  Construct the list of predicates [+:-:*:/:^]
                     :L:I{...}.        Call predicate 1 with [[+:-:*:/:^]:L:I] as input
  

• Prédicat 1

  bhv?t.                               If the second element of Input is empty (i.e. L),
                                       unify Output with the last element of Input
  |                                    Or
  [O:L:I]                              Input = [O:L:I]
         h$(P,                         P is O circularly permutated to the left
              LbM,                     M is L minus the first element
                  OhA,                 A is the first element of O
                      Lh:Ir:A&         Call predicate A on [I:First element of L]
                              :M:Pr&.  Call predicate 1 recursively with P:M:
  

FPU IBM PC 8087, 66 82 octets

Utilise uniquement le coprocesseur mathématique Intel 8087 du PC IBM pour les calculs.

Essayez-le hors ligne! (dans DOSBox ou autre). Donnez à la vieille puce 8087 ennuyée de votre ancien PC quelque chose à faire, en plus de toutes les feuilles de calcul Lotus 1-2-3 que vous utilisiez dans les années 80.

9bdf 0783 c302 499b de07 83c3 0249 e342 9bde 2783 c302 49e3 399b de0f 83c3 0249 
e330 9bde 3783 c302 49e3 2751 8b0f 9bd9 e883 f900 7413 9c7f 02f7 d99b d8c9 e2fb 
9d7d 069b d9e8 9bd8 f159 83c3 0249 e302 ebb5 c3

Ungolfed (non assemblé):

START: 
    ; RUN TESTS  
    MOV  BX, OFFSET TST     ; 5, 12, 23, 2, 4, 4, 2, 6, 7
    MOV  CX, CTST           ; input array length
    CALL WOMI               ; calculate sequence
    CALL PRINT_FLT          ; output to console

    MOV  BX, OFFSET TST1    ; 5, 12, 23, 2, 4, -4, 2, 6, 7
    MOV  CX, CTST1
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST2    ; -8, 50, 3, 3, -123, 4, 17, 99, 13
    MOV  CX, CTST2
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST3    ; 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
    MOV  CX, CTST3
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST4    ; 1,0,1,0,1,0
    MOV  CX, CTST4
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST5    ; -9, -8, -1
    MOV  CX, CTST5
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST6    ; 0, -3
    MOV  CX, CTST6
    CALL WOMI
    CALL PRINT_FLT

    MOV  AX, 4C00H          ; exit to DOS
    INT  21H

;  TEST DATA

TST   DW  5, 12, 23, 2, 4, 4, 2, 6, 7
CTST  EQU ($-TST)/(SIZE TST)    ; count of items on list

TST1  DW  5, 12, 23, 2, 4, -4, 2, 6, 7
CTST1 EQU ($-TST1)/(SIZE TST1)  ; count of items on list

TST2  DW -8, 50, 3, 3, -123, 4, 17, 99, 13
CTST2 EQU ($-TST2)/(SIZE TST2)  ; count of items on list

TST3  DW 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
CTST3 EQU ($-TST3)/(SIZE TST3)  ; count of items on list

TST4  DW 1,0,1,0,1,0
CTST4 EQU ($-TST4)/(SIZE TST4)  ; count of items on list

TST5  DW -9, -8, -1
CTST5 EQU ($-TST5)/(SIZE TST5)  ; count of items on list

TST6  DW 0, -3
CTST6 EQU ($-TST6)/(SIZE TST6)  ; count of items on list

; 8087 exponent: ST(0) = ST(0) ^ EXP
FIEXP   MACRO   EXP
        LOCAL   REPEAT, DONE
        PUSH CX
        MOV  CX, EXP        ; Exponent is count for loop
        FLD1                ; load 1 into ST
        CMP  CX, 0          ; is exponent pos, neg or 0?
        JZ   DONE           ; exit (with value 1) if exponent is 0
        PUSHF               ; save result flags for later
        JG   REPEAT         ; if exp > 1 start calculation
        NEG  CX             ; make exponent positive for loop
REPEAT:
        FMUL ST(0), ST(1)   ; multiply ST0 = ST0 * ST1
        LOOP REPEAT
        POPF                ; retrieve flags from earlier
        JGE  DONE           ; if exponent was negative, divide 1 by result
        FLD1                ; push 1 into numerator
        FDIV ST(0), ST(1)   ; ST0 = 1 / ST1
DONE:
        POP  CX
        ENDM

; Function WOMI: (Weapons of Math Instruction)
; input: BX - address of start of input array
;       CX - length of input array
; output: ST - result on top of 8087 register stack
WOMI PROC
    FILD WORD PTR [BX]      ; load first item
    ADD  BX, 2              ; move to next
    DEC  CX
CALC:
    FIADD WORD PTR [BX]     ; add
    ADD  BX, 2              ; move to next
    DEC  CX                 ; decrement counter
    JCXZ OUTPUT             ; check if done

    FISUB WORD PTR [BX]     ; subtract
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIMUL WORD PTR [BX]     ; multiply
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIDIV WORD PTR [BX]     ; divide
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIEXP [BX]              ; exponent
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT
    JMP CALC                ; start again

OUTPUT:
    RET 
WOMI ENDP

PRINT_FLT PROC
; print top of 8087 stack
; scaling: 14 digits, 4 decimal places
; input: BX = address of a TBYTE (BCD) output buffer
;       ST = value to display on top of 8087 stack  
    LEA   BX, BUFF                  ; set BX to BCD output buffer
    MOV   AH, 2
    MOV   WORD  PTR[BX], 10000      ; ten thousand (scale factor)
    FIMUL WORD  PTR[BX]             ; scale up by 10000
    FBSTP TBYTE PTR[BX]             ; store as BCD
    FWAIT                           ; sync 8088 and 8087
    TEST  BYTE  PTR[BX+9], 80H      ; check sign bit
    JE    PF_1                      ; 0, goto PF_1
    MOV   DL, '-'                   ; output '-'
    INT   21H
PF_1:
    ADD   BX, 8                     ; point to high byte
    MOV   CH, 7                     ; 14 digits before decimal point
    MOV   CL, 4                     ; 4 shifts (8 bytes / 2 = 4 = 1 nibble)
    MOV   DH, 2                     ; 2 times (8 bytes / 4)
PF_LOOP:
    MOV   DL, [BX]                  ; get BCD digits
    SHR   DL, CL                    ; move high digit to low nibble
    OR    DL, 30H                   ; convert to ASCII
    INT   21H
    MOV   DL, [BX]                  ; get byte again
    AND   DL, 0FH                   ; mask out high digit
    OR    DL, 30H                   ; convert to ASCII
    INT   21H                       ; output
    DEC   BX                        ; next byte
    DEC   CH                        ; decrement byte
    JG    PF_LOOP                   ; repeat if more bytes
    DEC   DH                        ; second time?
    JE    PF_DONE                   ; yes, done
    MOV   DL, '.'                   ; no, output decimal point
    INT   21H
    MOV   CH, 2                     ; 4 more digits after decimal point
    JMP   PF_LOOP                   ; go print digits
PF_DONE:
    MOV  DL, 0DH                    ; display newline CRLF
    MOV  AH, 2
    INT  21H
    MOV  DL, 0AH
    INT  21H
    RET 
PRINT_FLT ENDP

BUFF DT 0   ; output buffer for floating point digit string

_TEXT ENDS
END START

Sortie:

A>WOMI.COM
00000000000539.0000
-00000000000027.9136
-00000000001055.3569
00000000000256.0000
00000000000001.0000
-00000000000016.0000
-00000000000003.0000

L'entrée s'effectue via un PROC (x86 correspondant le plus à une fonction), BX étant un pointeur sur un tableau de mots en mémoire, CX étant le nombre d'éléments qu'il contient et renvoie le résultat en ST.

* Remarque: le code actuel de la fonction est 6682 octets. Bien sûr, le code servant à écrire un nombre à virgule flottante sur la console (code du livre de recettes) est de 83 octets. Le programme de test et les données sont183215 octets, rendant le fichier .COM exécutable 305 380 octets au total.

APL (Dyalog Unicode) , 29 ^{SBCS sur} 27 octets

Fonction de préfixe tacite anomyme. Notez que *c'est une exponentiation en APL.

≢{⍎3↓⍕⌽⍵,¨⍨⍺⍴'+-×÷*',¨'⍨'}⊢

Essayez-le en ligne!

Comme APL s'exécute de droite à gauche, nous pouvons simplement inverser l'ordre des arguments des opérations insérées et inverser l'expression entière. Postfix ⍨inverse les arguments. Après avoir parfaitement mélangé chiffres et opérations, il suffit d’inverser, d’aplanir et d’évaluer:

≢{… }⊢ Appeler la fonction suivante avec le nombre et les nombres réels tels que ⍺et ⍵:

 '⍨' ce personnage

 '+-×÷*',¨ ajoutez chacun de ces personnages à cela; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

 ⍺⍴ utiliser de manière cyclique l'argument de gauche (nombre de chiffres) r Eshape que

 ⌽ sens inverse

 ⍕ format comme ficelle plate

 3↓supprimer les 3 premiers caractères (un espace et un symbole et ⍨)

 ⍎ exécuter en tant que code APL

Japt , 16 octets

r@[XY]r"p+-*/"gZ

Essayez-le en ligne!

Explication:

r@                  #Reduce the input list:
       "p+-*/"      # The list of functions to apply (offset by one due to the behavior of Z)
              gZ    # Choose the one at the current index, wrapping
  [  ]r             # Apply that function to:
   X                #  The result of the previous step
    Y               #  and the current number
                    #Implicitly return the result of the final step

c #, 238 , 202 octets

double d(double[]a){Array.Reverse(a);var s=new Stack<double>(a);int i=0,j;while(s.Count>1){double l=s.Pop(),r=s.Pop();j=i++%5;s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l,r));}return s.Peek();}

Je n'ai pas vu de solution C #, donc je vais en donner une. Ceci est mon premier codegolf. J'ai commencé à écrire en c # "il y a deux mois" (bien que je connaisse Java dans une certaine mesure).

Il utilise Stack

Ungolfed et cas de test

using System;
using System.Collections.Generic;

class M 
{
    double d(double[]a) {
        Array.Reverse(a);
        var s = new Stack<double>(a);
        int i=0,j;
        while (s.Count>1)
        {
            double l=s.Pop(),r=s.Pop();
            j=i++%5;
            s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l, r));
        }
        return s.Peek();
    }

    public static void Main()
    {
        int[][] a = new int[][]{
            new int[]{1,2,3,4,5},
            new int[]{5,12,23,2,4,4,2,6,7},
            new int[]{-8,50,3,3,-123,4,17,99,13},
            new int[]{2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
            new int[]{1,0,1,0,1,0},
            new int[]{-9,-8,-1},
            new int[]{0,-3},
            new int[]{-99}
        };

        for (int i = 0; i < a.Length; i++)
        {
            Console.WriteLine(new M().d(Array.ConvertAll(a[i], e => Convert.ToDouble(e))));
        }
        Console.ReadKey();
    }
}

Sortie:

0
539
-1055,35694384628
256
1
-16
-3
-99

PHP, 206 , 198 , 197 octets

function f($a){while(count($a)>1){$l=array_shift($a);$r=array_shift($a);array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));}return array_pop($a);}

Ungolfed

<?php

function f($a)
{
    while(count($a)>1)
    {
        $l = array_shift($a); $r = array_shift($a);
        array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));
    }
    return array_pop($a);
}

echo f([1,2,3,4,5])."\n";
echo f([5,12,23,2,4,4,2,6,7])."\n";
echo f([-8,50,3,3,-123,4,17,99,13])."\n";
echo f([2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2])."\n";
echo f([1,0,1,0,1,0])."\n";
echo f([-9,-8,-1])."\n";
echo f([0,-3])."\n";
echo f([-99])."\n";

En PHP, une logique similaire à ma réponse c # ( 202 octets ) :).