Ce numéro peut-il être écrit au format (3 ^ x) - 1?

41

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 donc moins d’octets gagnés


OEIS associé : A024023

P. Ktinos
la source
4
Je demande à la sortie X parce que je crois que c'est plus difficile de cette façon. Il serait trop facile, à mon avis, de trouver simplement le format 3 ^ x - 1.
P. Ktinos
2
À moins que ce ne soit une déclaration de fausseté dans votre langage de programmation, non.
P. Ktinos
2
Puis-je vouloir que le numéro soit entré en ternaire?
John Dvorak
2
avoir à gérer des entiers non négatifs rendrait 0 3^0-1 une sortie valide et donc non utilisable comme fausse,
Jasen
2
quiconque songe à utiliser log()dans sa réponse devrait confirmer qu'il donne la bonne réponse 5quand il le saisit 242 .
Jasen

Réponses:

23

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.

Martin Ender
la source
13

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 .

nmjcman101
la source
vous pouvez réécrire comme [n for n in range(x)if 3**n-1==x]pour -4 octets, liste vide sous falsy
Rod
Fixe, merci! @Rod alors il reviendrait [n] au lieu de n je pense
nmjcman101
@ nmjcman101 cela ne devrait pas être un problème
Rod
@Rod Je préférerais adhérer strictement aux spécifications pour l'instant
nmjcman101
@Rod Si la sortie d'un entier est requise, vous ne pouvez pas le sortir dans une liste à moins que l'OP ne le permette spécifiquement.
mbomb007
13

Haskell, 35 octets

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

Exemple d'utilisation: f 26-> 3.

nimi
la source
PS: Essayez-le en ligne! soutient Haskell! (Belle réponse d'ailleurs!)
mardi
11

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
Emigna
la source
05AB1E est apparemment bon en conversion de base. Est-ce vraiment la meilleure approche?
Jasen
1
@Jasen: Mes tentatives de conversion de base se sont toutes avérées plus longues. S'il existe un meilleur moyen que celui-ci, je ne le vois pas. N'hésitez pas à me prouver le
contraire
assez juste, je n'ai lu que la description de la langue, et je m'attendais donc à une solution de 5 octets ....
Jasen
1
@Jasen <3zm©.ïi®est le plus proche que je n'ai pas utilisé des gammes comme il l'a fait.
Urne Magique Octopus
1
3DÝms<k... Peu importe ... Je ne peux pas supprimer un octet de plus, je pourrais jurer.
Urne magique Octopus
9

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).
Dennis
la source
6

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.

Xnor
la source
6

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

Dada
la source
5

Pyth, 11 octets

?-JjQ3 2ZlJ

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

orlp
la source
Vous pouvez réduire cela d'un octet avec ?-2JjQ3ZlJ, puisque <col> <num>et <num> <col>sont interchangeables -en Pyth.
Notjagan
5

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

Arnauld
la source
5

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.


la source
3
Cela n’imprimerait-il que Vrai ou Faux quand il pourra être écrit dans le format? Mais j'ai demandé l'exposant quand le résultat est True
P. Ktinos
2
C'est du génie! +1 pour une approche très intelligente
DJMcMayhem
C’est intelligent ... Je pense que vous pouvez supprimer les parens et les faire simplement i->. De plus, si vous prenez en itant que Long, vous pouvez alors utiliser a.toString(...)(les ides donneront des avertissements sur l’utilisation incorrecte des fonctions statiques, mais ils devraient être compilés). Cependant, comme OP l’a dit, vous devez renvoyer la valeur, pas seulement Vrai ou Faux.
FlipTack
Si le lambda est stocké dans un type de fonction différent, l'astuce statique fonctionne. J'ai aussi fixé la valeur de retour. J'ai dû manquer cette partie.
5

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.

Kritixi Lithos
la source
@ FlipTack Oui, je savais que ce ne serait pas en Java. Je viens de demander car je n'étais pas sûr que Processing n'avait pas ajouté quelque chose dans ce sens. La "valeur distincte" à utiliser était cependant -1, pas 0. Elle a été modifiée depuis, cependant, je vais probablement nettoyer mes commentaires à ce sujet.
Geobits
Attends, puis-je revenir 0maintenant?
Kritixi Lithos
Je dirais toujours non. La question donne une valeur entière alternative à utiliser si faux, mais 0n'est jamais faux en Java / Traitement que je connaisse.
Geobits
Je pensais que le traitement était supposé être moins volumineux que Java
Pavel
@Pavel Mais je n'utilise pas de lambdas: /
Kritixi Lithos
4

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
Fataliser
la source
Vous pouvez presque jouer au golf jusqu’à 7 octets +~^r~:3, mais ~:ne fait malheureusement pas ce à quoi vous pouvez vous attendre (probablement parce que :c’est la syntaxe plutôt qu’une commande intégrée), et semble être traité de manière identique :.
@ ais523 C'est exact, :c'est un symbole de contrôle qui ~ne fonctionne que sur les prédicats.
Fataliser
3

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

}
Brad Gilbert b2gills
la source
3

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.

tourbull
la source
3

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
Nom McChange
la source
2

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
Riley
la source
2

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
Luis Mendo
la source
2

Japt , 11 octets

o æ@U+1¥3pX

Essayez ici .

Un grand merci à ETHproductions pour son aide!

Oliver
la source
2

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)
Dfernan
la source
Vous pouvez mettre tout votre code sur une seule ligne et l'utiliser from math import*. Aussi return n==3**x-1and x.
mbomb007
@ mbomb007 Les fonctions sont autorisées à imprimer le résultat STDOUT, vous pouvez donc changer ce retour en impression.
FlipTack
Si vous présentez cela comme une solution SageMath plutôt que comme une solution Python, vous pouvez supprimer la première ligne.
Federico Poloni
Avec l'autre réduction à 65 octets, vous pouvez utiliser import mathet math.ceilpour un seul octet. Aussi, vous pouvez vous tourner 3**x-1==n and xversx*(3**x-1==n)
nmjcman101
2

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}}
Valeur d'encre
la source
2

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

Jasen
la source
Enregistrer un octet avec a%3<1au lieu de !(a%3). Un de plus avec 0pour falsy.
Titus
En supposant que vous utilisez GCC pour la compilation, vous pouvez enregistrer un total de 10 (11) octets: vous n'avez pas besoin d'initialiser n à zéro si vous savez que vous n'appellerez cette fonction qu'une seule fois, car n sera nul par défaut ( parce que c'est global) - c'est 4 octets de moins; De plus, vous n'avez pas besoin de l'instruction return. En écrivant, a=--a?-1:n;vous économiserez 5 octets. Si une fonction non vide n'a pas de retour, il utilisera simplement la dernière affectation. Aussi ce que @ Titus a dit.
Etaoin Shrdlu
1
Suggérez au a%3?0:(a/=3)lieu de!(a%3)&&(a/=3)
ceilingcat
2

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.

Mitchell Spector
la source
2

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.

Wade Tyler
la source
1
oui, mais ça marche? comparer les flottants pour l'égalité est souvent la recette d'un échec inattendu (essayez des entrées de grande taille)
Jasen
@ Jasen Hmm, je n'ai pas essayé ça, mais en C, ça logrevient doubledonc peut-être que ça va marcher.
Wade Tyler
double est un type de valeur en virgule flottante pour que le problème persiste.
Jasen
semble fonctionner correctement pour 3 ^ 19, ce qui est probablement assez grand.
Jasen
@Jasen Cela ne fonctionne pas pour 3 ^ 10
Wade Tyler
2

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
l4m2
la source
2

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

mudkip201
la source
dans quelle page de code est-ce que 9 octets? (en UTF-8, c'est 17 octets)
Jasen
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
mbomb007
la source
Ne pas sortir xni -1.
dfernan
Le programme devrait sortir xau lieu de ndans le cas d'une correspondance.
dfernan
Non, il devrait générer le nombre entier positif qui, une fois remplacé par X, vous obtiendrez l’entrée. La question se réfère à X en tant que variable et non en tant que chaîne
P. Ktinos
@ P.Ktinos l'a corrigé.
mbomb007
1

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.

Glen O
la source
1

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

Barre
la source