ท้าทาย

เขียนฟังก์ชั่นหรือโปรแกรมที่ใช้ตัวเลขทศนิยมบวกเรียกมันว่าAและเอาท์พุทตัวเลขสองบวกBและCเช่นนั้น:

• A == B bitxor C
• BและCต้องไม่มีตัวเลข 0, 3 หรือ 7 ใด ๆ ในการแทนทศนิยม

ตัวอย่าง

>>> decompose(3)
1, 2
>>> decompose(7)
1, 6
>>> decompose(718)
121, 695
>>> decompose(99997)
2, 99999
>>> decompose(4294967296)
4294968218, 922
>>> decompose(5296080632396965608312971217160142474083606142654386510789497504098664630388377556711796340247136376)
6291484486961499292662848846261496489294168969458648464915998254691295448225881546425551225669515922,
1191982455588299219648819556299554251659915414942295896926425126251962564256469862862114191986258666

เนื่องจากการสลายตัวไม่ซ้ำกันฟังก์ชั่น / โปรแกรมของคุณจึงไม่จำเป็นต้องแสดงผลลัพธ์เช่นเดียวกับตัวอย่างที่ให้

กฎรายละเอียดมาก

1. การส่งควรอยู่ในรูปแบบของฟังก์ชั่นหรือโปรแกรมที่สมบูรณ์ importคำแถลงจะนับรวมเป็นคะแนนสุดท้าย

2. คุณอาจจะถือว่าอินพุตAมีตัวเลขอย่างน้อย 0, 3 หรือ 7 เสมอ

3. คุณอาจถือว่าการสลายตัวอยู่เสมอ

4. คุณสามารถใช้ BigInt ได้หากพวกเขาเป็นส่วนหนึ่งของไลบรารีมาตรฐานของภาษาหรือสามารถติดตั้งผ่านทางผู้จัดการแพ็คเกจทางภาษา

5. ฟังก์ชั่นควรจะรวดเร็ว ควรใช้เวลาไม่เกิน20 วินาทีในการทำงานบนคอมพิวเตอร์ที่ทันสมัยพอสมควรเมื่อป้อนหมายเลข 100 หลักและไม่เกิน 2 วินาทีเมื่อป้อนหมายเลข 10 หลัก

6. ฟังก์ชั่น / โปรแกรมควรสนับสนุนการป้อนข้อมูลขึ้นไปอย่างน้อย100 ตัวเลข

   • หากฟังก์ชั่น / โปรแกรมสามารถรองรับจำนวนเต็มไม่เกิน N <100 หลักจะมีค่าปรับเท่ากับ + 10 × (100 / N - 1) ไบต์เป็นคะแนนสุดท้าย นี่คือการสนับสนุนให้นักกอล์ฟให้การสนับสนุนในช่วงกว้างของตัวเลขแม้ว่าการนำเข้าอาจจะ verbose

7. มีข้อ จำกัด ในการนำเสนอของอินพุต / เอาต์พุตตราบเท่าที่พวกเขาได้อย่างชัดเจนในการเป็นตัวแทนทศนิยม

   • ฟังก์ชั่นอาจอินพุตและเอาต์พุตสตริง / BigInts หากประเภทจำนวนเต็มในตัวไม่เพียงพอ
   • อินพุตอาจมาจากพารามิเตอร์ฟังก์ชันอาร์กิวเมนต์บรรทัดคำสั่งหรือ STDIN
   • ฟังก์ชันอาจส่งคืนผลลัพธ์หรือเพียงพิมพ์ผลลัพธ์โดยตรงไปที่ STDOUT
   • อย่างไรก็ตามไม่อนุญาตให้โอเวอร์โฟลว์ที่มีการเซ็นชื่อในอินพุต / เอาท์พุต
   • คำตอบโดยประมาณจะไม่ได้รับการยอมรับโดยอินพุต / เอาท์พุตจะต้องแน่นอน

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

นี่คือรหัสกอล์ฟ ทางออกที่สั้นที่สุดในหน่วยไบต์ชนะ

มีการลงโทษหากโปรแกรมรองรับตัวเลขที่น้อยกว่า 100 หลักเท่านั้น:

• จำนวนเต็ม 64- บิต (19 หลัก) = +42 ไบต์
• จำนวนเต็ม 63 บิต (18 หลัก) = +45 ไบต์
• จำนวนเต็ม 53 บิต (15 หลัก) = +56 ไบต์
• จำนวนเต็ม 31/32 บิต (9 หลัก) = +101 ไบต์

CJam, 70 ไบต์

ri:Q{;Qmr_Q^`1$`+730`&}g_Q^p

ลองออนไลน์

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

ตัวอย่างการวิ่ง

$ cjam t <<< 7777777777; echo
2695665494
6161166119

เสียงกระเพื่อมสามัญ240 224 183 173 169 ไบต์

Common LISP เป็น verbose เล็กน้อยสำหรับการเล่นกอล์ฟ อย่างไรก็ตามสิ่งนี้จะสลายตัวตัวเลข 100 หลักภายในไม่กี่วินาทีและจำนวนเต็ม 200 หลักในเวลาน้อยกว่าสิบวินาทีดังนั้นจึงไม่จำเป็นต้องถูกปรับ อัลกอริทึมนั้นถูกกำหนดไว้แล้ว

(defun s(z)(and #1=(some(lambda(q)(position q(format()"~a"z)))"037")(+ z(floor z(expt 10 #1#)))))
(defun d(x)(do((y x(or(s y)(s #3=(logxor x y))(return`(,y,#3#)))))(())))

การป้อนบรรทัดระหว่างฟังก์ชันใช้เพื่อการพิมพ์เท่านั้น ทดสอบการทำงานด้วยอินพุตอ้างอิง 100 หลัก:

(time (d 5296080632396965608312971217160142474083606142654386510789497504098664630388377556711796340247136376))
took 677,000 microseconds (0.677000 seconds) to run.
      20,989 microseconds (0.020989 seconds, 3.10%) of which was spent in GC.
During that period, and with 8 available CPU cores,
     671,875 microseconds (0.671875 seconds) were spent in user mode
           0 microseconds (0.000000 seconds) were spent in system mode
 54,221,104 bytes of memory allocated.
(1864921261592819619661568919418981552559955289196969112566252282429216186594265918444566258544614425
 5891958562486995519825158818455999516899524658151445485616155916296966645869599949958954491929662561)

เป็นโบนัสฉันรวมรุ่นของรหัสที่สร้างขึ้นจากบนลงล่างโซลูชัน สามารถจัดการตัวเลข 1,000 หลักในเวลาน้อยกว่าสิบวินาที แต่ไม่สามารถแข่งขันกอล์ฟได้เนื่องจากรหัสเพิ่มเติม

(defun decompose (x)
  (flet ((s (z)
           (mapcan #'(lambda (c) (and #1=(position c #2=(format () "~a" z))
                                 (list (- (length #2#) #1# 1))))
                   '(#\0 #\3 #\7))))
    (do ((y x (let ((p (nconc (s y) (s #3=(logxor x y)))))
                (or p (return`(,y,#3#)))
                (+ y (expt 10 (apply #'max p))))))
        (nil))))

* (time (decompose (parse-integer (make-string 1000 :initial-element #\7))))
took 9,226,000 microseconds (9.226000 seconds) to run.
        90,966 microseconds (0.090966 seconds, 0.99%) of which was spent in GC.
During that period, and with 8 available CPU cores,
     9,234,375 microseconds (9.234375 seconds) were spent in user mode
             0 microseconds (0.000000 seconds) were spent in system mode
 487,434,560 bytes of memory allocated.
(8889898889152488921298888992819221914229899249999918899888899888888889999989141219898898888988988898888888888899142442899924898918898898988988895189988898888924192198992454114198911989191888889898888918888988988998888891421118891899122898888998989898888898988898888999988918888898889189918889888888899888989219188898998888988892119889198888988888894888912188898989952999888888888898899998988898889228918998949999998898898991141888898999988912121292118899889998989899999892889941898888911888898889118998898888911889889888891452888998889288921141888888942189888899988891918889118888888888989892198899199914111188988889421111188889118888918989988912989999998989891119888898888888892621229888988888999619888952462219889189899998899888889989898891118989218888888898962988891188899888888888999888888888888888888888891269188921288888888998898899214191188888888898992188998898889919888889989889899988892115549998888898889218899988998911898989199918898918988898888891889888989119899888889888998918889112189998
 4184469818464841952189561886965821566229261221619858498284264289194458622668559698924621446851546256444641488616184155821914881485164244662156846141894655485889656891849662551896595944656451462198891289692696856414192264846811616261884188919426294584158925218559295881946496911489245664261126565546419851585441144861859822815144162828551969425529258169849412525611662488849586554989254181228254465226521648916188265491499166186964881248156451994924294646681548996645996894665198811511522424996844864211629888924642289925565591484541149414914699289441561496451494562955652129199261462268846144518142486845251946444998812988291119592418684842524648484689261441456645518518812265495165189812912919529151991611962525419626921619824496626511954895189658691229655648659252448158451924925658586522262194585891859285841914968868466462442488528641466655911199816288496111884591648442984864269495264612518852292965985888414945855422266658614684922884216851481646226111486498155591649619266595911992489425412191)
* (apply #'logxor *)
7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777

Python 2, 103 + 42 = 145 ไบต์

Python ให้การสนับสนุน bigint แต่โปรแกรมนี้มีความยาวเกิน 20 วินาทีสำหรับตัวเลข 100 หลัก อย่างไรก็ตามมันจะสลายตัวจำนวนเต็ม 64- บิตในเวลาประมาณ 2 วินาที

from random import *
def d(a):
 b=c=0
 while set(`b`+`c`)&set('037'):
    b=randint(1,a);c=a^b
 return b,c

Python 3 (132 ไบต์)

(นี่เป็นเพียงการกระตุ้นโซลูชันที่ดีกว่านี่คือโซลูชันของฉันเมื่อแก้ไขปัญหาต้นฉบับในภาพยนตร์ ASCII)

def d(a):
 l=len(str(a));s=int('1'*l);u=10**(l-1)
 while u:
  while set(str(s)+str((a^s)//u))&set('037'):s+=u
  u//=10
 print(s,a^s)

แม้ว่าพฤติกรรมของ xor บิตในระบบทศนิยมมีความซับซ้อนสวยมีหนึ่งข้อสังเกตที่สำคัญ: การปรับเปลี่ยนตัวเลขต่ำจะไม่ส่งผลกระทบต่อตัวเลขสูง ดังนั้นเราสามารถทำงานจากบนลงล่าง: พยายามทำให้ตัวเลขบนสุดเป็นอิสระจาก 0, 3, 7 และจากนั้นทำงานกับตัวเลขถัดไปจนกว่าตัวเลขทั้งหมดจะหมด สิ่งนี้ช่วยให้เราสามารถทำงานในเวลาเชิงเส้นจากนั้นการประมวลผลตัวเลขพันหลักสามารถทำได้ภายใน 1 วินาที (วิธีแก้ปัญหาทั่วไป Lisp ใช้เทคนิคเดียวกับที่ฉันเชื่อ)