একটি তালিকার মধ্যে সত্য মানের সীমাগুলি সন্ধান করুন

Question

চ্যালেঞ্জ:

কোনও ফাংশন বা প্রোগ্রাম লিখুন যা বুলিয়ান মানগুলির একটি তালিকা গ্রহণ করে এবং সত্যের সমস্ত ব্যাপ্তি প্রদান করে।

পরীক্ষার কেস:

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

নিয়মাবলী:

• আপনি কীভাবে ইনপুট এনকোড করা চয়ন করতে পারেন, যেমন একটি তালিকা, অ্যারে, স্ট্রিং ইত্যাদি,
• আউটপুট অবশ্যই তালিকার মতো তালিকার মতো বা স্ট্রিংয়ের মতো স্ট্রিং হিসাবে এনকোড হওয়া আবশ্যক, সুতরাং অ্যারে, তালিকা, টিপলস, ম্যাট্রিকেস, ভেক্টর ইত্যাদি showing
• বুলিয়ান মানগুলি অবশ্যই ধ্রুবক হিসাবে এনকোড করা উচিত, তবে অন্যথায় পছন্দসই ধ্রুবকগুলিতে টি / এফের কোনও সহজ রূপান্তর অনুমোদিত
• সম্পাদনা: রানটাইম আইএস চলাকালীন ইয়াল বা অনুরূপ অনুমোদিত।
• কীভাবে প্রোগ্রাম / ফাংশনে ইনপুটটি পাস হয় তা ব্যাখ্যা করতে এবং পরীক্ষার ক্ষেত্রে এর ইনপুট / আউটপুট দিতে ভুলবেন না
• পছন্দসই ইনপুট বিন্যাসে রূপান্তর গণনা করা হয়নি
• স্ট্যান্ডার্ড লুফোলগুলি অনুমোদিত নয়
• আপনার ভাষার যদি এটি করার কোনও কার্য থাকে তবে এটি অনুমোদিত নয় it's
• আমি আমার নিজের জমা গ্রহণ করব না
• সম্পাদনা: আউটপুট ফর্ম্যাট নমনীয়। একটি তালিকা বা অনুরূপ মুদ্রণ না করা হলে, পরিসরের মানগুলি অবশ্যই একটি অ-সংখ্যাসূচক অক্ষর এবং পৃথক রেঞ্জ দ্বারা পৃথক করা উচিত।

স্কোরিং:

• স্কোরটি বাইটে থাকে, যদি না আপনার ভাষা (যেমন পিটে কোডেল)
• সর্বনিম্ন স্কোর জয়

ইনপুট এবং আউটপুটটিতে বেশ কিছুটা নমনীয়তা রয়েছে, তবে সমস্ত কাজ করার মতো ফাংশনগুলির সাথে টি / এফ প্রতিস্থাপনের সমাধানগুলি অনুমোদিত নয়।

ডিবাগিং:

আপনি যদি হাসকেলে লিখে থাকেন বা হাসকল থেকে ফোন করতে পারেন, নীচে আপনার কার্য / প্রোগ্রামটি যাচাই করবে:

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)

Comments

আমি কিছু অনুপস্থিত হতে পারে, তবে আউটপুটে কোনও ব্যাপ্তিটি কীভাবে উপস্থাপন করা হয় তার বিবরণ দেখতে পাচ্ছি না।

— পিটার টেলর

আউটপুটটি কি 1-সূচকযুক্ত হতে পারে?

— LegionMammal978

রেঞ্জগুলি কি অর্ধ-একচেটিয়া হতে পারে?

— lirtosiast

@ লিজিয়ানম্যামাল978 কেবলমাত্র যদি আপনার ভাষার ডিফল্ট 1-সূচিযুক্ত হয়, উদাহরণস্বরূপ ম্যাথমেটিকা

— মাইকেল ক্লিন

@ থমাসকওয়া নোপ, এটি "প্রান্ত" ক্ষেত্রে খুব আলাদা বলে মনে হচ্ছে

— মাইকেল ক্লেইন

Answer 1

পাইথ, 17 16 বাইট

fT.b*Y,~+ZNtZrQ8

রান দৈর্ঘ্যের এনকোডিংয়ের সাথে কিছু অভিনব পোস্ট-বরাদ্দ কাউন্টার যাদু ব্যবহার করে।

একটি অ্যারের হিসাবে ইনপুট লাগে 0s এবং 1গুলি, যেমন [1, 1, 0, 1, 0]। চ্যালেঞ্জের মতো ফলাফলগুলি যেমন, উদাহরণস্বরূপ [[0, 1], [3, 3]]।

পরীক্ষা স্যুট

Comments

আমি একটি পরীক্ষার স্যুট যুক্ত করেছি। যদি সম্পাদনা অনুমোদিত হয় এবং কেউ স্ন্যিপ করে না, আপনার কাছে সবচেয়ে সংক্ষিপ্ত বৈধ উত্তর রয়েছে।

— মাইকেল ক্লিন

Answer 2

পাইথ, 18 বাইট

CxR.:++~Zkz02_B_`T

পরীক্ষা স্যুট

সত্য হিসাবে প্রতিনিধিত্ব করা হয় 1, মিথ্যা হিসাবে 0।

পরিসীমা অন্তর্ভুক্তভাবে প্রতিনিধিত্ব করা হয়।

Comments

আপনি একটি ব্যাখ্যা যোগ করতে পারেন?

— lirtosiast

অবশ্যই, অন্য কোথাও।

— isaacg

Answer 3

রেটিনা , 82 34 27 বাইট

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

S_`:

খালি লাইনে একটি একক স্থান থাকা উচিত।

ইনপুট _সত্য এবং :মিথ্যা জন্য একটি সমতল স্ট্রিং । আউটপুট হল পৃথক লাইনে প্রতিটি পৃথক পৃথক জোড়।

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা

সত্য এবং মিথ্যা উপস্থাপনার চতুর পছন্দ দ্বারা 82 থেকে নীচে 27 বাইটে ভারী গল্ফিং সম্ভব হয়েছিল। _সত্যের জন্য আমি একটি শব্দের অক্ষর বাছাই করেছি , (এটি কোনও অঙ্ক নয়) এবং মিথ্যার জন্য একটি শব্দহীন অক্ষর :, (এটির জন্য পালানোর দরকার নেই)। এটি আমাকে শব্দের সীমানা হিসাবে ব্যাপ্তির শেষগুলি সনাক্ত করতে দেয়।

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

আমরা একটি শব্দ সীমানা মেলে। আমরা সেই সীমানাটি সত্যবাদী মানের সম্পর্কিত সূচকের সাথে প্রতিস্থাপন করতে চাই। নীতিগতভাবে এটি রেটিনার সাম্প্রতিক $#বৈশিষ্ট্যের সাথে বেশ সহজ , যা একটি গোষ্ঠীর ক্যাপচারের সংখ্যা গণনা করে। আমরা কেবল প্রতিটি চরিত্রকে সেই অবস্থানের সামনে একটি গোষ্ঠীতে ক্যাপচার করি। এই চরিত্রগুলি গণনা করে আমরা অবস্থানটি পাই। একমাত্র ক্যাচটি হ'ল রেঞ্জের প্রান্তগুলি এখন একের মধ্যে বন্ধ হয়ে গেছে। আমরা আসলে ম্যাচের সামনের অক্ষরের সূচিটি চাই want এটি সহজেই _capturedচ্ছিকভাবে কোনওটিকে ক্যাপচার না করে মেলাতে স্থির করা হয় , যার ফলে যখন আমরা কোনও পরিসীমা শেষে থাকি তখন একটি অক্ষর এড়িয়ে যায়।

_+
<space>

এখন আমরা আন্ডারস্কোরের সমস্ত রানকে একটি স্থান দিয়ে প্রতিস্থাপন করি। এটি হ'ল, আমরা আন্ডারস্কোরগুলি থেকে মুক্তি পেয়ে প্রতিটি রেঞ্জের শুরু এবং শেষের মধ্যে একটি স্থান সন্নিবেশ করি।

S_`:

এটি কলোনগুলি ছেড়ে যায় (এবং আমাদের এখনও জোড়া আলাদা করতে হবে)। আমরা প্রতিটি কোলনের চারপাশে সম্পূর্ণ স্ট্রিংকে লাইনে বিভক্ত করে এটি করি। SActives মোড বিভক্ত, এবং _শুষে খালি অংশ যেমন যে খালি লাইন টন পাবেন না আমরা কোলন এর রান আছে।

Answer 4

পাইথন 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চমত্কার দুর্গন্ধযুক্ত হয়। সম্ভবত পুনরাবৃত্তি ভাল হবে,

Answer 5

এমএটিএল , 17 18 20 বাইট

j'T+'1X32X34$2#XX

ব্যবহার বর্তমান সংস্করণ (9.1.0) ভাষা / কম্পাইলার করুন।

ইনপুট হ'ল একটি স্ট্রিং অক্ষর Tএবং F। আউটপুট একটি দ্বি-সারি সারণী, যেখানে প্রতিটি কলাম 1-ইনডেক্সিং ব্যবহার করে একটি সীমা নির্দেশ করে, যা ভাষা ডিফল্ট।

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

Answer 6

অক্টাভা, 43 বাইট

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

find(diff([0,x,0]))ইনপুট অ্যারেটি সত্য এবং মিথ্যা মধ্যে পরিবর্তিত হয় এমন সমস্ত অবস্থান সন্ধান করে। এটিকে 2-বাই-এন ম্যাট্রিক্সে রুপান্তরিত করে আমরা দুটি জিনিস অর্জন করি: সত্য থেকে মিথ্যা এবং মিথ্যা থেকে সত্যে পরিবর্তনগুলি দুটি সারিতে বিভক্ত। এটি সেই সমস্ত সারি থেকে 1 এবং 2 বিয়োগ করা সম্ভব করে। এক সারিতে 1 টি বিয়োগ করা আবশ্যক কারণ অক্টভেভ 1-সূচকযুক্ত, শূন্য-সূচকযুক্ত নয়। সারি দুটি থেকে 2 বিয়োগ করা প্রয়োজন কারণ find(diff())সন্ধানগুলি প্রথম মিথ্যা মানটির অবস্থান আবিষ্কার করে, যখন আমরা শেষ সত্যের মানটি চাই। বিয়োগের অংশটি কেবল অ্যাটাকভে সম্ভব, ম্যাটল্যাবে নয়।

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

Comments

সম্প্রচারের দুর্দান্ত ব্যবহার!

— লুইস মেন্ডো

Answer 7

সিজেম, 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

Answer 8

জাপট, 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একটি খালি অ্যারেতে সেট করা আছে, এভাবে ম্যানুয়ালি এটি তৈরির প্রয়োজনীয়তা দূর করে।

Answer 9

হাস্কেল, 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)]

Answer 10

জে, 26 বাইট

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

এটি একটি নামবিহীন monadic ক্রিয়া (আনরি ফাংশন) যা 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.

Answer 11

রুবি, 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

..কিভাবে রুবি সমেত রেঞ্জ প্রতিনিধিত্ব করে।

এখানে একটি আকর্ষণীয় বিষয় হ'ল আমি কীভাবে পরিসীমাটির শেষের সূচকটি পাই। এটা অদ্ভুত. আমি গতিশীলভাবে একটি নিয়মিত ভাব প্রকাশ করি যা পরিসরের শেষ চরিত্রের সাথে মেলে এবং তারপরে সমস্ত অক্ষর এবং স্ট্রিংয়ের শেষটি সঠিক ম্যাচটি জোর করার জন্য। তারপরে আমি =~মূল স্ট্রিংয়ের মধ্যে সেই রেজেক্সের সূচক পেতে ব্যবহার করি ।

সন্দেহ হয় রুবিতে -naF পতাকা ব্যবহার করে এটি করার আরও ছোট উপায় হতে পারে।

Answer 12

জাভাস্ক্রিপ্ট (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>

Comments

বাহ, আমি ঠিক জাপটে একই সমাধান নিয়ে এসেছি এবং এটি জেএসে অনুবাদ করতে চলেছিলাম। খুব সুন্দর :)

— ETH প্রোডাকশনগুলি

Answer 13

𝔼𝕊𝕄𝕚𝕟, 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

Answer 14

হাস্কেল, 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 টি বিয়োগ করে ফলাফলগুলি জিপ করে।

Comments

বাহ, সিনথ্যাক্সটি আরও বেশি মোড় করে ফেলেছিল যা আমি ভেবেছিলাম হাস্কেল নেবেন। এটি জিপ [i | (আমি, 0,1) <- এস] [আই -1 | (আমি) , 1,0) <- গুলি] "?

— মাইকেল ক্লিন

@ মিশেলক্লেইন হ্যাঁ, আমি এখান থেকে নিমির কাছ থেকে প্রহরীদের বাঁধাইয়ের কৌশলটি শিখেছি । এটি লম্বা বাঁধাই-ল্যাম্বদার সমতুল্য f l=(\s->zip[i|(i,0,1)<-s][i-1|(i,1,0)<-s])$zip3[0..](0:l)$l++[0]।

— xnor

Answer 15

পাইথ, 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

এখানে চেষ্টা করুন ।

Answer 16

পার্ল, 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

Answer 17

পাইথন 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]]

অবশ্যই এর চেয়ে একটি ছোট সমাধান আছে, তবে এটি কার্যকর হয়।

Answer 18

হাস্কেল: 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)))

Comments

এমনকি যখন গল্ফ না হয়: allTrue s e = and (subList s e)বা হতে পারে allTrue = (and.) . sublist।

— নিমি

ঠিক আছে, যে কারণে আমি মনে করি না, আমি ভাবছিলাম যখন আমি উচ্ছ্বসিত ছিলাম তখন এটি আরও "স্পষ্ট" ছিল ... (সম্পাদিত)

— মাইকেল ক্লেইন

ওহ, অবশ্যই, "পরিষ্কার" কি বিষয়ে মতামত পৃথক। আমিও মনে করি all (==True) (subList s e)খুব পরিষ্কার।

— নিমি

Answer 19

সিজেম, 30 বাইট

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

0এস এবং 1এস এর সিজেএম-স্টাইলের অ্যারে হিসাবে ইনপুট । জোসের সিজ্যাম-স্টাইলের অ্যারে হিসাবে আউটপুট।

সমস্ত পরীক্ষার কেস চালান। (ইনপুট ফর্ম্যাটগুলির রূপান্তর যত্ন নেয়))

Answer 20

জাপট, 27 বাইট

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

এটি নিচে গল্ফ করার একটি উপায় আছে ...

যাইহোক, এটি আমার উত্তর হিসাবে একই।

Comments

বাহ, আমি কেবল এই সমাধানটি নিজেই নিয়ে এসেছি .... চমৎকার অ্যালগরিদম!

— ইটিএইচ প্রডাকশনগুলি

Answer 21

এপিএল, ১rs টি চর

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

ইন ⎕IO←0এবং ⎕ML←3। ইংরেজীতে:

• ⍵×⍳⍴⍵: তত্ক্ষণাত তর্ক যতক্ষণ না ততক্ষণ সূচক ভেক্টরের উপাদানগুলি শূন্য করে নিন
• ⍵⊂: সত্যের প্রতিটি রানের শুরুতে কাটা এবং মিথ্যাগুলি ফেলে দিন
• (↑,↑∘⊖)¨: প্রতিটি সুবারে প্রথম এবং শেষ উপাদানটি নিন

Answer 22

পাওয়ারশেল, 82 বাইট

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

ম্যাচইনফো অবজেক্টের বৈশিষ্ট্যগুলি ব্যবহার করে রেইগেক্স সমাধান ।

উদাহরণ

PS > .\BoolRange.ps1 'F'


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

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

Answer 23

গণিত, 45 বাইট

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

বিশেষ আকর্ষণীয় নয়; একটি অন্তর্নির্মিত ব্যবহার করে।

Answer 24

ক্লোজার, 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]))