ক্যালকুলেটর স্পিন

16

পরিচিতি:

উইন্ডোজের একটি স্ট্যান্ডার্ড ক্যালকুলেটরটি একবার দেখে নেওয়া যাক: এই চ্যালেঞ্জের জন্য আমরা কেবলমাত্র নীচের বোতামগুলিতে নজর দেব এবং অন্য সমস্ত কিছু উপেক্ষা করব:
এখানে চিত্র বর্ণনা লিখুন

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

চ্যালেঞ্জ নিয়ম:

  • P ইনপুটগুলি যে কোনও যুক্তিসঙ্গত বিন্যাসে থাকতে পারে। প্রথম ইনপুট হতে পারে 0-3, 1-4, A-D, 0,90,180,270, ইত্যাদি দ্বিতীয় ইনপুট 0-ইন্ডেক্স 2D অ্যারে, 1-ইন্ডেক্স 2D অ্যারে, একটি স্ট্রিং, পয়েন্ট-বস্তুর তালিকা, ইত্যাদি আপনার কলের হতে পারে। এমনকি দেওয়া ইনপুটগুলির তুলনায় x এবং y স্থানাঙ্কের অদলবদল করা এমনকি সম্ভব। আপনার উত্তরটিতে কোন ইনপুট ফর্ম্যাটগুলি ব্যবহার করেছেন দয়া করে তা জানান!
  • আপনি চাইলে স্পেস যুক্ত করতে পারবেন (যেমন 517 * 6 = 3102) are
  • কম্মার পরে আপনাকে সর্বোচ্চ তিনটি (যেমন 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
code-golf  number  arithmetic  integer 
— কেভিন ক্রুইজসেন
সূত্র
1
পরীক্ষার বিষয় অনেক ত্রুটি আছে (যেমন 3 য় এবং 4 র্থ X এবং Y আনা হয়েছে (1 ম না) এবং আমি এমনকি জানি না কি 2nd ঘটেছে)
— dzaima
2
প্রোগ্রামটি কি অদ্ভুত বোতাম টিপতে হবে? উইন্ডোজ 1+-*/+-*/2দেয় 0.5(10) ক্যালকুলেটর।
— ব্যবহারকারী 202729
1
দ্বিতীয় পরীক্ষার [1,3],
— উরিল
1
আমাদের কি দশমিকের চেয়ে কম 1 লিড না করে 1 এর চেয়ে কম পরিচালনা করতে হবে 2+.7?
— টুটলম্যান
4
অপারেটরের অগ্রাধিকার হ'ল আমি কখনই স্ট্যান্ডার্ড মোডে উইন্ডোজ ক্যালকুলেটর ব্যবহার করি না।
— নিল

উত্তর:

4

এসওজিএল ভি0.12 , 70 69 67 বাইট

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

এটি এখানে চেষ্টা করুন , বা এমন কোনও সংস্করণ চেষ্টা করুন যা পরীক্ষার ক্ষেত্রে প্রদত্ত ইনপুট গ্রহণ করে

এসওজিএল Iঅপারেটর ব্যবহার করে , যা অ্যারেটি ঘোরায়। তারপরে একটি জাভাস্ক্রিপ্ট অ্যারে হিসাবে একটি স্ট্রিং পড়ে এবং যেখানে কোনও অপারেশন ব্যবহৃত হয়, পূর্ববর্তী ফলাফলকে বন্ধনীতে আবদ্ধ করে, জাভাস্ক্রিপ্ট হিসাবে মূল্যায়ন করে এবং তারপর বন্ধনীগুলি সরিয়ে দেয়।

— dzaima
সূত্র
3

ডায়ালগ এপিএল, 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)etc.

এটি এপিএলে প্রকাশের ডান হাতের মূল্যায়নের কারণে যথেষ্ট অগোছালো হয়ে পড়েছে।

— ঊরীয়েল
সূত্র
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]>)

ইনপুট ফর্ম্যাট (টিআইও হিসাবে রয়েছে):

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

মন্তব্য সহ দর্শনীয় সংস্করণ:

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।

খুব দু: খিত সি এর একটি নেই eval😭

— কিউ গান
সূত্র
আপনি প্রকৃত ক্ষেত্রে 3*-5অবৈধ হিসাবে বিবেচনা করতে পারেন । আমি এটি নিয়মে উল্লেখ করেছি।
— কেভিন ক্রুইজসেন 22'17
নিয়মগুলিতে প্রয়োজনীয় নির্ভুলতা বিবেচনা করে কেবল 3 টি জায়গা, আপনি একটি ফ্রি বাইটের doubleসাথে প্রতিস্থাপন করতে পারেন float। এছাড়াও, putc()অভিন্ন নয় putchar()? যদিও আমি ভুল হতে পারি।
— ওরিওন
@ ওরিওন আমার মনে আছে আপনি কোন স্ট্রমে লিখছেন putcতা নির্দিষ্ট করার জন্য দ্বিতীয় যুক্তির প্রয়োজন?
— কিউ গা
— সিলিংক্যাট
2

জাভাস্ক্রিপ্ট (ES6), 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`)`)

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
1

পাইথন 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])
— nocturama
সূত্র
1

জাভা 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;}

আমার নিজের প্রশ্নেরও উত্তর দেওয়ার সিদ্ধান্ত নিয়েছে। আমি নিশ্চিত যে ভিন্ন পদ্ধতির সাহায্যে আরও কিছুটা গল্ফ করা যেতে পারে। ( ) এবং (0-সূচিযুক্ত / চ্যালেঞ্জের বর্ণনার মতো একই )
ইনপুট করুন । ফলাফল দশমিক সংখ্যার পরিবর্তে পূর্ণসংখ্য হলে অগ্রণী হিসাবে আউটপুট ।int0-3int[][]float.0

-২ বাইটস @ সিলিংক্যাটকে ধন্যবাদ ।

ব্যাখ্যা:

এখানে চেষ্টা করুন।

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
— কেভিন ক্রুইজসেন
সূত্র
1

পিএইচপি ,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 বাইট।

ইনপুট দিকনির্দেশগুলি হ'ল: 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);");

?>
— গিলারমো ফিলিপস
সূত্র
আমি পিএইচপি সঙ্গে খুব পরিচিত নই, কিন্তু আমি তোমাদের গলফ পারেন মনে &&করার &একটি বাইট সংরক্ষণ করুন। এবং দুর্দান্ত উত্তর, আমার কাছ থেকে +1! :)
— কেভিন ক্রুইজসেন
আসলে, আমি মনে করি if(!is_numeric($s)&$s!='.')আরও গল্ফ করা যেতে পারে if(strpos(' /*-+',$s))(যদি আমি এই এসও উত্তরটি সঠিকভাবে বুঝতে পারি )।
— কেভিন ক্রুইজসেন
অবশ্যই! এবং ধন্যবাদ. সেখানে আমি যদি বিবৃতি দেখছিলাম, কিন্তু কিছুই আসে নি।
— গিলারমো ফিলিপস
0

05AB1E , 57 54 বাইট

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

চ্যালেঞ্জের বর্ণনার মতো এবং এর [0,1,2,3]জন্য 0-ভিত্তিক স্থানাঙ্কগুলি ব্যবহার করে[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)
— কেভিন ক্রুইজসেন
সূত্র
0

বারলেস্কু , 122 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এই হিসাবে আর্গুমেন্ট নেয়: "[[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 * /
— DeathIncarnate
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.