도전:

입력을 기반으로 다음 6 개의 산술 테이블 중 하나의 '정수 숫자'를 출력합니다
.-더하기 ( +);
-빼기 ( -);
-곱셈 ( *);
-구분 ( /);
-지수화 ( ^);
-모듈로 연산 ( %).

규칙 :

• 정확히 다음 중 하나입니다 산술 연산의 모든 결과 : 나는 '정수 숫자'로 정의하는 일 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. 즉 , 모든 결과 이상, 모든 결과 이하 또는 정수가 아닌 모든 결과 를 제외해야 합니다 .10-1
• 산술 결과를 계산하는 방법 : 먼저 최상위 숫자를 사용한 다음 왼쪽 숫자와 함께 피연산자를 사용하십시오. 6 개의 출력 모두에 대해 일관된 한, 그 반대로 (즉, y/x대신 x/y) 이 작업을 수행 할 수 있습니다 ! (사용할 수 없습니다 그래서 y-x와 x/y같은 대답.) †
• 우리는 0 테스트 케이스로 나누기 위해 아무것도 나눌 수 없습니다 (나눗셈 및 모듈로 연산 테이블의 경우)
• edge-case에 대해서는 아무것도 출력하지 않습니다 0^0.

산출:

따라서 다음을 출력하십시오 (테이블 형식은 다소 유연합니다 (아래 참조). 따라서 선택 사항이며 주로 테스트 사례의 가독성을 위해 추가됩니다).

부가:

+ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 1 2 3 4 5 6 7 8 9
1 | 1 2 3 4 5 6 7 8 9
2 | 2 3 4 5 6 7 8 9
3 | 3 4 5 6 7 8 9
4 | 4 5 6 7 8 9
5 | 5 6 7 8 9
6 | 6 7 8 9
7 | 7 8 9
8 | 8 9
9 | 9

빼기:

- | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 1 2 3 4 5 6 7 8 9
1 |   0 1 2 3 4 5 6 7 8
2 |     0 1 2 3 4 5 6 7
3 |       0 1 2 3 4 5 6
4 |         0 1 2 3 4 5
5 |           0 1 2 3 4
6 |             0 1 2 3
7 |               0 1 2
8 |                 0 1
9 |                   0

곱셈:

* | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 0 0 0 0 0 0 0 0 0 0
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0 2 4 6 8
3 | 0 3 6 9
4 | 0 4 8
5 | 0 5
6 | 0 6
7 | 0 7
8 | 0 8
9 | 0 9

분할:

/ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0   1   2   3   4
3 | 0     1     2     3
4 | 0       1       2
5 | 0         1
6 | 0           1
7 | 0             1
8 | 0               1
9 | 0                 1

지수화 :

^ | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 |   1 1 1 1 1 1 1 1 1
1 | 0 1 2 3 4 5 6 7 8 9
2 | 0 1 4 9
3 | 0 1 8
4 | 0 1
5 | 0 1
6 | 0 1
7 | 0 1
8 | 0 1
9 | 0 1

모듈로 :

% | 0 1 2 3 4 5 6 7 8 9
-----------------------
0 | 
1 | 0 0 0 0 0 0 0 0 0 0
2 | 0 1 0 1 0 1 0 1 0 1
3 | 0 1 2 0 1 2 0 1 2 0
4 | 0 1 2 3 0 1 2 3 0 1
5 | 0 1 2 3 4 0 1 2 3 4
6 | 0 1 2 3 4 5 0 1 2 3
7 | 0 1 2 3 4 5 6 0 1 2
8 | 0 1 2 3 4 5 6 7 0 1
9 | 0 1 2 3 4 5 6 7 8 0

도전 규칙 :

• 후행 줄 바꾸기 및 후행 공백은 선택 사항입니다.
• 테스트 케이스의 가로 및 세로 선은 선택 사항입니다. 가독성을 높이기 위해 추가했습니다. †
• 각 결과 사이의 공백은 선택 사항이 아닙니다.
• 산술에 대한 기호는 그것이 어느 것이 분명한 한 다를 수 있습니다. 즉, ×또는 ·대신에 *곱셈; 분할 ÷대신에 /; 등 †
  그리고 한 그것의로 단일 문자, 파이썬의 미안 **.
• 입력 형식이 유연합니다. 해당하는 6 개의 테이블에 대해 0-5 또는 1-6의 색인을 선택할 수 있습니다. 피연산자 기호를 입력 할 수 있습니다. 등. (결과에 표시하는 것과 달리 완전한 문자열을 입력하거나 **Python의 경우
  입력 할 수 있습니다.) 응답에 사용하는 입력 형식을 명시하십시오!

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수가있는 기능 / 방법, 전체 프로그램을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

† 가로 및 세로 줄이없고 ÷기호로 사용되는 y/x대신 유효한 출력 예 x/y:

÷ 0 1 2 3 4 5 6 7 8 9
0   0 0 0 0 0 0 0 0 0
1   1
2   2 1
3   3   1
4   4 2   1
5   5       1
6   6 3 2     1
7   7           1
8   8 4   2       1
9   9   3           1

Japt , 45 바이트

@ETHproductions와 협력

AÆAÇU¥'p«Z«XªOvZ+U+X)+P r"..+"SÃuXÃuAo uU)m¸·

온라인으로 실행하십시오!

다음과 같이 입력을받습니다.

"+" 또한

"-" 빼기

"*" 곱셈

"/" 분할

"p" 지수화

"%" 모듈로

설명 (확장 된 단축키 사용) :

AÆ  AÇ  U¥ 'p«  Z«  Xª OvZ+U+X)+P r"..+"SÃ uXÃ uAo uU)m¸  ·
AoX{AoZ{U=='p&&!Z&&!X||OvZ+U+X)+P r"..+"S} uX} uAo uU)mqS qR

A                                                             // By default, 10 is assigned to A
 o                                                            // Create a range from [0...9]
  X{                                         }                // Iterate through the range, X becomes the iterative item
    Ao                                                        //   Create another range [0...9]
      Z{                                 }                    //   Iterate through the range, Z becomes the iterative item
                                                              //     Take:
        U=='p                                                 //       U (input) =="p"
             &&!Z                                             //       && Z != 0
                 &&!X                                         //       && X != 0
                     ||                                       //     If any of these turned out false, instead take
                       Ov                                     //       Japt Eval:
                         Z+U+X                                //         Z{Input}X
                              )+P                             //     Whichever it was, convert to a string
                                  r"..+"S                     //     Replace all strings of length 2 or more with " "
                                                              //     (this makes sure the result !== "false" and has length 1)
                                           uX                 //   Insert X (the row number) into the front of the row
                                               u              // Insert at the beginning the first row:
                                                Ao            //   [0...9]
                                                   uU)        //   with the input inserted at the beginning
                                                      mqS     // Join each item in the final array with " "
                                                          qR  // Join the final array with "\n"

JavaScript (ES7), 128 바이트

f=
c=>[...c+`0123456789`].map((r,_,a)=>a.map(l=>l==c?r:r==c?l:/^\d$/.test(l=c<`^`?eval(l+c+r):l|c?l**r:l/r)?l:` `).join` `).join`
`

<select onchange=o.textContent=f(this.value)><option>><option>+<option>-<option>*<option>/<option>%<option>^<option>&<option>,<option>.</select><pre id=o>

특수 케이스 0^0비용은 8 바이트입니다.

동작 인화점 스크립팅 언어 343 333 303 301 바이트

f={o=_this;s=o+" 0 1 2 3 4 5 6 7 8 9\n";i=0;while{i<10}do{j=0;s=s+format["%1",i];if(i<1&&(o=="/"||o=="%"||o=="^"))then{if(o=="^")then{if(j<1)then{s=s+"  ";j=1}}else{s=s+"\n1";i=1}};while{j<10}do{r=call format["%1%2%3",j,o,i];if(r>9||r<0||r%1>0)then{r=" "};s=s+format[" %1",r];j=j+1};s=s+"\n";i=i+1};s}

전화 :

hint ("+" call f)

언 골프 드 :

f=
{
    o=_this;
    s=o+" 0 1 2 3 4 5 6 7 8 9\n";
    i=0;
    while{i<10}do
    {
        j=0;
        s=s+format["%1",i];
        if(i<1&&(o=="/"||o=="%"||o=="^"))then
        {
            if(o=="^")then{if(j<1)then{s=s+"  ";j=1}}
            else{s=s+"\n1";i=1}
        };
        while{j<10}do
        {
            r=call format["%1%2%3",j,o,i];
            if(r>9||r<0||r%1>0)then{r=" "};
            s=s+format[" %1",r];
            j=j+1
        };
        s=s+"\n";
        i=i+1
    };
    s
}

산출:

연산자 +

운영자 -

운영자 *

운영자 /

연산자 ^

운영자 %

파이썬 (2) , 240 (231) 226 224 203 202 200 197 바이트

a=i=input()
R=range(10)
for z in R:a+=' '+`z`
print a
for x in R:
 try:
	d=`x`
	for b in R:c=eval("b%s(x*1.)"%('**',i)[i<'^']);d+=' '+(' ',`int(c)`)[(i<'^'or x+b>0)and c in R]
 except:pass
 print d

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

"+", "-", "*", "/", "^"또는 "%"중 하나로 입력을받습니다.

편집

-9 멋진 힌트를 @FelipeNardiBatista 덕분에 -16

@FelipeNardiBatista의 도움을 받아 221까지 줄인 다음 잃어 버려 203으로 줄었습니다 and E(c)==int(E(c)). 경우 우리가 확인하는 경우 E(c)에 range(10)이있을 경우 항상 정수가됩니다. 중복 검사가 필요 없습니다.

이것은 이 파이썬 3로 전환하고 선언하지 않고 200 아래로 이동합니다 P=print. 어떤 아이디어? 나는 항상 배우게되어 기쁘다.

네! 나는 그것이 가능하다는 것을 알았습니다. 197. 지금 자기 시간. 나는 이것에 충분한 시간을 보냈다. 흥미로운 도전 @KevinCruijssen에 감사드립니다.

Mathematica, 150 바이트

r=0~Range~9;p=Prepend;±i_:=Grid@p[p[If[0<=#<=9,#]/._@__->""&/@<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>[i][r,#],#]&/@r,r~p~i]

±문자 중 하나를 +-*/^%입력으로 사용하여 i(예 :) 단항 함수 를 정의 하고 OP의 마지막 출력과 똑같이 보이는 객체를 ±"^"반환합니다 Grid.

<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>각각의 가능한 입력 문자에 대응하는 (목록 가능한) 이진 함수 ( #-#2&,1##&,#/#2&골프 버전이 있는 곳) 를 연관시키고 Subtract,Times,Divide; 따라서 <|...|>[i][r,#]가능한 모든 첫 번째 인수와 #두 번째 인수로 이진 연산을 계산합니다 . If[0<=#<=9,#]/._@__->""&각 결과를 Null또는 ""한 자리 결과가 아닌 경우 로 변환합니다 ( /._@__->""같은 결과 1/0는 부등식으로 처리 할 수 없기 때문에 필요 합니다 0<=#<=9). 마지막으로 다양한 머리글과 바닥 글을 붙여 답변을 표시합니다.

파이썬 3 343 335 363 362 바이트

이것에 대한 가장 슬픈 부분은 Java 응답이 나를 때리고 있다는 것입니다. 나는 아침에 이것을 더 골프로 칠 것입니다.

o=input()
r=range(10)
g=[['']*10 for i in r]
for x in r:
 for y in r:exec('if"/"!=o and(o!="%"or x)and(o!="**"or x or y):k=str(y'+o+'x);g[x][y]=k')
if'/'==o:
 for x in r:
  for y in r:
   if x and y%x<1:g[x][y]=str(round(y/x))
if'**'==o:o='^'
print('\n'.join([' '.join([o]+list(map(str,r)))]+[' '.join([str(q)]+[' 'if len(x)!=1else x for x in g[q]])for q in r]))

ReplIT

에지 사례를 피하기 위해 이중 루프 +28 바이트 대신 목록 이해로 전환하여 -8 바이트 0 ^ 0. -.-
변경함으로써 -1 바이트 ==0로 <1@StewieGriffin 덕분

자바 (7), (312) 305 바이트

String c(int o){String r=("+-*/^%".charAt(o))+" 0 1 2 3 4 5 6 7 8 9\n";for(int i=0,j,p;i<10;i++){r+=i+" ";for(j=0;j<10;r+=p<0|p>9?"  ":p+" ")p=p(o,i,j++);r+="\n";}return r;}int p(int o,int a,double b){b=o<1?b+a:o<2?b-a:o<3?b*a:o<4&a>0?b/a:o<5&(a!=0|b!=0)?Math.pow(b,a):a>0?b%a:-1;return b%1==0?(int)b:-1;}

가로 / 세로 줄을 사용하지 않고 챌린지 예 ( +-*/^%) 에 문자가 표시됩니다 . 6 개의 수학적 피연산자
에 0-5대한 인덱스 를 입력으로 사용합니다.

@Frozn 덕분에 -7 바이트 .

설명:

String c(int o){                   // Method with integer parameter and String return-type
  String r = ("+-*/^%".charAt(o))  //  Get the current mathematical operand character based on the input index
    + " 0 1 2 3 4 5 6 7 8 9\n";    //  Append the column header and a new-line
  for(int i=0,j,p; i<10; i++){     //  Loop over the rows
    r += i+" ";                    //   Append the left-side row-nr
    for(j=0; j<10;                 //   Inner-loop over the columns of the current row
        r += p<0|p>9?"  ":p+" ")   //     And after every iteration, append the result with either a space or an integer
      p = p(o,i,j++);              //    Calculate the current sum-result
                                   //   End of inner-loop (implicit / single-line body)
    r+="\n";                       //   Append result with new-line
  }                                //  End of loop
  return r;                        //  Return result String
}                                  // End of method

int p(int o,int a,double b){       // Separate method with two integer and a double parameters and integer return-type
  b = o<1 ?                        //  If the given operand is 0:
       b+a                         //   Use addition
      : o<2 ?                      //  Els-if the given operand is 1:
       b-a                         //   Use subtraction
      : o<3 ?                      //  Else-if the given operand is 2:
       b*a                         //   Use multiplication
      : o<4 & a>0 ?                //  Else-if the given operand is 3 and `a` is above 0:
       b/a                         //   Use division
      : o<5 & (a!=0|b!=0) ?        //  Else-if the given operand is 4 and not both `a` and `b` are 0:
       Math.pow(b,a)               //   Use exponentiation
      : a>0 ?                      //  Else-if the given operand is 5:
       b%a                         //   Use modulo
      :                            //  Else:
       -1;                         //   Use -1 as result
  return b%1 == 0 ?                //  If the result is not a decimal number:
     (int)b                        //   Return the result
    :                              //  Else:
     -1;                           //   Return -1 as result
}                                  // End of separate method

테스트 코드 :

여기에서 시도하십시오.

class M{
  String c(int o){String r=("+-*/^%".charAt(o))+" 0 1 2 3 4 5 6 7 8 9\n";for(int i=0,j,p;i<10;i++){r+=i+" ";for(j=0;j<10;r+=p<0|p>9?"  ":p+" ")p=p(o,i,j++);r+="\n";}return r;}int p(int o,int a,double b){b=o<1?b+a:o<2?b-a:o<3?b*a:o<4&a>0?b/a:o<5&(a!=0|b!=0)?Math.pow(b,a):a>0?b%a:-1;return b%1==0?(int)b:-1;}

  public static void main(String[]a){
    M m = new M();
    System.out.println(m.c(0)); // +
    System.out.println(m.c(1)); // -
    System.out.println(m.c(2)); // *
    System.out.println(m.c(3)); // /
    System.out.println(m.c(4)); // ^
    System.out.println(m.c(5)); // %
  }
}

하스켈, 230 (199) 182 + 53 47 세퍼레이터 46 + 1 바이트 = 284 247 232 229 바이트

f=head.show
g=[0..9]
h=(:" ")
y(%)s=unlines$(s:map f g>>=h):[f y:[last$' ':[f(x%y)|x%y`elem`g]|x<-g]>>=h|y<-g]
0?0=10;a?b=a^b
a!0=10;a!b|(e,0)<-a`divMod`b=e|1>0=10
a&0=10;a&b=mod a b

함수는 (zipWith y[(+),(-),(*),(!),(?),(&)]"+-*/^%"!!)53 바이트를 차지하며 0은 더하기, 1은 빼기, 2는 곱하기, 3은 나누기, 4는 지수, 5는 모듈로입니다.

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

설명

나중에 올 것입니다. . . . 지금은 약간의 작은 음식 :? 지수 연산자입니다! 나누기 연산자이고 &는 mod 연산자입니다.

편집 : 벌크의 일부는 다른 답변의 대부분 (?)이 eval을 사용하기 때문에 Haskell에 긴 가져 오기가없는 것입니다.

EDIT2 : 코드에서 -31 바이트 (와!)와 함수 -6 바이트에서 Ørjan Johansen에게 감사드립니다! 일관성을 위해 11 대 중 10 대를 10대로 변경했습니다. 업데이트 된 버전을 온라인으로 사용해보십시오!

EDIT3 : 같은 사람, 17 바이트 더! 온라인으로 업데이트되고 업데이트 된 버전을 사용해보십시오!

파이썬 2 , 197 바이트

p=input()
r=range(10)
s=' '
print p+s+s.join(map(str,r))
for i in r:print str(i)+s+s.join(eval(("s","str(j"+p+"i)")[i and(j%i==0 and'/'==p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r])for j in r)

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

입력 : 파이썬 2

'+' 부가

'-' 찰과상

'*' 곱셈

'/' 분할

'**' 지수화

'%' 모듈로

파이썬 3 , 200 바이트

p=input()
r=range(10)
s=' '
print(p+s+s.join(map(str,r)))
for i in r:print(str(i)+s+s.join(eval(("s","str(j"+p+"i)")[i and(j%i==0 and'/'in p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r])for j in r))

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

입력 : 파이썬 3

+ 부가

- 찰과상

* 곱셈

// 분할

** 지수화

% 모듈로

설명

range(10)변수에 저장 r하면 형식의 첫 번째 출력 줄을 얻을 수 있습니다.

operator 0 1 2 3 4 5 6 7 8 9

모든 int in r을 문자열 에 매핑 하고 문자열 목록 을 연산자 ['0','1','2','3','4','5','6','7','8','9']로 공백 과 결합sp

p+s+s.join(map(str,r)

그와 함께, 모든 대한 i의 r(범위), 모든이에 대한 j평가 i및 j운영자와

eval("j"+p+"i")

여기서 처리되지 않은 나눗셈 또는 모듈러스가 0이면 예외가 발생할 수 있습니다.이 경우 ( i and(j%i==0 and'/'==p or'%'==p))와 문제 설명에 설명 된 출력 형식 을 처리하려면 (각 평가에 대한 결과는 음수이거나 숫자보다 크지 않아야합니다. 10- eval("j"+p+"i")in r),

i and(j%i==0 and'/'==p or'%'==p)or p in'**+-'and eval("j"+p+"i")in r

따라서 산술 테이블을 인쇄하십시오!

행복한 코딩!

APL (Dyalog) , 68 76 바이트

⎕IO←0많은 시스템에서 기본값이 필요합니다 . 입력을 요구하고 피연산자를 나타내는 단일 문자를 예상합니다.

t←'|'=w←⎕
(w,n),n⍪⍉⍣t∘.{(⍺w⍵≡0'*'0)∨(t∧⍵≡0)∨⍺w≡0'÷':⍬
n∊⍨r←⍵(⍎w)⍺:r
⍬}⍨n←⍳10

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

대부분의 코드는 회피입니다 대한 APL의 결과 ÷0와 0*0와 APL의 모듈로 (즉 대응하기 위해 |) 인수가 대부분의 다른 언어에 비해 뒤바뀜있다. 41 바이트 밖에되지 않았을 것입니다그렇지 않으면 되지 입니다 :

w←⎕
(w,n),n⍪∘.{0::⍬
÷n∊⍨r←⍵(⍎w)⍺:r}⍨n←⍳10

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

R , 194 177 바이트

매트릭스 출력 조작으로 -17 바이트 전환

function(o){s=0:9
y=sapply(s,function(x)Reduce(o,x,init=s))
dimnames(y)=list(s,rep('',10))
y[!y%in%s|!is.finite(y)]=' '
if(o=='^')y[1]=' '
cat(substr(o,1,1),s)
print(y,quote=F)}

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

이 접근 방식으로 변경하면 몇 가지 단점이 있습니다. 즉, pryr 원래 행렬을 설정하는 것이 약간 어수선하지만 첫 번째 줄의 일부 공백으로 완벽하게 출력 할 수 있습니다.

나는 mod 연산자 substr때문에 여전히 트릭 을 사용해야합니다 %%. 내가 기회를 잡을 때 이것을 계속 다듬을 것인데, 여전히 특별한 경우를 다루는 것이 매우 어색합니다.

PHP, 191 바이트

** 대신에 ^입력+ - / % * **

echo$k=$argn,$k=="**"?"":" ",join(" ",$d=range(0,9));foreach($d as$r){echo"\n$r";foreach($d as$c){echo" ";($k=="/"|($m=$k=="%"))&$r<1?print" ":eval("echo in_array($c$k$r,\$d)?$c$k$r:' ';");}}

두 버전의 온라인 버전

PHP, 평가없이 245 바이트

입력 + - / % * ^

나누기 입력에 세 번째 매개 변수가 필요하기 때문에 bcpowmod($c,1,$r)대신 사용 bcmod($c,$r)하십시오. $c**1%$r==$c%$r

BC 수학 함수

echo$k=$argn," ".join(" ",$d=range(0,9));foreach($d as$r){echo"\n$r";foreach($d as$c)echo" ",in_array($s=($k=="/"|($m=$k=="%"))&$r<1?-1:("bc".["+"=>add,"-"=>sub,"/"=>div,"*"=>mul,"^"=>pow,"%"=>powmod][$k])($c,$m?1:$r,$m?$r:9),$d)?round($s):" ";}

05AB1E , 56 55 바이트

9ÝDãεðýì„/%Iåyθ_*I'mQyO_*~iðë.VD9ÝQàiïëð]«TôεN<š}®I:ðý»

라인이없고 출력이 반전 된 x및 y. 입력 / 출력을 사용하고 +, -, *, /, m, %.

온라인으로 시도 하거나 모든 테이블을 확인하십시오 .

21 바이트의 고정 에지에 사용되는 경우 /0, %0및 0^0의 결과 0, 0및 1각각의 05AB1E .. 여기서 그 부분이없는 ( 34 바이트 )

9ÝDãεðýì.VD9ÝQàiïëð]«TôεN<š}®I:ðý»

온라인으로 시도 하거나 모든 테이블을 시도하십시오 .

설명:

9Ý                     # Push list [0,1,2,3,4,5,6,7,8,9]
  D                    # Duplicate it (for the header later on)
   ã                   # Take the cartesian product with itself (creating all pairs):
                       #  [[0,0],[0,1],[0,2],...,[9,7],[9,8],[9,9]]
ε                      # Map each pair `y` to:
 ðý                    #  Join the pairs with a space
   ì                   #  Prepend it before the (implicit) input-char 
 „/%Iå                 #   If the input is "/" or "%"
         *             #   and
      yθ_              #   The last value of the pair is exactly 0
                  ~    #  OR
          I'mQ        '#   If the input is "m"
                 *     #   and
              yO_      #   The sum of the pair is exactly 0 (thus [0,0])
 i                     #  If that is truthy:
  ð                    #   Push a space character " "
 ë                     #  Else:
  .V                   #   Execute the string as 05AB1E code
    D                  #   Duplicate the result
     9ÝQài             #   If it's in the list [0,1,2,3,4,5,6,7,8,9]:
          ï            #    Cast it to an integer to remove any trailing ".0"
                       #    (since dividing always results in a float)
         ë             #   Else:
          ð            #    Push a space character " "
]                      # Close both the if-else clauses and the map
 «                     # Merge the resulting list with the duplicated [0,1,2,3,4,5,6,7,8,9]
  Tô                   # Split the list in parts of size 10
    ε   }              # Map each list to:
     N<                #  Get the map-index + 1
       š               #  And prepend it at the front of the list
         ®I:           # Then replace the "-1" with the input-character
ðý                     # And finally join every inner list by spaces
  »                    # And join the entire string by newlines (which is output implicitly)