What is my exponential potential?

Question

We'll define the N-exponential potential of a positive integer M as the count of prefixes of M^N that are perfect N-powers.

The prefixes of an integer are all the contiguous subsequences of digits that start with the first one, interpreted as numbers in base 10. For example, the prefixes of 2744 are 2, 27, 274 and 2744.

A prefix P is a perfect N-power if there exists an integer K such that K^N = P. For example, 81 is a perfect 4-power because 3⁴ = 81.

---

Given two strictly positive integers M and N, compute the N-exponential potential of M according to the definition above.

For instance, the 2-exponential potential of 13 is 3 because 13² is 169, and 1, 16 and 169 are all perfect squares.

Test cases

Naturally, the outputs will nearly always be pretty small because powers are... well... exponentially growing functions and having multiple perfect-power prefixes is rather rare.

M, N     -> Output

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

Answer 1

Brachylog, 12 bytes

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

Try it online!

Explanation

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

Answer 2

Jelly, 10 bytes

*DḌƤÆE%Ḅċ0

Try it online!

How it works

*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.

Answer 3

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

Try it online!

Extracts the prefixes arithmetically by repeated \x->div x 10. I tried expressing the last line point-free but didn't find a shorter expression.

Answer 4

05AB1E, 8 bytes

mηÓ¹%O0¢

Try it online!

Uses Dennis's Jelly 10-byte algorithm. Inputs are in reversed order.

Answer 5

Perl 5, 38 bytes

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

Try it online!

Answer 6

Haskell, 73 bytes

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

Try it online!

Answer 7

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;}

Try it online!

Credits

• -1 byte thanks to Kevin Cruijssen

Answer 8

Perl 6, 40 bytes

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

Try it online!

Answer 9

Jelly, 14 bytes

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

Try it online! or see the test suite

How it works

*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

Answer 10

APL (Dyalog), 31 bytes

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

Try it online!

Answer 11

Haskell, 83 bytes

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

Try it online!

Answer 12

Ruby, 60 bytes

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

a lot of it is to deal with floating point errors

Try it online!

Answer 13

Kotlin, 89 bytes

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

Try it online!

In the test cases, passed in n as double values (2.0, 10.0, 9.0) so that I don't have to convert to double when calling Math.pow().

Answer 14

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

Try it online!

Thx for 1 from ovs.

Answer 15

Jelly, 9 bytes

*DḌƤœ&*€L

Try it online!