Definiremos el potencial exponencial N de un entero positivo M como el recuento de prefijos de M ^N que son potencias N perfectas.

Los prefijos de un número entero son todas las subsecuencias contiguas de dígitos que comienzan con el primero, interpretados como números en la base 10. Por ejemplo, los prefijos de 2744 son 2 , 27 , 274 y 2744 .

Un prefijo P es una perfecta N -de potencia si existe un entero K tal que K ^N = P . Por ejemplo, 81 es una potencia perfecta de 4 porque 3 ⁴ = 81 .

Dados dos enteros estrictamente positivos M y N , calcule el potencial N- exponencial de M de acuerdo con la definición anterior.

Por ejemplo, el potencial exponencial 2 de 13 es 3 porque 13 ² es 169 , y 1 , 16 y 169 son cuadrados perfectos.

Casos de prueba

Naturalmente, las salidas casi siempre serán bastante pequeñas porque las potencias son ... bueno ... funciones que crecen exponencialmente y tener múltiples prefijos de potencia perfecta es bastante raro.

M, N     -> Output

8499, 2  -> 1
4,    10 -> 2
5,    9  -> 2
6,    9  -> 2
13,   2  -> 3

Brachylog , 12 bytes

{^a₀.&b~b^}ᶜ

Pruébalo en línea!

Explicación

{^a₀.&b~b^}ᶜ
{         }ᶜ  Count the number of ways the following can succeed:
  a₀            A prefix of
 ^                the first {input} to the power of the second {input}
    .&          produces the same output with the same input as
       ~b         any number
         ^        to the power of
      b           all inputs but the first (i.e. the second input)

Jalea , 10 bytes

*DḌƤÆE%Ḅċ0

Pruébalo en línea!

Cómo funciona

*DḌƤÆE%Ḅċ0  Main link. Left argument: m. Right argument: n.

*           Compute m**n.
 D          Generate its decimal digits.
  ḌƤ        Convert prefixes back to integers.
    ÆE      Get the exponents of each prefix's prime factorization.
      %     Take all exponents modulo n.
            For a perfect n-th power, all moduli will be 0.
       Ḅ    Convert from binary to integer, mapping (only) arrays of 0's to 0.
        ċ0  Count the zeroes.

Haskell , 56 bytes

0%n=0
x%n=sum[1|t<-[1..x],t^n==x]+div x 10%n
m#n=(m^n)%n

Pruébalo en línea!

Extrae los prefijos aritméticamente por repetidos \x->div x 10. Intenté expresar la última línea sin puntos pero no encontré una expresión más corta.

05AB1E , 8 bytes

mηÓ¹%O0¢

Pruébalo en línea!

Utiliza el algoritmo Dennis's Jelly de 10 bytes. Las entradas están en orden inverso.

Perl 5 , 38 bytes

#!/usr/bin/perl -p
/ /;$_=grep/^${\++$n**$'}/,($`**$')x$`

Pruébalo en línea!

Haskell, 73 bytes

m#n=sum[1|c<-scanl(\s c->s++[c])"0"$show$m^n,any(==read c)$map(^n)[1..m]]

Pruébalo en línea!

Java (OpenJDK 9) , 105 bytes

m->n->{int c=1,k=m;for(;--k>0;)if((""+(int)Math.pow(m,n)).matches((int)Math.pow(k,n)+".*"))c++;return c;}

Pruébalo en línea!

Créditos

• -1 byte gracias a Kevin Cruijssen

Perl 6 , 40 bytes

{1+(^$^m X**$^n).grep({$m**$n~~/^$^p/})}

Pruébalo en línea!

Jalea , 14 bytes

*DḌƤ*İ}ær⁵%1¬S

Pruébalo en línea!o ver el conjunto de pruebas

Cómo funciona

*DḌƤ*İ}ær⁵%1¬S - Main link. Arguments: n, m (integers)  e.g. 13, 2
*              - Power. Raise x to the power y               169
 D             - Convert to a list of digits                 [1 6 9]
   Ƥ           - Convert each Ƥrefix
  Ḍ            - Back to an integer                          [1 16 169]
     İ         - Calculate the İnverse of
      }        - The right argument                          0.5
    *          - Raise each element to that power            [1 4 13]
       ær⁵     - Round each to 10 ** -10                     [1 4 13]
               - to remove precision errors
          %1   - Take the decimal part of each               [0 0 0]
            ¬  - Logical NOT each                            [1 1 1]
             S - Sum                                         3

APL (Dyalog) , 31 bytes

{+/o=⌊o←(÷⍵)*⍨10⊥¨,\10⊥⍣¯1⊢⍺*⍵}

Pruébalo en línea!

Haskell , 83 bytes

import Data.List
m#n=sum[1|x<-read<$>(tail$inits$show(m^n)),x`elem`((^n)<$>[1..m])]

Pruébalo en línea!

Rubí , 60 bytes.

->m,n{c=1;s=m**n;c+=(0..m).count{|j|j**n==s}while 0<s/=10;c}

Mucho de esto es tratar con errores de coma flotante

Pruébalo en línea!

Kotlin , 89 bytes

m,n->1+(1..m-1).count{"${Math.pow(m+0.0,n)}".startsWith("${Math.pow(it+0.0,n).toInt()}")}

Pruébalo en línea!

En los casos de prueba, pasé n como valores dobles (2.0, 10.0, 9.0) para que no tenga que convertir a doble al llamar a Math.pow ().

Python 2 , 83 71 70 bytes

n,m=input();s=n**m;k=0
while s:k+=round(s**(1./m))**m==s;s/=10
print k

Pruébalo en línea!

Thx para 1 de los ovs.

Jalea , 9 bytes

*DḌƤœ&*€L

Pruébalo en línea!