Défi:

Créez un programme qui accepte un entier positif et vérifie s'il peut être écrit sous la forme de (3 ^ x) -1, X étant un autre entier positif .

Si possible, sortie X

Si ce n'est pas le cas, indiquez -1 ou une instruction falsy .

Exemple d'entrées / sorties

Contribution:

2

Il peut être écrit (3 ^ 1) - 1, donc nous produisons x qui est 1

Sortie:

1

Contribution:

26

26 peut être écrit comme (3 ^ 3) - 1, donc nous produisons x (3)

Sortie:

3

Contribution:

1024

1024 ne peut pas être écrit sous la forme de (3 ^ x) - 1, donc nous produisons -1

Sortie:

-1

C’est du code-golf donc moins d’octets gagnés

OEIS associé : A024023

Mathematica, 21 16 octets

-1&@@Log[3,#+1]&

Utilise le calcul symbolique de Mathematica. Si #+1est une puissance de trois alors Log[3,#+1]calculera un résultat entier qui est une valeur atomique. Sinon, nous obtiendrons Log[#+1]/Log[3]tel quel. Puisque ce n'est pas une valeur atomique, c'est une expression qui est toujours de la forme head[val1,val2,...]. Dans ce cas, c'est en fait quelque chose comme Times[Power[Log[3], -1], Log[#+1]].

Nous distinguons les deux cas en appliquant une autre fonction au résultat. En réalité, l’application remplace la headpartie d’une expression. Puisque les résultats entiers sont atomiques, leur appliquer n'importe quelle fonction ne fait rien du tout. En particulier f @@ atom == atom.

Cependant, dans l’autre cas, la tête est remplacée. La fonction que nous utilisons est -1&une fonction simple qui ignore ses arguments et retourne -1. Nous obtenons donc quelque chose -1&[Power[Log[3], -1], Log[#+1]]dans les cas non entiers, ce qui évalue directement à -1. Boîtier spécial par magie.

Python, 46 44 octets

lambda x:max(n*(3**n-1==x)for n in range(x))

Essayez-le en ligne!

Dans ce cas, 0serait la valeur de la fausseté. Merci à @ mbomb007 pour avoir signalé ma sortie incorrecte ainsi qu’à une []économie de 2 octets .

Haskell, 35 octets

f x=last(-1:[i|i<-[1..x],3^i-1==x])

Exemple d'utilisation: f 26-> 3.

05AB1E , 7 octets

3IÝm<¹k

Essayez-le en ligne!

Explication

3        # push 3 
 I       # push input
  Ý      # range [0 ... input]
   m     # 3^[0 ... input]
    <    # -1
     ¹k  # find index of input, return -1 if not found

Gelée , 5 octets

R3*’i

Sorties x ou 0 (fausseté).

Essayez-le en ligne!

Comment ça marche

R3*’i  Main link. Argument: n

R      Range; yield [1, ..., n].
 3*    Map each k to 3**k.
   ’   Decrement the results.
    i  First index of n (0 if not found).

Python 2, 41 octets

f=lambda n,i=0:i*0**n or n%3/2*f(n/3,i+1)

Une fonction récursive qui renvoie 0les entrées non correspondantes. De manière répétée, le plancher divise l’entrée par 3, en comptant le nombre de pas i, qui est finalement sortie. Mais si une étape produit une valeur nqui n'est pas 2 modulo 0, le nombre n'était pas de for 3^i-1, la sortie est donc multipliée par 0.

Perl, 31 octets

say grep{3**$_-1==$i}0..($i=<>)

Nécessite le -Edrapeau pour fonctionner:

perl -E 'say grep{3**$_-1==$i}0..($i=<>)' <<< 26

Explications:
grep{3**$_-1==$i}0..($i=<>)renvoie une liste des éléments de la plage 0..$_(c'est-à-dire de 0 à l'entrée) satisfaisant le test 3**$_-1==$i. Un seul élément au plus peut satisfaire à ce test. Cette instruction renvoie donc un tableau de 0 ou 1 élément. Nous imprimons ensuite cette liste: soit le Xsoit rien (ce qui est faux).

Pyth, 11 octets

?-JjQ3 2ZlJ

Convertit en base 3 et vérifie l’égalité en [2, 2, ..., 2].

JavaScript (ES7), 38 36 34 octets

f=(n,k=33)=>3**k-n-1&&--k?f(n,k):k

Ou juste 30 29 octets s'il est possible de quitter avec une erreur en cas d'échec:

f=(n,k)=>~(n-3**k)?f(n,-~k):k

Tester

f=(n,k=33)=>3**k-n-1&&--k?f(n,k):k

console.log(f(177146))
console.log(f(847288609442))
console.log(f(5559060566555522))
console.log(f(123456))

Java 8, 37 58 67 octets

i->{String s=i.toString(i,3);return s.matches("2*")?s.length():-1;}

Ce lambda correspond à une Function<Integer, Integer>référence et utilise le tour simple base 3.

Cette fois, cela devrait fonctionner correctement.

Traitement, 60 56 octets

void q(float n){n=log(n+1)/log(3);print(n>(int)n?-1:n);}

Sorties -1si fausseté.

Explication

void q(float n){              // n is input
  n=log(n+1)/log(3);          // finds X in 3^X+1=n as a float (here we'll storing that in n)
  print(n>(int)n?-1:n);       // checks if the float is greater than
                              // the number rounded down (by int casting)
                              // if it is greater, output -1
                              // otherwise output X
}

voidest plus court que 1 octet float, c'est pourquoi cette fonction affiche directement au lieu de renvoyer une valeur.

Solution alternative

void z(float n){int c=0;for(++n;n>1;c++)n/=3;print(n==1?c:-1);}

pour 63 octets, mais je pense que cette variante peut être plus courte que la solution originale. J'y travaille.

Brachylog , 8 octets

,3:.^-?,

Essayez-le en ligne!

Affiche la valeur si vrai et false.si cela est impossible.

Explication

Ceci est une transcription directe de la relation donnée:

,     ,      (Disable implicit unification)
 3:.^        3^Output…
     -?              … - 1 = Input

Perl 6 ,  25  24 octets

{first $_==3** *-1,0..$_}

L'essayer

{first $_==3***-1,0..$_}

La suppression de l'espace après **fonctionne car il est plus long que l'autre opérateur infixe qui pourrait correspondre *.
Ainsi …***…est analysé comme … ** * …plutôt que … * ** ….

L'essayer

Étendu:

{  # bare block lambda with implicit parameter ｢$_｣

  first
    $_ == 3 ** * - 1,   # WhateverCode lambda
    #          ^- current value

    0 .. $_             # a Range up-to (and including) the input

}

R, 24 octets

Une approche différente de celle de plannapus , et un octet plus court!

match(scan(),3^(1:99)-1)

Tous les entiers de Génère 3^1-1à 3^99-1, et vérifie si les matchs de stdin. Si tel est le cas, il renvoie l'index auquel il correspond, qui est x. Sinon, retourne NAcomme valeur de fausseté.

Incidemment, il acceptera plusieurs valeurs en entrée et les testera toutes, ce qui est une fonctionnalité intéressante.

Prolog, 20 octets

d(A,X):-A#=(3**X)-1.

Cette langue est cool comme l'enfer.

| ?- d(1024,X).

no
| ?- d(26,X).

X = 3

yes
| ?- d(2,X).

X = 1

yes

05AB1E , 9 octets

DÝ3sm<Q1k

Essayez-le en ligne!

Imprime -1 pour la fausseté.

D         # Duplicate the input
 Ý3sm     # Push [0 .. input]^3 (e.g. [0^3, 1^3, 2^3, 4^3 ...])
     <    # subtract 1
      Q   # push a 1 everywhere that equals the input, and 0 everywhere else
       1k # push the index of the 1, or -1 if not found
          # implicit output

MATL , 8 octets

3i:^qG=f

Cela renvoie le nombre xs’il existe, ou ne renvoie rien sinon, ce qui est faux.

Essayez-le en ligne!

Explication

3    % Push 3
i    % Input n
:    % Range: gives `[1 2 ... n]
^    % Power, element-wise. Gives [3^1 3^2 ... 3^n]
q    % Subtract 1, element-wise. Gives [3^1-1 3^2-1 ... 3^n-1]
=    % Test for equality. Contains 'true' at the position x, if any,
     % where 3^x-1 equals n
f    % Find. Gives index of the 'true' position, which ix x; or gives
     % an empty array if no such position exists. Implicitly display

Japt , 11 octets

o æ@U+1¥3pX

Essayez ici .

Un grand merci à ETHproductions pour son aide!

Python 3, 74 66 64 octets

_{-10 octets grâce à @ mbomb007, @FlipTack et @ nmjcman101}

from math import*
def f(n):x=ceil(log(n,3));print((3**x-1==n)*x)

Ruby, 30 octets

Renvoie nil(une valeur de fausseté) si aucun nombre n'a été trouvé. [Essayez-le en ligne]

->n{(0..n).find{|i|3**i-1==n}}

C, 56 octets

 n;f(a){n=0;for(a++;!(a%3)&&(a/=3);++n);return --a?-1:n;}

ajoute un à l'entrée, puis divise plusieurs fois par trois jusqu'à trouver un reste

Utilitaires Bash / Unix, 37 à 35 octets

bc<<<`dc<<<3o$1p|grep ^2*$|wc -c`-1

Essayez-le en ligne!

Utilise dc pour convertir en base 3, vérifie que la chaîne résultante est composée de 2 caractères, compte le nombre de caractères (y compris une nouvelle ligne), puis utilise bc pour soustraire 1.

Si le nombre en base 3 n'est pas tous les 2s, alors grep ne génère rien (pas même une nouvelle ligne), le nombre de caractères est donc 0 et la soustraction 1 donne -1.

C compilé avec Clang 3.8.1, 53 , 52 , 54 , 51 octets

n;f(y){y++;for(n=0;y%3==0;y/=3)n++;return y^1?0:n;}

@SteadyBox a déjà posté une solution en C, mais j'utilise une approche différente.

@Merci à Jasen pour avoir aidé à économiser des octets.

C, 42 octets, optimisé par Wade Tyler

n;f(y){for(n=0;y%3>1;y/=3)n++;return!y*n;}

Essayer

C, 37 octets, sans return

n;f(y){for(n=0;y%3>1;y/=3)n++;n*=!y;}

Essayer

nest global mais (I)MULne peut avoir que son opérande dest dans un registre, il faut donc le mettre dans EAX(le choix habituel) et le déplacer

JavaScript 6, 32 octets

f=(y,n)=>y%3>1?f(y/3|0,-~n):!y*n
;[1,2,3,8,12,43046720].forEach(x=>console.log(f(x)))

Si le "faux" doit être identique, 33 octets:

f=(y,n)=>y%3>1?f(y/3|0,-~n):!y&&n

Pyt , 10 à 9 octets

←⁺3ĽĐĐƖ=*

Explication:

←                Get input
 ⁺               Add one
  3Ľ             Log base 3
    ĐĐ           Triplicate top of stack
      Ɩ          Convert top of stack to integer
       =         Check for equality between top two on stack
        *        Multiply by log_3(input+1)

Enregistré un octet en utilisant la fonction d'incrémentation au lieu d'ajouter explicitement 1

Python, 64 octets

Sorties Falsesi le nombre ne peut pas être écrit dans ce format.

def f(n):L=[3**x-1for x in range(n)];print n in L and L.index(n)

Cela fonctionne également en 64 octets et affiche une chaîne vide sous forme de sortie falsifiée:

def f(n):
 try:print[3**x-1for x in range(n)].index(n)
 except:0

Une solution créative pour 65 octets, sortie 0 pour falsy:

lambda n:-~",".join(`3**x-1`for x in range(n+1)).find(',%s,'%n)/2

Pyth, 10 octets

*J@hQ3!%J1

Essayez-le ici!

Julia, 30 octets

n->findfirst(n.==3.^(0:n)-1)-1

C'est une fonction simple - il crée un vecteur qui a un trueseul dans la position correspondante dans 3^a-1, où aest un vecteur contenant des entiers compris entre 0 et n. Il trouve la "première" position qui est trueet soustrait 1 (si c'est toutfalse , la recherche est évaluée à zéro et renvoie -1).

Comme 0:na 0en premier lieu, il faut soustraire 1 corrige les pour l' indexation et permet également la -1réponse fausse.

Pyke, 9 à 6 octets

3m^Qh@

Essayez-le ici!

3m^    -  map(3**i, range(input))
     @ - V in ^
   Qh  -  input + 1

Ancienne version à 9 octets:

b3'l}\2q*

Essayez-le ici!

Pyth 8 octets

xm^3dUQh

     UQ  # generate all values 1..Q (Q is the input)
 m^3d    # map 3^d over this ^ list
x      h # find the input+1 (hQ) in the result of the last command

Essayez ici