कैलकुलेटर को स्पिन करें

Question

परिचय:

आइए विंडोज में एक मानक कैलकुलेटर पर एक नज़र डालें: इस चुनौती के लिए, हम केवल निम्नलिखित बटन देखेंगे, और बाकी सब चीजों को अनदेखा करेंगे:

7 8 9 /
4 5 6 *
1 2 3 -
0 0 . +

चुनौती:

इनपुट:
आपको दो इनपुट प्राप्त होंगे:

• एक 90 डिग्री की वृद्धि में रोटेशन को इंगित करने के लिए कुछ है
• अन्य निर्देशांक की एक सूची है जो घुमाए गए कैलकुलेटर पर दबाए गए बटन का प्रतिनिधित्व करता है।

पहले इनपुट के आधार पर, हम घड़ी की दिशा में उल्लिखित लेआउट को 90 डिग्री की वृद्धि में घुमाते हैं। इसलिए यदि इनपुट है 0 degrees, तो यह जैसा है, वैसा ही रहता है; लेकिन अगर इनपुट है 270 degrees, तो इसे तीन बार दक्षिणावर्त (या एक बार वामावर्त) घुमाया जाएगा। यहाँ चार संभावित ले-आउट हैं:

Default / 0 degrees:
7 8 9 /
4 5 6 *
1 2 3 -
0 0 . +

90 degrees clockwise:
0 1 4 7
0 2 5 8
. 3 6 9
+ - * /

180 degrees:
+ . 0 0
- 3 2 1
* 6 5 4
/ 9 8 7

270 degrees clockwise / 90 degrees counterclockwise:
/ * - +
9 6 3 .
8 5 2 0
7 4 1 0

दूसरे इनपुट किसी भी उचित प्रारूप में निर्देशांक की एक सूची है † । उदाहरण के लिए (0-सूचकांक 2D पूर्णांक-सरणी):

[[1,2],[2,3],[0,3],[1,0],[1,1]]

आउटपुट:
हम दोनों राशि, साथ ही परिणाम (और एक बराबर चिह्न =) का उत्पादन करते हैं।

उदाहरण:
तो यदि इनपुट है 270 degreesऔर [[1,2],[2,3],[0,3],[1,0],[1,1]], आउटपुट बन जाएगा:

517*6=3102

चुनौती नियम:

• Be इनपुट किसी भी उचित प्रारूप में हो सकते हैं। पहला इनपुट हो सकता है 0-3, 1-4, A-D, 0,90,180,270, आदि दूसरे इनपुट 0-अनुक्रमित 2 डी सरणी, 1 अनुक्रमित 2 डी सरणी, एक स्ट्रिंग, प्वाइंट वस्तुओं की सूची, आदि आपका कॉल हो सकता है। दिए गए उदाहरण इनपुट की तुलना में x और y निर्देशांक को स्वैप करना संभव है। कृपया बताएं कि आपने अपने उत्तर में किन इनपुट प्रारूपों का उपयोग किया है!
• 517 * 6 = 3102यदि आप चाहते हैं तो आपको रिक्त स्थान (यानी ) जोड़ने की अनुमति है।
• आप अल्पविराम के बाद अनुगामी शून्य जोड़ने के लिए, तीन की एक अधिकतम (यानी की अनुमति दी जाती 3102.0/ 3102.00/ 3102.000बजाय 3102या 0.430के बजाय 0.43)।
• आपको आउटपुट में कोष्ठक जोड़ने की अनुमति नहीं है, इसलिए (((0.6+4)-0)/2)/4=0.575एक मान्य आउटपुट नहीं है।
• आपको अपनी भाषा के लिए अन्य ऑपरेंड-प्रतीकों का उपयोग करने की अनुमति है। इसलिए ×या ·इसके बजाय *; या ÷इसके बजाय /; आदि।
• चूंकि एक ऑपरेटर को इनपुट करते समय एक कैलकुलेटर स्वचालित रूप से गणना करता है, इसलिए आपको ऑपरेटर की पूर्वता को अनदेखा करना चाहिए! तो 10+5*3परिणाम होगा 45( (10+5)*3=45), नहीं 25( 10+(5*3)=25)
  (यानी 10→ +→ 5→ *(यह अब प्रदर्शन में 15 प्रदर्शित करता है) → 3→ =(अब यह उत्तर प्रदर्शित करता है 45))। उपयोग करते समय इसे ध्यान में रखें evalऔर परिणामी राशि पर समान कार्य करें।
• 0 से विभाजन के लिए कोई परीक्षण मामले नहीं होंगे।
• परिणाम के रूप में तीन से अधिक दशमलव अंकों के साथ कोई भी परीक्षण मामले नहीं होंगे, इसलिए परिणाम को गोल करने की कोई आवश्यकता नहीं है।
• ऐसे कोई भी परीक्षण मामले नहीं होंगे जहां कई ऑपरेशंस एक-दूसरे का अनुसरण करते हैं, या जहां दो डॉट्स एक-दूसरे का अनुसरण करते हैं।
• ऋणात्मक संख्याओं के लिए कोई परीक्षण मामले नहीं होंगे। ऋण-चिह्न ( -) केवल ऑपरेंड के रूप में उपयोग किया जाएगा, नकारात्मक के रूप में नहीं।
• .##अल्पविराम से पहले एक प्रमुख संख्या के बिना कोई भी परीक्षण मामले 2+.7नहीं होंगे (यानी एक वैध परीक्षण मामला नहीं होगा, लेकिन 2+0.7हो सकता है)।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
• डिफ़ॉल्ट लूपोल्स वर्जित हैं।
• यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
• इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामलों:

Input:   270 degrees & [[1,2],[2,3],[0,3],[1,0],[1,1]]
Output:  517*6=3102

Input:   90 degrees & [[3,1],[0,0],[0,1],[3,3],[2,0],[0,3],[0,0],[0,2],[3,0],[2,1]]
Output:  800/4+0.75=200.75

Input:   0 degrees & [[0,0],[1,0],[2,0],[3,0],[1,2],[2,1],[2,2]]
Output:  789/263=3

Input:   180 degrees & [[3,0],[1,0],[1,2],[0,0],[3,2],[0,1],[2,0],[0,3],[2,1],[0,3],[3,2]]
Output:  0.6+4-0/2/4=0.575

Comments

परीक्षण के मामलों में कई त्रुटियां हैं (जैसे कि 3rd और 4th में X और Y स्वैप किया गया है (पहली नहीं) और मुझे यह भी नहीं पता कि 2 को क्या हुआ)

— dzaima

क्या कार्यक्रम को अजीब बटन प्रेस को संभालना चाहिए? विंडोज (10) कैलकुलेटर पर 1+-*/+-*/2देता है 0.5।

— user202729

दूसरा परीक्षण मामला शुरू होना चाहिए[1,3],

— उरेल

क्या हमें 0 से कम 0 के बिना दशमलव को संभालना है, जैसे 0 में 2+.7?

— टटलमैन

ऑपरेटर पूर्वता है कि मैं मानक मोड में विंडोज कैलकुलेटर का उपयोग क्यों नहीं करता।

— नील

Answer 1

SOGL V0.12 , 70 69 67 बाइट्स

i⅛⁸Νο;⌡░▼Y6γj±²‘1n4n.⌡Iø,→{_≤whwιh:"/*-+”;W? )Κ; (Κ;}+}:Ƨ)(čøŗoļ=→p

इसे यहाँ आज़माएँ , या एक ऐसे संस्करण को आज़माएँ जो इनपुट-टेस्ट के मामलों में दिया गया हो

SOGLs Iऑपरेटर का उपयोग करता है , जो सरणी को घुमाता है। फिर एक जावास्क्रिप्ट सरणी के रूप में एक स्ट्रिंग पढ़ता है, और जहां एक ऑपरेशन का उपयोग किया जाता है, कोष्ठक में पिछले परिणाम का एनसेसमेंट करता है, जावास्क्रिप्ट के रूप में मूल्यांकन करता है और फिर कोष्ठक हटाता है।

Answer 2

डायलॉग एपीएल, 94 88 86 85 बाइट्स

{o,'=',⍎('('\⍨+/'+-×÷'∊⍨o),'[×÷+-]'⎕R')&'⊢o←(((⌽∘⍉⍣⍺)4 4⍴'789÷456×123-00.+')⊃⍨⊂∘⊢)¨⍵}

इसे ऑनलाइन आज़माएं!

समन्वय की 0-3सूची के रूप में, रोटेशन को बाएं तर्क के रूप में और सही तर्क के रूप में 1-आधारित सूचकांकों को लेता हैy x(1 1)(2 3)(4 5) आदि।

एपीएल में अभिव्यक्तियों के सही-सही मूल्यांकन के कारण यह काफी गड़बड़ हो गया।

Answer 3

सी (जीसीसी) , 282294 295 296 300 304 306 310 बाइट्स

सभी अनुकूलन को बंद करने की आवश्यकता है और केवल 32-बिट जीसीसी पर काम करना है।

float r,s;k,p,l,i;g(d,x,y){int w[]={y,x,3-y,3-x,y};d=w[d+1]*4+w[d];}f(x,y,z)int**z;{for(i=0;i<=y;i++)putchar(k=i-y?"789/456*123-00.+"[g(x,z[i][0],z[i][1])]:61),57/k*k/48?p?r+=(k-48)*pow(10,p--):(r=10*r+k-48):k-46?s=l?l%2?l%5?l&4?s/r:s+r:s-r:s*r:r,r=p=0,l=k:(p=-1);printf("%.3f",s);}

@ बाइट के लिए 1 बाइट धन्यवाद!

इसे ऑनलाइन आज़माएं!

समारोह प्रोटोटाइप:

f(<Direction 0-3>, <Number of entries>, <a int** typed array in [N][2]>)

इनपुट प्रारूप (TIO पर):

<Direction 0~3> <Number of entries>
<Entries 0 Row> <Entries 0 Column>
<Entries 1 Row> <Entries 1 Column>
....
<Entries N Row> <Entries N Column>

टिप्पणियों के साथ Ungolfed संस्करण:

float r, s;
k, p, l, i;
g(d, x, y) {
  int w[] = {
    y,
    x,
    3 - y,
    3 - x,
    y
  };
  d = w[d + 1] * 4 + w[d];
}
f(x, y, z) int **z; {
  for (i = 0; i <= y; i++)
  {
      putchar(k = i - y ? 
      "789/456*123-00.+"[g(x, z[i][0], z[i][1])] : 61),     // Print character, otherwise, '='
      57 / k * k / 48 ?                                     // If the character is from '0'~'9'
        p ?                                                 // If it is after or before a dot
            r += (k - 48) * pow(10., p--)                   // +k*10^-p
        :
            (r = 10 * r + k - 48)                           // *10+k
      :
          k - 46 ?                                          // If the character is not '.', that is, an operator, + - * / =
            s = l ?                                         // Calculate the result of previous step (if exist)
                    l % 2 ?                                 // If + - /
                        l % 5 ?                             // If + /
                            l & 4 ?
                                s / r
                            :
                                s + r
                        :
                            s - r
                    :
                        s * r
                 :
                    r,
                    r = p = 0, l = k                        // Reset all bits
          :
            (p = -1);                                       // Reverse the dot bit
  }
  printf("%.3f", s);
}

कोड ऐसे मामलों को संभाल सकता है 1+.7या जैसे -8*4।

बहुत दुखी सी में Very नहीं है eval।

Comments

आप वास्तव में 3*-5अमान्य जैसे मामलों को हटा सकते हैं । मैंने इसे नियमों में निर्दिष्ट किया है।

— केविन क्रूज़सेन

नियमों में आवश्यक सटीकता को ध्यान में रखते हुए केवल 3 स्थान हैं, आप एक मुफ्त बाइट के doubleसाथ बदल सकते हैं float। भी, के putc()समान नहीं है putchar()? मुझसे गलती भी हो सकती है।

— ओरियन

@ मुझे याद है putcकि आप किस स्ट्रीम को लिख रहे हैं यह निर्दिष्ट करने के लिए एक दूसरे तर्क की आवश्यकता है?

— कीउ गण

292 बाइट्स

— सीलिंगकैट

Answer 4

जावास्क्रिप्ट (ईएस 6), 162 160 157 बाइट्स

ओरिएंटेशन oऔर सरणी के रूप में इनपुट लेता है (y, x)a करी सिंटैक्स में निर्देशांक (o)(a)।

अभिविन्यास एक पूर्णांक है [0..3] में :

• 0 = 0 °
• 1 = 90 ° दक्षिणावर्त
• 2 = 180 ° दक्षिणावर्त
• 3 = 270 ° दक्षिणावर्त

o=>a=>(s=a.map(([y,x])=>'789/456*123-00.+'[[p=y*4+x,12+(y-=x*4),15-p,3-y][o]]).join``)+'='+eval([...x=`0)+${s}`.split(/(.[\d.]+)/)].fill`(`.join``+x.join`)`)

परीक्षण के मामलों

let f =

o=>a=>(s=a.map(([y,x])=>'789/456*123-00.+'[[p=y*4+x,12+(y-=x*4),15-p,3-y][o]]).join``)+'='+eval([...x=`0)+${s}`.split(/(.[\d.]+)/)].fill`(`.join``+x.join`)`)

console.log(f(3)([[2,1],[3,2],[3,0],[0,1],[1,1]])) // 517*6=3102
console.log(f(1)([[1,3],[0,0],[1,0],[3,3],[0,2],[3,0],[0,0],[2,0],[0,3],[1,2]])) // 800/4+0.75=200.75
console.log(f(0)([[0,0],[0,1],[0,2],[0,3],[2,1],[1,2],[2,2]])) // 789/263=3
console.log(f(2)([[0,3],[0,1],[2,1],[0,0],[2,3],[1,0],[0,2],[3,0],[1,2],[3,0],[2,3]])) // 0.6+4-0/2/4=0.575

Answer 5

रूबी , 135 133 132 बाइट्स

->r,c{a="";c.map{|x,y|a=((w="789/456*123-00.+"[[y*4+x,12-x*4+y,15-y*4-x,x*4+3-y][r]])=~/[0-9.]/?a:"#{eval a}")+w;w}*""+"=#{eval a}"}

इसे ऑनलाइन आज़माएं!

पूर्णांक के रूप में अभिविन्यास: 0 ° 0 के लिए, 1 90 ° और इतने पर।

Answer 6

अजगर 3, 235 234 230 बाइट्स

थोड़ा बदसूरत लेकिन यह पहले को छोड़कर सभी परीक्षण मामलों के लिए काम करता है, जो उदाहरण कैलकुलेटर से मेल नहीं खाता है। मैं रोटेशन को 0-3 (0-270) के रूप में लेता हूं और ऑफसेट करने के लिए 16 से गुणा करता हूं।

eval() एक अंतर्निहित है जिसमें कोड के रूप में तारों को संकलित करने का प्रयास किया जाता है और ऑपरेटरों को पाठ प्रतीकों को परिवर्तित करने का काम करता है।

import re
def f(r,c,J=''.join):
 b='789/456*123-00.+01470258.369+-*/+.00-321*654/987/*-+963.85207410'
 s=t=J([b[r*16+x*4+y]for y,x in c]);t=re.split('([\+\-\/\*])',s)
 while len(t)>2:t=[str(eval(J(t[0:3])))]+t[3:]
 print(s+'='+t[0])

वैकल्पिक विधि, यह थोड़ा लंबा हो गया, लेकिन मुझे सरणी को घुमाने के लिए वास्तव में यह एसओ टिप पसंद है ।

import re
def f(r,c):
 L=list;b=L(map(L,['789/','456*','123-','00.+']))
 while r:b=L(zip(*b[::-1]));r-=1
 s=''.join([b[x][y]for y,x in c]);t=re.split('([\+\-\/\*])',s)
 while len(t)>2:t=[str(eval(''.join(t[0:3])))]+t[3:]
 print(s+'='+t[0])

Answer 7

जावा 10, 418 380 378 बाइट्स

d->a->{String r="",g=d>2?"/*-+963.85207410":d>1?"+.00-321*654/987":d>0?"01470258.369+-*/":"789/456*123-00.+",n[],o[];for(var i:a)r+=g.charAt(i[1]*4+i[0]);n=r.split("[-/\\+\\*]");o=r.split("[[0-9]\\.]");float s=new Float(n[0]),t;for(int i=1,O,j=0;++j<o.length;O=o[j].isEmpty()?99:o[j].charAt(0),s=O<43?s*t:O<44?s+t:O<46?s-t:O<48?s/t:s,i+=1-O/99)t=new Float(n[i]);return r+"="+s;}

मेरे ही सवाल का जवाब देने का फैसला किया। मुझे यकीन है कि यह एक अलग दृष्टिकोण का उपयोग करके कुछ और गोल्फ हो सकता है।
इनपुट के रूप में int( 0-3) और int[][](0-अनुक्रमित / चुनौती विवरण में समान)। यदि परिणाम दशमलव संख्या के बजाय पूर्णांक है तो floatअग्रणी के साथ आउटपुट .0।

-2 बाइट्स @ceilingcat की बदौलत ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

d->a->{                       // Method with int & 2D int-array parameters and String return
  String r="",                //  Result-String, starting empty
    g=d>2?                    //  If the input is 3:
       "/*-+963.85207410"     //   Use 270 degree rotated String
      :d>1?                   //  Else if it's 2:
       "+.00-321*654/987"     //   Use 180 degree rotated String
      :d>0?                   //  Else if it's 1:
       "01470258.369+-*/"     //   Use 90 degree rotated String
      :                       //  Else (it's 0):
       "789/456*123-00.+",    //   Use default String
    n[],o[];                  //  Two temp String-arrays
  for(var i:a)                //  Loop over the coordinates:
    r+=g.charAt(i[1]*4+i[0]); //   Append the result-String with the next char
  n=r.split("[-/\\+\\*]");    //  String-array of all numbers
  o=r.split("[[0-9]\\.]");    //  String-array of all operands (including empty values unfortunately)
  float s=new Float(n[0]),    //  Start the sum at the first number
        t;                    //  A temp decimal
  for(int i=0,                //  Index-integer `i`, starting at 0
      O,                      //  A temp integer
      j=0;++j<o.length        //  Loop `j` over the operands
      ;                       //    After every iteration:
       O=o[j].isEmpty()?      //     If the current operand is an empty String
          99                  //      Set `O` to 99
         :                    //     Else:
          o[j].charAt(0),     //      Set it to the current operand character
       s=O<43?                //     If the operand is '*':
          s*t                 //      Multiply the sum with the next number
         :O<44?               //     Else-if the operand is '+':
          s+t                 //      Add the next number to the sum
         :O<46?               //     Else-if the operand is '-':
          s-t                 //      Subtract the next number from the sum 
         :O<48?               //     Else-if the operand is '/':
          s/t                 //      Divide the sum by the next number
         :                    //     Else (the operand is empty):
          s,                  //      Leave the sum the same
       i+=1-O/99)             //     Increase `i` if we've encountered a non-empty operand
    t=new Float(n[i]);        //   Set `t`  to the next number in line
  return r+"="+s;}            //  Return the sum + sum-result

Answer 8

पीएचपी ,267 235 229 225 221 213 बाइट्स

<?php $t=[1,12,15,4,1];$j=$t[$k=$argv[1]];($o=$i=$t[$k+1])<5&&$o--;foreach(json_decode($argv[2])as$c){echo$s='/*-+963.85207410'[($c[0]*$i+$c[1]*$j+$o)%16];strpos(' /*-+',$s)&&$e="($e)";$e.=$s;}eval("echo'=',$e;");

इसे ऑनलाइन आज़माएं!

6 बाइट्स @Kevin क्रूज़सेन के लिए धन्यवाद।

इनपुट निर्देश हैं: 0 0 है, 1 90 है, 2 180 है और 3 270 डिग्री है।

Ungolfed

रोटेशन मुश्किल है, मेरा विचार उन्मुखीकरण के आधार पर प्रतीकों को फिर से मैप करना है। पुन: मानचित्रण x और y को अलग-अलग मात्राओं द्वारा समन्वयित करके और परिणाम को ऑफसेट करके किया जाता है। तो, एक ट्रिपल प्रति अभिविन्यास ($ रोट में संग्रहीत) है। वहाँ शायद एक बेहतर तरीका है, लेकिन मैं इस समय के बारे में सोच भी नहीं सकता!

$coords = json_decode($argv[2]);
$symbols = '789/456*123-00.+';
$r=$argv[1];
$rot = [1,4,0,12,1,12,15,12,15,4,15,3];    
list($xs,$ys,$o)=array_slice($rot,$r*3,3);

$expression='';

foreach($coords as $coord) {
    $symbol=$symbols[($coord[0]*$xs+$coord[1]*$ys+$o)%16];

    if (!is_numeric($symbol) && $symbol!='.') {
        $expression = "($expression)";
    }
    $expression .=$symbol;
    echo $symbol;
}

eval ("echo '='.($expression);");

?>

Comments

मैं PHP से बहुत परिचित नहीं हूं, लेकिन मुझे लगता है कि आप एक बाइट को बचाने के &&लिए गोल्फ कर सकते हैं &। और अच्छा जवाब, +1 मेरी तरफ से! :)

— केविन क्रूज़सेन

वास्तव में, मुझे लगता है कि if(!is_numeric($s)&$s!='.')इसे आगे बढ़ाया जा सकता है if(strpos(' /*-+',$s))(यदि मैं इस एसओ उत्तर को सही ढंग से समझता हूं )।

— केविन क्रूज़सेन

बेशक! और धन्यवाद। वहाँ मैं बयान दे रहा था कि घूर रहा था, लेकिन कुछ भी नहीं आया।

— गिलर्मो फिलिप्स

Answer 9

05AB1E , 57 54 बाइट्स

εžm3ôí…/*-ø"00.+"ª€SIFøí}yθèyнè}JD'=s.γžh'.«så}R2ôR».VJ

0-आधारित निर्देशांक का उपयोग चुनौती विवरण के समान है, और [0,1,2,3] के लिए [0,90,180,270]इनपुट के रूप में क्रमशः।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ε                    # Map over each of the (implicit) input-coordinates:
 žm                  #  Push builtin "9876543210"
   3ô                #  Split it into parts of size 3: [987,654,321,0]
     í               #  Reverse each inner item: [789,456,123,0]
      …/*-           #  Push string "/*-"
          ø          #  Zip the lists together: [["789","/"],["456","*"],["123","-"]]
           "00.+"ª   #  Append string "00.+": [["789","/"],["456","*"],["123","-"],"00.+"]
                  €S #  Convert each inner item to a flattened list of characters
                     #   [[7,8,9,"/"],[4,5,6,"*"],[1,2,3,"-"],[0,0,".","+"]]
 IF                  #  Loop the input-integer amount of times:
   ø                 #   Zip/transpose the character-matrix; swapping rows/columns
    í                #   And then reverse each inner row
 }                   #  Close the loop (we now have our rotated character matrix)
  yθèyнè             #  Index the current coordinate into this matrix to get the character
}J                   # After the map: join all characters together to a single string
  D                  # Duplicate the string
   '=               '# Push string "="
     s               # Swap to get the duplicated string again
      .γ             # Group it by (without changing the order):
        žh           #  Push builtin "0123456789"
          1/         #  Divide it by 1, so it'll become a float with ".0": "0123456789.0"
                     #  (1 byte shorter than simply appending a "." with `'.«`)
            så       #  And check if this string contains the current character
       }             # Close the group-by, which has separating the operators and numbers
                     #  i.e. "800/4+0.75" → ["800","/","4","+","0.75"]
        R            # Reverse this list
                     #  i.e. ["0.75","+","4","/","800"]
         2ô          # Split it into parts of size 2
                     #  i.e. [["0.75","+"],["4","/"],["800"]]
           R         # Reverse the list again
                     #  i.e. [["800"],["4","/"],["0.75","+"]]
            »        # Join each inner list by spaces, and then those strings by newlines
                     #  i.e. "800\n4 /\n0.75 +"
             .V      # Execute this string as 05AB1E code
               J     # Join this with the earlier string and "=" on the stack
                     # (after which the result is output implicitly)

Answer 10

बर्लेस्क , 122 बाइट्स

pe'1'9r@3co{".-"".*""./"}z[)FL{'0'0'.".+"}+]j{{}{tp}{)<-<-}{tp)<-}}j!!e!<-Ppra{pPj<-d!}msJ'=_+j{><}gB3co{rtp^}mwpe?+'.;;++

इसे ऑनलाइन आज़माएं!

के रूप में args लेता है: "[[1,2],[2,3],[0,3],[1,0],[1,1]]" 3

pe                  # Push args to stack
'1'9r@              # Range of characters [1,9]
3co                 # Split into chunks of 3
{".-" ".*" "./"}z[  # Zip in the operators
)FL                 # Flatten the resulting list (giving us the first 3 rows)
{'0 '0 '. ".+"}+]   # Add the 4th row
j                   # Swap rotation index to top of stack
{
 {}                 # NOP
 {tp}               # Transpose
 {)<- <-}           # Reverse each column and row
 {tp )<-}           # Transpose and reverse each row
}
j!!e!               # Select which based on rotation spec and eval
<-                  # Reverse the result
Pp                  # Push to hidden stack
ra                  # Read the coords as array
{
 pP                 # Pop from hidden stack
 j<-                # Reverse the coords (tp'd out)
 d!                 # Select this element
}ms                 # For each coord and accumulate result as string
J                   # Duplicate said string
'=_+j               # Put the equals at the end of the other string
{><}gB              # Group by whether digits
3co                 # Split into chunks of 3
{
 rt                 # rotate (putting op in post-fix position)
 p^                 # Ungroup
}mw                 # Map intercalating spaces
pe                  # Evaluate the result
?+                  # Combine the results
'.;;++              # Change .* ./ etc to * /