Giriş:

Windows'ta standart bir Hesap Makinesi'ne bakalım: Bu meydan okuma için sadece aşağıdaki düğmelere bakacağız ve diğer her şeyi göz ardı edeceğiz:

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

Meydan okuma:

Giriş:
İki giriş alırsınız:

• Biri, 90 derecelik artışlarla dönüşü gösteren bir şeydir
• Diğeri, döndürülmüş hesap makinesinde basılan düğmeleri temsil eden koordinatların bir listesidir.

İlk girişe dayanarak, yukarıda belirtilen düzeni 90 derecelik artışlarla saat yönünde döndürüyoruz. Yani giriş ise 0 degrees, olduğu gibi kalır; ancak giriş doğruysa, 270 degreessaat yönünde üç kez (veya saat yönünün tersine) döndürülür. İşte dört olası yerleşim:

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

İkinci giriş, herhangi bir makul formattaki koordinatların bir listesidir † . Örneğin (0 dizinli 2 tam sayı dizisi):

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

Çıktı:
Hem toplamı hem de sonucu (ve eşittir işareti =) çıkarırız .

Örnek:
Yani giriş 270 degreesve [[1,2],[2,3],[0,3],[1,0],[1,1]]ise, çıktı:

517*6=3102

Zorluk kuralları:

• † Girişler makul herhangi bir formatta olabilir. Birinci giriş olabilir 0-3, 1-4,A-D ,0,90,180,270 ikinci giriş vs. için çağrı 0 endeksli 2D dizisi, 1-endeksli 2B dizisi, bir String, noktasında nesnelerin listesi olabilir, vb. Verilen örnek girişlere kıyasla x ve y koordinatlarını değiştirmek bile mümkündür. Lütfen cevabınızda hangi giriş formatlarını kullandığınızı belirtiniz!
• Boşluk eklemenize izin verilir (ör. 517 * 6 = 3102 ) .
• Virgülden sonra en fazla üç taneye (yani veya yerine 3102.0/ 3102.00/3102.00031020.430 yerine0.43 ).
• Çıktıya parantez eklemenize izin verilmediğinden, (((0.6+4)-0)/2)/4=0.575 geçerli bir çıktı değil.
• Diliniz için başka işlenen sembolleri kullanma izniniz var. Yani ×ya da ·yerine *; veya÷ yerine/ ; vb.
• Hesap makinesi bir işlenen girerken otomatik olarak hesapladığından, operatörün önceliğini göz ardı etmelisiniz! Böylece ( ) değil ( ) ile 10+5*3sonuçlanır (yani → → → (şimdi ekranda 15 görüntülenir) → → (şimdi yanıtı görüntüler )). Ortaya çıkan toplamda kullanırken ve benzer işlevleri kullanırken bunu aklınızda bulundurun .45(10+5)*3=452510+(5*3)=25
10+5*3=45eval
• 0'a bölmek için herhangi bir test vakası olmayacak.
• Sonuç olarak üçten fazla ondalık basamağa sahip test durumları olmayacaktır, bu nedenle sonucu yuvarlamaya gerek yoktur.
• Birden fazla işlenenin birbirini takip ettiği veya iki noktanın birbirini takip ettiği test durumları olmayacaktır.
• Negatif sayılar için herhangi bir test durumu olmayacaktır. Eksi işareti ( -) yalnızca işlenen olarak kullanılır, negatif olarak kullanılmaz.
• .##Virgülden önce önde gelen numara olmadan herhangi bir test durumu 2+.7olmayacaktır (yani geçerli bir test durumu 2+0.7olmayacak , ancak olabilir).

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için olabildiğince kısa bir cevap bulmaya çalışın.
• Standart kurallar geçerlidirCevabınız için , bu nedenle STDIN / STDOUT, fonksiyon / yöntemi uygun parametrelerle, tam programları kullanmanıza izin verilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, gerekirse bir açıklama ekleyin.

Test senaryoları:

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

SOGL V0.12 , 70 69 67 bayt

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

Buradan Deneyin veya test senaryolarında verilen girdileri alan bir sürümü deneyin

Idiziyi döndüren SOGL operatörünü kullanır . Sonra bir dizeyi JavaScript dizisi olarak okur ve bir işlemin kullanıldığı yerde önceki sonucu parantez içine alır, JavaScript olarak değerlendirir ve sonra parantezleri kaldırır.

Dyalog APL, 94 88 86 85 bayt

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

Çevrimiçi deneyin!

Dönüşleri sol argüman olarak 0-3ve 1 tabanlı endeksleri sağ argüman olarak, y xkoordinatlar listesi gibi alır (1 1)(2 3)(4 5).

APL'deki ifadelerin sağdan değerlendirilmesi nedeniyle bu oldukça karışık bir hal aldı.

C (gcc) , 282294 295 296 300 304 306 310 bayt

Tüm optimizasyonların kapatılması ve yalnızca 32 bit GCC'de çalışması gerekir.

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

@Orion sayesinde 1 bayt!

Çevrimiçi deneyin!

İşlev prototipi:

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

Giriş formatı (TIO'da olduğu gibi):

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

Yorumlar ile yorum yapılmamış sürüm:

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

Kod, 1+.7veya gibi durumları işleyebilir -8*4.

Çok üzücü C'nin evalhave'si yok.

JavaScript (ES6), 162 160 157 bayt

Girdiyi , köri sözdiziminde (y, x) koordinatlarının yönlendirmesi ove dizisi olarak alır .a(o)(a)

Yön, bir tamsayıdır [0..3] ' :

• 0 = 0 °
• 1 = 90 ° saat yönünde
• 2 = 180 ° saat yönünde
• 3 = 270 ° saat yönünde

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

Test senaryoları

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

Yakut , 135 133 132 bayt

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

Çevrimiçi deneyin!

Tamsayı olarak yönlendirme: 0 ° için 0, 90 ° için 1 vb.

Piton 3, 235 234 230 bayt

Biraz çirkin ama örnek hesap makinesiyle eşleşmeyen ilk test dışındaki tüm test durumları için çalışır. Dönüşü 0-3 (0-270) olarak alıp ofset için 16 ile çarpıyorum.

eval() dizeleri kod olarak derlemeye çalışan ve metin simgelerini operatörlere dönüştüren tutamaçlardır.

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

Alternatif yöntem, biraz daha uzun çıktı ama diziyi döndürmek için bu SO ipucunu gerçekten seviyorum .

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

Java 10, 418 380 378 bayt

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

Kendi sorumu da cevaplamaya karar verdim. Eminim farklı bir yaklaşım kullanarak biraz daha golf olabilir.
Girdi olarak int( 0-3) ve int[][](meydan okuma tarifnamede aynı / 0 endeksli). Sonuç ondalık sayı yerine bir tamsayı ise floatöndeki ile çıktı alın .0.

@Ceilingcat sayesinde -2 bayt .

Açıklama:

Burada deneyin.

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

PHP ,267 235 229 225 221 213 bayt

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

Çevrimiçi deneyin!

@Kevin Cruijssen sayesinde 6 bayt.

Giriş yönleri: 0 0, 1 90, 2 180 ve 3 270 derecedir.

Ungolfed

Döndürme zor, benim fikrime göre oryantasyona bağlı olarak sembolleri yeniden eşleştirmek. Yeniden eşleme, x ve y koordinatlarını farklı miktarlarla çarparak ve sonucu dengeleyerek yapılır. Yani, yön başına üçlü ($ rot içinde saklanır) vardır. Muhtemelen daha iyi bir yol var, ama şu anda düşünemiyorum!

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

?>

05AB1E , 57 54 bayt

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

Kullanım meydan açıklama benzer koordinatları 0 dayalı ve [0,1,2,3]için [0,90,180,270]girdi olarak tespit edilmiştir.

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

ε                    # 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)

vodvil , 122 bayt

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

Çevrimiçi deneyin!

Argleri şu şekilde alır: "[[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 * /