นี่คือ CMC (ความท้าทายในการแชทมินิ) ที่ฉันโพสต์ในห้องแชทของเรา, Ninteenth Byte , บิตที่ผ่านมา

ความท้าทาย

รับจำนวนเต็มบวกxขึ้นอยู่กับ 2 บิตสุดท้ายxทำต่อไปนี้:

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

Input / Output

Single Integer -> Single Integer  

บรรทัดใหม่ต่อท้ายได้รับอนุญาตในการส่งออก ไม่อนุญาตให้ใช้ช่องว่างอื่น

Testcases

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

นี่คือความท้าทายของรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดชนะ!

เยลลี่ขนาด 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 ใช้การจัดทำดัชนีแบบเดียวดังนั้นการลบ"_"จะถูกย้ายไปยังจุดสิ้นสุด

ị“+×*_”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.

Pythonขนาด 30 ไบต์

lambda x:[0,x+x,x*x,x**x][x%4]

ลองออนไลน์!

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

Mathematica 25 ไบต์

0[2#,#*#,#^#][[#~Mod~4]]&

บันทึกแล้ว 4 ไบต์ขอบคุณ @MartinEnder

Pyth, 8 ไบต์

.v@"0y*^

ล่าม

ทับทิมขนาด 26 ไบต์

->x{x*[0,2,x,x**~-x][x%4]}

ลองออนไลน์!

PHP, 37 ไบต์

<?=[0,2*$x=$argn,$x*$x,$x**$x][$x&3];

เวอร์ชั่นออนไลน์

PHP, 47 ไบต์

<?=(bc.[sub,add,mul,pow][($x=$argn)&3])($x,$x);

เวอร์ชั่นออนไลน์

ฟังก์ชั่น BC Math

Haskell, 28 27 ไบต์

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

ลองออนไลน์!

แก้ไข: ขอบคุณ @ Ørjan Johansen 1 ไบต์

JavaScript ขนาด 24 ไบต์

a=>[0,a+a,a*a,a**a][a%4]

ลองออนไลน์!

C, 63 หรือ 62 ไบต์

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

-1 ไบต์หากอนุญาตให้ใช้มาโครสมมติว่าxไม่ใช่นิพจน์ที่เหมือน3+5(เนื่องจากจะทำให้เกิดความผิดพลาด):

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

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

แม้ว่าจะถูกต้องตามกฎ แต่longก็เป็น 64- บิตดังนั้นจึงล้มเหลวสำหรับกรณีทดสอบการยกกำลังของ19^19และเหนือ หากต้องการแก้ไขว่าเราสามารถใช้BigDecimalวิธีการได้:

148 146 ไบต์

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; 

x86 Assembler, ไวยากรณ์ของ 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

ตัวอย่างแสร้งทำเพื่อความเร็วในการทำงานที่เร็วที่สุด Is เป็นส่วนของโปรแกรมหรือโปรแกรมซึ่งใช้การประชุม fastcall มันถือว่าตัวแปรอินพุตxในรีจิสเตอร์eaxและส่งคืนผลลัพธ์เช่นeaxกัน แนวคิดพื้นฐานอยู่ห่างจากการใช้การกระโดดแบบมีเงื่อนไขเช่นในบางตัวอย่างที่นี่ นอกจากนี้ยังไม่ได้ประเมินทุกอย่าง (เช่นในตัวอย่าง C กับอาร์เรย์) แต่ใช้อาร์เรย์ของพอยน์เตอร์เพื่อ functons และทำการกระโดดแบบไม่มีเงื่อนไขได้เร็วขึ้น (jmp / call) เป็น "สวิตช์ภาษา C () - กรณี .. " แบบอะนาล็อก เทคนิคนี้อาจมีประโยชน์ในรูปแบบของตัวประมวลผล finita automata เช่นตัวเลียนแบบตัวประมวลผลและอื่น ๆ

UPD: สำหรับ x64 ใช้ "R" ในชื่อลงทะเบียนแทน "E" (เช่นraxแทนeax, rcxแทนecx) ขนาดจะไม่สามารถเปลี่ยนแปลงได้และจะใช้คำที่ไม่ได้ลงชื่อ 64 บิต

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)

จริงแล้ว 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

05AB1E , 10 ไบต์

Ð"-+*m"è.V

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

J , 14 ไบต์

4&|{0,+:,*:,^~

ลองออนไลน์!

โอเอซิส 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 เป็นภาษาแบบสแต็ก

Cubix , 29 ไบต์

.;.O+@.UOI:4%!^s;((?u.^P;<^*;

ลองออนไลน์!

คำอธิบายจะถูกเพิ่มเร็ว ๆ นี้ ...

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)

ฉันไม่สามารถบอกได้ว่ามันเป็นตัวแปรที่สั้นที่สุดคำแนะนำใด ๆ ที่ชื่นชม

PHP, 36 ไบต์

<?=[0,2,$x=$argn,$x**~-$x][$x&3]*$x;

dc, 27

ฉันไม่เคยมีโอกาสใช้อาร์เรย์ใน dc มาก่อน:

[+]1:r[*]2:r[^]3:r?dd4%;rxp

ลองมันออนไลน์

Groovy ขนาด 26 ไบต์

{x->[0,x+x,x*x,x**x][x%4]}

ลองออนไลน์!

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];แต่ใช้การพอยน์เตอร์พอยน์เตอร์เพื่อ functons อย่างชาญฉลาดเพื่อให้กระโดดได้เร็วขึ้นอย่างไม่มีเงื่อนไข (jmp / การโทร) ด้วยเลขคณิตที่อยู่ที่เร็วกว่ามาก สลับ () - กรณี .. " เทคนิคนี้อาจเป็นประโยชน์ในหลาย ๆ ประเภทของ finita Automata เช่นตัวเลียนแบบตัวประมวลผล, ตัวจัดการ, ตัวแยกวิเคราะห์คำสั่งสตรีมและอื่น ๆ - ที่เรื่องความเร็วและรหัสเช่นswitch(x%4) case(0):... case(1):... ไม่เหมาะสมเพราะมันสร้างคำสั่ง cmp / jnz หลายชุด; และการดำเนินการเหล่านี้มีราคาแพงสำหรับ CPU

โปรแกรมทดสอบที่ง่ายและสั้นที่สุด (ในเงื่อนไขเริ่มต้น) สำหรับเคสจะเป็นดังนี้:

D(main,f(x))

มันจะเพิ่มน้ำหนักบรรทุกเพียง 12 ไบต์และจะเพิ่มขนาดของเราเป็น 127 ไบต์

แต่คุณควรจะบอกดีกว่าลิงเกอร์ที่จะใช้ฟังก์ชั่นเป็นจุดรายการแทนf mainนั่นคือวิธีที่ถ้าเรามุ่งหวังที่จะได้รับไบนารีการทำงานที่เร็วที่สุดที่เป็นไปได้สำหรับงานนี้จากรหัสที่สั้นที่สุด ;-) สิ่งนี้เกิดขึ้นเพราะห้องสมุด C เพิ่มรหัส init / shutdown พิเศษก่อนที่จะเรียกใช้ฟังก์ชัน main () ของคุณ

คอมไพล์โค้ดบน MSVS Community 2015 โดยไม่มีลูกเล่นและปัญหาใด ๆ ฉันยังไม่ได้ทดสอบด้วย gcc แต่ฉันแน่ใจว่ามันจะทำงานได้ดีเช่นกัน

R, 47 42 ไบต์

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

การใช้งานฟังก์ชั่น-, +, *หรือ^ขึ้นอยู่กับโมดูลัสของxการและxx

-เป็นสิ่งที่ฉลาด (ค่อนข้าง) เพียงอย่างเดียวเนื่องจากx-xเป็น 0 เสมอ

R, 33 ไบต์

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

วิธีการเดียวกับที่คนอื่นใช้ แม้ว่ามันจะสั้นกว่า แต่ฉันไม่ชอบมันมากนัก

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==3x^x

.vjd,+@"-+*^  example input: 10
      @"-+*^  "-+*^"[10], which is "*"
     +        "*10"
    ,         ["*10","10"]
  jd          "*10 10"
.v            evaluate as Pyth expression
              (Pyth uses Polish notation)

เพิ่มเติมเกี่ยวกับสัญกรณ์โปแลนด์: Wikipedia (แย่มากถ้าคุณอยู่ในตุรกี)

Japt , 13 ไบต์

Ov"^+*p"gU +U

ลองออนไลน์!

วิธีนี้ใช้วิธีการเดียวกันกับคำตอบของ eval อื่น ๆ ยกเว้นโปรแกรม-Uจะลบล้างUดังนั้นเราจึงใช้^(bitwise XOR) แทน

เป็นกลุ่ม 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.

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

แบตช์ 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พารามิเตอร์ แต่ฉันเป็น อย่างน้อยสามารถใช้กลอุบายการตกบางส่วนเพื่อเล่นกอล์ฟในบางไบต์

เรติน่า , 87 ไบต์

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

ลองออนไลน์! (ลิงก์มีชุดทดสอบ)

คำอธิบาย: สองบรรทัดแรกแปลงอินพุตเป็นเอกภาพและทำซ้ำ (ตอนนี้เรามีx;x) สองบรรทัดถัดไปค้นหาx&3หนึ่ง0หรือทั้งสอง1และเปลี่ยนx;xเป็นx;0หรือx;2เหมาะสม สองบรรทัดถัดไปค้นหาx&3==3และเปลี่ยนx;xเป็นx;x;x;...;x;1;x( x xs) ซึ่งหมายความว่าเรามีอย่างใดอย่างหนึ่งx;0, x;2, x;xหรือx;...;xและก็ยังคงที่ทุกอย่างเข้าด้วยกันและคูณแปลงกลับไปทศนิยม (รหัสการคูณจะขึ้นอยู่กับว่าใน Retina wiki แต่แก้ไขเพื่อจัดการการคูณด้วยศูนย์)