Geben Sie bei einer gegebenen Ganzzahl nden kleinsten Exponenten egrößer als 1 aus, n^eder neine Teilzeichenfolge enthält .

Zum Beispiel sollte 25die Antwort 2as sein 25 ^ 2 = 625, die 25als Teilzeichenfolge enthält , aber die Antwort für 13sollte 10as sein 13 ^ 10 = 137858491849, so 10ist der niedrigste Exponent, für den das Ergebnis 13als Teilzeichenfolge enthält .

Regeln

• Standard-E / A-Regeln
• Es gelten Standardlücken
• Kürzester Code in Bytes gewinnt
• n wird immer eine ganze Zahl größer als sein 0

Testfälle

1 => 2   (1 ^ 2 = 1)
2 => 5   (2 ^ 5 = 32)
3 => 5   (3 ^ 5 = 243)
4 => 3   (4 ^ 3 = 64)
5 => 2   (5 ^ 2 = 25)
6 => 2   (6 ^ 2 = 36)
7 => 5   (7 ^ 5 = 16807)
8 => 5   (8 ^ 5 = 32768)
9 => 3   (9 ^ 3 = 729)
10 => 2  (10 ^ 2 = 100)
11 => 11 (11 ^ 11 = 285311670611)
12 => 14 (12 ^ 14 = 1283918464548864)
13 => 10 (13 ^ 10 = 137858491849)
14 => 8  (14 ^ 8 = 1475789056)
15 => 26 (15 ^ 26 = 3787675244106352329254150390625)
16 => 6  (16 ^ 6 = 16777216)
17 => 17 (17 ^ 17 = 827240261886336764177)
18 => 5  (18 ^ 5 = 1889568)
19 => 11 (19 ^ 11 = 116490258898219)
20 => 5  (20 ^ 5 = 3200000)
25 => 2  (25 ^ 2 = 625)
30 => 5  (30 ^ 5 = 24300000)
35 => 10 (35 ^ 10 = 2758547353515625)
40 => 3  (40 ^ 3 = 64000)
45 => 5  (45 ^ 5 = 184528125)
50 => 2  (50 ^ 2 = 2500)
55 => 11 (55 ^ 11 = 13931233916552734375)
60 => 2  (60 ^ 2 = 3600)
65 => 17 (65 ^ 17 = 6599743590836592050933837890625)
70 => 5  (70 ^ 5 = 1680700000)
75 => 3  (75 ^ 3 = 421875)
80 => 5  (80 ^ 5 = 3276800000)
85 => 22 (85 ^ 22 = 2800376120856162211833149645328521728515625)
90 => 3  (90 ^ 3 = 729000)
95 => 13 (95 ^ 13 = 51334208327950511474609375)
100 => 2 (100 ^ 2 = 10000)

Python-Skript zum Generieren der ersten 1000 Antworten

Perl 6 , 31 Bytes

{$^a;first {$a**$_~~/$a/},2..*}

Probieren Sie es online!

R , 69 44 Bytes

function(n,i=2){while(!grepl(n,n^i))i=i+1;i}

Anonyme Funktion. Funktioniert in großen Dateien, iwenn nin BigZ konvertiert wird (siehe TIO). Danke, dass du mir etwas beigebracht hast, Giuseppe und digEmAll!

Probieren Sie es online!

Python 2 , 42 41 Bytes

^{-1 Byte danke an Ørjan Johansen ( ydirekt zurück)}

f=lambda x,y=2:y*(`x`in`x**y`)or f(x,y+1)

Probieren Sie es online!

Erklärung / Ungolfed

Rekursive Funktion versuchen von $2,3\dots$ bis es uns gelingt:

# Start recursion with y=2
def f(x,y=2):
    # If we succeed, we arrived at the desired y
    if `x` in `x**y`:
        return y
    # Else we try with next y
    else:
        return f(x, y+1)

Probieren Sie es online!

JavaScript (ES6 / Node.js),  41 bis  40 Byte

1 Byte dank @Shaggy gespeichert

Übernimmt Eingaben als Zahl (funktioniert für $n<15$ ) oder als BigInt- Literal.

n=>(g=x=>`${x*=n}`.match(n)?2:-~g(x))(n)

Probieren Sie es online!

APL (Dyalog Unicode) , 25 23 17 Bytes

-2 Bytes dank @Erik the Outgolfer

-6 Bytes dank @ngn

Vielen Dank an @ H.PWiz, dass der Code nicht benutzerdefiniert sein muss ⎕pp(Druckgenauigkeit)

⊢⍟×⍣(∨/(⍕÷)⍷0⍕⊣)⍨

Probieren Sie es online!

⊢⍟×⍣(∨/(⍕÷)⍷0⍕⊣)⍨
  ×⍣(          )⍨ generates a geometric progression by repeatedly multiplying the argument
                   by its original value
     ∨/(⍕÷)⍷0⍕⊣   the progression stops when this function, applied between the new and the
                   last old member, returns true
         ÷        the original argument (ratio between two consecutive members)
        ⍕         formatted as a string
           ⍷      occurrences within...
            0⍕    ...the formatted (with 0 digits after the decimal point)...
              ⊣   ...new member
     ∨/           are there any?
⊢⍟                use logarithm to determine what power of ⍵ we reached

Pyth , 9 Bytes

f}`Q`^QT2

Probieren Sie es online!

Brachylog , 8 Bytes

;.^s?∧ℕ₂

Probieren Sie es online!

Erläuterung

;.^         Input ^ Output…
   s?       …contains the Input as a substring…
     ∧      …and…
      ℕ₂    …the Output is in [2,+∞)

05AB1E , 7 Bytes

∞>.Δm¹å

Probieren Sie es online!

Erläuterung:

∞>.Δm¹å  //full program
∞        //push infinite list, stack = [1,2,3...]
 >       //increment, stack is now [2,3,4...]
  .Δ     //find the first item N that satisfies the following
     ¹   //input
      å  //is in
    m    //(implicit) input **  N

SAS, 71 66 Bytes

Bearbeiten: ;run;Am Ende entfernt, da dies durch das Ende der Eingaben impliziert wird.

data a;input n;e=1;do until(find(cat(n**e),cat(n)));e+1;end;cards;

Eingabedaten werden nach der cards;Anweisung wie folgt eingegeben :

data a;input n;e=1;do until(find(cat(n**e),cat(n)));e+1;end;cards;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Erzeugt einen Datensatz a, der die Eingabe nund die Ausgabe enthält e.

Gelee , 7 Bytes

2ẇ*¥@1#

Probieren Sie es online!

Sauber , 99 Bytes

import StdEnv,Text,Data.Integer
$n=hd[p\\p<-[fromInt 2..]|indexOf(""<+n)(""<+prod(repeatn p n))>=0]

Probieren Sie es online!

Wenn es nicht für riesige Mengen funktionieren muss, dann

Sauber , 64 Bytes

import StdEnv,Text
$n=hd[p\\p<-[2..]|indexOf(""<+n)(""<+n^p)>=0]

Probieren Sie es online!

Java (OpenJDK 8) , 84 Byte

Übernimmt die Eingabe als String, der die Zahl darstellt, und gibt ein int aus.

Die meisten Bytes stammen aus der Ausführlichkeit des BigDecimalWesens, das zur Verarbeitung der großen Zahlen benötigt wird.

n->{int i=1;while(!(new java.math.BigDecimal(n).pow(++i)+"").contains(n));return i;}

Probieren Sie es online!

Wie es funktioniert

Dies ist ziemlich einfach, aber ich werde die Erklärung für die Nachwelt einschließen;

n->{                                    // Lamdba taking a String and returning an int
    int i=1;                            // Initialises the count
    while(!                             // Loops and increments until
        (new java.math.BigDecimal(n)    // Creates a new BigDecimal from the input n
            .pow(++i)+"")               // Raises it to the power of the current count
            .contains(n)                // If that contains the input, end the loop
    );
    return i;                           // Return the count
}

Ruby , 37 Bytes

->n,i=2{i+=1until/#{n}/=~"#{n**i}";i}

Probieren Sie es online!

Japt, 10 Bytes

@pX søU}a2

Versuch es

JavaScript (Node.js) , 45 Byte

Testfälle aus der Antwort von @ Arnauld

a=>eval("for(i=1n;!(''+a**++i).match(a););i")

Probieren Sie es online!

Holzkohle , 19 Bytes

Ｗ∨‹Ｌυ²¬№ＩΠυθ⊞υＩθＩＬυ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｗ∨‹Ｌυ²¬№ＩΠυθ⊞

Wiederholen, bis die Listenlänge mindestens 2 beträgt und das Produkt die Eingabe enthält ...

⊞υＩθ

... die Eingabe in eine Ganzzahl umwandeln und in die Liste verschieben.

ＩＬυ

Wandeln Sie die Länge der Liste in eine Zeichenfolge und drucken Sie sie implizit aus.

Python 3 , 63-58 Bytes

def f(n,e=2):
	while str(n)not in str(n**e):e+=1
	return e

Probieren Sie es online!

Python2 wäre wahrscheinlich kürzer, aber ich verwende gerne 3. Es ist schwierig, mit einem Lambda aufzutauchen, aber ich versuche ein paar Dinge.

MathGolf , 10 Bytes

ôkï⌠#k╧▼ï⌠

Probieren Sie es online!

Erläuterung

Dies fühlt sich äußerst verschwenderisch an, da die Eingabe explizit zweimal gelesen und der Schleifenzähler zweimal inkrementiert werden muss.

ô            start block of length 6
 k           read integer from input
  ï          index of current loop, or length of last loop
   ⌠         increment twice
    #        pop a, b : push(a**b)
     k       read integer from input
      ╧      pop a, b, a.contains(b)
       ▼     do while false with pop
        ï    index of current loop, or length of last loop
         ⌠   increment twice

Ruby , 41 Bytes

f=->n,a=n{(a*=n).to_s=~/#{n}/?2:1+f[n,a]}

Probieren Sie es online!

C # (.NET Core) , 104 89 Bytes

a=>{int i=2;while(!(System.Numerics.BigInteger.Pow(a,i)+"").Contains(a+""))i++;return i;}

Probieren Sie es online!

-1 Byte: geändert für Schleife in while (dank Skidsdev )
-14 Byte: missbraucht die seltsame String-Behandlung von C #, um Aufrufe zu entfernenToString()

Die BigInteger- Bibliothek von C # muss verwendet werden, da die numerischen Standard-C # -Typen (int, double, long, ulong usw.) für einige größere Zahlen (einschließlich 12, 15 und 17) fehlschlagen.

Ungolfed:

a => {
    int i = 2;                                          // initialize i

    while( !(System.Numerics.BigInteger.Pow(a,i) + "")  // n = a^i, convert to string
                                .Contains(a + ""))      // if n doesn't contain a
        i++;                                                // increment i

    return i;
}

Python 2 , 47 Bytes

i,e=input(),2
while`i`not in`i**e`:e+=1
print e

Probieren Sie es online!

Inspiriert von der @ Gigaflop- Lösung .

Tcl , 69 81 Bytes

proc S n {incr i
while {![regexp $n [expr $n**[incr i]]]} {}
puts $i}

Probieren Sie es online!

PowerShell (V3 +), 67 Byte

function f{param($n)$i=1;do{}until([math]::pow($n,++$i)-match$n)$i}

Common Lisp, 78 Bytes

(lambda(n)(do((e 2(1+ e)))((search(format()"~d"n)(format()"~d"(expt n e)))e)))

Probieren Sie es online!

J , 26 Bytes

2>:@]^:(0=[+/@E.&":^)^:_~]

Probieren Sie es online!

ANMERKUNG: Ich habe das Finale ]in x:in der TIO geändert , um die Tests für größere ganze Zahlen zu bestehen.

Oracle SQL, 68 Byte

select max(level)+1 from dual,t connect by instr(power(x,level),x)=0

Es wird angenommen, dass die Quellennummer in einer Tabelle gespeichert ist t(x), z

with t as (select 95 x from dual)

Testen Sie in SQL * Plus

SQL> with t as (select 95 x from dual)
  2  select max(level)+1 from dual,t connect by instr(power(x,level),x)=0
  3  /

MAX(LEVEL)+1
------------
          13