ท้าทาย:

เขียนฟังก์ชั่นหรือโปรแกรมที่ยอมรับรายการค่าบูลีนและส่งกลับช่วงทั้งหมดของ True

กรณีทดสอบ:

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

กฎ:

• คุณสามารถเลือกวิธีการป้อนข้อมูลที่เข้ารหัสเช่นรายการอาร์เรย์สตริง ฯลฯ
• ผลลัพธ์จะต้องถูกเข้ารหัสเป็น list-like ของ list-ชอบหรือสตริงที่แสดงเช่นอาร์เรย์ดังนั้นรายการ list, tuples, เมทริกซ์, เวกเตอร์เป็นต้น
• ค่าบูลีนต้องเข้ารหัสเป็นค่าคงที่ แต่ไม่เช่นนั้นการแปลง T / F อย่างง่ายไปเป็นค่าคงที่ที่ต้องการจะได้รับอนุญาต
• แก้ไข: evalหรือคล้ายกันในระหว่างการอนุญาตให้ใช้งานจริง
• อย่าลืมที่จะอธิบายว่าอินพุตถูกส่งผ่านไปยังโปรแกรม / ฟังก์ชั่นและให้อินพุต / เอาต์พุตสำหรับกรณีทดสอบ
• การแปลงเป็นรูปแบบอินพุตที่ต้องการจะไม่ถูกนับ
• ช่องโหว่มาตรฐานไม่ได้รับอนุญาต
• หากภาษาของคุณมีฟังก์ชั่นในการทำเช่นนี้มันไม่ได้รับอนุญาต
• ฉันจะไม่ยอมรับข้อเสนอของฉันเอง
• แก้ไข: รูปแบบผลลัพธ์มีความยืดหยุ่น หากไม่พิมพ์รายการหรือคล้ายกันค่าช่วงจะต้องคั่นด้วยอักขระที่ไม่ใช่ตัวเลขและช่วงแยกเช่นกัน

เกณฑ์การให้คะแนน:

• คะแนนเป็นไบต์เว้นแต่ว่าไม่เหมาะกับภาษาของคุณ (เช่น codels ใน Piet)
• คะแนนต่ำสุดชนะ

มีความยืดหยุ่นเล็กน้อยในอินพุตและเอาต์พุต แต่โซลูชันที่ T / F ถูกแทนที่ด้วยฟังก์ชันที่ไม่อนุญาตให้ทำงานทั้งหมด

แก้จุดบกพร่อง:

หากคุณเขียนของคุณใน Haskell หรือสามารถโทรจาก Haskell ต่อไปนี้จะตรวจสอบการทำงานของคุณ / โปรแกรม:

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)

Pyth, 17 16 ไบต์

fT.b*Y,~+ZNtZrQ8

ใช้เวทมนตร์นับโพสต์ที่กำหนดมาพร้อมกับการเข้ารหัสการรันความยาว

จะเข้าเป็นอาร์เรย์ของ0และ1s [1, 1, 0, 1, 0]เช่น [[0, 1], [3, 3]]ขาออกเหมือนในความท้าทายเช่น

ชุดทดสอบ

Pyth, 18 ไบต์

CxR.:++~Zkz02_B_`T

ชุดทดสอบ

ทรูจะแสดงเป็นเท็จเป็น10

ช่วงจะถูกแสดงอย่างรวม

เรติน่า , 82 34 27 ไบต์

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

S_`:

บรรทัดว่างควรมีช่องว่างเดียว

อินพุตเป็นสตริงแบบแบนของ_สำหรับจริงและ:เท็จ เอาต์พุตคือคู่ที่คั่นด้วยช่องว่าง

ลองออนไลน์

คำอธิบาย

การเล่นกอล์ฟหนักจาก 82 ถึง 27 ไบต์เป็นไปได้โดยเลือกอย่างชาญฉลาดในการเป็นตัวแทนของจริงและเท็จ ฉันเลือกตัวอักษรคำ_(นั่นไม่ใช่ตัวเลข) สำหรับตัวจริงและตัวอักษรที่ไม่ใช่คำ:(ซึ่งไม่จำเป็นต้องหลบหนี) เป็นเท็จ ที่ช่วยให้ฉันตรวจสอบจุดสิ้นสุดของช่วงเป็นขอบเขตของคำ

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

เราจับคู่ขอบเขตของคำ เราต้องการแทนที่ขอบเขตนั้นด้วยดัชนีที่สอดคล้องกันของค่าความจริง ในหลักการที่ค่อนข้างง่ายด้วย$#ฟีเจอร์ล่าสุดของ Retina ซึ่งนับจำนวนการดักจับของกลุ่ม เราจับตัวละครแต่ละตัวไว้หน้าตำแหน่งนั้น ๆ ในกลุ่ม โดยการนับตัวละครเหล่านั้นเราได้ตำแหน่ง สิ่งเดียวที่จับได้คือตอนจบของช่วงนั้นปิดหนึ่งครั้ง เราต้องการจริงดัชนีของตัวละครในด้านหน้าที่การแข่งขัน นั่นยังได้รับการแก้ไขอย่างง่ายดายโดยการจับคู่แบบทางเลือก_ซึ่งไม่ได้ถ่ายดังนั้นการข้ามอักขระหนึ่งตัวเมื่อเราอยู่ในช่วงท้าย

_+
<space>

ตอนนี้เราแทนที่การขีดเส้นใต้ทั้งหมดด้วยช่องว่าง นั่นคือเราแทรกช่องว่างระหว่างจุดเริ่มต้นและจุดสิ้นสุดของแต่ละช่วงในขณะที่กำจัดขีดล่าง

S_`:

นั่นทำให้โคลอน (และเรายังต้องแยกคู่) เราทำอย่างนั้นโดยแยกสตริงทั้งหมดออกเป็นเส้นรอบ ๆ เครื่องหมายโคลอน Sactives โหมดการแบ่งและ_กลุ่มไม่ใส่ว่างดังกล่าวที่ไม่ได้รับตันของเส้นที่ว่างเปล่าเมื่อเรามีการทำงานของทวิภาค

Python 2, 69 ไบต์

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

ตัวอย่างผลลัพธ์:

2 3; 7 16; 18 18;

วิธีการโดยตรงไม่มีในตัว แทร็คค่าปัจจุบันและความคุ้มค่าก่อนหน้านี้x pเมื่อสิ่งเหล่านี้แตกต่างเราได้สลับการทำงาน เมื่อวันที่เปลี่ยน0ไป1, iพิมพ์ดัชนีปัจจุบัน ในการสลับ1ไปที่0พิมพ์ดัชนีปัจจุบันลบหนึ่งตามด้วยเครื่องหมายอัฒภาค

ifเป็นเหม็นสวย บางทีการสอบถามซ้ำอาจจะดีกว่า

MATL , 17 18 20ไบต์

j'T+'1X32X34$2#XX

ใช้เวอร์ชันปัจจุบัน (9.1.0)ของภาษา / คอมไพเลอร์

การป้อนข้อมูลเป็นสตริงที่มีตัวอักษรและT Fเอาท์พุทเป็นตารางสองแถวที่แต่ละคอลัมน์ระบุช่วงโดยใช้การจัดทำดัชนี 1 ซึ่งเป็นค่าเริ่มต้นของภาษา

ขอบคุณStewie Griffin ที่ลบ 2 ไบต์

ตัวอย่าง

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

คำอธิบาย

มันขึ้นอยู่กับการแสดงออกปกติง่าย ๆ :

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

อ็อกเทฟ 43 ไบต์

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

find(diff([0,x,0]))ค้นหาตำแหน่งทั้งหมดที่อินพุตอาร์เรย์เปลี่ยนแปลงระหว่างจริงและเท็จ โดยการเปลี่ยนรูปแบบนี้เป็นเมทริกซ์ขนาด 2 คูณสองเราได้สองสิ่ง: การเปลี่ยนแปลงจากความจริงเป็นเท็จและจากเท็จเป็นจริงถูกแบ่งออกเป็นสองแถว สิ่งนี้ทำให้สามารถลบ 1 และ 2 จากแต่ละแถวเหล่านั้นได้ การลบ 1 จากแถวหนึ่งเป็นสิ่งจำเป็นเนื่องจากอ็อกเทฟคือ 1 ที่ได้รับการจัดทำดัชนีไม่ใช่การทำดัชนีเป็นศูนย์ การลบ 2 จากแถวที่สองเป็นสิ่งที่จำเป็นเพราะการfind(diff())ค้นหาตำแหน่งของค่าเท็จครั้งแรกในขณะที่เราต้องการมูลค่าที่แท้จริงสุดท้าย ส่วนการลบสามารถทำได้ใน Octave เท่านั้นไม่ใช่ใน 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 ไบต์

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

TTFTFTการป้อนข้อมูลคาดว่าเหมือน ลองมันออนไลน์

คำอธิบาย

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 ไบต์

การลองใช้แนวทางใหม่นี้ได้ผลจริงในครั้งนี้

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

ลองออนไลน์!

การป้อนข้อมูลเป็นสตริงที่มีFสำหรับfalseและสำหรับT trueเอาต์พุตเป็นอาร์เรย์ของอาร์เรย์ การเป็นตัวแทนสตริงทำให้ดูเหมือนว่าอาเรย์เดียว

มันทำงานอย่างไร

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

หมายเหตุ: ตอนนี้ฉันเห็นว่ามีหลายคนคิดอัลกอริทึมนี้แล้ว แต่ฉันค้นพบมันอย่างอิสระ

เวอร์ชันที่ไม่ใช่คู่แข่ง, 22 ไบต์

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

ในการกระทำล่าสุดของ GitHubฉันได้เพิ่มฟีเจอร์ใหม่: การเป็นผู้นำ;กำหนดตัวแปรA-J,Lให้เป็นค่าที่แตกต่างกัน Aถูกตั้งค่าเป็นอาเรย์ที่ว่างเปล่าจึงไม่จำเป็นต้องสร้างมันขึ้นมาเอง

Haskell, 74 ไบต์

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

ตัวอย่างการใช้งาน: ->map(\l->(fst$l!!0,fst$last l)).wordsBy(not.snd).zip[0..] $ [True,False,True,True,False][(0,0),(2,3)]

มันทำงานอย่างไร:

                               -- 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 ไบต์

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

นี่คือกริยา monadic ที่ไม่มีชื่อ (ฟังก์ชัน unary) ที่ส่งคืนอาร์เรย์ 2D หรือจำนวนเต็ม มันถูกใช้ดังนี้

  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

คำอธิบาย

[: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.

ทับทิม, 39

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

ตัวอย่างการร้องขอ:

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

นี่..คือวิธีที่ Ruby แสดงช่วงรวม

สิ่งหนึ่งที่น่าสนใจที่นี่คือวิธีที่ฉันได้ดัชนีของจุดสิ้นสุดของช่วง มันเป็นเรื่องแปลก. ฉันสร้างนิพจน์ทั่วไปที่ตรงกับอักขระตัวสุดท้ายของช่วงแบบไดนามิกจากนั้นอักขระที่ตามมาทั้งหมดและจุดสิ้นสุดของสตริงเพื่อบังคับให้จับคู่ที่ถูกต้อง จากนั้นฉัน=~จะใช้รับดัชนีของ regex นั้นในสตริงเดิม

สงสัยว่าอาจเป็นวิธีที่สั้นกว่าในการทำเช่นนี้ใน Ruby โดยใช้แฟล็ก -naF

JavaScript (ES6), 59

ฟังก์ชันที่ไม่ระบุชื่ออินพุตเป็นสตริงTและFส่งคืนเอาต์พุตเป็นอาร์เรย์ของอาร์เรย์

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

ทดสอบ

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 ตัวอักษร / 28 ไบต์

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

Try it here (Firefox only).

คำอธิบาย

ïħ`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 ไบต์

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

ใช้เป็นรายการของ 0 และ 1

ให้ลิสlต์ด้วย 0 ทั้งสองข้างและคำนวณรายการที่จัดทำดัชนีของคู่ที่ต่อเนื่องกัน ตัวอย่างเช่น

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

จากนั้นแยกดัชนีที่สอดคล้องกับองค์ประกอบที่ต่อเนื่องกัน(0,1)และ(1,0)ซึ่งเป็นจุดเริ่มต้นของบล็อก 0 และ 1 ลบออก 1 จากจุดเริ่มต้น 0 เพื่อให้ได้จุดสิ้นสุดของ 1 และซิปผลลัพธ์

Pyth, 19 18 ไบต์

m-VdU2cx1aV+ZQ+QZ2

คำอธิบาย:

             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

ลองมันนี่

Perl, 47 ไบต์

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

ด้วยตัวเลือก perlrun ต่อไปนี้-lpe:

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

ทางเลือกที่เอาต์พุตถูกคั่นด้วยเส้น (34 ไบต์)

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

Python 2, 108 ไบต์

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

กรณีทดสอบ:

$ 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]]

แน่นอนว่ามีวิธีแก้ปัญหาที่สั้นกว่านี้ แต่ใช้งานได้

Haskell: 123 ไบต์ (ตัวอย่างไม่สามารถชนะ)

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

หักกอล์ฟ:

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 ไบต์

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

อินพุตเป็นอาเรย์ของ CJAM ในลักษณะ0s และ1s เอาต์พุตเป็นอาร์เรย์สไตล์คู่ของ CJam

เรียกใช้กรณีทดสอบทั้งหมด (ดูแลการแปลงรูปแบบอินพุต)

Japt, 27 ไบต์

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

จะต้องมีวิธีในการลงเล่นกอล์ฟนี้ ...

อย่างไรก็ตามมันเหมือนกับคำตอบของฉัน

APL, 17 ตัวอักษร

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

ในและ⎕IO←0 ⎕ML←3เป็นภาษาอังกฤษ:

• ⍵×⍳⍴⍵: ศูนย์องค์ประกอบของเวกเตอร์ดัชนีตราบใดที่อาร์กิวเมนต์ที่อาร์กิวเมนต์เป็นเท็จ
• ⍵⊂: ตัดที่จุดเริ่มต้นของแต่ละวิ่งของความจริงและทิ้งของปลอม
• (↑,↑∘⊖)¨: ใช้องค์ประกอบแรกและสุดท้ายของแต่ละ subarray

PowerShell, 82 ไบต์

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

โซลูชัน Regex ใช้คุณสมบัติของวัตถุMatchInfo

ตัวอย่าง

PS > .\BoolRange.ps1 'F'


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

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

Mathematica ขนาด 45 ไบต์

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

ไม่น่าสนใจเป็นพิเศษ ใช้ builtin

Clojure 109 ตัวอักษร

#(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 %)))

สิ่งแรกที่มาถึงใจของฉันอยู่บนพื้นฐานและreducepartition-by

กรณีทดสอบอย่างง่าย (แผนที่TไปยังtrueและFไปยัง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]))