Thử thách:

Viết hàm hoặc chương trình chấp nhận danh sách các giá trị boolean và trả về tất cả các phạm vi của True.

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

f [F]                               = []
f [T]                               = [[0,0]]
f [T,T,F,T]                         = [[0,1],[3,3]]
f [F,T,T,F,F,T,T,T]                 = [[1,2],[5,7]]
f [F,T,T,F,F,F,T,T,T,T]             = [[1,2],[6,9]]
f [T,T,F,F,F,T,T,T,T,T,T,T,T,T,T,F] = [[0,1],[5,14]]
f [F,F,T,T,F,F,F,F,F,F,F,F,T,T,T,T,T,T,T,T,F,F,F,F,F,F,F,F,F,F,F,F,F,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,T,T] = [[2,3],[12,19],[33,54],[93,94]]

Quy tắc:

• Bạn có thể chọn cách mã hóa đầu vào, ví dụ: danh sách, mảng, chuỗi, v.v.
• Đầu ra phải được mã hóa dưới dạng danh sách giống như danh sách hoặc chuỗi hiển thị như vậy, vì vậy mảng, danh sách, bộ dữ liệu, ma trận, vectơ, v.v.
• Các giá trị boolean phải được mã hóa dưới dạng hằng, nhưng nếu không, bất kỳ chuyển đổi đơn giản nào của T / F sang hằng số mong muốn đều được cho phép
• EDIT: eval hoặc tương tự trong thời gian chạy IS được cho phép.
• Đừng quên giải thích cách đầu vào được chuyển đến chương trình / hàm và cung cấp đầu vào / đầu ra cho các trường hợp thử nghiệm
• Chuyển đổi sang định dạng đầu vào mong muốn không được tính
• Các sơ hở tiêu chuẩn không được phép
• Nếu ngôn ngữ của bạn có chức năng để làm điều này, nó không được phép
• Tôi sẽ không chấp nhận trình của riêng tôi
• EDIT: Định dạng đầu ra là linh hoạt. Nếu không in một danh sách hoặc tương tự, các giá trị phạm vi phải được phân tách bằng một ký tự không phải là số và các phạm vi riêng biệt.

Ghi điểm:

• Điểm được tính bằng byte, trừ khi không phù hợp với ngôn ngữ của bạn (chẳng hạn như codel trong Piet)
• Điểm số thấp nhất sẽ thắng

Có một chút linh hoạt trong đầu vào và đầu ra, nhưng các giải pháp trong đó T / F được thay thế bằng các chức năng làm tất cả công việc đều không được phép.

Gỡ lỗi:

Nếu bạn viết của bạn bằng Haskell hoặc có thể gọi nó từ Haskell, phần sau đây sẽ kiểm tra chức năng / chương trình của bạn:

import Test.QuickCheck

tf = cycle [True,False]
gen l = foldl (++) [] $ map (\i -> [tf!!i | x<-[1..i]]) l
putIn (a,b) l = zipWith (||) l [(a <= p) && (p <= b) | p <- [0..length l]]
putAllIn rs len = foldr putIn [False|i<-[1..len]] rs
main = print $ quickCheck (check functionNameGoesHere)

Bình thường, 17 16 byte

fT.b*Y,~+ZNtZrQ8

Sử dụng một số phép thuật truy cập bài tập ưa thích cùng với mã hóa chiều dài chạy.

Lấy đầu vào là một mảng của 0s và 1s, vd [1, 1, 0, 1, 0]. Đầu ra như trong thử thách, ví dụ [[0, 1], [3, 3]].

Phòng thử nghiệm

Bình thường, 18 byte

CxR.:++~Zkz02_B_`T

Bộ kiểm tra

Đúng được biểu diễn dưới dạng 1, Sai là 0.

Phạm vi được thể hiện bao gồm.

Võng mạc , 82 34 27 byte

\b(?<=(.)*_?)
$#1
_+

S_`:

Dòng trống nên chứa một khoảng trắng.

Đầu vào là một chuỗi phẳng _cho đúng và :sai. Đầu ra là các cặp được phân tách bằng dấu cách, mỗi cặp trên một dòng riêng biệt.

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

Giải trình

Việc chơi golf nặng từ 82 xuống còn 27 byte là có thể bằng cách lựa chọn thông minh đại diện của đúng và sai. Tôi đã chọn một ký tự từ _, (đó không phải là một chữ số) cho đúng và một ký tự không phải từ :, (không cần thoát) cho sai. Điều đó cho phép tôi phát hiện các đầu của phạm vi dưới dạng ranh giới từ.

\b(?<=(.)*_?)
$#1

Chúng tôi phù hợp với một ranh giới từ. Chúng tôi muốn thay thế ranh giới đó bằng chỉ số tương ứng của giá trị trung thực. Về nguyên tắc khá dễ dàng với $#tính năng gần đây của Retina , tính số lần chụp của một nhóm. Chúng tôi chỉ đơn giản là bắt từng nhân vật trước vị trí đó thành một nhóm. Bằng cách đếm những nhân vật đó, chúng ta có được vị trí. Điều hấp dẫn duy nhất là bây giờ các đầu của phạm vi đã tắt. Chúng tôi thực sự muốn chỉ số của nhân vật ở phía trước trận đấu. Điều đó cũng dễ dàng được khắc phục bằng cách tùy ý khớp với một _cái không bị bắt, do đó bỏ qua một ký tự khi chúng ta ở cuối phạm vi.

_+
<space>

Bây giờ chúng tôi thay thế tất cả các hoạt động của dấu gạch dưới bằng một khoảng trắng. Đó là, chúng tôi chèn một khoảng trắng giữa đầu và cuối của mỗi phạm vi, trong khi loại bỏ các dấu gạch dưới.

S_`:

Điều đó để lại dấu hai chấm (và chúng ta vẫn cần tách các cặp). Chúng tôi làm điều đó bằng cách chia toàn bộ chuỗi thành các dòng xung quanh mỗi dấu hai chấm. Các Shoạt tính chia chế độ, và _ngăn chặn các phân khúc sản phẩm nào đó mà không nhận được tấn của dòng sản phẩm nào khi chúng ta có chạy của dấu hai chấm.

MATL , 17 18 20 byte

j'T+'1X32X34$2#XX

Sử dụng phiên bản hiện tại (9.1.0) của ngôn ngữ / trình biên dịch.

Đầu vào là một chuỗi chứa các ký tự Tvà F. Đầu ra là một bảng hai hàng, trong đó mỗi cột biểu thị một phạm vi sử dụng chỉ mục 1, là mặc định ngôn ngữ.

Cảm ơn Stewie Griffin đã loại bỏ 2 byte.

Thí dụ

>> matl
 > j'T+'1X32X34$2#XX
 >
> FTTFFFTTTT
2 7
3 10

Giải trình

Nó dựa trên một biểu thức chính quy đơn giản:

j         % input string
'T+'      % regular expression: match one or more `T` in a row
1X3       % predefined string literal: 'start'
2X3       % predefined string literal: 'end'
4$2#XX    % regexp with 4 inputs (all the above) and 2 outputs (start and end indices)
          % implicitly display start and end indices

Octave, 43 byte

@(x)reshape(find(diff([0,x,0])),2,[])-[1;2]

find(diff([0,x,0]))tìm tất cả các vị trí trong đó mảng đầu vào thay đổi giữa đúng và sai. Bằng cách định hình lại điều này thành ma trận 2 nhân, chúng ta đạt được hai điều: Các thay đổi từ đúng thành sai và từ sai thành đúng được chia thành hai hàng. Điều này làm cho nó có thể trừ 1 và 2 từ mỗi hàng đó. Trừ 1 từ hàng một là cần thiết vì Octave được lập chỉ mục 1, không được lập chỉ mục bằng không. Trừ 2 từ hàng hai là cần thiết vì find(diff())tìm thấy vị trí của giá trị sai đầu tiên, trong khi chúng tôi muốn giá trị đúng cuối cùng. Phần trừ chỉ có thể có trong Octave, không phải trong MATLAB.

F=0;T=1;
x=[F,F,T,T,F,F,F,F,F,F,F,F,T,T,T,T,T,T,T,T,F,F,F,F,F,F,F,F,F,F,F,F,F,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,T,T]

reshape(find(diff([0,x,0])),2,[])-[1;2]
ans =    
    2   12   33   93
    3   19   54   94

x=[T,T,F,F,F,T,T,T,T,T,T,T,T,T,T,F]
reshape(find(diff([0,x,0])),2,[])-[1;2]
ans =    
    0    5
    1   14

CJam, 27 25 byte

0qe`{~~{+}{1$+:X(]pX}?}/;

Mong đợi đầu vào như thế nào TTFTFT. Hãy thử trực tuyến .

Giải trình

0                               Push 0, to kick off index
qe`                             Push input and run length encode
                                e.g. FFFFTTTFT -> [[4 'F] [3 'T] [1 'F] [1 'T]]
{                 }/            For each pair in the RLE...
 ~                                Unwrap the pair
  ~                               Evaluate T -> 0 (falsy), F -> 15 (truthy)
   { }{         }?                 Ternary based on T/F
    +                                If 'F: add count to index
       1$+:X(]pX                     If 'T: output inclusive range, updating index
;                               Discard the remaining index at the top of the stack

Japt, 34 31 25 byte

Thử một cách tiếp cận mới thực sự có hiệu quả thời gian này.

V=[]Ur"T+"@Vp[YY-1+Xl]};V

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

Đầu vào là một chuỗi với Ffor falsevà Tfor true. Đầu ra là một mảng các mảng; biểu diễn chuỗi làm cho nó trông giống như một mảng duy nhất.

Làm thế nào nó hoạt động

          // Implicit: U = input string
V=[]      // Set V to an empty array. (Why don't I have a variable pre-defined to this? :P)
Ur"T+"    // Take each group of one or more "T"s in the input,
@         // and map each matched string X and its index Y to:
Vp[       //  Push the following to an array in V:
Y         //   Y,
Y-1+Xl    //   Y - 1 + X.length.
]};       //  This pushes the inclusive start and end of the string to V.
V         // Implicit: output last expression

Lưu ý: Bây giờ tôi thấy rằng một số người đã đưa ra thuật toán này, nhưng tôi đã phát hiện ra nó một cách độc lập.

Phiên bản không cạnh tranh, 22 byte

;Ur"T+"@Ap[YY-1+Xl]};A

Trong cam kết GitHub mới nhất , tôi đã thêm một tính năng mới: hàng đầu ;đặt các biến A-J,Lthành các giá trị khác nhau. Ađược đặt thành một mảng trống, do đó loại bỏ nhu cầu tạo nó bằng tay.

Python 2, 69 byte

p=i=0
for x in input()+[0]:
 if x-p:b=x<p;print`i-b`+';'*b,
 p=x;i+=1

Ví dụ đầu ra:

2 3; 7 16; 18 18;

Một cách tiếp cận trực tiếp, không có tích hợp. Theo dõi giá trị hiện tại xvà giá trị trước đó p. Khi chúng khác nhau, chúng tôi đã chuyển sang chạy. Khi chuyển 0sang 1, in chỉ mục hiện tại i. Khi chuyển 1sang 0, in chỉ mục hiện tại trừ đi một dấu chấm theo dấu chấm phẩy.

Các iflà khá nặng mùi. Có lẽ đệ quy sẽ tốt hơn,

Haskell, 74 byte

import Data.Lists
map(\l->(fst$l!!0,fst$last l)).wordsBy(not.snd).zip[0..]

Ví dụ sử dụng: map(\l->(fst$l!!0,fst$last l)).wordsBy(not.snd).zip[0..] $ [True,False,True,True,False]-> [(0,0),(2,3)].

Làm thế nào nó hoạt động:

                               -- example input: [True,False,True,True,False]

zip[0..]                       -- pair each element of the input with it's index
                               -- -> [(0,True),(1,False),(2,True),(3,True),(4,False)]
wordsBy(not.snd)               -- split at "False" values into a list of lists
                               -- -> [[(0,True)],[(2,True),(3,True)]]
map                            -- for every element of this list
   (\l->(fst$l!!0,fst$last l)) -- take the first element of the first pair and the
                               -- first element of the last pair
                               -- -> [(0,0),(2,3)]

J, 26 byte

[:I.&.|:3(<`[/,]`>/)\0,,&0

Đây là một động từ đơn âm chưa được đặt tên (hàm unary) trả về một mảng 2D hoặc số nguyên. Nó được sử dụng như sau.

  f =: [:I.&.|:3(<`[/,]`>/)\0,,&0
  f 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 0
0  1
5 14

Giải trình

[:I.&.|:3(<`[/,]`>/)\0,,&0
                       ,&0  Append 0 to input
                     0,     then prepend 0.
        3(         )\       For each 3-element sublist (a b c):
               ]`>/           Compute b>c
          <`[/                Compute a<b
              ,               Concatenate them
                            Now we have a 2D array with 1's on left (right) column
                            indicating starts (ends) or 1-runs.
[:I.&.|:                    Transpose, get indices of 1's on each row, transpose back.

Ruby, 39

->s{s.scan(/T+/){p$`.size..s=~/.#$'$/}}

Yêu cầu mẫu:

2.2.3 :266 > f=->s{s.scan(/T+/){p$`.size..s=~/.#$'$/}}
 => #<Proc:0x007fe8c5b4a2e8@(irb):266 (lambda)> 
2.2.3 :267 > f["TTFTTFTTTFT"]
0..1
3..4
6..8
10..10

Đây ..là cách Ruby đại diện cho phạm vi bao gồm.

Một điều thú vị ở đây là làm thế nào tôi có được chỉ số ở cuối phạm vi. Thật lạ. Tôi tự động tạo một biểu thức chính quy khớp với ký tự cuối cùng của phạm vi, và sau đó tất cả các ký tự tiếp theo và cuối chuỗi để buộc khớp chính xác. Sau đó, tôi sử dụng =~để lấy chỉ mục của regex đó trong chuỗi ban đầu.

Nghi ngờ có thể có một cách ngắn hơn để làm điều này trong Ruby bằng cách sử dụng các cờ -naF.

JavaScript (ES6), 59

Một hàm ẩn danh, đầu vào là một chuỗi Tvà F, trả về đầu ra dưới dạng một mảng của các mảng

x=>x.replace(/T+/g,(a,i)=>o.push([i,a.length+i-1]),o=[])&&o

KIỂM TRA

f=x=>x.replace(/T+/g,(a,i)=>o.push([i,a.length+i-1]),o=[])&&o

// TEST

arrayOut=a=>`[${a.map(e=>e.map?arrayOut(e):e).join`,`}]`

console.log=x=>O.textContent+=x+'\n'

;[
  'F','T','TTFT','FTTFFTTT','FTTFFFTTTT','TTFFFTTTTTTTTTTF',
  'FFTTFFFFFFFFTTTTTTTTFFFFFFFFFFFFFTTTTTTTTTTTTTTTTTTTTTTFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFTT'
].forEach(t=>console.log(t+'\n'+arrayOut(f(t))+'\n'))

<pre id=O></pre>

, 18 ký tự / 28 byte

ïħ`T+`,↪ᵖ[_,$Ꝉ+‡_]

Try it here (Firefox only).

Giải trình

ïħ`T+`,↪ᵖ[_,$Ꝉ+‡_] // implicit: ï=input
ïħ`T+`,            // for each T-sequence...
       ↪ᵖ[_,$Ꝉ+‡_] // push [start index of sequence, end index of sequence] to the stack
                   // implicit stack output

Haskell, 62 byte

f l|s<-zip3[0..](0:l)$l++[0]=zip[i|(i,0,1)<-s][i-1|(i,1,0)<-s]

Đưa vào đầu vào một danh sách 0 và 1.

Đưa ra danh sách l, đệm nó với 0 ở cả hai bên và tính toán danh sách các cặp liên tiếp được lập chỉ mục. Ví dụ

l = [1,1,0]
s = [(0,0,1),(1,1,1),(2,1,0),(3,0,0)]

Sau đó, trích xuất các chỉ số tương ứng với các phần tử liên tiếp (0,1)và (1,0), đó là điểm bắt đầu của các khối 0 và 1, trừ 1 từ đầu 0 để có kết thúc 1 và nén kết quả.

Pyth, 19 18 byte

m-VdU2cx1aV+ZQ+QZ2

Giải trình:

             implicit: Q=input
m            map lambda d:
  -V         Vectorized subtraction by [0,1]
     d
     U2     
c            split every 2 elements
  x            find all indexes of
    1          1s
    aV         in vectorized xor:
       +ZQ     Q with a 0 on the front
       +QZ     Q with a 0 on the end
  2

Hãy thử nó ở đây .

Perl, 47 byte

s/F*(T*)(T)F*/[$-[0],$+[1]],/g;chop$_;$_="[$_]"

Với các tùy chọn perlrun sau -lpe:

$ perl -lpe's/F*(T*)(T)F*/[$-[0],$+[1]],/g;chop$_;$_="[$_]"' <<< 'TTFFFTTTTTTTTTTF'
[[0,1],[5,14]]

Thay thế trong đó đầu ra được phân tách dòng (34 byte):

$ perl -pE's/F*(T*)(T)F*/$-[0] $+[1]\n/g;chomp' <<< TTFFFTTTTTTTTTTF
0 1
5 15

Python 2, 108 byte

l=input();l+=[0];o=[];s=k=0
for i,j in enumerate(l):s=j*~k*i or s;~j*l[i-1]and o.append([s,i-1]);k=j
print o

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

$ python2 rangesinlists2.py
[0]
[]
$ python2 rangesinlists2.py
[-1]
[[0, 0]]
$ python2 rangesinlists2.py
[-1,-1,0,-1]
[[0, 1], [3, 3]]
$ python2 rangesinlists2.py
[0,-1,-1,0,0,-1,-1,-1]
[[1, 2], [5, 7]]
$ python2 rangesinlists2.py
[0,-1,-1,0,0,0,-1,-1,-1,-1]
[[1, 2], [6, 9]]
$ python2 rangesinlists2.py
[-1,-1,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0]
[[0, 1], [5, 14]]
$ python2 rangesinlists2.py
[0,0,-1,-1,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1]
[[2, 3], [12, 19], [33, 54], [93, 94]]

Chắc chắn có một giải pháp ngắn hơn thế này, nhưng nó hoạt động.

Haskell: 123 byte (Ví dụ, không thể thắng)

f l=[(s,e)|let m=length l-1,let r=[0..m],s<-r,e<-r,and[l!!x|x<-[s..e]],s<=e,let(#)p=not$l!!p,s==0||(#)(s-1),e==m||(#)(e+1)]

Ít chơi gôn hơn:

f l = [(start,end) | start <- [0..max], end <- [0..max], allTrue start end, start <= end, notBelow start, notAbove end]
  where
    max = (length l) - 1
    allTrue s e = and (subList s e)
    subList s e = [l !! i | i <- [s,e]]
    notBelow  s = (s == 0) || (not (l !! (s-1)))
    notAbove  e = (s == m) || (not (l !! (e+1)))

CJam, 30 byte

0l~0++2ewee{1=$2,=},{~0=-}%2/`

Nhập vào dưới dạng mảng kiểu CJam của 0s và 1s. Đầu ra dưới dạng một cặp kiểu CJam.

Chạy tất cả các trường hợp thử nghiệm. (Chăm sóc việc chuyển đổi các định dạng đầu vào.)

Japt, 27 byte

A=[];Ur"T+"@Ap[YXl +´Y]};A·

Phải có một cách để đánh gôn này ...

Dù sao, nó cũng giống như câu trả lời của tôi.

APL, 17 ký tự

{(↑,↑∘⊖)¨⍵⊂⍵×⍳⍴⍵}

Trong ⎕IO←0và ⎕ML←3. Bằng tiếng Anh:

• ⍵×⍳⍴⍵: zero out các phần tử của vectơ chỉ số miễn là đối số trong đó đối số là sai
• ⍵⊂: cắt ở đầu mỗi sự thật và vứt bỏ sự giả dối
• (↑,↑∘⊖)¨: lấy phần tử đầu tiên và cuối cùng của mỗi phân đoạn

PowerShell, 82 byte

("$args"|sls 't+'-A).Matches|%{if($_){'{0},{1}'-f$_.Index,($_.Index+$_.Length-1)}}

Giải pháp Regex, sử dụng các thuộc tính của đối tượng MatchInfo .

Thí dụ

PS > .\BoolRange.ps1 'F'


PS > .\BoolRange.ps1 'T'
0,0

PS > .\BoolRange.ps1 'TTFFFTTTTTTTTTTF'
0,1
5,14

Toán học, 45 byte

SequencePosition[#,{True..},Overlaps->False]&

Không đặc biệt thú vị; sử dụng tích hợp.

Clojure, 109 ký tự

#(first(reduce(fn[[r i]p](let[e(+(count p)i)][(if(first p)(conj r[i(dec e)])r)e]))[[]0](partition-by not %)))

Điều đầu tiên tôi nghĩ đến, dựa trên reducevàpartition-by .

Trường hợp thử nghiệm đơn giản (ánh xạ Ttới truevà Fđến false):

(def f #(first(reduce(fn[[r i]p](let[e(+(count p)i)][(if(first p)(conj r[i(dec e)])r)e]))[[]0](partition-by not %))))
(f (map #(= 'T %) '[F,T,T,F,F,T,T,T]))