Nhóm lấy một danh sách và chia nó thành các danh sách mới của các phần tử liền kề bằng nhau. Ví dụ

[1,1,2,1,1] -> [[1,1],[2],[1,1]]

Nếu sau đó bạn lấy chiều dài của các nhóm này, bạn sẽ nhận được một danh sách số nguyên mới

[1,1,2,1,1] -> [2,1,2]

Nhiệm vụ của bạn là viết một chương trình lấy danh sách các số nguyên dương và tìm số lần bạn có thể nhóm và kéo dài nó trước khi danh sách kết quả có một phần tử. Ví dụ, danh sách [1,2,3,3,2,1]có thể được nhóm lại 4 lần

[1,2,3,3,2,1]
[1,1,2,1,1]
[2,1,2]
[1,1,1]
[3]

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

Các trường hợp thử nghiệm

[1,2,3,3,2,1] -> 4
[1,2,3,4,5,6,7] -> 2
[1,1,1,1,1,1] -> 1
[2] -> 0
[1,2,4] -> 2
[1,2,2,1,1,2] -> 4
[1,2,2,1,1,2,1,2,2] -> 5
[1] -> 0

Haskell, 49 byte

import Data.List
f[_]=0
f c=1+f(length<$>group c)

Hãy thử trực tuyến!

CJam , 18 byte

q~_,{_e`0f=}*]:,1#

Hãy thử trực tuyến!

Japt , 12 byte

ÊÉ©1+ßUò¦ ml

Kiểm tra nó trực tuyến!

Giải trình

 Ê É © 1+ßUò¦  ml
Ul -1&&1+ßUò!= ml    Ungolfed
                     Implicit: U = input array
Ul -1                Take U.length - 1.
     &&              If this is non-zero:
          Uò!=         Split U between non-equal elements.
               ml      Take the length of each run of equal elements.
         ß             Run the entire program again on the resulting array.
       1+              Add one to the return value.

Recursion là một cách tiếp cận thực sự không thông thường đối với Japt, nhưng dường như nó ngắn hơn 4 byte so với phương án thay thế tiếp theo ...

Brachylog , 12 byte

;.{ḅlᵐ}ⁱ⁾l1∧

Hãy thử trực tuyến!

Giải trình

;.{   }ⁱ⁾        Iterate Output times the following predicate on the input:
   ḅ               Group consecutive equal elements together
    lᵐ             Map length
         l1∧     The result of this iteration must have length 1

C (gcc) , 108 byte

j,k,n;f(A,l)int*A;{for(j=k=n=0;j<l;j++)if(n++,A[j]-A[k])A[k++]=--n,A[k]=A[j],n=1;A=l>1?-~f(A,k,A[k++]=n):0;}

Hãy thử trực tuyến!

Giải trình

j,k,n;                // array pos, group pos, group val
f(A,l)int*A;{         // function takes array and length
 for(j=k=n=0;j<l;j++) // initialize, loop through array
  if(n++,             // increase n (*), check if group ended
  A[j]-A[k])          // group ended
   A[k++]=--n,        // advance group pos, decrease n, counteracting (*)
   A[k]=A[j],         // store new group type
   n=1;               // group is at least one long
 A=l>1?               // check if array length is larger than one
  -~f(A,k,A[k++]=n)   // fix last group length, enter recursion
  :0;}                // array length is less than two, return zero

Hãy thử trực tuyến!

JavaScript (ES6), 67 65 63 byte

f=a=>a[1]?1+f(q=j=i=[],a.map(x=>x^a[++i]?j=!q.push(++j):++j)):0

Thật kỳ lạ, JavaScript và Japt dường như có cùng một thuật toán ngắn nhất cho một lần ...

K (oK) , 20 19 byte

Giải pháp:

#2_{#:'(&~~':x)_x}\

Hãy thử trực tuyến!

Ví dụ:

#2_{#:'(&~~':x)_x}\1 2 3 3 2 1
4
#2_{#:'(&~~':x)_x}\1 2 3 4 5 6 7
2
#2_{#:'(&~~':x)_x}\1 1 1 1 1 1
1
#2_{#:'(&~~':x)_x}\1#2
0
#2_{#:'(&~~':x)_x}\1 2 4
2

Giải trình:

Cách này khá đơn giản, tôi tự hỏi liệu có cách tiếp cận nào tốt hơn nữa không ... Tìm các chỉ số nơi đầu vào khác nhau, phân chia tại các chỉ số đó và sau đó đếm độ dài của mỗi danh sách phụ. Lặp lại cho đến khi kết quả hội tụ đến 1.

#2_{#:'(&~~':x)_x}\ / the solution
   {             }\ / scan over lambda until results converge
                x   / implicit input
               _    / cut at indices
       (      )     / do this together
         ~~':x      / differ... not (~) match (~) each-previous (':) x)
        &           / indices where true
    #:'             / count (#:) each (')
 2_                 / drop first two results
#                   / count result

Ghi chú:

Giải pháp 14 byte sau đây hoạt động cho tất cả ngoại trừ danh sách một mục:

#1_(-':&~~':)\

Hãy thử trực tuyến!

J , 25 23 byte

Lưu 1 byte nhờ streetster

Lưu 1 byte nhờ FrownyFrog

2#@}.#;.1@(0,2=/\])^:a:

Hãy thử trực tuyến!

Giải pháp ban đầu:

_2+[:#(#;.1~1,2~:/\])^:a:

Hãy thử trực tuyến!

Giải trình

      (               )^:a: - repeat until result stops changing, store each iteration
        ;.1~                - cut the input (args swapped)              
            1,2~:/\]      - where the items are no longer the same
       #                    - and take the length of the sublists
 2+[:#                      - finally subtract 2 from the number of steps

Stax , 9 byte

ÆÑfá╒]`*Ä

Chạy và gỡ lỗi trực tuyến

Đại diện ascii của cùng một chương trình là đây.

{D}{|RMHgf%

Này sử dụng một tính năng Stax gọi là máy phát điện sản xuất giá trị theo chuyển đổi và lọc khối.

{ }            the filter for the generator
 D             tail of array; this is truthy for length >= 2
   {    gf     generator block - termination condition is when the filter fails
    |R         run-length encode into pairs [element, count]
      M        transpose matrix
       H       last element
          %    length of final generated array

Python 2 , 84 byte

f=lambda a:len(a)>1and-~f(eval(''.join('1'+',+'[x==y]for x,y in zip(a,a[1:]))+'1,'))

Hãy thử trực tuyến!

Làm sao?

flà một hàm đệ quy, nếu đầu vào của nó a, có độ dài 2 trở lên ( len(a)>1) trả về 1+f(x)* trong đó xđộ dài nhóm là a; trong khi nếu đầu vào của nó có độ dài 1 hoặc 0 trả về False(bằng 0 trong Python) - điều này là do phía bên phải của andkhông được đánh giá khi bên trái là falsey.

* -~f(x)là -(-1 - f(x))nhưng có thể tiếp tục andkhông giống 1+f(x)hoặc f(x)+1)

Độ dài nhóm được tính bằng cách tạo mã sau đó được ước tính eval(...). Mã được tạo là một cái gì đó giống như 1,1,1+1+1,1,1+1,1,đánh giá một tuple như thế nào (1,1,3,1,2,1).

Mã được tạo bằng cách nén qua avà akhông có đầu của nó ( ...for x, y in zip(a,a[1:])tạo xvà ytừng cặp liền kề a. Nếu cặp này được x==yđánh giá bằng True(1) nếu không False(0) - kết quả này được sử dụng để lập chỉ mục cho chuỗi ,+ có năng suất +và ,tương ứng và mỗi nhân vật kết quả được đi trước bởi một 1( '1'+...) - toàn bộ điều đó đã một trận chung kết, trailing 1,. nối Ví dụ, nếu ađược [5,5,2,9,9,9]thì x,ycặp sẽ được (5,5)(5,2)(2,9)(9,9)(9,9)làm cho bất bình đẳng 10011thì các nhân vật sẽ được +,,++, mà với trước 1s trở 1+1,1,1+1+và dấu thức 1,làm1+1,1,1+1+1,mà đánh giá (2,1,3)theo yêu cầu.

Lưu ý rằng việc theo dõi ,đảm bảo rằng một đầu vào với một nhóm duy nhất được đánh giá là một tuple chứ không phải là một số nguyên (nghĩa là [3,3]-> 1+1,-> (2)thay vì [3,3]-> 1+1-> 2)

CJam , 19 byte

q~{_);}{_e`0f=}w],(

Hãy thử trực tuyến!

CJam , 20 byte

l~{__,(}{e`z0=}w;;],

Hãy thử trực tuyến!

Perl 5 , 53 50 49 45 byte

Bao gồm +3cho-p

Đưa ra danh sách các số dưới dạng một dòng trên STDIN

#!/usr/bin/perl -p
s%%$\+=1<s:\d+:$.++x($'-$&and$.=1):eg%eg}{

Hãy thử trực tuyến!

Husk , 8 byte

_{-1 byte nhờ @Zgarb!}

←Vε¡(mLg

Hãy thử trực tuyến!

Giải trình

←Vε¡(mLg)  -- example input: [1,2,3,3,2,1]
   ¡(   )  -- repeatedly apply the function & collect results
    (  g)  -- | group: [[1],[2],[3,3],[2],[1]]
    (mL )  -- | map length: [1,1,2,1,1]
           -- : [[1,2,3,3,2,1],[1,1,2,1,1],[2,1,2],[1,1,1],[3],[1],[1],...
 V         -- index where
  ε        -- | length is <= 1: [0,0,0,0,1,1...
           -- : 5
←          -- decrement: 4

Thạch , 10 byte

ŒgL€$ḊпL’

Hãy thử trực tuyến!

05AB1E , 9 byte

[Dg#γ€g]N

Hãy thử trực tuyến!

Giải trình

[Dg#   ]     # loop until the length of the current value is 1
    γ        # split into groups of consecutive equal elements
     €g      # get length of each
        N    # push the iteration variable N

Ngôn ngữ Wolfram (Mathicala) , 32 byte

Đã lưu 2 byte nhờ Martin Ender. Sử dụng mã hóa CP-1252, trong đó ±là một byte.

±{_}=0;±x_:=1+±(Length/@Split@x)

Hãy thử trực tuyến!

Hồng ngọc , 54 56 55 54 byte

g=->l,d=0{l[1]?g[l.chunk(&:i).map{|i,j|j.size},d+1]:d}

Hãy thử trực tuyến!

SmileBASIC, 110 108 byte

DEF R L,J
K=LEN(L)FOR I=1TO K
N=POP(L)IF O-N THEN UNSHIFT L,0
INC L[0]O=N
NEXT
IF I<3THEN?J ELSE R L,J+1
END

Chức năng gọi như R list,0; đầu ra được in ra bàn điều khiển.

Python 2 , 85 byte

from itertools import*
f=lambda a:~-len(a)and-~f([len(list(v))for k,v in groupby(a)])

Hãy thử trực tuyến!

R , 51 45 byte

f=function(a)"if"(sum(a|1)>1,f(rle(a)$l)+1,0)

Hãy thử trực tuyến!

Đệ quy lấy độ dài của mã hóa chiều dài chạy và tăng bộ đếm.

Võng mạc 0.8.2 , 31 byte

,.*
$&_
}`(\b\d+)(,\1)*\b
$#2
_

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

,.*
$&_

Nếu có dấu phẩy, chúng ta sẽ thực hiện một lần lặp khác, vì vậy hãy thêm một ký tự đếm.

}`(\b\d+)(,\1)*\b
$#2

Thay thế mỗi lần chạy với chiều dài giảm dần của nó. Các giai đoạn trên lặp lại cho đến khi không còn dấu phẩy.

_

Đếm số lần lặp.

Perl 6 , 52 byte

{+($_,*.comb(/(\d+)[" "$0»]*/).map(+*.words)...^1)}

Kiểm tra nó

Mở rộng:

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

  + (              # turn the following into a Numeric (get the count)


      $_,          # seed the sequence with the input

      *.comb(      # turn into a string, and grab things that match:

        /          # regex
          ( \d+ )  # a run of digits (number)
          [
            " "    # a space
                   # (gets inserted between elements of list when stringified)

            $0     # another instance of that number
            »      # make sure it isn't in the middle of a number

          ]*       # get as many as possible
        /
      ).map(
        +*.words  # turn each into a count of numbers
      )

      ...^        # keep doing that until (and throw away last value)

      1           # it gives a value that smart-matches with 1
                  # (single element list)
  )
}

Brain-Flak , 78 byte

({}<>)<>({()<(<>{}<(())><>){({}[({})]<>){((<{}>))}{}((){})<>}<>{}({}<>)<>>}{})

Hãy thử trực tuyến!

Bình thường , 9 byte

ltt.uhMr8

Bộ thử nghiệm!

Kotlin , 123 byte

Chấp nhận List<Int>.

{var a=it;var b=0;while(a.size>1){var c=a[0];var d=0;with(a){a=listOf();forEach{if(it!=c){a+=d;d=0};d++;c=it};a+=d};b++};b}

Dễ đọc hơn:

{ l ->
    var input = l
    var result = 0
    while (input.size > 1) {
        var last = input[0]
        var runSize = 0
        with(input) {
            input = listOf()
            forEach { current ->
                if (current != last) {
                    input += runSize
                    runSize = 0
                }
                runSize++
                last = current
            }
            input += runSize
        }
        result++
    }
    result
}

Hãy thử trực tuyến!

131 byte, TIO

{l->var a=l;var b=0;while(a.size>1){var c=a[0];var d=0;a.let{a=arrayListOf();for(e in it){if(e!=c){a+=d;d=0};d++;c=e};a+=d};b++};b}

181 byte, TIO

Bao gồm 39 cho import kotlin.coroutines.experimental.*.

{l->var a=l;var b=0;while(a.size>1){var c=a[0];var d=0;a=buildSequence{for(e in a){if(e!=c){yield(d);d=0;};d++;c=e};yield(d)}.toList();b++};b}

Màu đỏ , 140 byte

func[b][n: 0 while[(length? b)> 1][l: copy[]parse split form b" "[any[copy s[set t string! thru any t](append l length? s)]]b: l n: n + 1]n]

Hãy thử trực tuyến!

Tôi chỉ muốn thử phương ngữ Parse của Red một lần nữa.

Bị đánh cắp

f: func [b] [
    n: 0
    while [(length? b) > 1][
        l: copy []
        parse split form b " " [
            any [copy s [set t string! thru any t]
                (append l length? s)]
        ]
        b: l
        n: n + 1
    ]
    n
]