Règles

1. Aucune référence de plage de cellules ( A2:B3).

2. Maximum 9 lignes et 9 colonnes.

3. Aucune référence circulaire ou erreur de formule.

4. Les cellules vides sont évaluées 0.

5. Les données sont uniquement des nombres, mais peuvent être considérées comme des chaînes.

6. Les formules sont des chaînes.

Choix d'implémentation

Vous devez indiquer vos choix dans ces domaines:

7. Exiger que les formules soient préfixées par un caractère unique, par exemple =- ou non.

8. La cellule la plus à gauche de la deuxième ligne est A2ou R2C1, selon les deux conventions utilisées par Excel et al.

9. Exiger tout préfixe ou suffixe à caractère unique dans les références de cellule, par exemple $- ou non.

10. Une chaîne vide, vide, liste vide, etc., (mais pas 0) pour représenter des cellules vides.

11. Langue de votre soumission (les gestionnaires de feuilles de calcul ne sont pas autorisés).

12. Langue des formules (peut différer de la précédente). *

13. Points brownie ou cookies pour expliquer votre solution.

Exemples

Choix: 7 =:; 8 A2:; 9: aucun; 10 "":; 12: langage de formule Excel

Dans:

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

En dehors:

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

Dans:

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

En dehors:

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

Dans:

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

En dehors:

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

Dans:

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

En dehors:

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

^{* Le langage de la formule doit être PPCG admissible , mais il vous suffit de prendre en charge les références de cellule plus les critères 3 et 4, wiz. l'addition et la détermination de la primauté.}

JavaScript, 125 112 105 octets

Pour l'utiliser, ajoutez f=au début et invoquez 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))

Les choix:

7. Ne nécessite pas =.
8. La cellule la plus à gauche de la deuxième ligne est A2.
9. Ne nécessite aucun préfixe ou suffixe.
10. "" (Chaîne vide) pour indiquer une cellule vide.
11. JavaScript.
12. JavaScript.
13. Biscuits. 🍪🍪🍪

Explication:

Cette solution parcourt toutes les cellules de la feuille de calcul (chaque élément des sous-tableaux du tableau donné) et si une chaîne non vide est trouvée, remplace ses références de cellule par les références correspondantes en termes du tableau donné et évalue l'expression avec eval()(ouais, cette mauvaise chose qui vous hante dans vos cauchemars ). Cette solution suppose que les constantes fournies dans le tableau d'entrée sont de type entier.

Cas de 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 222 213 202 196 octets

avec array_walk_recursiveune fonction anonyme récursive et 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).';');});}

ou

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

fonctionne en entrée: appel par référence. Testez-le en ligne .

• aucun préfixe d'expression
• format de référence R2C1, pas de préfixe
• quelque chose de faux pour une cellule vide
• évalue toute expression PHP (en minuscules), y compris toutes les arithmétiques

panne (première version)

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 octets

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

Les choix:

7. Pas de préfixe.
8. R2C1 style.
9. Aucun préfixe ou suffixe.
10. "" pour les cellules vides.
11. Mathematica.
12. Mathematica. Les expressions arithmétiques arbitraires qui n'utilisent pas de variables du formulaire RxCyet n'ont pas d'effets secondaires devraient fonctionner.

Explication

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

Nous commençons par remplacer toutes les chaînes vides dans l'entrée ( #) par des zéros et en stockant le résultat m, car nous en aurons besoin à un autre endroit.

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

Remplacez à plusieurs reprises toute chaîne restante spar ce qui suit ...

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

Faites correspondre les séquences de la forme RxCyen sles remplacer par ...

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

Ce qui donne m[[x,y]], qui utilise xet ycomme indices dans la matrice m.

...ToExpression@...

Finallz, évaluez cette chaîne comme une expression Mathematica.

Clojure, 263 281 octets

Oh putain sans ça apply map vectorle résultat est en transposition, comme A2avant alphabétiquement 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)))))

Exemples:

(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. Les formules sont des expressions S
8. A2
9. Non, (+ A1 A2)ça va
10. nilet falsefonctionnent comme des cellules vides, mais la chaîne vide ne
11. Clojure
12. Expressions S (Clojure + toutes les macros intégrées)

Un exemple de première macro de thread:

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

La valeur de départ de Cdans la boucle est une carte de hachage, les clés sont des noms de cellule et les valeurs sont des valeurs d'origine. Ensuite, toutes les références de cellules sont remplacées par le contenu des cellules référencées jusqu'à ce que nous ayons convergé ( Previous = urrent C), puis les cellules sont évaluées et la structure plate est partitionnée à nouveau dans une liste imbriquée.

Ce serait cool de trouver une solution où A1, A2etc. sont en fait des fonctions appelables, puis (* 2 B2 B3)pourraient être réécrites (* 2 (B2) (B3))et exécutées.

Essayez-le en ligne!

APL (Dyalog) , 51 octets

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

7. Aucun

8. A2

9. Aucun

10. Chaîne vide

11. APL

12. APL

Essayez-le en ligne!

⍎¨ Évaluez chaque cellule du résultat de

(… L' )⍣≡ application continue des deux fonctions suivantes jusqu'à ce que plus rien ne change

 { première fonction anonyme à appliquer…

  0 en cas d'
  :: erreur:
   ⍵ renvoyer l'argument non modifié

  ⋄ Essayez maintenant;

  ⍵ si le
  ≢ décompte de l'argument :
  × est positif
  : alors:
   ⍕ stringify
   ⍎ l'  argument
   ⍕ stringified évalué
   ⍵

  ⋄ autre;

  0 retourner zéro

 }¨ … À chaque cellule

 { deuxième fonction anonyme à appliquer…

  '←',¨ ajouter une flèche d'affectation à chaque cellule de
  ⍵ l'argument

  (… ),¨ Ajoutez le texte suivant à chaque cellule de cette

   1↓ supprimer le premier de
   ⎕D la chaîne de tous les chiffres D (c'est-à-dire zéro)

   ⎕A Avec toutes les lettres de l' A lphabet aller vers le bas,
   ∘., faire une table de concaténation (avec les chiffres restants vont à droite)

   ⍉ transposer (pour diminuer les nombres, faire avancer les lettres à droite)

   (… )↑ Prenez la sous-matrice supérieure gauche de la taille de…

    ⍴ la taille de
    ⍵ l'argument

 } … Au résultat de la fonction précédente.

Python 2 273 265 265 , 259 octets

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

Essayez-le en ligne!

Les choix:

7. =

8. A2

9. aucun

10. ""

11. Python 2.7

12. Expressions Python

Explication de base:

Pour chaque formule de la sous-liste, remplacez-la par la liste correspondante (c'est-à-dire pour B1 s [0] [1]) et évaluez le résultat!

• -4 octets en changeant str () en backticks!