L'ultima volta che ho provato a trovare qualcosa di facile che non era un duplicato, è finito per essere troppo difficile .. Quindi speriamo che questa volta sia davvero qualcosa che i nuovi arrivati ​​possano provare.

Ingresso:

Un array / elenco con numeri interi / decimali. (O una stringa che rappresenta un array con numeri interi / decimali.)

Produzione:

Scorrere i numeri e applicare i seguenti cinque operandi matematici in questo ordine:

• Addizione ( +);
• Sottrazione ( −);
• Moltiplicazione ( *o ×o ·);
• Divisione Reale / Calcolatrice ( /o ÷);
• Esponenziazione ( ^o **).

(NOTA: I simboli tra parentesi sono appena aggiunti come chiarimento. Se il tuo linguaggio di programmazione utilizza un simbolo completamente diverso per l'operazione matematica rispetto agli esempi, allora è ovviamente del tutto accettabile.)

Continua fino a quando non hai raggiunto la fine dell'elenco, quindi dai il risultato della somma.

Regole della sfida:

• L'esponenziazione di 0 ( n ^ 0) dovrebbe risultare in 1 (questo vale anche per 0 ^ 0 = 1).
• Non ci sono casi di test per la divisione per 0 ( n / 0), quindi non devi preoccuparti di quel caso limite.
• Se l'array contiene un solo numero, lo restituiamo come risultato.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.

Casi 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

Gelatina , 13 byte

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

Provalo online! o verifica tutti i casi di test .

Come funziona

“+_×÷*”ṁṖ⁸ż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 byte

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

Salvati 9 byte grazie a Dom Hastings, salvati altri 6 grazie a Leaky Nun

Utilizza il nuovo operatore di esponenziazione.

Haskell, 76 65 64 62 byte

Grazie a @Damien per aver rimosso altri due byte =)

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

Questo utilizza ciò >>che qui aggiunge semplicemente l'elenco [(+),...]a se stesso length vvolte. Il resto funziona ancora allo stesso modo delle versioni precedenti.

Vecchie versioni:

Queste soluzioni fanno uso degli elenchi infiniti, in quanto cycle[...]ripetono semplicemente l'elenco indicato all'infinito. Quindi viene sostanzialmente modificato zipcon l'elenco dei numeri e semplicemente fold( riduciamo in altre lingue) l'elenco compresso tramite un lambda, che applica gli operatori all'elemento accumulatore / elenco corrente.

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 byte

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

Provalo qui!

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

Haskell, 61 byte

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

Crea una serie di trasformazioni in un elenco, come in [aggiungi 1, aggiungi 2, sottrai 3, ...], iniziando con 2 aggiunte perché iniziamo con 0 nella piega. Successivamente, facciamo ciò che chiamo Elenco applicazione piega, o foldl (flip id), che applica un elenco di omomorfismi in serie. Questo inizia con zero, aggiunge il valore iniziale, quindi esegue tutte le trasformazioni calcolate sopra per ottenere un risultato finale.

Si noti che (flip id) è uguale a (\ x y-> yx), solo più corto.

Esempio di utilizzo:

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

TSQL 116 115 88 byte

Grazie al suggerimento di Ross Presser sono stato in grado di giocare a golf fino a 88 caratteri

-- 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 @

Provalo online

Pyth, 27 26 25 byte

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

Suite di test.

Pyth usa la notazione con prefisso: 1+2è scritto come +1 2(spazio necessario per separare i numeri).

Pertanto, per il primo testcase, l'espressione sarebbe (((1+2)-3)*4)/5, che in notazione con prefisso, sarebbe scritta come /*-+ 1 2 3 4 5.

In Pyth, la divisione float è cinvece di /, quindi diventa c*-+ 1 2 3 4 5.

Inoltre, in Pyth, -100è scritto come _100invece.

Pertanto, per il terzo caso di test, che è ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), diventa: *-+^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.

Storia

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

In realtà, 23 byte

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

Provalo online!

In realtà utilizza la notazione postfix per la matematica e gli operatori che accettano sempre e solo due argomenti (come gli operatori per addizione, sottrazione, moltiplicazione, divisione ed esponenziazione) non fanno nulla quando c'è solo un elemento nello stack. Pertanto, trasformare l'input in Realmente codice è semplice come invertire l'input, formattarlo come numeri e aggiungere le operazioni. Quindi, il codice risultante può essere eseguito, fornendo l'output desiderato.

Spiegazione:

;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

Esempio di codice tradotto per l'input 1,2,3,4,5:

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

Julia, 53 50 byte

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

Provalo online!

J, 40 byte

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

Trova il numero di valori necessari per utilizzare un multiplo di 5 operatori, rispetto ai pad con i valori di identità di tali operatori. Nell'ordine, +è 0, -è 0, *è 1, %è 1 ed ^è 1, che può essere un valore in bit 00111, o 7 in base 10. Quindi opera su quell'elenco mentre si scorre tra gli operatori.

uso

   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

Spiegazione

^~`(%~)`*`(-~)`+/@(|.@,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 byte

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

L'input è una matrice di float. Provalo su Ideone .

Come funziona

'*+-*/*'[i::5]seleziona ogni quinto carattere della stringa, iniziando con quello all'indice i , quindi questo produce **se i = 0 , +se i = 1 , -se i = 2 , *se i = 3 e /se i = 4 . Poiché la stringa ha lunghezza 6 , l'espressione produrrà una stringa vuota se i> 5 .

Inizializziamo la variabile da i a 10 . Per ogni numero n nella matrice di input, costruiamo la stringa r<op>=n, che execviene eseguita.

Inizialmente, i = 10 , quindi <op>è la stringa vuota e inizializza r con r+=n. Dopo ogni passaggio, incrementiamo i modulo 5 con i=-~i%5, quindi il passaggio successivo recupererà l'operatore corretto.

Quando tutti i numeri di input sono stati elaborati e stampiamo r , che contiene l'output desiderato.

Matlab - 95 91 85 byte / Ottava - 81 byte

L'input è in tale forma a = ['1' '2' '3' '4' '5'];:, spero che questo sia coperto da "stringa che rappresenta un array con numeri interi / decimali", altrimenti sono necessari 2 num2str aggiuntivi.

Ogni risultato intermedio viene stampato su console perché ciò mi fa risparmiare qualche punto e virgola. a(1)viene eseguito, quindi il suo valore viene quindi salvato in ans. Ovviamente anche usare ansnel codice è una cattiva pratica.

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

In Octave, '+-*/^'(mod(i+2,5)+1)funziona anche, il che consente di risparmiare altri 4 byte, grazie Adám e Luis Mendo:

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

changelog:

• Spazi rimossi ove possibile
• aggiunta la soluzione Octave
• ha sostituito strcat () con []

Mathematica, 67 66 65 byte

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

Semplice Foldcon una variabile che itiene l'indice.

CJam, 18 byte

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

L'input è una matrice di float. Provalo online!

Come funziona

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 byte

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

Provalo online!

Haskell - 74

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

Casi 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

Probabilmente potrebbe essere più breve; Il supporto di Haskell per elenchi infiniti e funzioni di ordine superiore rende la soluzione diretta abbastanza piacevole. Una versione di ^ :: Double -> Double -> Doublesarebbe migliore per giocare a golf, ma non riuscivo a trovarne una. Per fortuna, non avevo bisogno di una lambda completa, quindi lo stile inutile si è rasato pochi byte.

PowerShell v2 +, 124 byte

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

A lungo perché PowerShell non ha un operatore ^o **, quindi dobbiamo tenere conto di un caso separato e utilizzare una chiamata .NET.

Prende l'input $ncome un array, imposta il nostro output $ocome prima cifra. Quindi controlliamo l' .countarray, e fintanto che è maggiore di uno entriamo in if. Altrimenti, saltiamo il file if.

All'interno del ifciclo attraversiamo l'array 1..$y|%{...}e ogni iterazione reimpostata su $oun nuovo valore, il risultato di un'altra if/elseistruzione. Finché il nostro contatore $i++non è modulo-5 uguale a 4 (cioè non siamo ^all'operatore), semplicemente lo prendiamo $oe lo concateniamo con il simbolo appropriato '+-*/'[$x]e il numero successivo nella matrice di input $n[$_]. Lo reindirizziamo a iex(alias for Invoke-Expressione simili a eval), e quello viene nuovamente salvato $o. Se siamo sull'operatore ^, siamo nel else, quindi eseguiamo una [math]::Pow()chiamata e quel risultato viene nuovamente salvato $o.

In entrambi i casi, eseguiamo semplicemente l'output $oalla pipeline e usciamo , con output implicito.

Ruggine, 123 , 117 byte

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

stupidi nomi di metodi lunghi ^^ ahh molto meglio

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

ungolfed

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 byte

{$/=[(|(&[+],&[-],&[*],&[/],&[**])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*}

Spiegazione:

-> *@_ {
  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
}

Tecnicamente * + *è un qualunque lambda, ma è effettivamente lo stesso &[+]che è l'abbreviazione &infix:<+>dell'insieme di subroutine che gestiscono l'addizione numerica infissa.
Non l'ho usato per la moltiplicazione o l'espiazione poiché i modi per scriverli in quel modo sono almeno lunghi quanto quello che ho ( *×*o * * *e * ** *)

Test:

Provalo su ideone.com
(dopo l'aggiornamento a una versione di Rakudo che non è di un anno e mezzo prima dell'uscita ufficiale degli spettacoli di Perl 6 )

#! /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 byte

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

È iniziato molto più breve ma poi la precedenza dell'operatore mi ha sconfitto e ho dovuto includere molte parentesi ...

Oracle PL / SQL, 275 254 byte

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;

I dati devono essere inseriti in una tabella chiamata Tcon una colonna Ndi tipoNUMBER

Uso:

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;

Produzione:

-1055,356943846277162152071601242992595623

Versione da 275 byte:

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 byte

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

Spiegazione:

Provalo qui.

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

Alcuni trucchi possono ridurre l'approccio di @ Willmore da 23 a 174 byte (richiede php 5.6 o successivo). La parte più salvifica è la rimozione di parentesi non necessarie (-10 byte).

funzione f ($ a) {while (count ($ a)> 1) {$ l = array_shift ($ a); $ r = array_shift ($ a); array_unshift ($ a, ($ j = $ i ++% 5) ? ($ j == 1 $ L- $ r:? ($ j == 2 $ l * $ r:? ($ j == 3 $ l / $ r:? $ l $ ** r))): $ l + $ r);} fine del ritorno ($ a);}

Ma l'uso **dell'operatore invece di pow()consente anche di utilizzare evalun array per le operazioni; e con qualche altro trucco ...

PHP> = 5,6, 82 byte

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

prende l'elenco dai parametri della riga di comando. Corri con php -nr '<code>'o provalo online .

vecchia versione, 161 157 151 145 144 140 137 117 byte

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

Il golf più efficace è venuto dalla scrittura del risultato intermedio direttamente sul primo elemento, dopo aver spostato il risultato precedente dall'array.

abbattersi

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 di test

$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 byte

Grazie @titus, -5 byte, più 0 correzione del caso!

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

Provalo online!

Meno golfy:

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

Effettivamente il rooting per array_reduce () funzionava per questo, ma richiede troppi caratteri per battere l'attuale punteggio PHP più basso.

Pubblicandolo comunque nel caso qualcuno abbia qualche suggerimento!

Brachylog , 68 byte

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

È lungo ... ma non utilizza predicato di valutazione.

Spiegazione

• Predicato principale

  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
  

• Predicato 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:
  

IBM PC 8087 FPU, 66 82 byte

Utilizza solo il coprocessore matematico Intel 8087 del PC IBM per i calcoli.

Provalo offline! (in DOSBox o altro). Dai al tuo vecchio PC 8087 annoiato il chip qualcosa da fare, oltre a tutti quei fogli di calcolo Lotus 1-2-3 che facevi negli anni '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 assemblato):

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

Produzione:

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

L'input avviene tramite un PROC (x86 il più equivalente a una funzione), con BX come puntatore a un array di WORD in memoria e CX come numero di elementi in esso e restituisce il risultato in ST.

* Nota: il codice effettivo per la funzione è 6682 byte. Naturalmente, il codice solo per scrivere un numero in virgola mobile sulla console (codice del libro di cucina) è 83 byte. Il programma di test e i dati sono183215 byte, rendendo eseguibile .COM 305 380 byte in totale.

APL (Dyalog Unicode) , 29 27 byte ^SBCS

Anomia tacita prefisso funzione. Si noti che *è esponenziazione in APL.

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

Provalo online!

Poiché APL viene eseguito da destra a sinistra, possiamo semplicemente invertire l'ordine degli argomenti delle operazioni inserite e invertire l'intera espressione. Postfix ⍨inverte gli argomenti. Dopo aver fatto un perfetto mix di numeri e operazioni, abbiamo solo bisogno di invertire, appiattire e valutare:

≢{... }⊢ chiama la seguente funzione con il conteggio dei numeri effettivi come ⍺e ⍵:

 '⍨' questo personaggio

 '+-×÷*',¨ anteporre ognuno di questi personaggi a quello; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

 ⍺⍴ utilizzare l'argomento sinistra (conteggio di numeri) per ciclicamente r eshape che

 ⌽ inverso

 ⍕ formato come stringa piatta

 3↓rilasciare 3 caratteri iniziali (uno spazio e un simbolo e ⍨)

 ⍎ eseguire come codice APL

Japt , 16 byte

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

Provalo online!

Spiegazione:

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 byte

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

Non ho visto alcuna soluzione c # quindi ne darò una. Questo è il mio primo codegolf. Ho iniziato a scrivere in c # "due mesi fa" (anche se conosco Java in una certa misura).

Usa Stack

Ungolfed e casi di 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();
    }
}

Produzione:

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

PHP, 206 , 198 , 197 byte

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

In PHP, logica simile alla mia risposta c # ( 202 byte ) :).