Soit un entier positif composé de chiffres décimaux . Soit un autre entier positif.$A$$n$$d_1,d_2,...,d_n$$B$

Aux fins de ce défi, nous appelons un copieur de s'il existe au moins une liste d'entiers positifs tels que:$A$$B$$p_1,p_2,...,p_n$

$A$ et sont appelés imitateurs réciproques si est un imitateur de et est un imitateur de .$B$$A$$B$$B$$A$

Exemple

$526$ et sont des imitations réciproques parce que:$853$

et:

Le défi

Étant donné deux entiers positifs et , votre tâche consiste à imprimer ou à renvoyer une valeur véridique si et sont des contre-copies réciproques ou une valeur fausse dans le cas contraire.$A$$B$$A$$B$

Clarifications et règles

• Vous pouvez prendre et dans n'importe quel format raisonnable et sans ambiguïté (par exemple des entiers, des chaînes, des listes de chiffres, ...)$A$$B$
• $A$ et$B$ peuvent être égaux. Si un nombre est une copie réciproque de lui-même, il appartient à A007532 .
• Au lieu de valeurs véridiques / fausses, vous pouvez renvoyer deux valeurs cohérentes distinctes .
• Pour et , votre code doit se terminer en moins d'une minute . Si cela prend trop de temps pour des valeurs plus élevées, il faut cependant pouvoir les résoudre en théorie.$1\le A<1000$$1\le B<1000$
• C'est du code-golf .

Cas de test

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 octets

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

Essayez-le en ligne!

Sorties true.oufalse.

Explication

ẹ                     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 octets

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

Essayez-le en ligne! Termine tous les cas de test sous 1000 en environ 11 secondes.

Explication

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

Pourquoi ça marche

Si nous avons $B = d_1^{p_1} + \cdots + d_n^{p_n}$ où $d_i$ sont des chiffres et des $p_i$ sont des nombres entiers positifs, alors $d_i^{p_i} \leq B$ pour tous les $i$ , ou de manière équivalente $p_i \leq \log_{d_i} B$ . On peut ignorer le cas $d_i \leq 1$ , puisque exponentiariser $0$ ou $1$ ne le change pas. Dans mon programme, l'espace de recherche est$1 \leq p_i \leq \sqrt{B}$ (pour respecter la restriction de temps; j'utiliserais$1 \leq p_i \leq B$sinon), donc si nous avons$\lfloor \log_{d_i} B \rfloor \leq \lfloor \sqrt{B} \rfloor$, alors tout va bien. Si$d_i \geq 3$, cela vaut pour tous les nombres naturels$B$, donc le seul cas dangereux est$d_i = 2$. Nous avons$\lfloor \log_2 B \rfloor > \lfloor \sqrt{B} \rfloor$uniquement pour$B = 8$. Dans ce cas,$2^3 = 8$, mais la recherche ne prend en compte que les exposants$1$et$2$. Si l'autre numéro numéro$A$contient le chiffre$2$, soit il a aussi d'autres chiffres non nuls (donc l'exposant de$2$ne peut pas être$3$dans la somme), soit$A = 2 \cdot 10^k$pour certains$k$. Dans ce dernier cas,$A$n'est pas une puissance de$8$, il ne peut donc pas être un copieur de$B$ de toute façon, et le programme renvoie correctement une valeur falsifiée indépendamment de l'autre calcul.

Python 2 , 102 octets

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

Essayez-le en ligne!

05AB1E , 26 22 octets

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

Prend l'entrée comme une liste (c. [526,853]-à-d.).

Essayez-le en ligne ou vérifiez la plupart des cas de test de la gamme[1,999] .

Similaire à mon ancienne réponse ci-dessous, sauf que la [1,n]liste est codée en dur [1,100]et crée la liste cartésienne deux fois, une fois pour chaque mappage d'entrée, qui est le principal goulot d'étranglement en termes de performances.

Ancienne réponse de 26 octets, meilleure pour les performances:

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

Dans cette version, j'ai échangé quelques octets pour améliorer considérablement les performances afin de pouvoir fonctionner [1,1000]facilement. Les cas de test contenant des nombres dans la plage [1,9999]sont effectués en environ une seconde sur TIO. Cas de test de l'ordre [10000,99999]de 10 à 15 secondes sur TIO. Au-dessus, cela expirera.

Essayez-le en ligne ou vérifiez tous les cas de test avec des nombres dans la plage[1,9999] .

Explication:

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 octets

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

Essayez-le en ligne!

Perl 6 , 87 84 69 octets

-15 octets grâce à nwellnhof!

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

Essayez-le en ligne!

Bloc de code anonyme qui renvoie True ou False.

Explication:

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

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)

Essayez-le en ligne!

Attendez-vous à l'entrée en tant que (A)(B).

J , 56 octets

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

Essayez-le en ligne!

Oui, définition explicite imbriquée!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

_{-4 octets, merci à Vedant Kandoi}

J, 68 octets

Je pensais que J se comporterait assez bien ici, mais cela a fini par être plus difficile que ce à quoi je m'attendais et j'adorerais toute suggestion pour continuer à jouer au golf ...

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

Essayez-le en ligne!

REMARQUE: nous soustrayons 3 caractères du nombre de TIO car f=.la fonction principale ne compte pas

non golfé

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