Pouvoirs autonomes

13

Étant donné un entier n, affichez le plus petit exposant esupérieur à 1 tel qu'il n^econtient ncomme sous-chaîne.

Par exemple, pour 25, la réponse doit être 2, as 25 ^ 2 = 625, qui contient 25comme sous-chaîne, mais la réponse pour 13doit être 10, as 13 ^ 10 = 137858491849, tout 10comme l'exposant le plus bas pour lequel le résultat contient 13comme sous-chaîne.

Règles

  • Règles d'E / S standard
  • Des échappatoires standard s'appliquent
  • Le code le plus court en octets gagne
  • n sera toujours un entier supérieur à 0

Cas de test

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)

Script Python pour générer les 1000 premières réponses

Skidsdev
la source
En relation
Skidsdev
A045537
Shaggy

Réponses:

4

R , 69 44 octets

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

Fonction anonyme. Fonctionne sur grand ilorsquen est converti en BigZ (voir TIO). Merci de m'avoir appris quelque chose Giuseppe et digEmAll!

Essayez-le en ligne!

BLT
la source
61 octets - vous avez eu un espace supplémentaire n, ?n^iet pasteconvertis à characterpar défaut :-)
Giuseppe
56 octets - le retour idevrait être suffisant.
Giuseppe
2
La pâte de 44 octets n'est pas nécessaire, grepl se convertit en caractère par défaut :)
digEmAll
Le problème est qu'il est "défectueux" lorsque les exposants deviennent grands en raison de la précision des virgules flottantes et du fait que les grands nombres sont convertis en chaîne en notation scientifique. Par exemple, 15 renvoie 17 alors qu'il devrait être 26. Donc, théoriquement, cela fonctionne, mais dans la pratique, nous devrions utiliser un package Big Integer ou quelque chose comme ça ...
digEmAll
1
@digEmAll pour BigInt vous pouvez simplement forcer l'entrée à être un bigInt comme BigZ de gmp et cela devrait toujours fonctionner, sauf éventuellement pour la conversion i en bigZ également
Giuseppe
3

Python 2 , 42 41 octets

-1 octet grâce à Ørjan Johansen (retoury direct)

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

Essayez-le en ligne!

Explication / Non golfé

Fonction récursive essayant de 2,3 jusqu'à ce que nous réussissions:

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

Essayez-le en ligne!

ბიმო
la source
1
Le retour y est plus court
Ørjan Johansen
@ ØrjanJohansen: Bizarre, je pensais avoir essayé ça, pas vraiment sûr de ce que j'avais raté. Merci beaucoup!
ბიმო
J'ai dû échanger la multiplication pour éviter un espace, c'était peut-être ça?
Ørjan Johansen
@ ØrjanJohansen: C'était probablement ça, oui.
ბიმო
3

JavaScript (ES6 / Node.js),  41  40 octets

1 octet enregistré grâce à @Shaggy

Prend l'entrée comme un nombre (fonctionne pour n<15 ) ou un littéral BigInt .

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

Essayez-le en ligne!

Arnauld
la source
1
Vous avez fini avec une solution très similaire à la vôtre pour 40 octets
Shaggy
@Shaggy Vous devez utiliser de grands entiers, sinon il ne retournera pas la bonne réponse dans certains cas de test. À la fin, il a le même bytecount n=>(g=x=>$ {x * = n}.match(n)?2n:-~g(x))(n)
Luis felipe De jesus Munoz
1
@LuisfelipeDejesusMunoz, en général, nous n'avons pas à nous soucier des problèmes de précision, mais cela fonctionnera également avec BigInts.
Shaggy
Chose mineure mais si cela utilise BigInt, le titre ne devrait-il pas être JavaScript (Node.js)? ES6 n'a pas encore BigInt.
Shieru Asakoto
@ShieruAsakoto Vous avez raison. Mon intention initiale était d'expliquer que cela fonctionne avec un nombre ou un BigInt. Maintenant clarifié.
Arnauld
3

APL (Dyalog Unicode) , 25 23 17 octets

-2 octets grâce à @Erik the Outgolfer

-6 octets grâce à @ngn

merci à @ H.PWiz pour avoir rendu le code ne nécessitant pas de personnalisation ⎕pp(précision d'impression)

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

Essayez-le en ligne!

⊢⍟×⍣(∨/(⍕÷)⍷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
Quintec
la source
Cela échoue pour 17 car il trouve 17dans 17 ^ 14 = 1.6837782655940093E17, mais idk à ce que les réponses de précision devraient prendre en charge
user41805
@Cowsquack Je dois juste ajuster arbitrairement ⎕PPje suppose
Quintec
Oh, attendez, ça ne marchera même pas
Quintec
23 octets .
Erik the Outgolfer
19 octets
ngn
2

Brachylog , 8 octets

;.^s?∧ℕ₂

Essayez-le en ligne!

Explication

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

05AB1E , 7 octets

∞>.Δm¹å

Essayez-le en ligne!

Explication:

∞>.Δ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
Cowabunghole
la source
2

SAS, 71 66 octets

Edit: supprimé ;run;à la fin, car il est impliqué par la fin des entrées.

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

Les données d'entrée sont entrées après l' cards;instruction, comme ceci:

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

Génère un ensemble de données acontenant l'entrée net la sortie e.

enter image description here

Josh Eller
la source
Cela semble être une définition de fonction, ou l'équivalent (je suppose en fait une "macro") Cela signifie que l'exiger d'être appelé avec des arguments (c'est-à-dire %p(n)) est tout à fait correct, mais la sortie dépend de si macros dans SAS peut retourner des valeurs. S'ils peuvent revenir, la "sortie" devrait être en renvoyant le résultat, sinon il devrait le sortir par n'importe quelle méthode de sortie standard prise en charge
Skidsdev
@Skidsdev Merci pour la rétroaction! SAS est un peu bizarre; les macros ne sont pas vraiment des fonctions, elles sont juste un langage de substitution de texte qui génère du «vrai» code SAS lors de sa compilation. J'ai regardé comment d'autres personnes ont fait des E / S pour SAS dans codegolf, et j'ai modifié ma réponse en fonction de cela, en me débarrassant des instructions de macro.
Josh Eller
1

Nettoyer , 99 octets

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

Essayez-le en ligne!

S'il n'a pas besoin de fonctionner pour des nombres énormes géants, alors

Nettoyer , 64 octets

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

Essayez-le en ligne!

Οurous
la source
1

Java (OpenJDK 8) , 84 octets

Prend l'entrée comme une chaîne représentant le nombre et génère un entier.

La plupart des octets proviennent de la verbosité de l' BigDecimalêtre nécessaire pour traiter les grands nombres.

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

Essayez-le en ligne!


Comment ça fonctionne

C'est assez simple mais je vais inclure l'explication de la postérité;

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
}
Luke Stevens
la source
0

Japt, 10 octets

@pX søU}a2

Essayez-le

Hirsute
la source
0

Fusain , 19 octets

W∨‹Lυ²¬№IΠυθ⊞υIθILυ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

W∨‹Lυ²¬№IΠυθ⊞

Répétez jusqu'à ce que la longueur de la liste soit d'au moins 2 et que son produit contienne l'entrée ...

⊞υIθ

... transtyper l'entrée en entier et la pousser dans la liste.

ILυ

Convertissez la longueur de la liste en chaîne et imprimez-la implicitement.

Neil
la source
0

Python 3 , 63 58 octets

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

Essayez-le en ligne!

Python2 serait probablement plus court, mais j'aime en utiliser 3. Il est difficile de monter avec un lambda, mais j'essaie quelques choses.

Gigaflop
la source
Je ne connais pas python mais n'est-ce pas plus court avec lambda?
Luis felipe De jesus Munoz
@LuisfelipeDejesusMunoz J'ai commencé par essayer de le faire, mais IDLE s'est plaint d'avoir un nu whiledans un lambda. Peut-être que je peux essayer d'autres façons ..
Gigaflop
Peut-être une fonction récursive?
Luis felipe De jesus Munoz
2
Définissant edans la liste d'arguments (ie. def f(n,e=2)) Et n**edevrait économiser quelques octets, Python 2 économiserait en effet pas mal d'octets.
ბიმო
@LuisfelipeDejesusMunoz Lambdas ne sont pas comme des fonctions. Le côté droit d'un lambda doit être une expression unique, et les commandes de contrôle de flux aiment forou whilene fonctionnent pas.
James
0

MathGolf , 10 octets

ôkï⌠#k╧▼ï⌠

Essayez-le en ligne!

Explication

Cela semble extrêmement inutile, d'avoir à lire explicitement l'entrée deux fois, d'avoir à incrémenter le compteur de boucle deux fois.

ô            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
maxb
la source
0

C # (.NET Core) , 104 89 octets

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

Essayez-le en ligne!

-1 octet: changé pour la boucle en while (grâce à Skidsdev )
-14 octets: abusé de la gestion des chaînes étranges de C # pour supprimer les ToString() appels

Besoin d'utiliser la bibliothèque BigInteger de C # , car les types C # numériques standard (int, double, long, ulong, etc.) échouent pour certains grands nombres (y compris 12, 15 et 17).

Non golfé:

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;
}
Suricate
la source
Vous pouvez enregistrer 1 octet en passant à une boucle while
Skidsdev
0

PowerShell (V3 +), 67 octets

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

J , 26 octets

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

Essayez-le en ligne!

NOTE: J'ai changé la finale ]de x:la TIO, pour effectuer les tests passent pour les entiers plus grands.

Jonas
la source
0

Oracle SQL, 68 octets

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

On suppose que le numéro source est stocké dans une table t(x), par exemple

with t as (select 95 x from dual)

Test dans 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
Dr Y Wit
la source