Regole

1. Nessun riferimento all'intervallo di celle ( A2:B3).

2. Massimo 9 righe e 9 colonne.

3. Nessun riferimento circolare o errori di formula.

4. Le celle vuote valutano 0.

5. I dati sono solo numeri, ma possono essere presi come stringhe.

6. Le formule sono stringhe.

Scelte di implementazione

Devi dichiarare le tue scelte in queste materie:

7. Richiede che le formule siano precedute da un singolo carattere, ad es. =- oppure no.

8. La cella più a sinistra della seconda riga è A2o R2C1, secondo le due convenzioni utilizzate da Excel et al.

9. Richiede qualsiasi prefisso o suffisso a carattere singolo nei riferimenti di cella, ad es. $- oppure no.

10. Una stringa vuota, vuota, elenco vuoto, ecc. (Ma non 0) per rappresentare celle vuote.

11. Lingua della richiesta (i gestori di fogli di calcolo non sono ammessi).

12. Lingua per le formule (può differire da quanto sopra). *

13. Punti brownie o cookie per spiegare la tua soluzione.

Esempi

Scelte: 7: =; 8 A2:; 9: nessuno; 10 "":; 12: Excel Formula Language

Nel:

[[       2, 3],
 ["=A1+B1",""]]

Su:

[[2,3],
 [5,0]]

Nel:

[[       2,"=A1+B2"],
 ["=A1+B1",      ""]]

Su:

[[2,2],
 [4,0]]

Nel:

[[ 3, 4,"=A1*B1"],
 [ 2, 5,"=A2*B2"],
 ["","","=C1+C2"]]

Su:

[[3,4,12],
 [2,5,10],
 [0,0,22]]

Nel:

[["","=2*B2*B3"     ,""],
 [ 3,"=A1+(A2+C2)/2", 2],
 [ 1,"=C1+(A3+C3)/2", 5]]

Su:

[[0,15,  0],
 [3, 2.5,2],
 [1, 3  ,5]]

^{* La lingua della formula deve essere ammissibile PPCG , ma devi solo supportare i riferimenti di cella più i criteri 3 e 4 lì, vale a dire. determinazione di addizione e primosità.}

JavaScript, 125 112 105 byte

Per usare, aggiungi f=all'inizio e invoca like f(argument).

a=>a.map(b=>b.map(p=>+p?p:p?eval(p.replace(/[A-I][1-9]/g,m=>`a[${m[1]-1}][${(m.charCodeAt(0)-65)}]`)):0))

scelte:

7. Non richiede =.
8. La cella più a sinistra della seconda riga è A2.
9. Non richiede alcun prefisso o suffisso.
10. "" (Stringa vuota) per indicare la cella vuota.
11. JavaScript.
12. JavaScript.
13. Biscotti. 🍪🍪🍪

Spiegazione:

Questa soluzione scorre su tutte le celle del foglio di lavoro (ogni elemento dei sotto-array della matrice data) e se viene trovata una stringa non vuota, sostituisce i suoi riferimenti di cella con i corrispondenti riferimenti in termini di matrice data e valuta l'espressione con eval()(sì, quella cosa malvagia che ti perseguita nei tuoi incubi ). Questa soluzione presuppone che le costanti fornite nell'array di input siano di tipo intero.

Casi test

f=a=>a.map(b=>b.map(p=>+p?p:p?eval(p.replace(/[A-I][1-9]/g,m=>`a[${m[1]-1}][${(m.charCodeAt(0)-65)}]`)):0))

console.log(f([[1,2,3],["A1+B1+C1",10,11]]));
console.log(f([[1,2,5,4,6,89,0],[0,1,2,3,"A2+A1",5,6]]));
console.log(f([[1,2,4,5],["A1/B1*C1+A1+Math.pow(5,B1)",2,3,4]]));

PHP, 265 263 259 258 257 240 224 222 213 202 196 byte

caratterizzato da array_walk_recursiveuna funzione anonima ricorsiva e preg_replace_callback:

function f(&$a){array_walk_recursive($a,$p=function(&$c)use($a,&$p){eval('$c='.preg_replace_callback("#R(.)C(.)#",function($m)use($a,&$p){$d=$a[$m[1]-1][$m[2]-1];$p($d);return$d;},$c?:0).';');});}

o

function f(&$a){array_walk_recursive($a,$p=function(&$c)use($a,&$p){eval('$c='.preg_replace_callback("#R(.)C(.)#",function($m)use($a,&$p){return$p($a[$m[1]-1][$m[2]-1]);},$c?:0).';');return$c;});}

opera su input: chiama per riferimento. Provalo online .

• nessun prefisso di espressione
• formato di riferimento R2C1, nessun prefisso
• qualcosa di falso per cella vuota
• valuta qualsiasi espressione PHP (minuscola), comprese tutte le aritmetiche

guasto (prima versione)

function f(&$a)
{
    array_walk_recursive($a,                    # walk through elements ...
        $p=function(&$c)use($a,&$p){            # use array $a and recursive $p
            eval('$c='.                             # 3. evaluate expression
                preg_replace_callback('#R(.)C(.)#', # 2. replace references with ...
                function($m)use($a,&$p){
                    $d=$a[$m[1]-1][$m[2]-1];            # $d=content of referenced cell
                    $p($d);                             # recursive evaluation
                    return$d;                           # return $d
                },$c?:0)                            # 1. replace empty with 0
                .';'
            );
        }
    );
}

Mathematica, 119 115 95 byte

(m=#/.""->0)//.s_String:>ToExpression@StringReplace[s,"R"~~x_~~"C"~~y_:>"m[["<>{x,",",y,"]]"}]&

scelte:

7. Nessun prefisso
8. R2C1 stile.
9. Nessun prefisso o suffisso.
10. "" per celle vuote.
11. Matematica.
12. Matematica. Le espressioni aritmetiche arbitrarie che non usano le variabili del modulo RxCye non hanno effetti collaterali dovrebbero funzionare.

Spiegazione

(m=#/.""->0)

Iniziamo sostituendo tutte le stringhe vuote nell'input ( #) con zeri e memorizzando il risultato m, perché ne avremo bisogno di nuovo in un altro posto.

...//.s_String:>...

Sostituisci ripetutamente qualsiasi stringa rimanente scon il seguente ...

...StringReplace[s,"R"~~x_~~"C"~~y_:>...]

Abbinare qualsiasi sottostringhe della forma RxCyin se sostituirli con ...

..."m[["<>{x,",",y,"]]"}

Che dà m[[x,y]], che usa xe ycome indici nella matrice m.

...ToExpression@...

Finallz, valuta questa stringa come espressione di Mathematica.

Clojure, 263 281 byte

Oh dannazione senza che apply map vectoril risultato sia in trasposizione, come in A2ordine alfabetico prima B1.

#(apply map vector(partition(count(% 1))(for[v(vals(loop[C(into{}(mapcat(fn[i r](map(fn[j v][(str j i)(or v"0")])"ABCDEFGHI"r))(rest(range))%))P[]](if(= C P)C(recur(into(sorted-map)(for[[k v]C][k(reduce(fn[r[K V]](clojure.string/replace r K V))v C)]))C))))](eval(read-string v)))))

Esempi:

(def f #(...))

(f [["2" "3"]["(+ A1 B1)" nil]])
([2 3] [5 0])

(f [[nil ,"(* 2 B2 B3)"                ,nil],
    ["3" ,"(+ A1 (/ (+ A2 C2) 2))"     ,"2"],
    ["1" ,"(-> A3 (+ C3) (/ 2) (+ C1))","5"]])
([0 15N 0] [3 5/2 2] [1 3 5])

7. Le formule sono espressioni S
8. A2
9. No, (+ A1 A2)va bene
10. nile falsefunzionano come celle vuote, ma le stringhe vuote no
11. Clojure
12. Espressioni S (Clojure + eventuali macro incorporate)

Un esempio di prima macro thread:

(macroexpand '(-> A3 (+ C3) (/ 2) (+ C1)))
(+ (/ (+ A3 C3) 2) C1)

Il valore iniziale di Cnel ciclo è una mappa hash, le chiavi sono nomi di celle e i valori sono valori originali. Quindi tutti i riferimenti di cella vengono sostituiti dal contenuto delle celle di riferimento fino a quando non abbiamo fatto convergere ( Previous =C urrent), quindi le celle vengono valutate e la struttura piatta viene ripartita in un elenco nidificato.

Sarebbe bello trovare una soluzione in cui A1, A2ecc. Sono effettivamente funzioni richiamabili, quindi (* 2 B2 B3)potrebbero essere riscritte (* 2 (B2) (B3))ed eseguite.

Provalo online!

APL (Dyalog) , 51 byte

⍎¨({((⍴⍵)↑⍉⎕A∘.,1↓⎕D),¨'←',¨⍵}{0::⍵⋄×≢⍵:⍕⍎⍕⍵⋄0}¨)⍣≡

7. Nessuna

8. A2

9. Nessuna

10. Stringa vuota

11. APL

12. APL

Provalo online!

⍎¨ Valuta ogni cella del risultato da

(... )⍣≡ applicazione continua delle seguenti due funzioni fino a quando non cambia più nulla

 { prima funzione anonima da applicare ...

  0 in caso di
  :: errore:
   ⍵ restituisce l'argomento non modificato

  ⋄ ora prova;

  ⍵ se il
  ≢ conteggio dell'argomento :
  × è positivo,
  : allora:
   ⍕ stringi
   ⍎ l'  argomento valutato
   ⍕ valutato
   ⍵

  ⋄ altro;

  0 restituisce zero

 }¨ ... per ogni cella

 { seconda funzione anonima da applicare ...

  '←',¨ anteporre una freccia di assegnazione a ciascuna cella
  ⍵ dell'argomento

  (... ),¨ anteponi quanto segue a ciascuna cella

   1↓ rilascia la prima della
   ⎕D stringa di tutte le D igit (cioè zero)

   ⎕A Con tutte le lettere dell'alfabeto A che scendono,
   ∘., crea una tabella di concatenazione (con le cifre rimanenti che vanno a destra)

   ⍉ trasporre (per ottenere numeri crescenti verso il basso, avanzando lettere a destra)

   (... )↑ prendi il sottomatrix in alto a sinistra con le dimensioni di ...

    ⍴ la dimensione
    ⍵ dell'argomento

 } ... al risultato della funzione precedente.

Python 2 273.265.263 , 259 byte

import re
def g(m):x=m.group();return's[%d][%d]'%(int(x[1])-1,ord(x[0])-65)
e=enumerate
while'='in`s`:
    for x,i in e(s):
        for i,j in e(i):
            try:s[x][i]=0if not j else float(eval(re.sub('\w\d',g,str(j)).strip('=')))
            except:pass

Provalo online!

scelte:

7. =

8. A2

9. nessuna

10. ""

11. Python 2.7

12. Espressioni Python

Spiegazione di base:

Per ogni formula nell'elenco secondario, sostituirla con l'indice dell'elenco corrispondente (ovvero, per B1 s [0] [1]) e valutare il risultato!

• -4 byte cambiando str () in backtick!