ปัญหา:

เป้าหมายของคุณคือการเพิ่มป้อนตัวเลขสองโดยไม่ต้องใช้ใด ๆ +,-,*,/ของผู้ประกอบการทางคณิตศาสตร์ต่อไปนี้:

นอกจากนี้คุณไม่สามารถใช้ฟังก์ชันในตัวที่ออกแบบมาเพื่อแทนที่ตัวดำเนินการทางคณิตศาสตร์เหล่านั้นได้

เกณฑ์การให้คะแนน:

รหัสที่เล็กที่สุด (ในจำนวนไบต์) ชนะ

ปรับปรุง

โปรแกรมส่วนใหญ่ที่ฉันเคยเห็นมาเรียงต่อกันสองอาร์เรย์ที่มีหมายเลขของพวกเขาหรือทำให้first numberตัวละครผนวกsecond numberตัวอักษรแล้วนับพวกเขาทั้งหมด

ตัวนับอาร์เรย์ที่สั้นที่สุด: APL ที่มี 8 ตัวอักษรโดย Tobia

การต่อแถวสั้นที่สุด: Golfscript พร้อม 4 chars โดย Doorknob

วิธีแก้ปัญหาลอการิทึมที่สั้นที่สุด: TI-89 Basic พร้อม 19 ตัวอักษรโดย Quincunx

โซลูชันการรวม: Mathematica กับ 45 chars โดย Michael Stern

เจ๋งที่สุดในความคิดของฉัน: ผู้ประกอบการระดับบิตในจาวาสคริปต์โดยเดฟ

สมอลล์ทอล์ค21 13

ทั้งหมดต่อไปนี้ใช้ได้กับจำนวนเต็มบวกเท่านั้น ดูคำตอบSmalltalk อื่น ๆสำหรับคำตอบที่จริงจัง

version1

เปลี่ยนเป็นจำนวนเต็มขนาดใหญ่และขอให้ดัชนีบิตสูง (ไม่ดีการจัดทำดัชนี ST เป็นพื้นฐาน 1 ดังนั้นฉันต้องการการเปลี่ยนที่ถูกต้องเพิ่มเติม):

(((1<<a)<<b)>>1)highBit

version2

ที่คล้ายกันและยังสั้นกว่าเล็กน้อย (เนื่องจากกฎของ Smalltalk มีความสำคัญและไม่จำเป็นต้องมีการเลื่อนขวา):

1<<a<<b log:2 

Version3

อีกรูปแบบของชุดรูปแบบ "คอลเลกชัน - การต่อข้อมูล - ขอ",
กำหนดตัวเลขสองตัวเป็น a และ b,

((Array new:a),(Array new:b)) size

ใช้ช่วงเวลาเป็นคอลเลคชันเราจะได้หน่วยความจำที่เป็นมิตรมากขึ้น ;-) ใน 21 ตัวอักษร:

((1to:a),(1to:b))size

ไม่แนะนำสำหรับการทำ crunching จำนวนมาก

version4

เพื่อความสนุกของคุณหากคุณต้องการแลกเปลี่ยนเวลาเพื่อความจำลอง:

Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]

ซึ่งมักจะถูกต้องเพียงพอ (แต่ไม่มีการรับประกัน ;-)))

version5

เขียนไปยังไฟล์และถามขนาดของมัน

(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print

Javascript (25)

while(y)x^=y,y=(y&x^y)<<1

นี่เป็นการเพิ่มตัวแปรสองตัว x และ y โดยใช้การดำเนินการระดับบิตเท่านั้นและเก็บผลลัพธ์ไว้ใน x

ใช้ได้กับตัวเลขติดลบเช่นกัน

C - 38 ไบต์

main(){return printf("%*c%*c",3,0,4);}

ฉันจะโกงนิดหน่อยที่นี่ผู้ปฏิบัติการบอกว่าจะไม่ใช้ตัวดำเนินการทางคณิตศาสตร์ใด ๆ

*ในprintf()รูปแบบวิธีการที่สนามกว้างใช้ในการพิมพ์ตัวอักษรที่จะนำมาจากการโต้แย้งของprintf()ในกรณีนี้, 3 และ 4. ค่าตอบแทนของprintf()เป็นจำนวนตัวอักษรที่พิมพ์ ดังนั้นมันจึงพิมพ์' 'ด้วยความกว้างของฟิลด์ที่ 3 และที่มีความกว้างของฟิลด์ที่ 4 ทำให้รวม 3 + 4 ตัวอักษร

ค่าที่ส่งคืนคือตัวเลขที่เพิ่มเข้ามาในการprintf()โทร

Python - 49 ไบต์

สมมติว่าการป้อนข้อมูลตามตำแหน่งในตัวแปรและxy

from math import*
print log(log((e**e**x)**e**y))

นี้ไบต์ 61วิธีการแก้ปัญหาเป็นโปรแกรมเต็มรูปแบบ:

from math import*
print log(log((e**e**input())**e**input()))

เมื่อพิจารณาว่าคุณไม่ได้ห้ามการยกกำลังฉันต้องโพสต์สิ่งนี้ print input() + input()เมื่อคุณลดความซับซ้อนของการแสดงออกโดยใช้คุณสมบัติของลอการิทึมคุณก็จะได้รับ

สิ่งนี้รองรับทั้งตัวเลขติดลบและทศนิยม

หมายเหตุ: ฉันทำตามคำแนะนำของ gnibblerและแบ่งคำตอบนี้ออกเป็นสามข้อ นี่คือทางออกที่ Mathematicaและนี่คือTI-89 การแก้ปัญหาพื้นฐาน

JavaScript [25 ไบต์]

~eval([1,~x,~y].join(''))

Mathematica ขนาด 21 ไบต์

มีหลายวิธีในการทำเช่นนี้ใน Mathematica หนึ่งใช้ฟังก์ชั่นการสะสมและโยนทุกอย่าง แต่จำนวนสุดท้ายในการส่งออก เช่นเดียวกับการแก้ปัญหาอื่น ๆ ของฉันด้านล่างผมถือว่าป้อนข้อมูลตัวเลขที่อยู่ในตัวแปรและa b21 ไบต์

Last@Accumulate@{a, b}

ความสนุกสนานมากขึ้นแม้ว่าจะเป็น 45 ตัวอักษรให้ใช้ตัวเลขเพื่อกำหนดบรรทัดและรวมเข้าด้วยกัน

Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]

โบนัสทั้งสองวิธีทำงานได้กับจำนวนเชิงซ้อนทั้งหมดไม่ใช่แค่จำนวนเต็มบวกอย่างที่เป็นกรณีของโซลูชันอื่น ๆ ที่นี่

GolfScript, 6 4 ตัวอักษร / ไบต์

ป้อนข้อมูลในรูปแบบของ10, 5(=> 15)

~,+,

+เป็นอาร์เรย์เข้ากันไม่ได้นอกจาก

วิธีการทำงานคือการ,ใช้เพื่อสร้างอาร์เรย์ของความยาวที่หมายเลขนั้นเป็น ( 0,1,...,n-2,n-1) การทำเช่นนี้สำหรับทั้งสองหมายเลขจากนั้นอาร์เรย์จะต่อกัน ,จะใช้อีกครั้งเพื่อวัตถุประสงค์อื่นเพื่อหาความยาวของอาเรย์ที่เกิดขึ้น

ตอนนี้ที่นี่เป็นเคล็ดลับ ฉันชอบอันนี้มากเพราะมันละเมิดรูปแบบอินพุต มันมีลักษณะเหมือนว่ามันจะเป็นเพียงแค่ป้อนอาร์เรย์ แต่จริงๆตั้งแต่การป้อนข้อมูลจะถูกดำเนินการตามรหัส GolfScript เป็นครั้งแรกที่,จะทำแล้วสำหรับฉัน! (เวอร์ชั่นเก่าของตัวละคร 6 ตัวนั้นเป็น~,\,+,รูปแบบอินพุต10 5ซึ่งฉันได้ลบ 2 chars โดยกำจัด\,(swap-array))

รุ่นเก่า (12) :

fสร้างฟังก์ชั่น

{n*\n*+,}:f;

*และ+มีการทำซ้ำสตริงและเรียงต่อกันตามลำดับเลขคณิตฟังก์ชั่นไม่ได้

คำอธิบาย: nสร้างสตริงหนึ่งอักขระ (ขึ้นบรรทัดใหม่) นี้จะแล้วซ้ำแล้วซ้ำอีกครั้งจากนั้นสิ่งเดียวกันจะทำด้วยa bสตริงถูกต่อกันและจากนั้น,จะใช้สำหรับความยาวสตริง

C, 29 27 ไบต์

การใช้ตัวชี้ทางคณิตศาสตร์:

f(x,y)char*x;{return&x[y];}

x ถูกกำหนดเป็นตัวชี้ แต่ผู้เรียกควรผ่านจำนวนเต็ม

ผู้ใช้ที่ไม่ระบุชื่อแนะนำต่อไปนี้ - เช่นกัน 27 ไบต์ แต่พารามิเตอร์เป็นจำนวนเต็ม:

f(x,y){return&x[(char*)y];}

Brainf * ck, 9 36

,>,[-<+>]

++[->,[->>[>]+[<]<]<]>>>[<[->+<]>>]<

วิธีนี้ใช้งานได้โดยไม่ต้องใช้วิธีการง่ายๆ มันจะผ่านและวางเส้นทางของ 1 แล้วนับพวกเขา

หมายเหตุ: +และ-เป็นเพียงการเพิ่มครั้งเดียวและไม่มีอะไรสามารถทำได้ใน brainf * ck หากไม่มีพวกเขา พวกเขาไม่ได้เพิ่ม / ลบดังนั้นฉันเชื่อว่านี่ยังคงนับ

J (6)

คุณไม่ได้บอกว่าเราไม่สามารถใช้ฟังก์ชัน succ:

>:@[&0

การใช้งาน:

   9>:@[&0(8)
17

มันทำซ้ำ 9 ครั้ง>:ในวันที่ 8

วิธีการเรียงลำดับรายการใช้งานได้เช่นกัน: #@,&(#&0). และ - ฉันรู้ว่ามันขัดกับกฎ - ฉันไม่สามารถปล่อยให้คำตอบนี้ไปได้หากไม่มีวิธีแก้ปัญหา J-ish ที่สุด: *&.^(การคูณภายใต้การยกกำลัง)

Postscript, 41

เรากำหนดฟังก์ชันด้วยนิพจน์ 41 ไบต์ตราบใดที่:

/a{0 moveto 0 rmoveto currentpoint pop}def

จากนั้นเราเรียกมันว่าเช่น:

gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='

ซึ่งจะช่วยให้

25.0

มันจัดการกับเนกาทีฟและลอยได้อย่างง่ายดายซึ่งแตกต่างจากคู่แข่งส่วนใหญ่ :-)

ทุบตี 20 ตัวอักษร

(seq 10;seq 4)|wc -l

Smalltalk (ตอนนี้จริงจัง), 123 118 105 (*)

ขออภัยที่ต้องตอบสองครั้ง แต่ให้พิจารณาคำตอบนี้อย่างจริงจังในขณะที่อีกคนตอบว่าเป็นอารมณ์ขันมากกว่า ที่จริงแล้วการดำเนินการต่อไปนี้เกิดขึ้นจริงในขณะนี้ในเครื่องของเรา (ในฮาร์ดแวร์) แปลกที่มันมาอยู่ในใจของคนอื่น ...

ด้วยการรวมสองส่วนสองส่วนและทำทุกคำในแบบคู่ขนานเราจะได้รับ (อินพุต a, b; เอาต์พุตใน s) เวอร์ชันที่อ่านได้:

  s := a bitXor: b.            
  c := (a & b)<<1.             

  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s           

ลูปสำหรับการแพร่กระจายการดำเนินการ มาสก์ให้ความมั่นใจว่ามีการจัดการจำนวนเต็มที่ลงนามแล้ว พวกเขายังกำหนดความยาวของคำศัพท์ข้างต้นสำหรับการดำเนินงาน 32 บิต หากคุณชอบการเพิ่ม 68 บิตให้เปลี่ยนเป็น 16rFFFFFFFFFFFFFFFFFFF

รุ่นกอล์ฟ (123 ตัวอักษร) (หลีกเลี่ยงหน้ากากยาวโดยใช้ซ้ำใน m):

[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]

(*) โดยใช้ -1 แทน 16rFFFFFFFF เราสามารถเล่นกอล์ฟได้ดีขึ้น แต่รหัสไม่สามารถใช้งานกับหมายเลขที่มีความแม่นยำได้อีกต่อไปเฉพาะสำหรับขนาดเล็กคำเฉพาะของอินเทอร์เนท

[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]

ทำให้ขนาดโค้ดลดลงเหลือ 105 ตัวอักษร

APL, 8 และ 12

ไม่มีอะไรใหม่ที่นี่เวอร์ชันการนับอาร์เรย์:

{≢∊⍳¨⍺⍵}

และรุ่นบันทึกการทำงาน:

{⍟⍟(**⍺)**⍵}

ฉันแค่คิดว่าพวกเขาดูเท่ห์ใน APL!

{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments

{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵

sed, 359 ไบต์ (โดยไม่มีการจัดรูปแบบแฟนซี)

ขออภัยสำหรับคำตอบที่ล่าช้าและอาจเป็นคำตอบที่ยาวที่สุดที่นี่ แต่ฉันต้องการดูว่าเป็นไปได้กับ sed:

                       s/([^ ]+) ([^ ]+)/\1:0::\2:/
                       :d /^([^:]+):\1::([^:]+):/tx
                       s/(:[^:]*)9([_:])/\1_\2/g;td
s/(:[^:]*)8(_*:)/\19\2/g;s/(:[^:]*)7(_*:)/\18\2/g;s/(:[^:]*)6(_*:)/\17\2/g
s/(:[^:]*)5(_*:)/\16\2/g;s/(:[^:]*)4(_*:)/\15\2/g;s/(:[^:]*)3(_*:)/\14\2/g
s/(:[^:]*)2(_*:)/\13\2/g;s/(:[^:]*)1(_*:)/\12\2/g;s/(:[^:]*)0(_*:)/\11\2/g
                       s/:(_+:)/:1\1/g; y/_/0/; # #
                       bd;  :x  s/.*::([^:]+):/\1/;
                       # # # # # # #  # # # # # # #

สิ่งนี้คล้ายกับhttps://codegolf.stackexchange.com/a/38087/11259ซึ่งเพิ่มตัวเลขในสตริงได้อย่างง่ายดาย แต่มันจะเพิ่มการดำเนินการแทนในวง

อินพุตถูกนำมาจาก STDIN ในรูปแบบ "x y" นั่นถูกเปลี่ยนเป็น "x: 0 :: y:" เป็นครั้งแรก จากนั้นเราจะเพิ่มตัวเลขทั้งหมดที่ตามหลังอักขระ ":" จนกว่าเราจะได้รับ "x: x: :( x + y):" จากนั้นเราก็กลับมา (x + y)

เอาท์พุต

$ printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 67890" "123 1000000000000000000000"  | sed -rf add.sed
0
1
1
1008
1008
80235
1000000000000000000123
$

โปรดทราบว่านี่ใช้งานได้กับจำนวนที่เป็นธรรมชาติเท่านั้น อย่างไรก็ตาม (ในทางทฤษฎีอย่างน้อย) มันทำงานกับจำนวนเต็มขนาดใหญ่โดยพลการ เนื่องจากเรากำลังดำเนินการเพิ่ม x ใน y การสั่งซื้อสามารถสร้างความแตกต่างอย่างมากต่อความเร็ว: x <y จะเร็วกว่า x> y

เส้นประ , 18 ไบต์

time -f%e sleep $@

ต้องใช้ GNU เวลา 1.7 หรือสูงกว่า เอาต์พุตคือ STDERR

ลองออนไลน์!

โปรดทราบว่าสิ่งนี้จะไม่ทำงานในB ash เนื่องจากคำสั่งเวลาในตัวของมันแตกต่างจากเวลา GNU

ด้วยค่าใช้จ่ายเพิ่มเติมหนึ่งไบต์\timeสามารถใช้แทนtimeการบังคับให้ Bash ใช้คำสั่งภายนอก

Javascript (67)

อาจจะดีกว่ามาก

a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)

ทับทิม 18 ตัวอักษร

a.times{b=b.next}

และอีกสองสายพันธุ์ verbose, 29 ตัวอักษร

[*1..a].concat([*1..b]).size

อีกรุ่น 32 ตัวอักษร

(''.rjust(a)<<''.rjust(b)).size

C # - ในการสร้างรหัสการบิน

ใช่มีการเพิ่มในนั้นจริง ๆ แต่ไม่ใช่ตัวดำเนินการ + และไม่ใช่แม้แต่ฟังก์ชันเฟรมเวิร์กที่เพิ่ม แต่แทนที่จะสร้างวิธีขึ้นมาทันทีเพื่อเพิ่ม

public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}

ทับทิม 39

f=->a,b{[*1..a].concat([*1..b]).length}

R 36

function(x,y)length(rep(1:2,c(x,y)))

โดยที่repสร้างเวกเตอร์ของxวัตถุตามด้วยytwos

TI Basic 89 - 19 ไบต์

รันสิ่งนี้ใน TI-89 ของคุณ (หน้าจอหลักหรือแอพพลิเคชั่นการเขียนโปรแกรม):

ln(ln((e^e^x)^e^y))

สิ่งนี้ใช้กฎการบันทึกเพื่อคำนวณx+yเช่นเดียวกับในโซลูชันนี้ เป็นโบนัสมันใช้กับตัวเลขทศนิยมและเลขจำนวนเต็ม มันใช้งานได้กับจำนวนจริงทั้งหมด หากกฎลอการิทึมยังคงใช้ได้กับเลขชี้กำลังเชิงซ้อนนั่นก็ใช้ได้กับจำนวนเชิงซ้อนด้วย อย่างไรก็ตามเครื่องคิดเลขของฉันคายขยะเมื่อฉันพยายามแทรกเลขชี้กำลังที่ซับซ้อน

ขอขอบคุณที่ไมเคิลสเติร์นสำหรับการเรียนการสอนให้ฉัน Mathematica สัญกรณ์

Mathematica - 21 20 ไบต์

Log@Log[(E^E^x)^E^y]

วิธีนี้ใช้วิธีการเดียวกับโซลูชันนี้แต่มันอยู่ใน Mathematica เพื่อทำให้สั้นลง งานนี้สำหรับลบและตัวเลขทศนิยมเช่นเดียวกับจำนวนเต็มในและxy

การทำให้นิพจน์ง่ายขึ้นโดยใช้กฎล็อกให้ผลx+yแต่มันถูกต้องเนื่องจากใช้การยกกำลังไม่ใช่หนึ่งใน 4 ตัวดำเนินการพื้นฐาน

C # - สตริง arithmetics

เราแปลงตัวเลขทั้งสองเป็นสตริงทำการเพิ่มด้วยการตัดสตริง (ด้วยการพกพาและทุกอย่างที่คุณรู้) จากนั้นแยกกลับเป็นจำนวนเต็ม ทดสอบกับ i1, i2 เป็น 0..200 ทำงานเหมือนมีเสน่ห์ ค้นหาการเพิ่มในนี้!

public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}

C (79)

void main(){int a,b;scanf("%d%d",&a,&b);printf("%d",printf("%*c%*c",a,0,b,0));}

Python - 22 ตัวอักษร

len(range(x)+range(y))

APL: 2

1⊥

สิ่งนี้จะแปลงตัวเลขจากฐาน 1 ดังนั้น (n * 1 ^ 1) + (m * 1 ^ 2) ซึ่งเท่ากับ n + m

สามารถลองได้ที่TryApl.org

TI-BASIC, 10

เพิ่มXและY

ln(ln(e^(e^(X))^e^(Y

K, 2 ไบต์

#&

ตัวอย่างการใช้งาน:

  #&7 212
219

ใช้โอเปอเรเตอร์ "ที่ไหน" (monadic &) กับตัวเลขในรายการอินพุต (อาจมีอิสระกับรูปแบบอินพุต) สิ่งนี้จะสร้างรายการที่มีเลขศูนย์แรกตามด้วยจำนวนที่สอง:

  &3 2
0 0 0 1 1

โดยปกติโอเปอเรเตอร์นี้จะใช้เป็น "รวบรวม" เพื่อสร้างรายการดัชนีขององค์ประกอบที่ไม่ใช่ศูนย์ของรายการบูลีน แต่รูปแบบทั่วไปจะมีประโยชน์ในบางครั้ง

จากนั้นก็นับจำนวนรายการ (monadic #)

หากการตีความข้อกำหนดอินพุตของฉันไม่เป็นที่ยอมรับโซลูชันที่ยาวขึ้นเล็กน้อยต่อไปนี้จะใช้กลอุบายแบบเดียวกัน:

{#&x,y}

Pyth , 29 ไบต์

AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H

ลองออนไลน์!

ส่งครั้งแรกของฉันที่นี่!

สิ่งนี้รวบรวมไปที่:

assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H