算术表的整数位


17

挑战:

根据输入,输出以下六个算术表之一的“整数”:
-加法(+);
-减法(-);
-乘法(*);
-除(/);
-取幂(^);
-模运算(%)。

规则:

  • 我该怎么界定为“整数位”:算术操作数正好是以下情况之一的每一个结果:0123456789。这意味着您将排除每个等于10或更高的结果,每个等于-1或更低的结果以及每个非整数的结果。
  • 我们如何计算算术结果:首先使用高位数字,然后使用左数位的操作数。你被允许这样做,反之亦然(即y/x代替x/y),只要你对输出的所有六个一致!(因此,不允许您使用y-xx/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

挑战规则:

  • 尾随换行符和尾随空格是可选的
  • 测试用例中的水平线和垂直线是可选的。我仅添加它们是为了提高可读性。
  • 每个结果之间的空格不是可选的。
  • 只要清楚知道算术符号,算术符号就可能不同。即×·代替*乘法;÷而不是/分裂;等
    而且只要它是一个单一的角色,所以很抱歉Python的**
  • 输入格式灵活。您可以从0-5或1-6中为对应的六个表选择索引;您可以输入操作数符号;等等。(不同于结果显示的内容,允许输入完整的字符串,或者**以Python的情况为准。)
    只需确保说明答案中使用的输入格式即可!

通用规则:

  • 这是,因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能短的答案。
  • 标准规则适用于您的答案,因此允许您使用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

如果是用我们的语言得出的结果,可以除以零吗?例如在APL中,默认情况下0÷0为1,而N mod-0为N?也可以选择另一种方案,其中被零除总是零。
亚当

我们在列之间允许一个以上的空间吗?
亚当

@Adám对不起,您的最后答复。至于您的第一个问题:对不起。我知道有些语言print 1,其他语言0,还有一些其他语言用于0^0除法或除法/修改0,但是您必须解决该问题。关于第二个问题:是的,只要数字仍在相同的列/行中,就可以使用任意多个空格。
凯文·克鲁伊森

参数的顺序对非交换运算重要吗?
亚当

@亚当所以你的意思是你会输出电网y-xy/xy^xy%x代替x-yx/yx^yx%y?嗯,我想那可能很好。我将在答案中对其进行编辑;只要您对这六个变量都保持一致(这样就不会y-xx/y答案相同)。
凯文·克鲁伊森

Answers:


7

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"

8

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个字节。


非常酷的如何在测试代码段中添加了诸如OR和AND的其他操作数。+1
Kevin Cruijssen

@KevinCruijssen我不得不删除OR来保存一个字节(所有其他运算符在之前排序^),但是谢谢!
尼尔,

5

闪点行动脚本语言,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
}

输出:

运算符+

操作员-

运算符*

操作员/

运算符^

运算符%


5

Python 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 -16,感谢@FelipeNardiBatista的出色提示

在@FelipeNardiBatista的更多帮助下下降到221,然后通过失败下降到203 and E(c)==int(E(c))。如果我们正在检查if E(c)是否在range(10)其中,那么它将始终是一个整数。无需重复检查。

走低于200,而无需切换到Python 3和声明P=print。有任何想法吗?我总是很高兴学习。

是的 我知道可以做到的。197.现在该睡觉了。我花了足够的时间在这上面。感谢@KevinCruijssen的有趣挑战。


1
('**',i)[i<'^'](i<'^'or x>0 or b>0)保存4个字节
Felipe Nardi Batista

1
a=i=input()for z in R:a+=' '+`z`vs 一起保存了一些额外的字节a=i+' 0 1 2 3 4 5 6 7 8 9'
Felipe Nardi Batista

1
1.vs 1.0E(c)in Rvs -1<E(c)<102个字节
Felipe Nardi Batista

1
x+b>0vs x>0 or b>0and "b%s(x*1.)"%('**',i)[i<'^']vs"b"+('**',i)[i<'^']+"(x*1.)"
Felipe Nardi Batista

1
有一组额外的括号的()在你的加入为223个字节
菲利普·纳迪巴蒂斯塔

4

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(例如±"^"),并返回一个Grid对象,该对象看上去与OP中的最后一个输出完全一样。

<|Thread[Characters@"+-*/^%"->{Plus,#-#2&,1##&,#/#2&,Power,Mod}]|>为每个可能的输入字符关联相应的(可列出的)二进制函数(其中#-#2&,1##&,#/#2&的高尔夫球版本Subtract,Times,Divide);因此<|...|>[i][r,#],使用所有可能的第一个参数并#作为第二个参数来计算二进制运算。If[0<=#<=9,#]/._@__->""&将每个结果转换为Null或(""如果不是一位数的结果)(这/._@__->""是必需的,因为某些结果1/0不能由不等式进行处理0<=#<=9)。最后,我们将各种页眉和页脚放在前面,并显示答案。


好的答案和解释。您也许有一个在线试用链接?还有一个问题/注释,我没有提到边缘情况规则:“ 我们不会为边缘情况输出任何内容0^0 ” Mathematica在这种情况下默认不输出任何内容吗?
凯文·克鲁伊森

1
我在上面添加了一个链接。Mathematica的计算结果0^0Indeterminate,这使我们在计算过程If[0<=Indeterminate<=9, Indeterminate]中得到了不满意的未评估结果;但是/._@__->""该规则接受所有未评估的函数及其参数,并将其更改为不可见的字符串。
格雷格·马丁

好的,因此Mathematica正确返回两个冲突规则,#^0=1并且0^#= 0发生了0^0。到现在为止还不错,并且可以轻松应对这一挑战。:)顺便说一句,您的链接似乎无效。我收到一个错误,我无权访问它。
凯文·克鲁伊森

好的,您必须转到sandbox.open.wolframcloud.com并将代码粘贴到您自己的代码中,然后使用像这样的命令进行调用±"^"
格雷格·马丁

4

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

复制

通过切换到列表理解而不是双循环
+28字节来避免-8个字节,从而避免出现边缘情况0 ^ 0。-.-
-1通过改变字节==0<1感谢@StewieGriffin


与此有关的最可悲的部分是Java答案正在击败我…… ”这部分使我咯咯笑。xD我喜欢您如何检查数字的长度以确定它是否在范围内0-9。顺便说一句,嗯。。我注意到您的Repl中有一个错误。当前输出**而不是^求幂。(此外,您也可以输入**,但不能在结果表中输出它。目前,您可以使用其他方法。)
Kevin Cruijssen

1
@KevinCruijssen哎呀。成功修复,字节数不变。感谢您指出了这一点!
HyperNeutrino

@StewieGriffin是的。谢谢。
HyperNeutrino

4

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

不使用水平/垂直线,并且字符显示在质询示例(+-*/^%)中。
使用0-5六个数学操作数的索引作为输入。

-7个字节,感谢@Frozn

说明:

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

1
也许你可以通过b一个doublep和摆脱r通过分配的链式三元的价值b
Frozn

3

Haskell中,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:感谢ØrjanJohansen减少了代码的-31个字节(哇!),并使该功能减少了-6个字节!出于一致性目的,还将11s更改为10s。在线尝试更新版本!

EDIT3:同一个人,还有十七个字节!在线尝试更新的版本!


1
较短的!测试:e<-a`div`b,e*b==a=e(e,0)<-a`divMod`b=e
与Orjan约翰森

1
较短的功能:(zipWith(#)"+-*/^%"[(+),(-),(*),(!),(?),(&)]!!)
与Orjan约翰森

反向测试+“标准”高尔夫技巧last$f k:[' '|k<0||k>9]。最后(也许),[0..9]它足够长,足以在两次使用时将其定义为名称。
与Orjan约翰森

不,一个:k<-[o x y]比a短let
与Orjan约翰森

一句话:哇!:)
通用显示名称

2

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

在线尝试!

输入:Python 2

'+' 加成

'-' 抽离

'*' 乘法

'/'

'**' 求幂

'%' 模数

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

在线尝试!

输入:Python 3

+ 加成

- 抽离

* 乘法

//

** 求幂

% 模数

说明

存储range(10)到变量中r,我们可以获得格式的第一行输出

operator 0 1 2 3 4 5 6 7 8 9

通过将每个int映射r到字符串并使用运算符将字符串列表['0','1','2','3','4','5','6','7','8','9']与空格连接s起来p

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

随着,对于每一个ir(范围),为每一个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

从而打印算术表!

编码愉快!


不错的Python 2答案。猜197使我们平等。我花了更多的努力。做得好。轻微问题。对于/,表显示.0,而不是整数。当然可以很容易地纠正:)
ElPedro

抱歉,一旦我看到我撤消了我的
投票

谢谢!但是,如果您使用“ /”作为输入,则Python 2会打印int,而python 3会打印float。杉木python 3您必须使用'//'。我已经明确提到了这一点。
Keerthana Prabhakaran

而且似乎有人正在编辑我的链接,并且te python 2链接已更改为python3。我现在将其还原。
Keerthana Prabhakaran

我以前有这个问题。这是因为您在同一页面上有2个TOI链接。单击任一链接时,它将打开找到的第一个链接定义。通过将第二个链接重命名为“在线尝试3”或其他方式,还可以重命名链接定义。那应该工作正常。
ElPedro

2

APL(Dyalog)68岁 76字节

要求⎕IO←0在许多系统上是默认设置。提示输入,并期望一个代表操作数的字符。

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

在线尝试!

与大多数其他语言相比,大部分代码都是为了规避APL的结果,÷00*0抵消APL的modulo(|)将其参数反过来。否则只有41个字节

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

在线尝试!


哇!以及我在Python答案上的辛勤工作。公平竞争。
ElPedro

1

R194177字节

-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并且设置原始矩阵有些笨拙,但是可以在第一行中留一些尾随空格,从而完美输出。

substr由于%%mod运算符,我仍然必须使用技巧。当我有机会时将继续进行调整,处理特殊情况仍然感觉很笨拙。


0

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个字节,没有eval

输入 + - / % * ^

使用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):" ";}

0

05AB1E56 55 字节

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

输出不带线,带x和和y。输入/输出使用+-*/m%

在线尝试验证所有表格

21个字节被用于固定边缘的情况下/0%0以及0^0,其导致001分别在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)
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.