减号，加号，时间，幂？

26

这是我不久前在我们的聊天室The Ninteenth Byte中发布的CMC（聊天迷你挑战）。

挑战

给定一个正整数x，取决于的最后2位x，请执行以下操作：

x & 3 == 0: 0
x & 3 == 1: x + x
x & 3 == 2: x * x
x & 3 == 3: x ^ x (exponentiation)

输入输出

Single Integer -> Single Integer

输出中允许尾随换行符。不允许其他空格。

测试用例

input       output
    1            2
    2            4
    3           27
    4            0
    5           10
    6           36
    7       823543
    8            0
    9           18
   10          100
   11 285311670611
   12            0

这是一个代码挑战，所以最短的代码胜出！

code-golf  math 
— 超中微子
source
8
如果不是0情况是x + 2，看到别人如何x * 2，x ^ 2以及x ^^ 2（迭代幂次）？：P
— ETHproductions'5
我们应该支持的最大产出是x ^ x多少（关于）？32位对于测试用例已经不够11，而64位对于测试用例还不够19。
— 凯文·克鲁伊森
@KevinCruijssen我要说的是，只要您的程序在给定的数值范围内理论上可以工作，您只需要处理输入和输出在您语言范围内的情况。
— HyperNeutrino'5
@HyperNeutrino好吧，在这种情况下，我已经修复了我的（Java 7）代码（用于+72字节
— 。.xD

Answers:

13

果冻，8字节

ị“+×*_”v

在线尝试！

怎么运行的

首先，请注意x&3等于x%4，其中%取模。然后，由于Jelly使用模块化索引（a[n] == a[n+len(a)]），因此我们甚至不需要处理它。

然后：

  • 如果为x%4==0，则返回x_x（减去）（以保持一致）；
  • 如果x%4==1返回x+x;
  • 如果为x%4==2，则返回x×x（相乘）；否则为。
  • 如果x%4==3，则返回x*x（取幂）

请注意，Jelly使用1索引，因此减法"_"将移至末尾。

ị“+×*_”v  example input: 10
ị“+×*_”   index 10 of the string “+×*_”, which gives "×"
       v  evaluate the above as a Jelly expression,
          with 10 as the argument, meaning "10×" is the
          expression evaluated. The dyad "×" takes the
          second argument from the only argument, effectively
          performing the function to itself.
— 漏尼姑
source
2
@andrybak AFAIK果冻具有自己的编码-参见此处，但我确实知道其所有字符均为1个字节。
— 斯蒂芬
“ 8个字节”。应该如何计算字节？这个答案由八个字符组成，但至少在该页面的stackexchange编码中，它占用15个字节（使用计数wc --bytes）。
— Andrybak
如果该语言以一种编码解释它，那么使用另一种编码来计算字节数（imo）就没有意义了
— Mackenzie McClane'May
@andrybak以某种编码编码的代码，以便浏览器正确显示它是15个字节。Jelly可以理解的编码形式的代码是8个字节。如果您想知道它的编码方式，请查看github.com/DennisMitchell/jelly/wiki/Code-page。
— Etoplay'5
9

CJam，12个字节

ri__"-+*#"=~

在线尝试！

说明

ri            e# Read an int from input (call it x).
  __          e# Duplicate x twice.
    "-+*#"    e# Push this string.
          =   e# Get the character from the string at index x (mod 4).
           ~  e# Eval that char, using the two copies of x from before.

根据x的值mod 4 运行以下操作之一（mod 4等效于AND 3）。

0:  -  Subtraction
1:  +  Addition
2:  *  Multiplication
3:  #  Exponentiation
— 商务猫
source
4

Pyth，8个字节

.v@"0y*^

口译员

— 暴民埃里克
source
是的，我已经对此进行了测试，并且可以正常工作。不，我不能使用v代替.v。
— 暴民埃里克（Erik the Outgolfer）'17年
我以为作用域是本地的...我以为.v无法访问Q...显然我在Pyth迷失了方向。为您+1。
— Leaky Nun
@LeakyNun不，v它具有局部作用域，.v只是评估一个表达式。
— 暴民埃里克（Erik the Outgolfer）'17年
我有很多东西要学...
— 漏水尼姑
3
那好美丽！太神奇了！我什至不知道那是不可能的。对于样式点，"0y*^可以为"-+*^。
— isaacg
3

Haskell，28 27字节

f x=cycle[0,x+x,x*x,x^x]!!x

在线尝试！

编辑：感谢@ØrjanJohansen提供1个字节。

— 妮米
source
嗯，我来晚了，但是您可以使用来将其缩短一个字节cycle。
— 与Orjan约翰森
@ØrjanJohansen：迟到总比不到好。谢谢！
— nimi
2

C，63或62个字节

#include<math.h>
f(x){return(int[]){0,x+x,x*x,pow(x,x)}[x&3];}

如果允许使用宏，x则为-1个字节，假定不是类似的表达式3+5（因为这样会使优先级混乱）：

#include<math.h>
#define f(x)(int[]){0,x+x,x*x,pow(x,x)}[x&3]
— 蒂姆·恰斯
source
@ceilingcat对，忘记了。
— 蒂姆·恰斯（TimČas）'17
无法在MSVS2015上编译；Intellisense说cast to incomplete array type "int[]" is not allowed编译器说error C4576: a parenthesized type followed by an initializer list is a non-standard explicit type conversion syntax; 也！int f（int x）在哪里？代码实际上至少要长8个字节；这也是非常缓慢且效率低下的，因为它评估了evertning –不要重复IRL）
@ xakepp35什么？1）它必须在C编译器中进行编译。(int[])在这种情况下，大多数（阅读：几乎所有MSVC除外）C编译器都支持这种语法。2）f(x)是完全合法的C89。我没有指定标准。3）这是关于代码大小，而不是效率。并且4）如果您打算光顾，请至少使用一个真正的编译器和/或检查您的事实。
— 蒂姆·恰斯（TimČas）'17
@TimČas啊，对不起！我试图将其编译为C ++代码。那是我的错）它可以编译并且运行良好！
2

Java 7，75字节

long c(int n){int x=n%4;return x<1?0:x<2?n+n:x<3?n*n:(long)Math.pow(n,n);}

即使根据规则有效，它也是long64位，因此对于19^19或以上的幂测试用例，它会失败。为了解决这个问题，我们可以使用一种BigDecimal方法：

148146字节

import java.math.*;BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

说明（BigDecimal方法）：

import java.math.*;                // Import required for BigDecimal
BigDecimal c(int n){               // Method with integer parameter and BigDecimal return-type
  int x=n%4;                       //  Input modulo-4
  BigDecimal m=new BigDecimal(n);  //  Convert input integer to BigDecimal
  return x<1?                      //  If the input mod-4 is 0:
    m.subtract(m)                  //   Return input - input (shorter than BigDecimal.ZERO)
   :x<2?                           //  Else if the input mod-4 is 1:
    m.add(m)                       //   Return input + input
   :x<3?                           //  Else if the input mod-4 is 2:
    m.multiply(m)                  //   Return input * input
   :                               //  Else:
    m.pow(n);                      //   Return input ^ input
}                                  // End of method

测试代码：

在这里尝试。

import java.math.*;
class M{
  static BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

  public static void main(String[] a){
    for (int i = 1; i <= 25; i++) {
      System.out.print(c(i) + "; ");
    }
  }
}

输出：

2; 4; 27; 0; 10; 36; 823543; 0; 18; 100; 285311670611; 0; 26; 196; 437893890380859375; 0; 34; 324; 1978419655660313589123979; 0; 42; 484; 20880467999847912034355032910567; 0; 50;
— 凯文·克鲁伊森
source
您不需要用这种方式来修复程序：P如果数字的大小无穷大，那么旧的答案将起作用。根据我的规格，第一个程序将是有效的。：P
— HyperNeutrino '17
@HyperNeutrino然后，我在答案中指定。.嗯，Java还是不会赢得任何代码高尔夫挑战。;）
— Kevin Cruijssen's
1
是的，我会指定。是的，它是Java，它不会赢。：D
— HyperNeutrino '17
2
“ 是的，它是Java，它不会赢。：D ”我已经习惯了。：P即使我有8个字节的最短Java答案，也比打高尔夫球的答案要长。xD尽管这是我第一次用Java答案击败了Python答案，但我认为这是必须的。;）
— Kevin Cruijssen '17
2

x86汇编器，Intel语法，192字节

.data
f dw @q,@w,@e,@r
.code
mov ecx, eax
and ecx, 3
mov edx,dword ptr f[ecx*4]
call [edx]
ret
q:
xor eax,eax
ret
w:
add eax,eax
ret
e:
mul eax,eax
ret
r:
mov ecx,eax
t:
mul eax,eax
loop t
ret

该示例假装为最快的工作速度。是一个程序或程序的一部分，它使用快速调用约定。它假定输入变量x在寄存器中eax，并在中返回结果eax。基本思想是避免使用条件跳转，如此处的某些示例所示。同样，它不是评估所有内容（如在C语言中使用数组的示例），而是使用指向函数的指针数组并作为优化的“ C语言switch（）-case ..”类似物来进行更快的无条件跳转（jmp / call）。这项技术在各种finita自动机中也可能有用，例如处理器仿真器，执行器等。

更新：对于x64，在寄存器名称中使用“ r”，而不是“ e”（例如，rax代替eax，rcx代替ecx）。大小不会更改，它将使用64位无符号字。

欢迎来到PPCG！这项挑战的目的是使您的代码尽可能短。在这种情况下，可以通过组合所有这些函数声明来轻松地缩短代码。您也可以删除一些空格。
— HyperNeutrino
@HyperNeutrino asm本身是一种“长”语言:)，所以我不知道如何使它更短。任何示例建议？
嗯，对不起，我必须已将对C答案的评论复制到这篇文章中。我不知道如何在ASM中编程，但是您是否可以删除一些空格？
— HyperNeutrino
@HyperNeutrino，对不起..，但似乎没有）它必须是最长的代码，我可以将Windows crlf截断为linux格式，所以209-> 192字节，更改不可见）
w 这太糟糕了。但是无论如何都很好提交！:)
— HyperNeutrino
2

C＃，39个字节

x=>new[]{0,2,x,Math.Pow(x,x-1)}[x&3]*x;

说明

注意：

（xx，x + x，x * x，x ^ x）==（0，2，x，x ^（x-1））* x

该解决方案创建一个数组，对其进行索引，然后将结果乘以x：

x => new[] { 0, 2, x, Math.Pow(x,x-1) }[x&3] * x;

替代版本：

x=>new[]{0,x+x,x*x,Math.Pow(x,x)}[x%4];

（39B，所有乘法在数组中完成，x%4替换x&3）

x=>x%4<2?x%2*2*x:Math.Pow(x,x%4<3?2:x);

（39B，与@MetaColon的答案相同，但x%2*2*x替换为x*x%4<1?0:2）

— 用户名
source
1

实际上，12个字节

;;3&"-+*ⁿ"Eƒ

在线尝试！

说明：

;;3&"-+*ⁿ"Eƒ
;;            two copies of input (so 3 total)
  3&          bitwise AND with 3
    "-+*ⁿ"E   index into this string
           ƒ  call the respective function
— 梅果
source
1

绿洲 25字节

mn4%3Q*nkn4%2Q*nxn4%1Q*++

在线尝试！

怎么运行的

请注意，x&3它等效于x%4，其中%取模。

mn4%3Q*nkn4%2Q*nxn4%1Q*++  input is n
mn4%3Q*                    (n**n)*((n%4)==3)
       nkn4%2Q*            (n**2)*((n%4)==2)
               nxn4%1Q*    (n*2)*((n%4)==1)
                       +   add the above two
                        +  add the above two

Oasis是一种基于堆栈的语言，其中每个字符都是命令。

— 漏尼姑
source
1

C＃，42个字节

x=>x%4<2?x*x%4<1?0:2:Math.Pow(x,x%4<3?2:x)

实际上，它是正常的C＃，但是由于您无法将其作为一个完整的程序运行，因此您必须将其键入到交互式程序中，我想您可以将其称为C＃交互式。

说明：

x => (x % 4) < 2     //If the bits are smaller than 2 (1 or 0)
? x *           //multiply x with
    (x % 4) < 1 //if the bits are 0
    ? 0         //0 (results in 0)
    : 2         //or else with 2 (results in 2*x or x+x)
: Math.Pow(x,   //otherwise power x by
    (x % 4) < 3 //if the bits are 2
    ? 2         //2 (results in x^2 or x*x)
    : x);       //or else x (results in x^x)

我不能说这是最短的变体，任何建议都值得赞赏。

— 元冒号
source
我认为那是不正确的。通常，您应该提交程序或函数。默认情况下，不允许使用摘要。
— Cyoce '17
@Cyoce这是一个程序。您只需要通过交互式程序运行它，它将解释程序。
— MetaColon'5
当我以交互方式运行它时，由于x未定义，因此会出现错误。这使它成为一个片段，而不是完整的程序。
— Cyoce
@Cyoce在挑战中说，定义了一个变量x。
— MetaColon
那不是什么意思。“给定一个正整数x”是指，你被给予 x通过标准输入方法（即，功能或程序）。
— Cyoce
1

C，115字节

#include<math.h>
#define D(K,L)K(x){return L;}
D(q,0)D(w,x+x)D(e,x*x)D(r,pow(x,x))(*g[])()={q,w,e,r};D(f,g[x%4](x))

例子是一个函数 int f(int x)

它假装为最快的工作速度，因为它使CPU避免使用条件跳转。而这只是此任务的正确速度优化方法。此外，它尝试不评估所有内容（如数组C的示例），return(int[]){0,x+x,x*x,pow(x,x)}[x%4];而是明智地使用指向函数的指针数组，以便通过更快的地址算术进行更快的无条件跳转（jmp / call），作为“ switch（）-case ..“。这项技术在几种类型的finita自动机中也可能有用，例如处理器仿真器，执行器，命令流解析器等，在这些情况下，速度和代码无关紧要，switch(x%4) case(0):... case(1):... 因为它会产生多个cmp / jnz指令；这些都是CPU的昂贵操作

对于这种情况，最简单和最短的测试程序（在默认条件下）将如下所示：

D(main,f(x))

它将仅添加12字节的有效负载，总大小为127字节；

但是，您最好告诉链接程序使用ffunction作为入口点，而不是main。如果我们的目标是从最短的代码中为该任务获得最快的工作二进制文件，则是这样；-)发生这种情况是因为C库在调用main（）函数之前添加了额外的初始化/关闭代码。

代码在MSVS Community 2015上编译，没有任何技巧和问题，并产生正确的结果。我尚未在gcc上进行测试，但我敢肯定它也能正常工作。

1
欢迎来到PPCG！这项挑战的目的是使您的代码尽可能短。在这种情况下，可以通过组合所有这些函数声明来轻松地缩短代码。您也可以删除一些空格。
— HyperNeutrino
我喜欢使用指向函数的指针的想法
— RosLuP，2017年
@RosLuP是的，但是它几乎比您的60字节版本长两倍。但它的运行速度要快得多，值得它的大小。
@Hyper Neutrino好吧。我已经压缩了更多。看来，这是最终版本！没有错误，所有测试均通过8
@ xakepp35您测量出自己的速度比我快吗？
— RosLuP
1

R，47 42字节

x=scan();c(`-`,`+`,`*`,`^`)[[x%%4+1]](x,x)

适用的功能-，+，*，或^基于的模量x，以x和x。

-是唯一（有点）聪明的东西，因为x-x它始终为0。

R，33个字节

pryr::f(c(0,2*x,x^2,x^x)[x%%4+1])

与其他人使用的方法相同。虽然比较短，但我不太喜欢。

— 贾德
source
0

Pyth，12个字节

.vjd,+@"-+*^

在线尝试！

怎么运行的

首先，请注意x&3等于x%4，其中%取模。然后，由于Pyth使用了模块化索引（a[n] == a[n+len(a)]），所以我们甚至不需要处理它。

然后：

  • 如果为x%4==0，则返回x-x（出于一致性考虑）；
  • 如果x%4==1返回x+x;
  • 如果x%4==2返回x*x;
  • 如果x%4==3，请返回x^x。
.vjd,+@"-+*^  example input: 10
      @"-+*^  "-+*^"[10], which is "*"
     +        "*10"
    ,         ["*10","10"]
  jd          "*10 10"
.v            evaluate as Pyth expression
              (Pyth uses Polish notation)

有关波兰语表示法的更多信息：Wikipedia（如果您在土耳其，那就太糟糕了）。

— 漏尼姑
source
?？这对我来说似乎太过分了。有关详细信息，请参见我的答案。
— 暴民埃里克（Erik the Outgolfer）'17年
0

Japt，13个字节

Ov"^+*p"gU +U

在线尝试！

它使用与其他eval答案相同的方法，不同之处在于该程序-U只是求反U，因此我们使用^（按位XOR）。

— ETH生产
source
0

Vim，50个字节

y$o^R"A-+*^^V^[0^R"lx0"_Dp^[0D@"kJ0"ad$:r!echo ^R"^R0|bc^<Enter>

在这里，^V代表一个Ctrl+V，^R代表Ctrl-R和^[代表esc钥匙

首先建立表达式，然后bc对其求值，以进行工作。期望输入在否则为空的缓冲区的第一行上。

说明：

y$o^R"                                                          Copies the input into register " and pastes it on the second line
      A-+*^^V^[0^R"lx0"_Dp                                      Enters that text after the input on the second line
                          ^[0D@"                                Executes the second line as a Vim command.
                                                                For example, if the input is 12, the second line would be 12A-+*^^[012lx0"_Dp, which means:
                                                                  12A-+*^^[           Insert the text -+*^ 12 times
                                                                           012lx0"_Dp Go 12 chars to the right and remove everything except for that.
                                                                If effect, this basically just selects the appropriate operation.
                                kJ0"ad$                         Put the operator after the number, cut it into register a
                                       :r!                      Execute the following shell command and put the result into the buffer:
                                          echo ^R"^R0|bc<Enter> The shell command "echo [contents of register a][contents of registers 0]|bc. As said above, register a contains the input and the operator, and register 0 contains the input. The <enter> then executes this command.
— 罗夫乔
source
当我键入内容时，^V它只是粘贴我在剪贴板中的内容，而不是数字...
— Leaky Nun
1
在线尝试！此外，您可以D代替d$
— DJMcMayhem
0

Pyth，9个字节

@[0yQ*QQ^

测试套件

这里没有什么幻想，只需计算四个值，然后选择一个带有模块化索引的值即可。

@[0yQ*QQ^
@[0yQ*QQ^QQ)Q    Implicit variable introduction
@           Q    Modularly index into the following list
 [0        )     0
   yQ            Q*2
     *QQ         Q*Q
        ^QQ      Q^Q
— 伊萨格
source
0

批次，135个字节

@set/an=%1*2^&6
@goto %n%
:6
@set n=1
@for /l %%i in (1,1,%1)do @set/an*=%1
@goto 0
:4
@set n=%1
:2
@set/an*=%1
:0
@echo %n%

我希望通过建立和评估形式的字符串来创建幂运算，[0+...+0, 2+...+2, x+...+x, x*...*x]具体取决于的最后两位，x但是不幸的是选择操作的代码花了太长时间来表达，因为我不能*用作for参数，但是我至少能够使用一些摔倒的技巧来打掉一些字节。

— 尼尔
source
0

视网膜，87字节

.+
$*1;$&$*
;((1111)*)(1?)$
;$3$3
1(?=1.*;((1111)*111)$)
$1;
+`\G1(?=.*;(1*))|;1*$
$1
1

在线尝试！（链接包括测试套件。）

说明：前两行将输入转换为一元并将其复制（因此现在有了x;x）。接下来的两行寻找or的一个x&3，然后适当地更改为or 。接下来的两行将查找并更改为（）。这意味着，我们要么，，，或者和它仍然乘法都在一起，并转换回小数。（乘法代码基于Retina Wiki中的代码，但已修改为以零处理乘法。）01x;xx;0x;2x&3==3x;xx;x;x;...;x;1;xx xx;0x;2x;xx;...;x

— 尼尔
source
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.