在考拉兹猜想假设，如果你把任意正整数，然后重复下面的算法足够的时间：

if number is odd, then multiply by three and add one
if number is even, then divide by two

您最终将得到1。它似乎总是可以工作，但是从未证明它总是可以工作。

您已经在计算达到1所需的时间了，所以我想我会稍微调整一下。

从给定的正整数开始，计算达到1所需的时间（其“停止时间”）。然后找到该号码的停止时间。

重复直到达到1，或者直到达到100次迭代的完全任意限制。在前一种情况下，打印所需的迭代次数。在后一种情况下，请打印“ Fail”或您选择的其他一致输出，只要它不是integer即可1≤n≤100。您可能不会为此选项输出空字符串。但是，允许输出[1，100]范围之外的整数。

例子：

Input: 2
2->1
Output: 1

Input: 5
5->5->5->5->5->...
Output: Fail

Input: 10
10->6->8->3->7->16->4->2->1
Output: 8

Input: 100
100->25->23->15->17->12->9->19->20->7->16->4->2->1
Output: 13

Input: 10^100
10^100->684->126->108->113->12->9->19->20->7->16->4->2->1
Output: 13

Input: 12345678901234567890
12345678901234567890->286->104->12->9->19->20->7->16->4->2->1
Output: 11

Input: 1
--Depending on your code, one of two things may happen. Both are valid for the purposes of this question.
1
Output: 0
--Or:
1->3->7->16->4->2->1
Output: 6

根据我的计算10^100，12345678901234567890使用的语言仅支持该大小的实数，如果您的语言更准确，则可能会得到不同的结果。

计分

由于这是代码高尔夫球，因此字节数最短的答案将获胜。

果冻，24字节

×3‘$HḂ?’пL’
Ç1¹?ȷ2Сi1’

在线尝试！

Python 2，70个字节

f=lambda n,k=0,j=0:n-1and-~f(k*[n/2,n*3+1][n%2]or f(j/99or n,1),k,j+1)

返回199进行一百次或更多次迭代。

在线尝试！

附件，40字节

`-&3@`#@PeriodicSteps[CollatzSize@Max&1]

在线尝试！

这是我制作的一种新语言。我想四处寻找一种合适的中缀语言，这就是结果：数学模型的诞生。万岁

说明

这是一些功能的组合。这些功能是：

• PeriodicSteps[CollatzSize@Max&1]这将产生一个函数，该函数将应用其参数，直到结果包含重复元素为止。此函数CollatzSize@Max&1应用于CollatzSize更大的输入1，以避免0对Collat​​Size 的无效输入。
• `#是带引号的运算符；以这种方式单调应用时，它获得其参数的大小
• `-&3是一个绑定函数，它将参数绑定3到该函数`-，其读数为“减3”。这是因为PeriodicSteps应用程序产生0s，这需要考虑。（它也巧妙地处理了5，映射到的越界数字-1。）

J，₄₉ 45字节

-4个字节，这要归功于@randomra 在此处的注释中采用的较短的Collat​​z序列代码。

(2-~[:#(>&1*-:+2&|*+:+>:@-:)^:a:)^:(<101)i.1:

输出101无效结果。

在线尝试！

说明

毫不奇怪，这种解释很快就过时了。我将按照我以前使用的旧的49字节答案进行说明，下面将包括在内。如果您要更新，请告诉我。它发现递归序列长度的方式保持不变，我只是使用了一种较短的Collat​​z Sequence方法。

(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:)^:(<101)i.1:

查找Collat​​z序列的长度

这部分代码如下

(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:)

解释如下：

(1 -~ [: # %&2`(1+3&*)@.(2&|) ^: (1&<) ^: a:)  Given an input n
                                       ^: a:   Apply until convergence, collecting
                                                each result in an array.
                              ^: (1&<)         If n > 1 do the following, else
                                                return n.
                        (2&|)                  Take n mod 2.
           %&2                                 If n mod 2 == 0, divide by 2.
               (1+3&*)                         If n mod 2 == 1, multiply by 3 
                                                and add 1.
         #                                     Get the length of the resulting
                                                array.
 1 -~                                          Subtract 1.

不幸的是，^:当被告知存储结果时，apply动词（）也会存储初始值，因此这意味着我们（像往常一样）相差一个。因此，为什么我们减去1。

查找递归序列的长度

(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:) ^: (< 101) i. 1:  Given an input n.
                                      ^: (< 101)        Apply 100 times,
                                                         collecting results
                                                         in an array.
(1-~[:#%&2`(1+3&*)@.(2&|)^:(1&<)^:a:)                   Collatz sequence length.
                                                 i. 1:  Index of first 1 (returns
                                                         101, the length of the
                                                         array if 1 not found).

C（gcc），75个字节

i,j;f(n){for(j=0;(i=n)&&j++<100;)for(n=0;i-1;++n)i=i&1?i*3+1:i/2;i=!i*j-1;}

返回-1的n>=100迭代。

在线尝试！

C（gcc），73个字节

i,j;f(n){for(j=-1;(i=n)&&j++<99;)for(n=0;i-1;++n)i=i&1?i*3+1:i/2;i=!i*j;}

返回0的n>=100迭代。

在线尝试！

JavaScript（ES6），57个字节

true失败时返回。返回0的1。

f=(n,k=i=0)=>n>1?f(n&1?n*3+1:n/2,k+1):k?i>99||f(k,!++i):i

测试用例

f=(n,k=i=0)=>n>1?f(n&1?n*3+1:n/2,k+1):k?i>99||f(k,!++i):i

console.log(f(2))    // 1
console.log(f(5))    // fail
console.log(f(10))   // 8
console.log(f(100))  // 13
console.log(f(1))    // 0

APL（Dyalog Unicode），39 60 53 52 49字节

-3个字节，感谢@ngn

0∘{99<⍺:⋄1=⍵:0⋄1+(⍺+1)∇{1=⍵:0⋄1+∇⊃⍵⌽0 1+.5 3×⍵}⍵}

在线尝试！

对Collat​​z使用@ngn代码，但以前使用@Uriel的代码。

这是不符合规范的旧版本：

{1=⍵:0⋄1+∇{1=⍵:0⋄2|⍵:1+∇1+3×⍵⋄1+∇⍵÷2}⍵}

Perl 6、56个字节

{($_,{($_,{$_%2??$_*3+1!!$_/2}...1)-1}...1).head(102)-1}

在线尝试！

返回101一个非终止序列。

外壳，21字节

←€1↑101¡ȯ←€1¡?½o→*3¦2

在线尝试！输入-1失败时 返回。01

说明

←€1↑101¡ȯ←€1¡?½o→*3¦2  Implicit input (a number).
             ?½o→*3¦2  Collatz function:
             ?     ¦2   if divisible by 2,
              ½         then halve,
               o→*3     else multiply by 3 and increment.
        ȯ←€1¡?½o→*3¦2  Count Collatz steps:
            ¡           iterate Collatz function and collect results in infinite list,
          €1            get 1-based index of 1,
        ȯ←              decrement.
       ¡               Iterate this function on input,
   ↑101                take first 101 values (initial value and 100 iterations),
←€1                    get index of 1 and decrement.

C（gcc），70 73字节

g(x){x=x-1?g(x%2?3*x+1:x/2)+1:0;}f(x,m){for(m=0;(x=g(x))&&100>m++;);x=m;}

在线尝试！

101当迭代次数超过100时返回。

干净，146个 ... 86个字节

-11个字节归功于ØrjanJohansen

import StdEnv
?f l n=hd[u\\1<-iterate f n&u<-l]

?(?(\b|isOdd b=3*b+1=b/2)[0..])[0..99]

作为部分函数文字。

在线尝试！

hd of []如果迭代次数超过100 ，则中止。除非指定更大的堆大小，否则输入大于〜将
退出。Heap Full2^23

Python 2中，99个 98 97字节

• 使用c and t or f代替节省了一个字节t if c else f。
• 通过输出-1代替（f或'f'用于非停止输入）保存字节。

exec"f,F="+"lambda n,i=0:n<2and i or %s"*2%("f([n/2,3*n+1][n%2],-~i),","i>99and-1or F(f(n),-~i)")

在线尝试！

BiwaScheme，151个字符

(define(f n i s)(if(= s 0) 'F(if(= n 0)i(f(letrec((c(lambda(m k)(if(= m 1)k(c(if(=(mod m 2)0)(/ m 2)(+(* m 3)1))(+ k 1))))))(c n 0))(+ i 1)(- s 1)))))

您可以在这里尝试。

R，119107字节

从此处部分使用Jarko Dubbeldam的collat​​z代码。返回0> 100次迭代（失败）。

pryr::f(x,{N=n=0
while(x-1){while(x-1){x=`if`(x%%2,3*x+1,x/2);n=n+1}
x=n
n=0
N=N+1
if(N==100)return(0)}
N})

在线尝试！

APL NARS，115字节，63个字符

{d←0⋄{⍵=1:d⋄99<d+←1:¯1⋄∇{c←0⋄{1=⍵:c⋄c+←1⋄2∣⍵:∇1+3×⍵⋄∇⍵÷2}⍵}⍵}⍵}

可能使用循环会更清楚...有4个函数，2个嵌套和ricorsive，第一个仅用于定义和初始化为= 0的变量d，从第二个函数看作为全局变量计数器。

q←{c←0⋄{1=⍵:c⋄c+←1⋄2∣⍵:∇1+3×⍵⋄∇⍵÷2}⍵}

此第三个函数将是返回用于解决其参数的Collat​​z猜想的调用数量的函数

{⍵=1:d⋄99<d+←1:¯1⋄∇q⍵}

这是第二个函数，如果其arg = 1，则停止其递归并返回d的次数称为其自身-1。否则，如果自身被调用超过99次，则停止其递归并返回-1（fail），否则为其arg计算Collat​​z猜想，并为Collat​​z序列长度值调用自身。对我来说，即使所有这些似乎都运行起来可能是一个大问题，但是当程序员将其视为局部变量时，如果定义了一个全局变量和一个具有相同名称的函数中的一个变量，那么这是一个很大的问题。

  f←{d←0⋄{⍵=1:d⋄99<d+←1:¯1⋄∇{c←0⋄{1=⍵:c⋄c+←1⋄2∣⍵:∇1+3×⍵⋄∇⍵÷2}⍵}⍵}⍵}     
  f 2
1
  f 3
5
  f 5
¯1
  f 10
8
  f 100
13
  f 12313
7
  f 1
0

（Emacs，Common，...）Lisp，105个字节

如果迭代次数> 100，则返回t

(defun f(n k c)(or(> c 100)(if(= n 1)(if(= k 0)c(f k 0(1+ c)))(f(if(oddp
n)(+ n n n 1)(/ n 2))(1+ k)c))))

展开：

(defun f (n k c)
  (or (> c 100)
      (if (= n 1)
          (if (= k 0) c
            (f k 0 (1+ c)))
        (f (if (oddp n) (+ n n n 1) (/ n 2))
           (1+ k) c))))
(f (read) 0 0)