Deje que $A$ sea un número entero positivo que consiste en $n$ dígitos decimales $d_1,d_2,...,d_n$ . Deje $B$ ser otro entero positivo.

A los efectos de este desafío, que llamamos $A$ un imitador de $B$ si existe al menos una lista de números enteros positivos $p_1,p_2,...,p_n$ tal que:

$A$ y$B$ se denominanimitadores recíprocossi$A$ es un imitador de$B$ y$B$ es un imitador de$A$ .

Ejemplo

$526$ y$853$ son imitadores recíprocos porque:

y:

El reto

Dados dos enteros positivos $A$ y $B$ , su tarea es imprimir o devolver un valor verdadero si $A$ y $B$ son copias recíprocas o un valor falso de lo contrario.

Aclaraciones y reglas.

• Puede tomar $A$ y $B$ en cualquier formato razonable y sin ambigüedades (por ejemplo, enteros, cadenas, listas de dígitos, ...)
• $A$ y$B$ pueden ser iguales. Si un número es una copia recíproca de sí mismo, pertenece aA007532.
• En lugar de valores de verdad / falsedad, puede devolver dos valores consistentes distintos .
• Para $1\le A<1000$ y $1\le B<1000$ , su código debe completarse en menos de un minuto . Si está tomando demasiado tiempo para valores más altos, debe ser capaz de resolverlos en teoría.
• Este es el código de golf .

Casos de prueba

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 bytes

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

Pruébalo en línea!

Salidas true.ofalse.

Explicación

ẹ                     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

Casco , 17 bytes

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

Pruébalo en línea! Termina todos los casos de prueba por debajo de 1000 en aproximadamente 11 segundos.

Explicación

Λλ€⁰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.

Por que funciona

$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$ de todos modos, y el programa devuelve correctamente un valor falso independientemente del otro cálculo.

Python 2 , 102 bytes

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

Pruébalo en línea!

05AB1E , 26 22 bytes

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

Toma la entrada como una lista (es decir [526,853]).

Pruébalo en línea o verifique la mayoría de los casos de prueba en el rango[1,999] .

Similar a mi respuesta anterior a continuación, excepto que la [1,n]lista está codificada para[1,100] y crea la lista cartesiana dos veces, una para cada asignación de entrada, que es el principal cuello de botella en términos de rendimiento.

Antigua respuesta de 26 bytes que es mejor para el rendimiento:

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

En esta versión, cambié algunos bytes para mejorar mucho el rendimiento y poder ejecutarlo [1,1000]con facilidad. Casos de prueba que contienen números en el rango[1,9999] se realizan en aproximadamente un segundo en TIO. Pruebe los casos en el rango [10000,99999]en aproximadamente 10-15 segundos con TIO. Por encima de eso, se agota el tiempo de espera.

Pruébelo en línea o verifique todos los casos de prueba con números en el rango[1,9999] .

Explicación:

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 bytes

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]]

Pruébalo en línea!

Perl 6 , 87 84 69 bytes

-15 bytes gracias a nwellnhof!

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

Pruébalo en línea!

Bloque de código anónimo que devuelve verdadero o falso.

Explicación:

{!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 bytes

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)

Pruébalo en línea!

Espere entrada como (A)(B).

J , 56 bytes

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

Pruébalo en línea!

¡Sí, definición explícita anidada!

Cómo funciona

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 bytes

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

Pruébalo en línea!

_{-4 bytes, gracias a Vedant Kandoi}

J, 68 bytes

Pensé que J se desempeñaría bastante bien aquí, pero terminó siendo más difícil de lo que esperaba y me encantaría cualquier sugerencia para seguir jugando al golf ...

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

Pruébalo en línea!

NOTA: restamos 3 caracteres del recuento de TIO allí ya que f=.en la función principal no cuenta

sin golf

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