挑战：

创建一个接受正整数的程序，并检查它是否可以（3 ^ x）-1的形式编写，其中X是另一个正整数。

如果可以，输出X

如果不能，则输出-1或伪造的语句。

输入/输出示例

输入：

2

可以写成（3 ^ 1）-1，所以我们输出x就是1

输出：

1

输入：

26

26可以写成（3 ^ 3）-1，所以我们输出x（3）

输出：

3

输入：

1024

1024不能以​​（3 ^ x）-1的形式写入，因此我们输出-1

输出：

-1

这是代码高尔夫球，因此最少的字节数获胜

相关OEIS：A024023

Mathematica，21个16字节

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

利用Mathematica的符号计算。如果#+1是3的幂，Log[3,#+1]则将计算一个整数结果，该结果是一个原子值。否则我们会照Log[#+1]/Log[3]原样。由于这不是原子值，因此它始终是形式的表达式head[val1,val2,...]。在这种情况下，实际上就像Times[Power[Log[3], -1], Log[#+1]]。

我们通过对结果应用另一个函数来区分这两种情况。应用的真正作用是替换head表达式的一部分。由于整数结果是原子的，因此将任何函数应用于它们根本没有任何作用。特别是f @@ atom == atom。

但是，在其他情况下，磁头确实会被更换。我们正在使用的函数-1&是一个简单的函数，它将忽略其参数并返回-1。因此，-1&[Power[Log[3], -1], Log[#+1]]在非整数情况下，我们得到的结果直接为-1。通过魔术特殊的外壳。

Python，46 44字节

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

在线尝试！

在这种情况下，0将是虚假的值。感谢@ mbomb007指出我的错误输出以及2字节的未[]节省空间。

Haskell，35个字节

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

用法示例：f 26-> 3。

05AB1E，7个字节

3IÝm<¹k

在线尝试！

说明

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

果冻，5个字节

R3*’i

输出x或0（错误）。

在线尝试！

这个怎么运作

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个字节

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

0为不匹配的输入返回的递归函数。反复将输入除以3，然后计算的步数i，最后将输出。但是，如果任何步骤产生的值n不是2模0，则该数字不是for的3^i-1，因此输出乘以0。

Perl，31个字节

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

需要-E标志才能运行：

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

说明：
grep{3**$_-1==$i}0..($i=<>)返回0..$_满足测试范围的元素列表（即从0到输入）3**$_-1==$i。最多只有一个元素可以满足此测试，因此此指令将返回一个0或1个元素的数组。然后，我们打印此列表：X或不打印（虚假）。

Pyth，11个字节

?-JjQ3 2ZlJ

转换为基数3并检查等于[2, 2, ..., 2]。

JavaScript（ES7），38 36 34字节

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

或仅30个 29字节（如果可以退出并出现错误错误）：

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

测试

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字节

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

此lambda适合Function<Integer, Integer>参考，并使用简单的base 3技巧。

这次应该可以正常工作了。

处理中，60 56字节

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

-1如果错误，则输出。

说明

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个字节float，因此这就是为什么此函数直接输出而不是返回值的原因。

替代解决方案

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

63个字节，但我认为可以比原始解决方案更短。我在做这个工作。

Brachylog，8个字节

,3:.^-?,

在线尝试！

如果为true false.则输出该值，如果不可能则输出。

说明

这是给定关系的直接转录：

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

Perl 6的， 25  24个字节

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

试试吧

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

下班后删除空格，**因为它比其他匹配的infix运算符长*。
因此…***…被解析为… ** * …而不是… * ** …。

试试吧

展开：

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

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

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

}

R，24个字节

与Plannapus的答案不同，而且要短一个字节！

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

从生成所有整数3^1-1到3^99-1，如果标准输入匹配检查。如果是这样，它将返回匹配的索引，即x。如果不是，则返回NA假值。

顺便说一句，它将接受多个值作为输入，并测试所有这些值，这是一个很好的功能。

Prolog，20个字节

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

这种语言很酷。

| ?- d(1024,X).

no
| ?- d(26,X).

X = 3

yes
| ?- d(2,X).

X = 1

yes

05AB1E，9个字节

DÝ3sm<Q1k

在线尝试！

打印-1表示错误。

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字节

3i:^qG=f

x如果存在该数字，则输出该数字，否则不输出任何数字，这是虚假的。

在线尝试！

说明

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个字节

o æ@U+1¥3pX

在这里尝试。

非常感谢ETHproductions的帮助！

Python 3，74 66 64字节

_{-10个字节，感谢@ mbomb007，@ FlipTack和@ nmjcman101}

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

Ruby，30个字节

nil如果找不到数字，则返回（伪造的值）。[在线试用]

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

C，56个字节

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

将一个加到输入中，然后重复除以三，直到找到余数，如果达到一个则返回除数的计数，否则为-1

Bash / Unix实用程序，37 35字节

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

在线尝试！

使用dc转换为基数3，检查结果字符串是否全为2，计算字符数（包括换行符），然后使用bc减去1。

如果以3为底的数字不是全为2，则grep不输出任何内容（甚至不包含换行符），因此字符计数为0，减去1得出-1。

Ç编译铛3.8.1，53，52，54，51个字节

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

@SteadyBox已经在C语言中发布了一个解决方案，但是我使用了另一种方法。

@感谢Jasen帮助保存字节。

C，42字节，从Wade Tyler's优化

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

尝试

C，37字节，无 return

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

尝试

n是全局的，但(I)MUL只能将其dest操作数存储在寄存器中，因此必须放入EAX（通常的选择）并移至该位置

JavaScript 6，32字节

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

如果“ falsy”必须相同，则为33个字节：

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

Pyt，10 9字节

←⁺3ĽĐĐƖ=*

说明：

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

通过使用增量功能而不是显式加1保存一个字节

Python，64位元组

False如果无法以该格式写入数字，则输出。

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

这也可以以64字节工作，并输出空字符串作为伪造的输出：

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

65字节的创造性解决方案，输出0为falsy：

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

Pyth，10个字节

*J@hQ3!%J1

在这里尝试！

朱莉娅，30个字节

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

这是一个简单的函数-它创建一个向量，该向量true仅在的相应位置具有3^a-1，其中a一个向量包含0到之间的整数n。它找到的是“第一个”位置，true然后减去1（如果为all false，则查找结果为零，并返回-1）。

作为0:n具有0在第一点中，减1个校正用于索引和也使-1假响应。

Pyke，9个 6字节

3m^Qh@

在这里尝试！

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

旧的9字节版本：

b3'l}\2q*

在这里尝试！

Pyth 8个字节

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

试试这里