17

অনুপ্রেরণা : কখনও কখনও তালিকার নির্দিষ্ট আইটেমগুলি আপনার মোটের দিকে গণনা করে না। উদাহরণস্বরূপ, সারিগুলিতে বিমানের যাত্রীদের গণনা করা হচ্ছে, যেখানে বাচ্চারা পিতামাতার কোলে বসে থাকে।

চ্যালেঞ্জ : আইটেমের তালিকা খণ্ডগুলিতে বিভক্ত করার জন্য একটি প্রোগ্রাম লিখুন। প্রতিটি খণ্ড (সম্ভবত শেষ ব্যতীত) একই আকার , যেখানে আকার একটি প্রাকটিক ফাংশন পাস করার আইটেমের সংখ্যা হিসাবে সংজ্ঞায়িত করা হয়।

বিধি :

আপনার প্রোগ্রাম অবশ্যই নেওয়া উচিত
- আইটেমের একটি তালিকা
- ধনাত্মক পূর্ণসংখ্যার খণ্ড আকার
- একটি ভবিষ্যদ্বাণীপূর্ণ ফাংশন (একটি আইটেম লাগে, এবং সত্য বা মিথ্যা ফেরত)
আপনাকে অবশ্যই ইনপুট তালিকার খণ্ডগুলিতে বিভক্ত করতে হবে
প্রতিটি অংশ আইটেমের একটি তালিকা
সামগ্রিকভাবে আইটেমগুলি অবশ্যই একই ক্রমে থাকতে হবে, কোনওটিই অবহেলিত না করে
প্রতিটি খণ্ডে প্রাকটিকেট পাসের আইটেমের সংখ্যা (সম্ভবত শেষ ব্যতীত) ইনপুট খণ্ডের আকারের সাথে মেলে।
শিকারী ব্যর্থ আইটেমগুলি এই আকারের দিকে গণনা করা উচিত নয়
ভবিষ্যদ্বাণী ব্যর্থ আইটেম হয়
1. এখনও আউটপুট খণ্ডে অন্তর্ভুক্ত
2. প্রথম অংশে বরাদ্দ দেওয়া হয়েছে, যদি একটি অংশ "পূর্ণ" হয় তবে পরবর্তী আইটেমগুলি হ'ল প্রাকটিকাকে ব্যর্থ করে
  - সুতরাং চূড়ান্ত খণ্ডটি সম্পূর্ণরূপে ভবিষ্যদ্বাণী করতে ব্যর্থ আইটেম সমন্বিত নাও হতে পারে
চূড়ান্ত খণ্ডটি আকারের আকারের চেয়ে কম আকারের হতে পারে কারণ সমস্ত আইটেমের জন্য অ্যাকাউন্ট করা হয়েছে।

অসাধারণ উদাহরণ:

সবচেয়ে সহজ উদাহরণ হ'ল 1এস এবং 0এস বিবেচনা করা , যেখানে প্রিডিকেট ফাংশনটি রয়েছে x ==> x > 0। এই ক্ষেত্রে, sumপ্রতিটি অংশের অবশ্যই অংশের আকারের সাথে মেলে।

আইটেম :, []আকার 2:, প্রিডিকেট: x > 0-> হয় []বা হয়[[]]
আইটেম :, [0, 0, 0, 0, 0, 0]আকার 2:, প্রিিকেট: x > 0->[[0, 0, 0, 0, 0, 0]]
আইটেম :, [0, 1, 1, 0]আকার 2:, প্রিিকেট: x > 0->[[0, 1, 1, 0]]
আইটেম :, [0, 1, 1, 0, 1, 0, 0]আকার 2:, প্রিিকেট: x > 0->[[0, 1, 1, 0], [1, 0, 0]]
আইটেম :, [0, 1, 0, 0, 1, 0, 1, 1, 0]আকার 2:, প্রিিকেট: x > 0->[[0, 1, 0, 0, 1, 0], [1, 1, 0]]

এবং আসুন বিমানের যাত্রীরা যেখানে বাচ্চারা বাবা-মায়ের কোলের উদাহরণে বসে থাকে তাদের দিয়ে শেষ করি । Aপ্রাপ্তবয়স্কদের bজন্য, শিশুর জন্য, বিমানের সারিটি 3সীট বিস্তৃত, প্রাপ্তবয়স্কদের সর্বদা তাদের শিশুর আগে তালিকাভুক্ত থাকে:

আইটেম :, [A, b, A, b, A, A, A, b, A, b, A, A, b]আকার 3:, প্রিিকেট: x => x == A->[[A, b, A, b, A], [A, A, b, A, b], [A, A, b]]

code-golf set-partitions

— টম ভিনার
সূত্র

6

এটি দেখতে একটি ভাল প্রশ্নের মতো দেখাচ্ছে তবে বর্তমানে এটির একটি বিজয়ী মানদণ্ডের অভাব রয়েছে। আমি কোড-গল্ফ ব্যবহার করার পরামর্শ দিচ্ছি ।

— লাইকনি

3

আমরা কি ধরে নিতে পারি যে তালিকা আইটেমগুলি একক অক্ষর? অথবা, বলুন, সংখ্যা?

— xnor

কাটানো আকর্ষণীয় শোনায়, যদিও সেট-পার্টিশন দ্বারা প্রতিস্থাপন করা যেতে পারে ।

— জোনাথন ফ্রেচ

@ লাইকোনি ট্যাগ -কোড-গল্ফ

— টম

1

@ অরিস আমি যুক্ত করেছি "কারণ সমস্ত আইটেমের জন্য অ্যাকাউন্ট করা হয়েছে", অর্থাৎ শেষ অংশটি "ফুল আপ" পাওয়ার সুযোগ পাবে না, কারণ ইনপুট আইটেমগুলির এটিই শেষ the

— টম ভিনার

2

জেলি , 10 বাইট

vⱮTm⁵ḊœṖŒṘ

প্রথম বিকল্প icচ্ছিক যুক্তি হিসাবে monadic ব্ল্যাক-বাক্স ফাংশন গ্রহণ একটি সম্পূর্ণ প্রোগ্রাম, দ্বিতীয় বিকল্প optionচ্ছিক যুক্তি হিসাবে তালিকা এবং তৃতীয় alচ্ছিক যুক্তি হিসাবে খণ্ড আকার যা ফলাফলের তালিকার তালিকার একটি পাইথন উপস্থাপনা মুদ্রণ করে (জেলির নিখুঁত ছাঁচটি এড়াতে অক্ষর ধারণকারী তালিকা)।

এটি অনলাইন চেষ্টা করুন! (মনে রাখবেন যে জেলি প্রোগ্রামে অক্ষরের একটি তালিকা পাইথন উদ্ধৃত স্ট্রিং হিসাবে ফর্ম্যাট করে)

কিভাবে?

vⱮTm⁵ḊœṖŒṘ - Main Link: B, L, S
 Ɱ         - map across second argument with (i.e. for X in L):
v          -   evaluate as a monad with input (i.e. B(X))
  T        - truthy indices (e.g. [0,0,1,0,1,1,1,0,0,0,1,0,0]T -> [3,5,6,7,10])
    ⁵      - 3rd optional argument = S
   m       - modulo slice   (e.g. [3,4,7,9,12,15,16,18,19,20]m3 -> [[3,4,7],[9,12,15],[16,18,19],[20]]
     Ḋ     - dequeue        (e.g. [[3,4,7],[9,12,15],[16,18,19],[20]]Ḋ -> [[9,12,15],[16,18,19],[20]]
      œṖ   - partition right (L) at the indices in that
        ŒṘ - print Python representaion

— জোনাথন অ্যালান
সূত্র

8

ব্র্যাচল্যাগ , 37 বাইট

hW&t~c.k{↰₂ˢl}ᵐ;WxĖ∧.bhᵐ↰₂ᵐ∧.t↰₂ˢl≤W∧

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

আমি আনন্দদায়কভাবে অবাক হয়ে জানতে পেরেছিলাম যে এটি - প্রশ্নের পুনরায় পুনরুদ্ধার - সাফল্যের সাথে শেষ করে এবং সঠিক আউটপুট উত্পাদন করে।

অনুমান করা যায় যে এই কোডের নীচে প্রিডিকেট 2 হিসাবে উপস্থিত রয়েছে। তালিকার একটি তালিকা ("অংশগুলি"), বা falseএকটি খালি ইনপুট জন্য আউটপুট দেয়।

ব্যাখ্যা:

hW&               % First input is W, the expected "weight" of each chunk
                  %  (i.e. the number of items passing predicate in each chunk)

t                 % Take the second input, the list of items
 ~c.              % Output is a partition of this list
    k{    }ᵐ      % For each partition (chunk) except the last, 
      ↰₂ˢ         %   Select the items in the chunk that pass the predicate
         l        %   Get the length of that
                  % (So now we have the list of the "weights" of each chunk)
            ;Wx   % Remove the input expected weight from this list, and 
               Ė  %  the result of this should be empty.
                  %  This verifies that the list of weights is either 
                  %  composed of all W-values, or is empty (when input is [0 0 0] for eg.)

    ∧.bhᵐ↰₂ᵐ      % And, the first element of each chunk (except the first) should
                  %  pass the predicate. This is another way of saying:
                  %  "Items failing the predicate are allocated to the earliest chunk"

    ∧.t↰₂ˢl≤W     % And, the final chunk (which we haven't constrained so far)
                  %  should have weight ≤ the input expected weight
                  %  This disallows putting everything in the final chunk and calling it a day!

    ∧             % (no further constraints on output)

— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র

7

এপিএল (ডায়ালগ ইউনিকোড) 17 16 বাইট (এসবিসিএস)

আমাকে 1 বাইট বাঁচানোর জন্য আদমকে ধন্যবাদ।

w⊆⍨⌈⎕÷⍨1⌈+\⎕¨w←⎕

এটি অনলাইন চেষ্টা করুন! ব্যাখ্যা উদ্দেশ্যে আমি 17 বাইট সমাধান ছেড়ে দেব।

{⍵⊆⍨⌈⍺÷⍨1⌈+\⍺⍺¨⍵}

⍺⍺¨⍵aplies লিস্টে সম্পৃক্ত একটি বুলিয়ান ভেক্টর ফিরে
+\একটি চলমান মোট উত্পন্ন
1⌈প্রতিস্থাপিত নেতৃস্থানীয় 0s এর সাথে 1গুলি
⌈⍺÷⍨ভাগ খণ্ড আকার এবং চক্রের আপ দ্বারা প্রতিটি উপাদান
⍵⊆⍨পার্টিশন মূল ভেক্টর এই দ্বারা

— jslip
সূত্র

2

ঐটা চিত্তাকর্ষক! এবং আমি আউটপুট প্রদর্শন, সমস্যার জন্য উপযুক্ত ভিজ্যুয়াল পছন্দ করি।

— সূন্দর - মনিকা পুনরায় স্থাপন করুন

প্রোগ্রামে রূপান্তর করে একটি বাইট সংরক্ষণ করুন (tradfn বডি): w⊆⍨⌈⎕÷⍨1⌈+\⎕¨w←⎕

— অ্যাডাম

5

পরিষ্কার , 96 92 বাইট

f :: a -> Boolমেটা sensকমত্য অনুযায়ী অনুমোদিত নামযুক্ত ফাংশন ব্যবহার করে ।

import StdEnv,StdLib
$l n|l>[]=last[[i: $t n]\\i<-inits l&t<-tails l|n>=sum[1\\e<-i|f e]]=[]

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

প্রসারিত (মন্তব্যগুলি প্রদর্শন করতে ডিফল্ট হাইলাইট করে):

$ l n // define function $ on `l` and `n`
 | l > [] // if `l` is not the empty list
  = last [ // the last element of ...
                   \\ i <- inits l // prefixes of `l`
                    & t <- tails l // matching suffixes of `l`
                    | n >= // where n is greater than or equal to
                           sum [1 \\ e <- i | f e] // the number of matching elements in the prefix
          [i: $t n] // prepend that prefix to the application of $ to the rest of the list
         ]
 = [] // if `l` is empty, return empty

— Οurous
সূত্র

4

জাভা 10, 207 186 159 148 বাইট

a->n->{var r=new java.util.Stack();int l=a.size(),i=0,c=0,j=0;for(;i<=l;i++)if(i==l||f(a.get(i))&&++c>n&i>0){r.add(a.subList(j,j=i));c=1;}return r;}

জাভা অবশ্যই এই চ্যালেঞ্জের জন্য সঠিক ভাষা নয় (বা অবশ্যই কোনও কোডগল্ফ-চ্যালেঞ্জ ..)

-21 বাইট ধন্যবাদ @ ওউবালেন্সকে

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

ব্যাখ্যা:

a->n->{                    // Method with List & int parameters & List of Lists return-type
  var r=new java.util.Stack();
                           //  Result-list, starting empty
  int l=a.size(),          //  Size of the input-List
      c=0,                 //  Count-integer, starting at 0
      j=0,                 //  Range-integer, starting at 0
  i=0;for(;i<=l;i++){      //  Loop `i` in the range [0, `l`]
    if(i==l||              //   If this is the last iteration
       f(a.get(i))         //   Or if the black-box function is true for the current item
       &&++c               //    Increase the counter by 1
        >n&                //    If the counter is now larger than the size
        &i>0){             //    and it's not the first item of the List
      a.subList(j,j=i);    //     Add a sub-List to the result from range [`j`, `i`)
                           //     And set `j` to `i` at the same time
      c=1;}                //     And reset `c` to 1
  return r;}               //  Return the List of Lists as result

ব্ল্যাক বক্স ইনপুট ফর্ম্যাট:

অনুমিত একটি নামকৃত ফাংশন boolean f(Object i)উপস্থিত রয়েছে, যা এই মেটা উত্তর অনুসারে অনুমোদিত ।

আমার Testডিফল্ট ফাংশন f(i), পাশাপাশি উপরের ল্যাম্বদা সহ একটি বিমূর্ত শ্রেণি রয়েছে :

abstract class Test{
  boolean f(Object i){
    return true;
  }

  public java.util.function.Function<java.util.List, java.util.function.Function<Integer, java.util.List<java.util.List>>> c =
    a->n->{var r=new java.util.Stack();int l=a.size(),i=0,c=0,j=0;for(;i<=l;i++)if(i==l||f(a.get(i))&&++c>n&i>0){r.add(a.subList(j,j=i));c=1;}return r;}
  ;
}

পরীক্ষার ক্ষেত্রে, আমি এই ফাংশনটি ওভাররাইট করি f। উদাহরণস্বরূপ, শেষ পরীক্ষার কেসটি এভাবে বলা হয়:

System.out.println(new Test(){
  @Override
  boolean f(Object i){
    return (char)i == 'A';
  }
}.c.apply(new java.util.ArrayList(java.util.Arrays.asList('A', 'b', 'A', 'b', 'A', 'A', 'A', 'b', 'A', 'b', 'A', 'A', 'b'))).apply(3));

— কেভিন ক্রুইজসেন
সূত্র

1

" (or any codegolf-challenge of course..)" হ্যাঁ, আমি কম করে কিছু ক্ষেত্রে আমার পরিষ্কার উত্তরগুলি ছুঁড়ে ফেলেছি। যাইহোক, আমি সর্বদা আপনার উত্তরগুলির অপেক্ষায় থাকি।

— Οurous

2

@ Ousurous এটি মেমের আরও বেশি যে জাভা কোনওভাবেই কোডগল্ফের জন্য উপযুক্ত নয়, যা আমি অনুমান করি যে ক্লিনের ক্ষেত্রেও প্রযোজ্য পাশাপাশি যদি আমরা এটি জেলি, 05 এবি 1 ই ইত্যাদির মতো বাস্তব গল্ফ ভাষার সাথে তুলনা করি তবে আমি এখনও এই সমস্ত কোডগল্ফ-চ্যালেঞ্জগুলি সমাধান করতে উপভোগ করি জাভাতে যদিও (এবং আপনি ক্লিনের পাশাপাশি আমিও ধরে নিই) এবং একবার (দীর্ঘ) এর মধ্যে, জাভা পাইথনকে পরাস্ত করতে সক্ষম । ;) এবং আমি একবার জাভাতে শীর্ষস্থানীয় উত্তর ছিলাম , যতক্ষণ না বাশ এটি ধ্বংস করে দেয় (এবং আর আরও গল্ফ করেছিল)। এক্সডি

— কেভিন ক্রুইজসেন

1

আপনি অ্যারের তালিকাটি

— ফিরিয়ে

@ ওউবালেন্স ধন্যবাদ! স্মার্ট ব্যবহার Arrays.copyOfRange!

— কেভিন ক্রুইজসেন

ইনপুটটিকে তালিকা হিসাবে গ্রহণ করে এবং ব্যবহার করে @ ওউবালেন্স আরও কিছুটা গল্ফ করতে সক্ষম হয়েছে .sublist। এটির বাইরেও আপনার কার্যকারিতা একই থাকে তবে এটি প্রচুর বাইট সংরক্ষণ করে আমদানি সরিয়ে দেয়। (এবং এখন এটি পূর্ণসংখ্যার পরিবর্তে অক্ষরের সাথেও টেস্ট-কেসের পক্ষে কাজ করে))

— কেভিন ক্রুইজসেন

4

আর , 58 বাইট

function(v,g,n,a=(cumsum(Map(g,v))-1)%/%n)split(v,a*(a>0))

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

-5 বাইটস @ জিউজ্পে ধন্যবাদ

— digEmAll
সূত্র

1

58 বাইট

— জিউসেপ

3

সি (জিসিসি) , 70 66 বাইট

আমি একটি উপ-তালিকার শুরুতে লক্ষ্য রাখতে একটি কাঠামো ব্যবহার করি, কারণ সি এই জাতীয় জিনিসগুলি সম্পর্কে জানেন না।

পরামর্শের জন্য সিলিংক্যাট ধন্যবাদ।

t;f(a,s,c)l*a;int(*c)();{for(;a->v;a++)(t+=c(a->v))>s?t=++a->s:0;}

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

— ErikF
সূত্র

3

হাস্কেল, 72 বাইট

p#s|let l@(h:t)!a|sum[1|e<-h:a,p e]>s=a:l![]|n<-a++[h]=t!n;_!a=[a]=(![])

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

p#s     = (![])         -- main function that takes a predicate function 'p',
                        -- a size 's' and a input list without a name that is
                        -- directly passed as the first argument to function '!'
  let  l@(h:t)!a        -- function '!' is a local function (so that 'p' and 's'
                        -- are in scope). Takes a list 'l' of at least one element
                        -- 'h' (and 't' being the rest of the list) and an
                        -- accumulator 'a'
   |sum[1|e<-h:a,p e]>s -- if 'p' holds for more than 's' elements in 'h' and 'a'
     =a:l![]            --   put 'a' in front of a recursive call with the same list
                        --   'l' and an empty accumulator
   |n<-a++[h]           -- else bind 'n' to 'h' appended to 'a' and
     =t!n               --   call '!' again with 't' and 'n'
  _!a=[a]               -- base case for '!'. If the input list is empty, return
                        --   a singleton list with 'a'

— nimi
সূত্র

3

এমএটিএল, 19 বাইট

HyX$Ysi/Xk1y>+!w7XQ

Jslip এর দুর্দান্ত এপিএল উত্তরের ভিত্তিতে ।

এমএটিএল এর মতো ব্যবহারকারীর দ্বারা সংজ্ঞায়িত ফাংশনগুলি নেই, তবে এটি যে পরিবেশে চলছে তার সাথে যোগাযোগ করার উপায় রয়েছে (ম্যাটল্যাব / অক্টাভা), সুতরাং এটি প্রাকটিক ফাংশনটির জন্য এটি ব্যবহার করে। ব্যবহারের ভালো কিছু হবে এই , কিন্তু যে কার্যকারিতা নিরাপত্তার কারণে অনলাইন নিষ্ক্রিয় করা হয়েছে, তাই এখানে একটি সংস্করণ একটি হার্ডকোডেড ব্যবহার করে এর isoddপরিবর্তে সম্পৃক্ত ফাংশন: MATL অনলাইন এটি ব্যবহার করে দেখুন ।

H    % Push the function name to be called, assumed to be 
     %  stored in the H clipboard
y    % Take the first input, push copies of it both below and above the 
     %  function name
X$   % Call the function (say 'isupper') with the input as argument
     %  returns a boolean vector
Ys   % Cumulative sum
i/   % Take the chunk size and divide each element by it
Xk   % ceil
1y>+ % Turn the (initial) 0s to 1s
!    % Transpose. Now we have a column vector specifying which chunk 
     %  each input element should go into
w    % Bring the other copy of the input on top 
7    % Code for this function: '@(x){x.'}'
     %  i.e. place each chunk in a row vector and enclose it in a cell
XQ   % 'accumarray' - split the input into chunks based on
     %   the given column vector, apply the given function to each chunk
     %   (which here just wraps it up as a cell), and accumulate the results
     %   in an array.
     % implicit output

— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র

2

জাভাস্ক্রিপ্ট (ES6), 69 বাইট

3 টি বাইট সংরক্ষিত হয়েছে @tsh এর জন্য ধন্যবাদ

বাক্য গঠন সিনট্যাক্সে ইনপুট নেয় (size)(predicate)(array)।

s=>p=>g=a=>a.every(x=>p(x)?k--:++j,j=k=s)?[a]:[a.splice(0,j),...g(a)]

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

— Arnauld
সূত্র

2

s=>p=>g=a=>a.every(x=>p(x)?k--:++j,j=k=s)?[a]:[a.splice(0,j),...g(a)]

— tsh

@ টিএসএস নিস অপ্টিমাইজেশন। ধন্যবাদ!

— 30:47

2

রুবি , 57 বাইট

->a,n,g{c=-1;a.group_by{|x|[0,c+=g[x]?1:0].max/n}.values}

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

বেনামে ল্যাম্বদা ইনপুট অ্যারে a, খণ্ড আকার nএবং প্রিডিকেট গ্রহণ করছে g। cইতিমধ্যে ব্যবহৃত অংশগুলির সংখ্যা অনুসারে প্রিকেট এবং গ্রুপ আইটেমগুলির সাথে মেলে আইটেমগুলির একটি কাউন্টার বজায় রাখে । দুর্ভাগ্যক্রমে, প্রাথমিক মান -1 / n 0 এর বেশি হয় না, সুতরাং এটি ঠিক করতে আমাদের কয়েকটি বাইট ব্যয় করতে হবে।

— কিরিল এল।
সূত্র

2

আর , 100 বাইট

function(L,K,P,s=sapply(L,P),y=cut(cumsum(s),seq(0,sum(s),K),,T))for(l in levels(y))cat(L[y==l],"
")

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

digEmAll দ্বারা সহজেই ছাপিয়ে গেল

— : Giuseppe
সূত্র

আউটপুট হিসাবে নামের তালিকাগুলি ঠিক আছে কিনা তা আমি জানি না (এবং যদি আমি কোনও প্রান্তের মামলাটি মিস করি ...): 65 বাইট

— ডিগএমল

হুম ভাল আমি পোস্টটি একটি পৃথক উত্তর হিসাবে!

— জিউসেপ 19

1

পাইথন 2 , 92 বাইট

lambda a,c,p:reduce(lambda r,v:[r[:-1]+[r[-1]+[v]],r+[[v]]][sum(map(p,r[-1]+[v]))>c],a,[[]])

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

— চ্যাস ব্রাউন
সূত্র

1

জাভাস্ক্রিপ্ট (নোড.জেএস) , 90 বাইট

(s,p,r=[l=[]],n=s+1)=>g=a=>0 in a?g(a,(n=(n||s)-p(v=a.shift()))||r.push(l=[]),l.push(v)):r

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

হিসাবে আহ্বান F(2, x => x > 0)([0, 1, 1, 0])

— TSH
সূত্র

1

গণিত, 82 বাইট

f[l_,s_,p_]:=Last@Reap[i=t=-1;Do[If[p@e,If[++i~Mod~s==0&&i>0,t++]];e~Sow~t,{e,l}]]

Ungolfed:

f[l_,s_,p_] :=                (* define a function that takes three    *)
                              (* arguments                             *)

  Last@Reap[                  (* collect and return results which were *)
                              (* gathered by the procedural loop below *)

    i=t=-1;                   (* initialize two counters               *)

    Do[                       (* start iterating over the list         *)

      If[p@e,                 (* if element passes predicate           *)
        If[                   (* then if preincremented i is 0 modulo  *)
          ++i~Mod~s==0&&i>0,  (* chunk size and i > 0                  *)
          t++                 (* increment t                           *)
        ]
      ];e~Sow~t,              (* finally sow the element tagged with   *)
                              (* the current value of t                *)

    {e,l}]                    (* e references current element of list  *)
                              (* l is the list itself                  *)
  ]

lইনপুট তালিকা; sখণ্ড আকার; pতালিকার উপাদানগুলিতে সত্য / মিথ্যা অপারেটিং প্রদান করে এমন একটি নামবিহীন / বেনাম / বিশুদ্ধ / ল্যাম্বদা ফাংশন is

Last@Reap[...]Sowভিতরে থাকা প্রতিটি উপাদানগুলির তালিকার একটি তালিকা প্রদান করে ...। তাদের দ্বিতীয় যুক্তির দ্বারা সংক্ষিপ্তসার হিসাবে সাবলিস্টে বিভক্ত করা e~Sow~tহয়েছে Sow[e, t]।

আমাকে 1-এর আকারের আকারটি পরিচালনা করতে কাউন্টারগুলি শুরু করতে হয়েছিল, অন্যথায় আমার 1 Mod[i, s]( i~Mod~s1) সমান যাচাই করা দরকার , যা কখনই ঘটতে পারে না।

কোডটির বাকী অংশটি বর্ণহীন ব্লকে ব্যাখ্যা করা হয়েছে।

— LLlAMnYP
সূত্র

মাপের খণ্ডগুলিতে একটি তালিকা বিভক্ত করুন, তবে আইটেমের অনুমান হিসাবে ব্যর্থ হয়েছে

জেলি , 10 বাইট

কিভাবে?

ব্র্যাচল্যাগ , 37 বাইট

ব্যাখ্যা:

এপিএল (ডায়ালগ ইউনিকোড) 17 16 বাইট (এসবিসিএস)

পরিষ্কার , 96 92 বাইট

জাভা 10, 207 186 159 148 বাইট

আর , 58 বাইট

সি (জিসিসি) , 70 66 বাইট

হাস্কেল, 72 বাইট

এমএটিএল, 19 বাইট

জাভাস্ক্রিপ্ট (ES6), 69 বাইট

রুবি , 57 বাইট

আর , 100 বাইট

পাইথন 2 , 92 বাইট

জাভাস্ক্রিপ্ট (নোড.জেএস) , 90 বাইট

গণিত, 82 বাইট