소개:

Windows에서 표준 계산기를 살펴 보자. 이 도전에서는 다음 버튼 만보고 나머지는 모두 무시합니다.

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 degreesand[[1,2],[2,3],[0,3],[1,0],[1,1]] 인 경우 출력 같습니다.

517*6=3102

도전 규칙 :

• † 입력의 형식은 합리적입니다. 첫 번째 입력이 될 수있다 0-3, 1-4, A-D,0,90,180,270 제 2 입력 등 내 통화 0 인덱스 2D 어레이 인덱스 1 차원 어레이, 문자열, 포인트 오브젝트리스트 일 수있다, 등등. 주어진 입력 예와 비교하여 x 및 y 좌표를 교체 할 수도 있습니다. 답변에 사용한 입력 형식을 명시하십시오!
• 공백을 추가 할 수 있습니다 (예 : 517 * 6 = 3102원하는 경우 .
• 세 가지의 최대 (즉,에, 쉼표 후 후행 0을 추가 할 수 있습니다 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으로 나누는 테스트 사례는 없습니다.
• 결과적으로 소수점 이하 3 자리를 초과하는 테스트 사례가 없으므로 결과를 반올림 할 필요가 없습니다.
• 여러 피연산자가 서로 뒤 따르거나 두 개의 점이 서로 뒤 따르는 테스트 사례는 없습니다.
• 음수에 대한 테스트 사례는 없습니다. 빼기 부호 (- )는 음수가 아닌 피연산자로만 사용됩니다.
• 거기에 대한 테스트 케이스되지 않습니다 .##즉, (쉼표 전에 선두 번호없이 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

SOGL V0.12 , 70 69 67 바이트

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

여기서 시도 하거나 테스트 사례에 주어진대로 입력을받는 버전을 사용해보십시오.

SOGL I연산자를 사용 하여 배열을 회전시킵니다. 그런 다음 문자열을 JavaScript 배열로 읽고 작업이 사용되는 경우 이전 결과를 괄호로 묶고 JavaScript로 평가 한 다음 괄호를 제거합니다.

Dyalog APL, 94 88 86 85 바이트

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

온라인으로 사용해보십시오!

회전을 왼쪽 인수로, 0-31 기반 인덱스를 오른쪽 인수로, y x좌표 목록 (1 1)(2 3)(4 5)등 으로 가져옵니다 .

이것은 APL의 표현에 대한 오른 손잡이 평가로 인해 상당히 지저분했습니다.

C (gcc) , 282294 295 296 300 304 306 310 바이트

모든 최적화를 해제하고 32 비트 GCC에서만 작동합니다.

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 덕분에 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>

주석이 달린 언 골프 버전 :

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.

매우 슬픈 C에는 eval😭 이 없습니다 .

자바 스크립트 (ES6) 162 160 157 바이트

카레 구문에서 (y, x) 좌표 o의 방향 및 배열 로 입력을 받습니다.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

루비 , 135133132 바이트

->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, 90 °의 경우 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])

다른 방법으로, 그것은 조금 더 길어진 것으로 밝혀졌지만 배열 회전을 위해이 SO 팁 을 정말로 좋아 합니다 .

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

자바 10, 418380 바이트

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+=O>98?0:1)t=new Float(n[i]);return r+"="+s;}

내 자신의 질문에도 대답하기로 결정했습니다. 다른 접근법을 사용하여 골프를 더 할 수 있다고 확신합니다.
입력으로서 int( 0-3) 및 int[][](도전 설명과 동일 / 0 인덱스). 결과가 10 진수 대신 정수인 경우 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+=O>98?0:1)           //     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