चुनौती:

एक फ़ंक्शन या प्रोग्राम लिखें जो बूलियन मानों की सूची को स्वीकार करता है और ट्रू के सभी श्रेणियों को लौटाता है।

परीक्षण के मामलों:

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

नियम:

आप चुन सकते हैं कि इनपुट कैसे एनकोडेड है, उदाहरण के लिए सूची, सरणी, स्ट्रिंग, आदि।
आउटपुट को लिस्ट-लाइक या लिस्ट-स्ट्रिंग के रूप में एन्कोड किया जाना चाहिए, जैसे एरे, लिस्ट, ट्यूपल्स, मैट्रिसेस, वैक्टर आदि।
बूलियन मूल्यों को स्थिरांक के रूप में एन्कोड किया जाना चाहिए, लेकिन अन्यथा वांछित स्थिरांक को टी / एफ के किसी भी सरल रूपांतरण की अनुमति है
EDIT: रनटाइम के दौरान eval या समान IS की अनुमति है।
यह बताना न भूलें कि प्रोग्राम / फ़ंक्शन को इनपुट कैसे पास किया जाता है और परीक्षण मामलों के लिए उसका इनपुट / आउटपुट दिया जाता है
वांछित इनपुट प्रारूप में रूपांतरण की गणना नहीं की गई है
मानक खामियों को अस्वीकार कर दिया जाता है
यदि आपकी भाषा में ऐसा करने का कोई कार्य है, तो इसकी अनुमति नहीं है
मैं अपनी अधीनता स्वीकार नहीं करूंगा
EDIT: आउटपुट स्वरूप लचीला है। यदि कोई सूची या समान प्रिंट नहीं कर रहा है, तो रेंज मानों को एक गैर-संख्यात्मक चरित्र और अलग-अलग श्रेणियों द्वारा अलग किया जाना चाहिए।

स्कोरिंग:

स्कोर बाइट्स में है, जब तक कि आपकी भाषा के लिए अयोग्य न हो (जैसे कि पीट में कोडेल)
सबसे कम स्कोर जीतता है

इनपुट और आउटपुट में एक अच्छा लचीलापन है, लेकिन समाधान जहां टी / एफ को उन कार्यों से बदल दिया जाता है जो सभी कार्य बंद हैं।

डिबगिंग:

यदि आप हास्केल में अपना लिखते हैं या इसे हास्केल से बुला सकते हैं, तो निम्नलिखित आपके कार्य / कार्यक्रम की जांच करेगा:

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)

code-golf array-manipulation

— माइकल क्लेन
स्रोत

1

मुझे कुछ याद आ रहा है, लेकिन मैं इस बात का विवरण नहीं देखता कि आउटपुट में किसी रेंज का प्रतिनिधित्व कैसे किया जाता है।

— पीटर टेलर

1

क्या आउटपुट को 1-अनुक्रमित किया जा सकता है?

— 22 मई को LegionMammal978

क्या रेंज आधी-अनन्य हो सकती हैं?

— lirtosiast

1

@ LegionMammal978 केवल अगर आपकी भाषा डिफ़ॉल्ट 1-अनुक्रमित है, उदाहरण के लिए गणितज्ञ

— माइकल क्लेन

@ThomasKwa नहीं, "किनारे" के मामलों के लिए बहुत अलग लगता है

— माइकल क्लेन

7

पायथ, 17 16 बाइट्स

fT.b*Y,~+ZNtZrQ8

रन लंबाई एन्कोडिंग के साथ कुछ फैंसी पोस्ट-असाइन काउंटर जादू का उपयोग करता है।

0एस और 1एस की एक सरणी के रूप में इनपुट लेता है , जैसे [1, 1, 0, 1, 0]। चुनौती में जैसे आउटपुट, उदाहरण के लिए [[0, 1], [3, 3]]।

परीक्षण सूट

— orlp
स्रोत

मैंने एक परीक्षण सूट जोड़ा। यदि संपादन स्वीकृत है और कोई नहीं लेता है, तो आपके पास सबसे कम वैध उत्तर होगा।

— माइकल क्लेन

9

पायथ, 18 बाइट्स

CxR.:++~Zkz02_B_`T

परीक्षण सूट

ट्रू के रूप में सच का प्रतिनिधित्व किया 1जाता है 0।

रंगों का समावेश समावेशी रूप से किया जाता है।

— isaacg
स्रोत

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— lirtosiast

ज़रूर, कभी न कभी।

— isaacg

7

रेटिना , 82 34 27 बाइट्स

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

S_`:

खाली लाइन में एकल स्थान होना चाहिए।

इनपुट _सत्य के लिए और :असत्य के लिए एक फ्लैट स्ट्रिंग है । आउटपुट अंतरिक्ष-अलग जोड़े हैं, प्रत्येक एक अलग लाइन पर।

इसे ऑनलाइन आज़माएं।

व्याख्या

82 से 27 बाइट तक की भारी गोल्फिंग सही और गलत के प्रतिनिधित्व की चतुर पसंद द्वारा संभव थी। मैंने एक शब्द चरित्र चुना है _, (जो कि एक अंक नहीं है) सत्य के लिए और एक गैर-शब्द चरित्र, :और (जो कि भागने के लिए आवश्यक नहीं है)। यह मुझे शब्द सीमाओं के रूप में पर्वतमाला के छोर का पता लगाने की अनुमति देता है।

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

हम एक शब्द सीमा से मेल खाते हैं। हम उस सीमा को सत्य मान के संगत सूचकांक से बदलना चाहते हैं। सिद्धांत रूप में यह रेटिना की हाल की $#विशेषता के साथ काफी आसान है , जो एक समूह के कैप्चर की संख्या को गिनता है। हम बस प्रत्येक स्थिति को एक समूह में उस स्थिति के सामने रखते हैं। उन पात्रों को गिनकर हम स्थिति प्राप्त करते हैं। एकमात्र कैच यह है कि रेंज के सिरे एक-एक करके बंद हो जाते हैं। हम वास्तव में मैच के सामने चरित्र का सूचकांक चाहते हैं। यह भी आसानी से तय किया _जाता है, जो कि एक सीमा के अंत में होने पर एक पात्र को छोड़ देता है, जो कि कैप्चर नहीं किया जाता है।

_+
<space>

अब हम एक जगह के साथ अंडरस्कोर के सभी रन बदलते हैं। यही है, हम अंडरस्कोर से छुटकारा पाने के दौरान, प्रत्येक सीमा की शुरुआत और अंत के बीच एक जगह डालते हैं।

S_`:

वह कॉलन छोड़ देता है (और हमें अभी भी जोड़े अलग करने की आवश्यकता है)। हम प्रत्येक बृहदान्त्र के चारों ओर लाइनों में पूरे स्ट्रिंग को विभाजित करके करते हैं। Sसक्रिय मोड अलग हो गए, और _दबा खाली क्षेत्रों ऐसी है कि खाली लाइनों के टन नहीं मिलता है हम कोलन की रन है जब।

— मार्टिन एंडर
स्रोत

5

पायथन 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बहुत बदबूदार है। शायद पुनरावृत्ति बेहतर होगा,

— XNOR
स्रोत

5

MATL , 17 18 20 बाइट्स

j'T+'1X32X34$2#XX

भाषा / संकलक के वर्तमान संस्करण (9.1.0) का उपयोग करता है ।

इनपुट वर्ण युक्त एक स्ट्रिंग है Tऔर F। आउटपुट एक दो-पंक्ति तालिका है, जहां प्रत्येक कॉलम 1-इंडेक्सिंग का उपयोग करके एक सीमा को इंगित करता है, जो कि भाषा डिफ़ॉल्ट है।

2 बाइट्स निकालने के लिए Stewie Griffin का धन्यवाद ।

उदाहरण

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

— लुइस मेंडो
स्रोत

4

ऑक्टेव, 43 बाइट्स

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

find(diff([0,x,0]))उन सभी स्थितियों को ढूँढता है जहाँ इनपुट सरणी सही और गलत के बीच बदलती है। 2-बाय-एन मैट्रिक्स में इसे फिर से आकार देने से हम दो चीजें प्राप्त करते हैं: सच्चे से असत्य और असत्य से असत्य में परिवर्तन को दो पंक्तियों में विभाजित किया जाता है। यह उन पंक्तियों में से प्रत्येक से 1 और 2 को घटाना संभव बनाता है। पंक्ति 1 से घटाना आवश्यक है क्योंकि ऑक्टेव 1-अनुक्रमित है, शून्य-अनुक्रमित नहीं। पंक्ति दो से घटाना 2 आवश्यक है क्योंकि find(diff())पहले झूठे मूल्य की स्थिति का पता चलता है, जबकि हम अंतिम सही मूल्य चाहते हैं। घटाव हिस्सा केवल ओक्टेव में संभव है, 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

— स्टीवी ग्रिफिन
स्रोत

1

प्रसारण का अच्छा उपयोग!

— लुइस मेंडो

4

सीजेएम, 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

— Sp3000
स्रोत

4

जाप, 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एक खाली सरणी पर सेट किया जाता है, इस प्रकार इसे मैन्युअल रूप से बनाने की आवश्यकता को समाप्त कर देता है।

— ETHproductions
स्रोत

3

हास्केल, 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)]

— nimi
स्रोत

3

जे, 26 बाइट्स

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

यह एक अनाम मौद्रिक क्रिया (यूनीरी फ़ंक्शन) है जो 2 डी सरणी या पूर्णांक लौटाता है। इसका उपयोग निम्नानुसार किया जाता है।

  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.

— Zgarb
स्रोत

3

रूबी, ३ ९

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

यह ..है कि रूबी समावेशी श्रेणियों का प्रतिनिधित्व कैसे करती है।

यहां एक दिलचस्प बात यह है कि मुझे सीमा के अंत का सूचकांक कैसे मिलता है। यह अजीब है। मैं गतिशील रूप से एक नियमित अभिव्यक्ति बनाता हूं जो सीमा के अंतिम चरित्र से मेल खाता है, और फिर बाद के सभी पात्रों और स्ट्रिंग के अंत में सही मैच को मजबूर करने के लिए। फिर मैं =~मूल स्ट्रिंग में उस रेगेक्स के सूचकांक को प्राप्त करने के लिए उपयोग करता हूं ।

संदेह है कि -nF झंडे का उपयोग कर रूबी में ऐसा करने का एक छोटा तरीका हो सकता है।

— histocrat
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

— edc65
स्रोत

वाह, मैं अभी जाप में इसी समाधान के साथ आया था और इसे जेएस में अनुवाद करने वाला था। एक अच्छा :)

— ETHproductions

2

S, 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

— मामा फन रोल
स्रोत

2

हास्केल, 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 घटाते हैं और परिणामों को ज़िप करते हैं।

— XNOR
स्रोत

वाह, मुझे लगता है कि Haskell ले जाएगा की तुलना में अधिक वाक्यविन्यास झुकता है। क्या यह "fl = let s = zip3 [0 ..] (0: l) (l ++ [0]) के बराबर है zip [i | (i, 0,1) <- s] [i-1 | (i) | , 1,0) <- रों] "?

— माइकल क्लेन

1

@MichaelKlein हां, मैंने यहां नीमी से गार्ड में बाध्यकारी की चाल सीखी । यह लम्बी बाइंडिंग-थ्रू-लैंबडा के बराबर भी है f l=(\s->zip[i|(i,0,1)<-s][i-1|(i,1,0)<-s])$zip3[0..](0:l)$l++[0]।

— xnor

2

पायथ, 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

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

2

पर्ल, 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

— andlrc
स्रोत

1

अजगर 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]]

निश्चित रूप से इससे छोटा समाधान है, लेकिन यह काम करता है।

— quintopia
स्रोत

1

हास्केल: 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)))

— माइकल क्लेन
स्रोत

गोल्फ न होने पर भी: allTrue s e = and (subList s e)या शायद allTrue = (and.) . sublist।

— निम्मी

ठीक है, एक कारण के लिए मुझे याद नहीं है, मैंने सोचा था कि जब मैं असहमत था तो वह अधिक "स्पष्ट" था ... (संपादित)

— माइकल क्लेन

1

ओह, निश्चित रूप से, राय "स्पष्ट" पर अलग है। मुझे भी लगता all (==True) (subList s e)है कि यह बहुत स्पष्ट है।

— nimi

1

सीजेएम, 30 बाइट्स

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

0एस और 1एस के सीजेम-शैली सरणी के रूप में इनपुट । जोड़े के CJam- शैली सरणी के रूप में आउटपुट।

सभी परीक्षण मामलों को चलाएं। (इनपुट प्रारूपों के रूपांतरण की देखभाल करता है।)

— मार्टिन एंडर
स्रोत

1

जाप, 27 बाइट्स

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

यह नीचे गोल्फ के लिए एक रास्ता है ...

वैसे भी, यह मेरे as उत्तर के समान है।

— मामा फन रोल
स्रोत

वाह, मैं अभी खुद इस समाधान के साथ आया था .... अच्छा एल्गोरिथ्म!

— ETHproductions

1

एपीएल, 17 वर्ण

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

में ⎕IO←0और ⎕ML←3। अंग्रेजी में:

⍵×⍳⍴⍵: जब तक कि तर्क गलत है, तब तक तर्जनी के तत्वों को शून्य से बाहर निकालें
⍵⊂: सत्य के प्रत्येक रन की शुरुआत में कटौती और झूठे को दूर फेंक दें
(↑,↑∘⊖)¨: प्रत्येक उपप्रकार का पहला और अंतिम तत्व लें

— lstefano
स्रोत

0

पॉवरशेल, 82 बाइट्स

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

रेगेक्स समाधान, MatchInfo ऑब्जेक्ट के गुणों का उपयोग करके ।

उदाहरण

PS > .\BoolRange.ps1 'F'


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

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

— beatcracker
स्रोत

0

गणितज्ञ, 45 बाइट्स

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

विशेष रूप से दिलचस्प नहीं; एक बिलिन का उपयोग करता है।

— एक सीमन्स
स्रोत

0

क्लोजर, 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 %)))

पहली बात जो मेरे दिमाग में आई, उसके आधार पर reduceऔर partition-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]))

— NikoNyrh
स्रोत

किसी सूची में सच्चे मानों की श्रेणी खोजें

चुनौती:

परीक्षण के मामलों:

नियम:

स्कोरिंग:

डिबगिंग:

पायथ, 17 16 बाइट्स

पायथ, 18 बाइट्स

रेटिना , 82 34 27 बाइट्स

व्याख्या

पायथन 2, 69 बाइट्स

MATL , 17 18 20 बाइट्स

उदाहरण

व्याख्या

ऑक्टेव, 43 बाइट्स

सीजेएम, 27 25 बाइट्स

व्याख्या

जाप, 34 31 25 बाइट्स

यह काम किस प्रकार करता है

गैर-प्रतिस्पर्धी संस्करण, 22 बाइट्स

हास्केल, 74 बाइट्स

जे, 26 बाइट्स

व्याख्या

रूबी, ३ ९

जावास्क्रिप्ट (ईएस 6), 59

S, 18 चार्ट / 28 बाइट्स

व्याख्या

हास्केल, 62 बाइट्स

पायथ, 19 18 बाइट्स

पर्ल, 47 बाइट्स

अजगर 2, 108 बाइट्स

हास्केल: 123 बाइट्स (उदाहरण, जीत नहीं सकते)

सीजेएम, 30 बाइट्स

जाप, 27 बाइट्स

एपीएल, 17 वर्ण

पॉवरशेल, 82 बाइट्स

उदाहरण

गणितज्ञ, 45 बाइट्स