Thử thách

Viết hàm hoặc chương trình lấy số thập phân dương, gọi nó là A và xuất ra hai số dương, B và C , sao cho:

• A == B bitxor C
• B và C không được chứa bất kỳ chữ số 0, 3 hoặc 7 nào trong biểu diễn thập phân của nó.

Ví dụ

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

Vì phép phân tách không phải là duy nhất, nên hàm / chương trình của bạn không cần xuất kết quả chính xác giống như các ví dụ được cung cấp này.

Quy tắc rất chi tiết

1. Đệ trình phải ở dạng chức năng hoặc chương trình hoàn chỉnh . importbáo cáo làm được tính vào điểm số cuối cùng.

2. Bạn có thể giả sử đầu vào A luôn chứa ít nhất một chữ số 0, 3 hoặc 7.

3. Bạn có thể cho rằng một sự phân rã luôn tồn tại.

4. Bạn có thể sử dụng bigint nếu họ là một phần của thư viện chuẩn của ngôn ngữ, hoặc có thể được cài đặt thông qua của ngôn ngữ jure de quản lý gói.

5. Các chức năng phải được nhanh chóng. Sẽ không mất quá 20 giây để chạy trên máy tính hiện đại hợp lý khi được cấp một số có 100 chữ số và không quá 2 giây khi được cấp một số có 10 chữ số.

6. Hàm / chương trình phải hỗ trợ đầu vào tối thiểu 100 chữ số .

   • Nếu chức năng / chương trình chỉ có thể hỗ trợ các số nguyên tối đa N <100 chữ số, sẽ có một hình phạt + 10 × (100 / N - 1) byte cho điểm số cuối cùng. Điều này là để khuyến khích người chơi golf hỗ trợ một phạm vi số rộng hơn ngay cả khi việc nhập có thể dài dòng.

7. Không có hạn chế về việc trình bày đầu vào / đầu ra miễn là chúng rõ ràng trong biểu diễn thập phân.

   • Hàm có thể nhập và xuất chuỗi / BigInt nếu các kiểu số nguyên tích hợp không đủ.
   • Đầu vào có thể đến từ tham số chức năng, đối số dòng lệnh hoặc STDIN.
   • Hàm có thể trả về kết quả hoặc chỉ in kết quả trực tiếp sang STDOUT.
   • Tuy nhiên, không được phép tràn tràn trong đầu vào / đầu ra.
   • Câu trả lời gần đúng không được chấp nhận, đầu vào / đầu ra phải chính xác.

Chấm điểm

Đây là một mã golf . Giải pháp ngắn nhất trong byte thắng.

Sẽ bị phạt nếu chương trình chỉ có thể hỗ trợ các số dưới 100 chữ số:

• Số nguyên 64 bit (19 chữ số) = +42 byte
• Số nguyên 63 bit (18 chữ số) = +45 byte
• Số nguyên 53 bit (15 chữ số) = +56 byte
• Số nguyên 31/32 bit (9 chữ số) = +101 byte

CJam, 70 byte

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

Hãy thử trực tuyến.

Chọn ngẫu nhiên các số nguyên cho đến khi tìm thấy kết quả khớp. Điều này hầu như không tuân thủ giới hạn 20 giây đối với số nguyên 64 bit (sử dụng trình thông dịch Java), vì vậy tôi đã thêm 42 vào số byte thực tế.

Chạy ví dụ

$ cjam t <<< 7777777777; echo
2695665494
6161166119

Lisp thường gặp, 240 224 183 173 169 byte

Lisp thông thường là một chút dài dòng cho việc chơi golf. Tuy nhiên, điều này phân tách các số có 100 chữ số dưới một giây và số nguyên 200 chữ số trong chưa đầy mười giây, do đó không cần phải bị phạt. Thuật toán mang tính quyết định.

(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#)))))(())))

Nguồn cấp dữ liệu giữa các chức năng chỉ dành cho mục đích đánh máy. Chạy thử với đầu vào tham chiếu 100 chữ số:

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

Như một phần thưởng, tôi bao gồm một phiên bản mã tăng dần giải pháp từ trên xuống. Nó có thể quản lý một số 1000 chữ số trong chưa đầy mười giây, nhưng không thể cạnh tranh trong golf do mã bổ sung.

(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 byte

Python vốn hỗ trợ bigint, nhưng chương trình này vượt xa 20 giây cho một số có 100 chữ số. Tuy nhiên, nó phân hủy các số nguyên 64 bit trong khoảng 2 giây.

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

(Đây chỉ là để kích thích các giải pháp tốt hơn. Đây là giải pháp của tôi khi giải quyết vấn đề gốc trong phim 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)

Mặc dù hành vi của bitwise xor trong hệ thập phân khá phức tạp, có một quan sát chính: sửa đổi các chữ số thấp sẽ không ảnh hưởng đến các chữ số cao . Do đó, chúng ta có thể làm việc từ trên xuống: cố gắng làm cho các chữ số trên cùng không có 0, 3, 7, và sau đó làm việc trên chữ số tiếp theo, cho đến khi toàn bộ số được xử lý. Điều này cho phép chúng ta chạy trong thời gian tuyến tính, sau đó xử lý một số nghìn chữ số có thể hoàn thành dưới 1 giây. (Giải pháp Lisp chung cũng sử dụng kỹ thuật tương tự mà tôi tin.)