Herausforderung:

Erstellen Sie ein Programm, das eine positive Ganzzahl akzeptiert und prüft, ob es in Form von (3 ^ x) -1 geschrieben werden kann, wobei X eine andere positive Ganzzahl ist .

Wenn dies möglich ist, geben Sie X aus

Wenn dies nicht möglich ist, geben Sie -1 oder eine falsche Anweisung aus.

Beispiel Ein- / Ausgänge

Eingang:

2

Es kann geschrieben werden als (3 ^ 1) - 1, also geben wir x aus, was 1 ist

Ausgabe:

1

Eingang:

26

26 kann geschrieben werden als (3 ^ 3) - 1, also geben wir x (3) aus

Ausgabe:

3

Eingang:

1024

1024 kann nicht in Form von (3 ^ x) - 1 geschrieben werden, daher geben wir -1 aus

Ausgabe:

-1

Dies ist Code-Golf, also gewinnt die geringste Anzahl von Bytes

Verwandte OEIS: A024023

Mathematica, 21 16 Bytes

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

Verwendet die symbolische Berechnung von Mathematica. Wenn #+1eine Log[3,#+1]Dreierpotenz ist, wird ein ganzzahliges Ergebnis berechnet, das ein atomarer Wert ist. Ansonsten werden wir bekommen, Log[#+1]/Log[3]wie es ist. Da dies kein atomarer Wert ist, ist es ein Ausdruck, der immer von der Form ist head[val1,val2,...]. In diesem Fall ist es tatsächlich so etwas wie Times[Power[Log[3], -1], Log[#+1]].

Wir unterscheiden die beiden Fälle, indem wir eine andere Funktion auf das Ergebnis anwenden. Was das Anwenden wirklich bewirkt, ist, dass es den headTeil eines Ausdrucks ersetzt. Da ganzzahlige Ergebnisse atomar sind, hat das Anwenden einer Funktion auf sie überhaupt nichts zu tun. Insbesondere f @@ atom == atom.

Im anderen Fall wird der Kopf jedoch ersetzt. Die Funktion, die wir verwenden -1&, ist eine einfache Funktion, die ihre Argumente ignoriert und zurückgibt -1. So bekommen wir -1&[Power[Log[3], -1], Log[#+1]]in nicht ganzzahligen Fällen etwas, was direkt ausgewertet wird -1. Spezialgehäuse durch Magie.

Python, 46 44 Bytes

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

Probieren Sie es online!

In diesem Fall 0wäre der Wert falsch. Vielen Dank an @ mbomb007 für den Hinweis auf meine fehlerhafte Ausgabe sowie 2 Byte keine []Einsparungen.

Haskell, 35 Bytes

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

Anwendungsbeispiel: f 26-> 3.

05AB1E , 7 Bytes

3IÝm<¹k

Probieren Sie es online!

Erläuterung

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

Gelee , 5 Bytes

R3*’i

Gibt x oder 0 (falsch) aus.

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Eine rekursive Funktion, die 0bei nicht übereinstimmenden Eingaben zurückgegeben wird. Dividiert die Eingabe wiederholt durch 3, wobei die Anzahl der Schritte gezählt wird i, die am Ende ausgegeben werden. Wenn jedoch ein Schritt einen Wert nergibt, der nicht 2 modulo 0 ist, war die Zahl nicht für 3^i-1, sodass die Ausgabe mit 0 multipliziert wird.

Perl, 31 Bytes

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

Benötigt -EFlag zum Ausführen:

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

Erläuterungen:
grep{3**$_-1==$i}0..($i=<>)Gibt eine Liste der Elemente des Bereichs 0..$_(dh von 0 bis zur Eingabe) zurück, die den Test erfüllen 3**$_-1==$i. Nur maximal ein Element kann diesen Test bestehen, daher gibt dieser Befehl ein Array mit 0 oder 1 Element zurück. Wir drucken dann diese Liste: entweder das Xoder nichts (was falsch ist).

Pyth, 11 Bytes

?-JjQ3 2ZlJ

Konvertiert zu Basis 3 und überprüft die Gleichheit zu [2, 2, ..., 2].

JavaScript (ES7), 38 36 34 Bytes

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

Oder nur 30 bis 29 Bytes, wenn das Beenden bei einem Fehler in Ordnung ist:

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

Prüfung

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 Bytes

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

Dieses Lambda passt in eine Function<Integer, Integer>Referenz und verwendet den einfachen Trick zur Basis 3.

Diesmal sollte es richtig funktionieren.

Verarbeitung, 60 56 Bytes

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

Ausgänge -1wenn falsy.

Erläuterung

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
}

voidist 1 Byte kürzer als die Verwendung float, daher gibt diese Funktion direkt aus, anstatt einen Wert zurückzugeben.

Alternative Lösung

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

Für 63 Bytes, aber ich denke, diese Alternative kann kürzer als die ursprüngliche Lösung sein. Ich arbeite dran.

Brachylog , 8 Bytes

,3:.^-?,

Probieren Sie es online!

Gibt den Wert aus, wenn dies wahr und false.unmöglich ist.

Erläuterung

Dies ist eine direkte Transkription der angegebenen Beziehung:

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

Perl 6 ,  25  24 Bytes

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

Versuch es

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

Entfernen des Leerzeichens nach der **Arbeit, da es länger ist als der andere übereinstimmende Infix-Operator *.
Also …***…wird da … ** * …eher geparst als … * ** ….

Versuch es

Erweitert:

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

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

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

}

R, 24 Bytes

Ein anderer Ansatz als die Antwort von Plannapus und ein Byte kürzer!

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

Erzeugt alle Ganzzahlen von 3^1-1bis 3^99-1und prüft, ob stdin übereinstimmt. In diesem Fall wird der Index zurückgegeben, zu dem die Übereinstimmung besteht x. Wenn nicht, wird NAals falscher Wert zurückgegeben.

Übrigens werden mehrere Werte als Eingabe akzeptiert und alle getestet, was eine nette Funktion ist.

Prolog, 20 Bytes

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

Diese Sprache ist verdammt cool.

| ?- d(1024,X).

no
| ?- d(26,X).

X = 3

yes
| ?- d(2,X).

X = 1

yes

05AB1E , 9 Bytes

DÝ3sm<Q1k

Probieren Sie es online!

Gibt -1 für falsch aus.

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 Bytes

3i:^qG=f

Dies gibt die Nummer aus, xwenn sie existiert, oder gibt sonst nichts aus, was falsch ist.

Probieren Sie es online!

Erläuterung

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 Bytes

o æ@U+1¥3pX

Probieren Sie es hier aus .

Ein grosses Dankeschön an ETHproductions für die Hilfe!

Python 3, 74 66 64 Bytes

_{-10 Bytes dank @ mbomb007, @FlipTack und @ nmjcman101}

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

Ruby, 30 Bytes

Gibt nil(einen falschen Wert) zurück, wenn keine Nummer gefunden wurde. [Online ausprobieren]

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

C 56 Bytes

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

addiere eins zur Eingabe und dividiere dann wiederholt durch drei, bis ein Rest gefunden wird. Wenn eins erreicht ist, gib die Anzahl der Teilungen zurück, sonst -1

Bash / Unix-Dienstprogramme, 37-35 Byte

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

Probieren Sie es online!

Konvertiert mit dc zur Basis 3, überprüft, ob die resultierende Zeichenfolge alle 2 ist, zählt die Anzahl der Zeichen (einschließlich einer neuen Zeile) und subtrahiert dann mit bc 1.

Wenn die Zahl in der Basis 3 nicht alle 2s ist, gibt grep nichts aus (nicht einmal eine neue Zeile), sodass die Zeichenanzahl 0 ist und das Subtrahieren von 1 -1 ergibt.

C kompiliert mit Clang 3.8.1, 53 , 52 , 54 , 51 Bytes

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

@SteadyBox hat bereits eine Lösung in C gepostet, aber ich benutze einen anderen Ansatz.

@Danke an Jasen für die Unterstützung beim Speichern von Bytes.

C, 42 Bytes, optimiert von Wade Tyler

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

Versuchen

C, 37 Bytes, ohne return

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

Versuchen

nist global, (I)MULkann aber nur seinen dest-Operanden in einem Register haben, muss also in EAX(die übliche Wahl) gestellt und dort verschoben werden

JavaScript 6, 32 Bytes

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

Wenn das "falsch" gleich sein muss, 33 Bytes:

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

Pyt , 10 9 Bytes

←⁺3ĽĐĐƖ=*

Erläuterung:

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

Mit der Inkrementierungsfunktion ein Byte gespeichert, anstatt explizit 1 hinzuzufügen

Python, 64 Bytes

Gibt aus, Falseob die Nummer nicht in diesem Format geschrieben werden kann.

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

Dies funktioniert auch in 64 Bytes und gibt einen leeren String als falsche Ausgabe aus:

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

Eine kreative Lösung für 65 Bytes, die 0fälschlicherweise ausgibt:

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

Pyth, 10 Bytes

*J@hQ3!%J1

Probieren Sie es hier aus!

Julia, 30 Bytes

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

Es ist eine einfache Funktion - sie erzeugt einen Vektor, der truenur an der entsprechenden Position in a steht 3^a-1, wobei aein Vektor Ganzzahlen zwischen 0 und enthält n. Es findet die "erste" Position, die 1 ist, trueund subtrahiert sie (wenn alles ist false, wird der Wert 0 angenommen, und es wird -1 zurückgegeben).

Wie 0:nhat 0im ersten Spot, ermöglicht die subtrahieren 1 korrigiert für die Indizierung und die -1falsche Antwort.

Pyke, 9 6 Bytes

3m^Qh@

Probieren Sie es hier aus!

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

Alte 9-Byte-Version:

b3'l}\2q*

Probieren Sie es hier aus!

Pyth 8 Bytes

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

Versuch es hier