Sfida:

Crea un programma che accetta un numero intero positivo e controlla se può essere scritto sotto forma di (3 ^ x) -1, dove X è un altro numero intero positivo .

Se possibile, invia X

In caso contrario, emettere -1 o un'istruzione falsy .

Esempi di ingressi / uscite

Ingresso:

2

Può essere scritto come (3 ^ 1) - 1, quindi produciamo x che è 1

Produzione:

1

Ingresso:

26

26 può essere scritto come (3 ^ 3) - 1, quindi produciamo x (3)

Produzione:

3

Ingresso:

1024

1024 non può essere scritto nella forma di (3 ^ x) - 1, quindi produciamo -1

Produzione:

-1

Questo è code-golf, quindi vince il minor numero di byte

OEIS correlato: A024023

Mathematica, 21 16 byte

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

Utilizza il calcolo simbolico di Mathematica. Se #+1è una potenza di tre Log[3,#+1], calcolerà un risultato intero che è un valore atomico. Altrimenti otterremo così Log[#+1]/Log[3]com'è. Poiché questo non è un valore atomico, è un'espressione che è sempre della forma head[val1,val2,...]. In questo caso è in realtà qualcosa di simile Times[Power[Log[3], -1], Log[#+1]].

Distinguiamo tra i due casi applicando un'altra funzione al risultato. Quello che fa davvero l'applicazione è che sostituisce la headparte di un'espressione. Poiché i risultati di numeri interi sono atomici, l'applicazione di qualsiasi funzione non fa nulla. In particolare f @@ atom == atom.

Tuttavia, nell'altro caso, la testa viene sostituita. La funzione che stiamo utilizzando è quella -1&che è una semplice funzione che ignora i suoi argomenti e restituisce -1. Quindi otteniamo qualcosa -1&[Power[Log[3], -1], Log[#+1]]in casi non interi, che valuta direttamente -1. Involucro speciale tramite magia.

Python, 46 44 byte

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

Provalo online!

In questo caso, 0sarebbe il valore falso. Grazie a @ mbomb007 per aver segnalato l'output errato e un []risparmio di 2 byte .

Haskell, 35 byte

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

Esempio di utilizzo: f 26-> 3.

05AB1E , 7 byte

3IÝm<¹k

Provalo online!

Spiegazione

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

Gelatina , 5 byte

R3*’i

Emette x o 0 (falsy).

Provalo online!

Come funziona

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 byte

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

Una funzione ricorsiva che ritorna 0per input non corrispondenti. Ripetutamente il pavimento divide l'input per 3, contando il numero di passaggi i, che viene emesso alla fine. Tuttavia, se un passaggio produce un valore ndiverso da 2 modulo 0, il numero non era per 3^i-1, quindi l'output viene moltiplicato per 0.

Perl, 31 byte

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

Richiede -Eflag per funzionare:

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

Spiegazioni:
grep{3**$_-1==$i}0..($i=<>)restituisce un elenco degli elementi dell'intervallo 0..$_(ovvero da 0 all'ingresso) che soddisfano il test 3**$_-1==$i. Solo un elemento al massimo può soddisfare questo test, quindi questa istruzione restituirà un array di 0 o 1 elemento. Quindi stampiamo questo elenco: o il Xniente (che è falso).

Pyth, 11 byte

?-JjQ3 2ZlJ

Converte in base 3 e verifica l'uguaglianza in [2, 2, ..., 2].

JavaScript (ES7), 38 36 34 byte

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

O solo 30 29 byte se va bene uscire con un errore in caso di errore:

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

Test

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 byte

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

Questo lambda si inserisce in un Function<Integer, Integer>riferimento e utilizza il semplice trucco base 3.

Questa volta dovrebbe funzionare correttamente.

Elaborazione, 60 56 byte

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

Output -1se falsi.

Spiegazione

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
}

voidè 1 byte più corto dell'uso float, quindi questa funzione emette direttamente invece di restituire un valore.

Soluzione alternativa

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

per 63 byte, ma penso che questo alt possa essere golfato per essere più corto della soluzione originale. Ci sto lavorando.

Brachylog , 8 byte

,3:.^-?,

Provalo online!

Emette il valore se vero e false.se questo è impossibile.

Spiegazione

Questa è una trascrizione diretta della relazione data:

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

Perl 6 ,  25  24 byte

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

Provalo

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

Rimuovere lo spazio dopo il **lavoro perché è più lungo dell'altro operatore infisso che potrebbe corrispondere *.
Quindi …***…viene analizzato come … ** * …piuttosto che … * ** ….

Provalo

Allargato:

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

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

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

}

R, 24 byte

Un approccio diverso dalla risposta di plannapus e un byte più breve!

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

Genera tutti i numeri interi da 3^1-1a 3^99-1e verifica se lo stdin corrisponde. In tal caso, restituisce l'indice a cui corrisponde, ovvero x. In caso contrario, restituisce NAun valore errato.

Per inciso, accetterà più valori come input e li testerà tutti, il che è una caratteristica accurata.

Prolog, 20 byte

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

Questa lingua è fantastica da morire.

| ?- d(1024,X).

no
| ?- d(26,X).

X = 3

yes
| ?- d(2,X).

X = 1

yes

05AB1E , 9 byte

DÝ3sm<Q1k

Provalo online!

Stampa -1 per falsa.

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 byte

3i:^qG=f

Questo genera il numero xse esiste, o altrimenti non produce nulla, il che è falso.

Provalo online!

Spiegazione

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 byte

o æ@U+1¥3pX

Provalo qui .

Grazie mille a ETHproductions per l'aiuto!

Python 3, 74 66 64 byte

_{-10 byte grazie a @ mbomb007, @FlipTack e @ nmjcman101}

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

Rubino, 30 byte

Restituisce nil(un valore errato) se non viene trovato alcun numero. [Provalo online]

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

C, 56 byte

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

aggiungi uno all'input e poi dividi ripetutamente per tre fino a quando non viene trovato un resto, se quello viene raggiunto restituisci il conteggio delle divisioni -1

Utilità Bash / Unix, 37 35 byte

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

Provalo online!

Usa dc per convertire in base 3, controlla che la stringa risultante sia tutta 2s, conta il numero di caratteri (inclusa una nuova riga), quindi usa bc per sottrarre 1.

Se il numero nella base 3 non è tutto 2s, grep non produce nulla (nemmeno una nuova riga), quindi il conteggio dei caratteri è 0 e sottraendo 1 si ottiene -1.

C compilato con Clang 3.8.1, 53 , 52 , 54 , 51 byte

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

@SteadyBox ha già pubblicato una soluzione in C, ma sto usando un approccio diverso.

@Grazie a Jasen per l'aiuto nel salvataggio dei byte.

C, 42 byte, ottimizzato da Wade Tyler's

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

Provare

C, 37 byte, senza return

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

Provare

nè globale ma (I)MULpuò solo avere il suo operando dest in un registro, quindi bisogna inserirlo EAX(la solita scelta) e spostarlo lì

JavaScript 6, 32 byte

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

Se il "falso" deve essere lo stesso, 33 byte:

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

Pyt , 10 9 byte

←⁺3ĽĐĐƖ=*

Spiegazione:

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

Salvato un byte utilizzando la funzione di incremento invece di aggiungere esplicitamente 1

Python, 64 byte

Emette Falsese il numero non può essere scritto in quel formato.

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

Funziona anche con 64 byte e stampa una stringa vuota come output errato:

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

Una soluzione creativa per 65 byte, 0risultando falsa:

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

Pyth, 10 byte

*J@hQ3!%J1

Provalo qui!

Julia, 30 byte

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

È una funzione semplice: crea un vettore che ha un truesolo nella posizione corrispondente in 3^a-1, dove aè un vettore contenente numeri interi compresi tra 0 e n. Trova la "prima" posizione che è truee sottrae 1 (se è tutto false, la ricerca restituisce zero e restituisce -1).

Come 0:nha 0in primo luogo, i sottrarre 1 corregge per l'indicizzazione e consente inoltre di -1risposta falsa.

Pyke, 9 6 byte

3m^Qh@

Provalo qui!

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

Vecchia versione a 9 byte:

b3'l}\2q*

Provalo qui!

Pyth 8 byte

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

Prova qui