Đặt là số nguyên dương gồm chữ số thập phân . Đặt là một số nguyên dương khác.$A$$n$$d_1,d_2,...,d_n$$B$

Với mục đích của thử thách này, chúng tôi gọi là bản sao của nếu có ít nhất một danh sách các số nguyên dương sao cho:$A$$B$$p_1,p_2,...,p_n$

$A$ và được gọi là bắt chước lẫn nhau nếu là một copycat của và là một copycat của .$B$$A$$B$$B$$A$

Thí dụ

$526$ và là copycats đối ứng vì:$853$

và:

Các thách thức

Cho hai số nguyên dương và , nhiệm vụ của bạn là in hoặc trả về giá trị trung thực nếu và là bản sao đối ứng hoặc giá trị giả.$A$$B$$A$$B$

Làm rõ và quy tắc

• Bạn có thể lấy và ở bất kỳ định dạng hợp lý, rõ ràng nào (ví dụ: số nguyên, chuỗi, danh sách các chữ số, ...)$A$$B$
• $A$ và có thể bằng nhau. Nếu một số là bản sao đối ứng của chính nó, thì nó thuộc về A007532 .$B$
• Thay vì các giá trị trung thực / giả, bạn có thể trả về hai giá trị nhất quán riêng biệt .
• Trong và , mã của bạn phải hoàn thành trong vòng chưa đầy một phút . Nếu nó mất quá nhiều thời gian cho các giá trị cao hơn, tuy nhiên nó phải có khả năng giải quyết chúng trên lý thuyết.$1\le A<1000$$1\le B<1000$
• Đây là mã golf .

Các trường hợp thử nghiệm

Truthy:
1 1
12 33
22 64
8 512
23 737
89 89
222 592
526 853
946 961
7 2401
24 4224
3263 9734
86 79424
68995 59227
32028 695345

Falsy:
1 2
3 27
9 24
24 42
33 715
33 732
222 542
935 994
17 2401
8245 4153

Brachylog , 19 byte

ẹ{∧ℕ₁;?↔^}ᵐ².+ᵐ↔?∧≜

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

Đầu ra true.hoặcfalse.

Giải trình

ẹ                     Split the numbers into lists of digits
 {       }ᵐ²          For each digit
  ∧ℕ₁                 Let I be a strictly positive integer
     ;?↔^                Compute the digit to the power I (which is unknown currently)
            .         Call . the list of those new numbers
            .+ᵐ       Their mapped sum results…
               ↔?     …in the reverse of the input
                 ∧≜   Find if there effectively are values for the numbers in . to satisfy
                        these relationships

Husk , 17 byte

Λλ€⁰mΣΠTṪ^ḣ√⁰d)De

Hãy thử trực tuyến! Kết thúc tất cả các trường hợp thử nghiệm dưới 1000 trong khoảng 11 giây.

Giải trình

Λλ€⁰mΣΠTṪ^ḣ√⁰d)De  Implicit inputs, say 12 and 33.
                e  Put into a list: [12,33]
               D   Duplicate: [12,33,12,33]
Λ                  Does this hold for all adjacent pairs:
                    (12,33 is checked twice but it doesn't matter)
                    For example, arguments are 33 and 12.
 λ            )     Anonymous function with arguments 33 (explicit) and 12 (implicit).
             d      Base-10 digits of implicit argument: [1,2]
          ḣ√⁰       Range to square root of explicit argument: [1,2,3,4]
        Ṫ^          Outer product with power: [[1,2],[1,4],[1,8],[1,16],[1,32]]
       T            Transpose: [[1,1,1,1,1],[2,4,8,16,32]]
      Π             Cartesian product: [[1,2],[1,4],...,[1,32]]
    mΣ              Map sum: [3,5,...,33]
  €⁰                Is the explicit argument in this list? Yes.

Tại sao nó hoạt động

$B = d_1^{p_1} + \cdots + d_n^{p_n}$$d_i$$p_i$$d_i^{p_i} \leq B$$i$$p_i \leq \log_{d_i} B$$d_i \leq 1$$0$$1$$1 \leq p_i \leq \sqrt{B}$$1 \leq p_i \leq B$$\lfloor \log_{d_i} B \rfloor \leq \lfloor \sqrt{B} \rfloor$$d_i \geq 3$$B$$d_i = 2$$\lfloor \log_2 B \rfloor > \lfloor \sqrt{B} \rfloor$$B = 8$$2^3 = 8$$1$$2$$A$$2$$2$$3$$A = 2 \cdot 10^k$$k$$A$$8$$B$ dù sao, và chương trình trả về chính xác giá trị giả bất kể tính toán khác.

Python 2 , 102 byte

lambda a,b:g(a,b)*g(b,a)
g=lambda a,b,e=1:b==a<1or(b>0<=b-e>=0<a)and(g(a/10,b-(a%10)**e)or g(a,b,e+1))

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

05AB1E , 26 22 byte

εVтLIàgãεYSym}OIyKå}˜P

Lấy đầu vào là một danh sách (tức là [526,853]).

Hãy thử trực tuyến hoặc xác minh hầu hết các trường hợp thử nghiệm trong phạm vi[1,999] .

Tương tự như câu trả lời cũ của tôi dưới đây, ngoại trừ [1,n]danh sách được mã hóa cứng [1,100]và nó tạo danh sách cartesian hai lần, một lần cho mỗi ánh xạ đầu vào, đây là điểm nghẽn chính về hiệu suất.

Câu trả lời 26 byte cũ tốt hơn cho hiệu suất:

Z©bgL®gãUεVXεYSym}OsN>èå}P

Trong phiên bản này, tôi đã giao dịch một số byte để làm cho hiệu suất tốt hơn rất nhiều để nó có thể chạy [1,1000]dễ dàng. Các trường hợp thử nghiệm chứa các số trong phạm vi [1,9999]được thực hiện trong khoảng một giây trên TIO. Các trường hợp thử nghiệm trong phạm vi [10000,99999]trong khoảng 10-15 giây trên TIO. Trên đó nó sẽ hết thời gian.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm với các số trong phạm vi[1,9999] .

Giải trình:

Z                 # Push the max of the (implicit) input-list (without popping)
                  #  i.e. [526,853] → 853
 ©                # Store it in the register (without popping)
  b               # Convert to binary
                  #  i.e. 853 → 1101010101
   g              # Take its length
                  #  i.e. 1101010101 → 10
    L             # Pop and push a list [1, n]
                  #  i.e. 10 → [1,2,3,4,5,6,7,8,9,10]
     ®            # Push the max from the register
      g           # Take its length
                  #  i.e. 853 → 3
       ã          # Cartesian product the list that many times
                  #  i.e. [1,2,3,4,5,6,7,8,9,10] and 3
                  #   → [[1,1,1],[1,1,2],[1,1,3],...,[10,10,8],[10,10,9],[10,10,10]]
        U         # Pop and store it in variable `X`
ε              }  # Map both values of the input list:
 V                # Store the current value in variable `Y`
  Xε    }         # Map `y` over the numbers of variable `X`
    Y             # Push variable `Y`
     S            # Convert it to a list of digits
                  #  i.e. 526 → [5,2,6]
      ym          # Take each digit to the power of the current cartesian product sublist
                  #  i.e. [5,2,6] and [3,9,3] → [125,512,216]
         O        # Take the sum of each inner list
                  #  i.e. [[5,2,6],[5,2,36],[5,2,216],...,[125,512,216],...]
                  #   → [13,43,223,...,853,...]
          s       # Swap to push the (implicit) input
           N>     # Push the index + 1
                  #  i.e. 0 → 1
             è    # Index into the input-list (with automatic wraparound)
                  #  i.e. [526,853] and 1 → 853
              å   # Check if it's in the list of sums
                  #  i.e. [13,43,223,...,853,...] and 853 → 1
                P # Check if it's truthy for both both (and output implicitly)
                  #  i.e. [1,1] → 1

Haskell , 77 byte

a#b=a!b&&b!a
a!b|a<1=b==0|b<1=b>1|1<2=or[div a 10!(b-mod a 10^e)|e<-[1..b+1]]

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

Perl 6 , 87 84 69 byte

-15 byte nhờ nwellnhof!

{!grep {!grep $^b,[X+] 0,|map (*X**1..$b.msb+1),$^a.comb},.[0,1,1,0]}

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

Khối mã ẩn danh trả về Đúng hoặc Sai.

Giải trình:

{!grep {!grep $^b,[X+] 0,|map (*X**1..$b.msb+1),$^a.comb},.[0,1,1,0]}

{                                                                   }  # Anonymous code block
 !grep    # None of:
                                                          .[0,1,1,0]   # The input and the input reverse
       {!grep       # None of
                  [X+]       # All possible sums of
                       0,|   # 0 (this is to prevent single digit numbers being crossed with themself)
                          map                  ,$^a.comb   # Each digit mapped to
                              (*X**           )  # The power of
                                   1..$b.msb+1   # All of 1 to the most significant bit of b plus 1
                                                 # This could just be b+1, but time constraints...
              $^b,  # Is equal to b

JavaScript (Node.js) , 116 92 89 86 83 77 byte

a=>b=>(G=(c,g,f=h=g%10)=>g?c>f&f>1&&G(c,g,h*f)||G(c-f,g/10|0):!c)(a,b)&G(b,a)

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

Mong đợi đầu vào như (A)(B).

J , 56 byte

h~*h=.4 :'x e.+/|:>,{x 4 :''<y&*^:(x&>)^:a:y''"+"."+":y'

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

Yay, định nghĩa rõ ràng lồng nhau!

Làm thế nào nó hoạt động

powers =. 4 :'<y&*^:(x&>)^:a:y'  Explicit aux verb. x = target, y = digit
                             y   Starting from y,
               y&*^:     ^:a:    collect all results of multiplying y
                    (x&>)        until the result is at least x
              <                  Box it.

h=.4 :'x e.+/|:>,{x powers"+"."+":y'  Explicit aux verb. x, y = two input numbers
                            "."+":y   Digits of y
                  x powers"+          Collect powers of digits of y under x
                 {            Cartesian product of each item
           +/|:>,             Format correctly and compute the sums
       x e.                   Does x appear in the list of sums?

h~*h  Tacit main verb. x, y = two input numbers
      Since h tests the condition in only one direction,
      test again the other way around (~) and take the AND.

Python 2 , 149 147 143 139 132 118 108 107 106 105 byte

lambda a,b:g(a,b)*g(b,a)
g=lambda a,b:any(g(a/10,b-(a%10)**-~i)for i in(a*b>0)*range(len(bin(b))))or b==0

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

_{-4 byte, nhờ Vedant Kandoi}

J, 68 byte

Tôi nghĩ rằng J sẽ hoạt động khá tốt ở đây, nhưng cuối cùng nó khó khăn hơn tôi mong đợi và sẽ thích bất kỳ đề xuất nào để chơi gôn thêm ...

g=.#@#:@[
1 1-:[:(([:+./[=1#.]^"#.1+g#.inv[:i.g^#@])"."0@":)/"1],:|.

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

LƯU Ý: chúng tôi trừ 3 ký tự từ số TIO ở đó vì f=.chức năng chính không được tính

vô dụng

1 1 -: [: (([: +./ [ = 1 #. ] ^"#. 1 + g #.inv [: i. g ^ #@]) "."0@":)/"1 ] ,: |.