পুনরাবৃত্তি আইটেমের গ্রুপ

10

চ্যালেঞ্জের বিবরণ

আইটেমগুলির একটি তালিকা / অ্যারে দেওয়া, ক্রমাগত পুনরাবৃত্তি আইটেমগুলির সমস্ত গোষ্ঠী প্রদর্শন করুন।

ইনপুট / আউটপুট বিবরণ

আপনার ইনপুটটি আইটেমগুলির একটি তালিকা / অ্যারে (আপনি ধরে নিতে পারেন যে সেগুলি সমস্ত একই ধরণের)। আপনার ভাষার প্রতিটি প্রকারের আপনাকে সমর্থন করার দরকার নেই, তবে কমপক্ষে একটিকে সমর্থন করতে হবে (অগ্রাধিকার হিসাবে intতবে এর ধরণগুলি booleanখুব আকর্ষণীয় না হলেও এটি বেশ ভাল)। নমুনা আউটপুট:

[4, 4, 2, 2, 9, 9] -> [[4, 4], [2, 2], [9, 9]]
[1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4] -> [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
[1, 1, 1, 3, 3, 1, 1, 2, 2, 2, 1, 1, 3] -> [[1, 1, 1], [3, 3], [1, 1], [2, 2, 2], [1, 1], [3]]
[9, 7, 8, 6, 5] -> [[9], [7], [8], [6], [5]]
[5, 5, 5] -> [[5, 5, 5]]
['A', 'B', 'B', 'B', 'C', 'D', 'X', 'Y', 'Y', 'Z'] -> [['A'], ['B', 'B', 'B'], ['C'], ['D'], ['X'], ['Y', 'Y'], ['Z']]
[True, True, True, False, False, True, False, False, True, True, True] -> [[True, True, True], [False, False], [True], [False, False], [True, True, True]]
[0] -> [[0]]

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

[1, 1, 1, 2, 2, 3, 3, 3, 4, 9] ->

1 1 1
2 2
3 3 3
4
9

গুরুত্বপূর্ণ জিনিসটি কোনও উপায়ে দলগুলিকে আলাদা রাখা separated

code-golf  array-manipulation 
— shooqie
সূত্র
হতে পারে আমরা একটি তালিকা আউটপুট করব যার কিছু বিশেষ বিভাজক মান আছে?
— xnor
@ এক্সনর: আপনি একটি উদাহরণ দিতে পারেন? একটি অ্যারের intগুলি পৃথক দ্বারা, উদাহরণস্বরূপ, 0করা একটি খারাপ ধারণা হবে যেহেতু হতে পারে 0ইনপুটে গুলি ...
— shooqie
উদাহরণস্বরূপ, [4, 4, '', 2, 2, '', 9, 9]বা [4, 4, [], 2, 2, [], 9, 9]।
— xnor
আসলে, আমাদের কী ধরণের সমর্থন করতে হবে। উপাদানগুলি কি তাদের তালিকা হতে পারে? আমি কল্পনা করি কিছু ভাষার অন্তর্নির্মিত প্রকার রয়েছে যা মুদ্রণযোগ্য নয় বা অদ্ভুত সাম্যতা-পরীক্ষা করা যায় না।
— xnor
@ এক্সনর: হ্যাঁ, আমার উদ্বেগটি এটাই ছিল - যদি আপনার ইনপুটটির ভিতরে তালিকা থাকে তবে বিভাজক হিসাবে খালি তালিকা ব্যবহার বিভ্রান্তিকর হতে পারে। এই কারণেই আমি অন্তর্ভুক্ত করেছি "আপনি সমস্ত আইটেম একই ধরণের বলে ধরে নিতে পারেন", যাতে বিভাজক হিসাবে আলাদা ধরণের ব্যবহার করতে পারে।
— shooqie

উত্তর:

8

জেলি , 5 বাইট

I0;œṗ

সমস্ত সংখ্যার জন্য কাজ করে। এটি অনলাইন চেষ্টা করুন! বা সমস্ত সংখ্যার পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

I0;œṗ  Main link. Argument: A (array)

I      Increments; compute the differences of consecutive elements.
 0;    Prepend a zero.
   œṗ  Partition; split A at truthy values in the result to the left.
— ডেনিস
সূত্র
8

রেটিনা , 15 8 বাইট

একটি সহজ আই / ও ফর্ম্যাট পরামর্শ দেওয়ার জন্য লিনকে ধন্যবাদ।

!`(.)\1*

অক্ষরের তালিকা হিসাবে ইনপুটটিকে বিবেচনা করে (এবং পৃথক গোষ্ঠীতে লাইনফিড ব্যবহার করে)।

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

এটি কেবল গোষ্ঠীগুলির সাথে মিলে এবং সেগুলি মুদ্রণের মাধ্যমে কার্যকর হয় (যা স্বয়ংক্রিয়ভাবে লাইনফিড বিচ্ছেদ ব্যবহার করে)।

— মার্টিন ইন্ডার
সূত্র
আমি জানতে চাইলে abbcccddd→ a bb ccc dddএকটি গ্রহণযোগ্য ইনপুট / আউটপুট বিন্যাস হচ্ছে, এবং ও.পি., এটা অনুমোদন তাই আমি অনুমান !`(.)\1*ঠিক আছে তো?
— লিন 21
@ লিন ওহ, ধন্যবাদ এটি অনেক সহজ।
— মার্টিন ইন্ডার
4

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

f=
s=>s.replace(/(\w+) (?!\1\b)/g,`$1
`)
;
<input oninput=o.textContent=f(this.value);><pre id=o>
স্নিপেট প্রসারিত করুন

যে কোনও স্থান-বিভাজিত শব্দের মতো টোকেনগুলিতে কাজ করে। @ মার্টিনএেন্ডার to এর জন্য 2 বাইট সংরক্ষণ করা হয়েছে ♦ অ্যারে ইনপুট এবং রিটার্নের জন্য আমি সেরা করতে পারি 68:

a=>a.reduce((l,r)=>(l==r?c.push(r):b.push(c=[r]),r),b=[c=[a[0]]])&&b
— নিল
সূত্র
1
আমি 56
— edc65
4

MATL , 9 বাইট

Y'v"@Z}Y"

Y'     % Take input. Run-length encoding. Gives two row arrays: values and run lengths
v      % Concatenate vertically   
"      % For each column
  @Z}  %   Push column and split into its two elements
  Y"   %   Run-length decoding
       % End for. Implicitly display

ইনপুট হ'ল সংখ্যার একটি সারি অ্যারে , পৃথককারী হিসাবে স্পেস বা কমা সহ।

এটি অনলাইন চেষ্টা করুন! সঙ্গে টেস্ট অ পূর্ণসংখ্যা সংখ্যার ।

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

lidgvYsG7XQ

ইনপুট বিভাজক হিসাবে ব্যবহার করে উভয় সংখ্যা বা অক্ষরের কলাম অ্যারে ;।

এটি অনলাইন চেষ্টা করুন! স্বেচ্ছাসেবী সংখ্যার সাথে পরীক্ষা করুন । অক্ষর দিয়ে পরীক্ষা ।

l     % Push 1
i     % Take input, say [4;4;2;2;9;9]
d     % Consecutive differences of input: [0;-2;0;7;0]
g     % Convert to logical: gives 1 if consecutive entries were different: [0;1;0;1;0]
v     % Concatenate vertically with the initial 1: [1;0;1;0;1;0]
Ys    % Cumulative sum. Each value is a group label: [1;1;2;2;3;3]
G     % Push input again
7XQ   % Split into horizontal arrays as indicated by group labels: {[4 4];[2 2];[9 9]}
      % Implicitly display
— লুইস মেন্ডো
সূত্র
3

জিএস 2, 2 বাইট

c-

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

cএটি একটি অন্তর্নির্মিত অন্তর্নির্মিত যা হুবহু এটি করে, তাই আমরা এটি STDIN এ কল করি (যা একটি স্ট্রিং, অর্থাত্ অক্ষরের একটি তালিকা) এবং স্ট্রিংগুলির একটি তালিকা পাই। দুঃখের বিষয়, ফলাফলটি ইনপুট থেকে পৃথক করা যায়, তাই আমাদের পৃথককারী যুক্ত করতে হবে! -(স্পেস দ্বারা যোগদান) কৌশলটি করে।

একটি বিকল্প উত্তর হ'ল cα(সিপি 437 এর 2 বাইট), যা কেবল cএকটি বেনাম ফাংশনে আবৃত হয়।

— লিন
সূত্র
2

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

:{s.dl1}fs.c?

সতর্কতা: এটি চূড়ান্তভাবে অক্ষম, এবং আপনি ব্যাখ্যাতে কেন তা বুঝতে পারবেন।

এটি [1:1:2:2:2]ইনপুট হিসাবে একটি তালিকা (যেমন ) প্রত্যাশা করে । তালিকার ভিতরে থাকা উপাদানগুলি বেশ কিছু হতে পারে।

ব্যাখ্যা

:{     }f       Find all ordered subsets of the Input with a unique element in them
  s.                Output is a subset of the input
    dl1             Output minus all duplicates has a length of 1 (i.e. one unique value)
         s.     Output is an ordered subset of those subsets
           c?   The concatenation of those subsets is the Input

এটি কেবলমাত্র s - Subsetইউনিফর্ম করার কারণে কাজ করে : সবচেয়ে ছোট সেটগুলি শেষে রয়েছে। সুতরাং প্রথমটি এটি খুঁজে পায় যে ইনপুটটির সাথে মিল রেখে সবচেয়ে দীর্ঘতম রান হয়, উদাহরণস্বরূপ [[1:1]:[2:2:2]]এবং উদাহরণস্বরূপ নয় [[1:1]:[2:2]:[2]]।

— Fatalize
সূত্র
2

জে , 13 বাইট

<;.1~1,2~:/\]

যেহেতু জে রাগযুক্ত অ্যারেগুলি সমর্থন করে না, তাই সমান উপাদানগুলির প্রতিটি রান বক্স করা হয়। ইনপুট মানগুলির একটি অ্যারে এবং আউটপুট বাক্সযুক্ত অ্যারের অ্যারে।

ব্যবহার

   f =: <;.1~1,2~:/\]
   f 4 4 2 2 9 9
┌───┬───┬───┐
│4 4│2 2│9 9│
└───┴───┴───┘
   f 1 1 1 3 3 1 1 2 2 2 1 1 3
┌─────┬───┬───┬─────┬───┬─┐
│1 1 1│3 3│1 1│2 2 2│1 1│3│
└─────┴───┴───┴─────┴───┴─┘
   f 'ABBBCDXYYZ'
┌─┬───┬─┬─┬─┬──┬─┐
│A│BBB│C│D│X│YY│Z│
└─┴───┴─┴─┴─┴──┴─┘
   f 0
┌─┐
│0│
└─┘

ব্যাখ্যা

<;.1~1,2~:/\]  Input: s
            ]  Identify function to get s
       2       The constant 2
           \   Operate on each overlapping sublist of size 2
        ~:/      Are the two values unequal, 1 if true else 0
     1,        Prepend a 1 to it
<;.1~          Using the list just made, chop s at each index equal to 1 and box it
               Return this as the result
— মাইল
সূত্র
2

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

p=-1
for x in input():print"|"[:x^p],x,;p=x

বুলিয়ানদের তালিকায় কাজ করে। উদাহরণ:

>> [True,True,False,False,False,True,False,True,False]
 True  True | False  False  False | True | False | True | False

শেষ দেখা উপাদানটি সংরক্ষণ করে ইনপুট তালিকার মাধ্যমে আইট্রেটিস। পূর্ববর্তীের চেয়ে পৃথক পৃথক উপাদানের আগে একটি বিভাজক বারটি মুদ্রণ করা হয় ^, 0 এর বিটওয়াইজ জোর হিসাবে পরীক্ষা করা p=-1হয় প্রথম উপাদানটির আগে বিভাজককে এড়ানো শুরু করা হয় ।

— xnor
সূত্র
খুব খারাপ groupbyএকটি ব্যথা ...
— Sp3000
2

সিজেম, 9 বাইট

দুটি সমাধান:

{e`:a:e~}
{e`{(*}%}

এটি এখানে পরীক্ষা করুন।

ব্যাখ্যা

e`   e# Run-length encode (gives a list of pairs [run-length value]).
:a   e# Wrap each pair in a singleton list.
:e~  e# Run-length decode each list.

অথবা

e`   e# Run-length encode.
{    e# Map this block over each pair...
  (  e#   Pull out the run length.
  *  e#   Repeat the list containing only the value that many times.
}%
— মার্টিন ইন্ডার
সূত্র
2

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

import Data.List
group

একটি অন্তর্নির্মিত আছে। সাম্যকে সমর্থন করে এমন যে কোনও ধরণের কাজ করে।

— xnor
সূত্র
2
এটি সম্প্রদায়ের উইকি কেন কোনও কারণ?
— ফ্যাটালাইজ করুন
@ ফ্যাটালাইজ যে কেউ
— xnor
1
এটি মহৎ তবে অন্য যেহেতু কেউ এটি করছে না, আপনি মেটাতে কেন এটি সম্পর্কে জিজ্ঞাসা করবেন না?
— অবধি চিহ্নিত করুন
2

এমএটিএল, 8 7 বাইট

@ স্যুভারকে ধন্যবাদ 1 বাইট সরানো হয়েছে

ly&Y'Y{

পূর্ণসংখ্যা / ফ্লোট / চরগুলি / বুলিয়ানস / ইউনিকর্ন পয়েন্ট / অন্যান্য কাল্পনিক ইনপুটগুলির সাথে কাজ করে।
বুলিয়ানদের জন্য, ইনপুটগুলি হয় T/F, আউটপুট হয় 1/0।

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

দলবদ্ধ এবং পুনরাবৃত্তি

ly&Y'Y{
l          % push 1 onto the stack
 y         % duplicate the input
  &Y'      % run-length encoding (secondary output only)
     Y{    % break up array into cell array of subarrays
— পানপাত্র
সূত্র
1

সি #, 117 বাইট

void f(List<String>m){Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));}

অবারিত (সত্য নয়)

    public static void f(List<String>m)
    {
        Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));
    }
— downrep_nation
সূত্র
1

পাইথ, 9 7 বাইট

mr9]dr8

2 বাইটের জন্য @ লিকইনকে জমা দিন!

ব্যাখ্যা:

             input
     r8      run-length decode
m            for each...
   ]d        ...treat each run as standalone encoded form...
 r9          ...decode 
             print

পুরানো উত্তর, 12 বাইট

hf.Am!t{dT./

অন্তর্নির্মিত রান দৈর্ঘ্য সম্পর্কে ভুলে গেছেন, তবে আমি মনে করি এটি একটি ঠিক পদ্ধতি, তাই আমি এটি রেখেছি।

ব্যাখ্যা:

                input
          ./    all possible partitions
 f       T      filter by...
  .A            ...whether all groups of integers...
    m!t{d       ...have length one after deduplication
h               get the first element (first one has no adjacent [1,1] and [1])
                print
— busukxuan
সূত্র
এটি 7 বাইট
— লিকি নুন
পছন্দ করুন চমৎকার.
— বুসুক্সুয়ান
1
আমি বিশ্বাস করি এটি 6 এর জন্য কাজ করে
— FryAmTheEggman
@FryAmTheEggman নিস অপব্যবহার m।
— ফাঁস নুন
@ ফ্রাইআম দ্য এজম্যান ওয়াও, আমি ওও বুঝতে পারি না
— বুসুক্সুয়ান
1

পাইথ , 36 35 বাইট

VQIqNk=hZ).?=+Y]*]kZ=Z1=kN;t+Y]*]kZ

পরীক্ষার লিঙ্ক

সম্পাদনা: ব্যাখ্যা:

                                      standard variables: Y=[], Z=0, k='', Q=input
VQ                                    iterate over input
  IqNk                                if the current entity is equal to k:
      =hZ)                            increase Z.
          .?                          else:
               ]*]kZ                  list of length Z filled with k
            =+Y                       add it to Y
                    =Z1               set Z to 1
                       =kN            set k to the current entity
                          ;           end loop
                              ]*]kZ   list of length Z filled with k
                            +Y        add it to Y
                           t          implicitly print the tail of Y (removing the first element)
— Arfie
সূত্র
1

রেটিনা , 24 22 বাইট

মার্টিন ইন্ডারকে 2 বাইট ধন্যবাদ

একটি 15-বাইট উত্তর ইতিমধ্যে বিদ্যমান, সুতরাং এটি কেবলমাত্র অন্য পদ্ধতি যা আরও বাইট ব্যয় করে।

S-`(?<=(\d+)) (?!\1\b)

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

এটি এমন স্পেসে বিভক্ত হয় যার পূর্ববর্তী নম্বরটি এগিয়ে যাওয়ার চেয়ে পৃথক হয়।

এটি লুকোচুরির একটি প্রদর্শনী।

— ফুটো নুন
সূত্র
1

05 এ বি 1 ই, 13 বাইট

¬svyÊi¶}yðJ?y

ব্যাখ্যা

¬s             # push first element of list to stack and swap with input
  v            # for each X in input
   yÊi¶}       # if X is different from last iteration, push a newline
        yðJ?   # push X followed by a space to stack and join stack to string
            y  # push X to stack for next iterations comparison

যে কোনও তালিকার জন্য কাজ করা উচিত।
ইনট এবং চর নিয়ে পরীক্ষা করা হয়েছে ested

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

— Emigna
সূত্র
1

সুইফ্ট, 43 বাইট

var p=0;i.map{print($0==p ?"":",",$0);p=$0}

ধরে নিই আমি সমমানের বস্তুর একটি অ্যারে হতে পারি; কাস্টম অবজেক্টস থেকে স্ট্রিং থেকে স্ট্রিং পর্যন্ত যে কোনও কাজের জন্য কাজ করে। আউটপুটটিতে ধরণের ধরণের যে আউটপুটটিতে প্রচুর নতুন লাইনের উপস্থিতি রয়েছে তবে সেই প্রিটিটিয়ার তৈরি করা বাইটের জন্য ব্যয় করতে পারে।

প্রিটটিয়ার, অরগোল্ফড সংস্করণ:

var prev = Int.max // unlikely to be the first element, but not the end of the world if it happens to be.
i.map { n in
    print(n == prev ? " " : "\n•", n, terminator: "")
    prev = n
}

এই সংস্করণটি প্রতিটি কোডকে আরও বেশি কোডের ব্যয়ে একটি নতুন লাইনে মুদ্রণ করে।

উন্নতির জন্য ধারণা

i.reduce(0){print($0==$1 ?"":"•",$1);return $1}

এই সংস্করণটিতে 47 বাইট রয়েছে, তবে এটি একটি ভিন্ন পদ্ধতির, তাই সম্ভবত সেখানে অপ্টিমাইজ করার কিছু আছে? সবচেয়ে বড় সমস্যা হ'ল রিটার্ন স্টেটমেন্ট।

— juliand665
সূত্র
1

সি, 88 77 বাইট

সরানো হয়েছে strmcmp ভিতরে printf 11 বাইট সংরক্ষণ

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}

ব্যবহার:

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}
main(c,v)char**v;{f(v);}

নমুনা ইনপুট:

(কমান্ড লাইন প্যারামিটার)

1 1 1 1 2 2 2 2 3 3 3 3 4 5 6 7777

নমুনা আউটপুট:

1 1 1 1
2 2 2 2
3 3 3 3
4
5
6
7777

পরীক্ষিত:

gcc 4.4.7 (Red Hat 4.4.7-16)  - OK
gcc 5.3.0 (Cygwin)            - Segmetation Fault
gcc 4.8.1 (Windows)           - OK

আমি 5.3.0 সেগমেটেশন ফল্ট ঠিক করার চেষ্টা করছি।

88 সংস্করণ 

f(char**a){*a++;char*x;for(;*a;x=*a++)strcmp(*a,x)?printf("\n%s ",*a):printf("%s ",*a);}
— গিয়াকোমো গারাবেলো
সূত্র
1

জাভা 134 বাইট

void a(String[]a){int i=0,l=a.length;for(;i<l-1;i++)System.out.print(a[i]+((a[i].equals(a[i+1]))?" ":"\n"));System.out.print(a[l-1]);}

এর মাধ্যমে পুনরাবৃত্তি হয় এবং সিদ্ধান্ত নেয় যে কোনও নতুন লাইন বা কোনও স্থানের সাথে পৃথক করা হবে।

— রোহান ঝুনঝুনওয়ালা
সূত্র
স্টার্টার জন্য আপনি সরাতে পারে publicএবং staticকীওয়ার্ড। এছাড়াও আপনি লুপের জন্য কোঁকড়ানো বন্ধনীগুলি সরিয়ে ফেলতে পারেন
— user902383
সম্পন্ন @ ব্যবহারকারী 902383
— রোহান ঝুনঝুনওয়ালা
1

লিস্টশার্প , 134 বাইট

STRG l = READ[<here>+"\\l.txt"]
[FOREACH NUMB IN 1 TO l LENGTH-1 AS i]
{
[IF l[i] ISNOT l[i-1]]
STRG o=o+"\n"
STRG o=o+l[i]
}
SHOW = o

তালিকাশার্প ফাংশন সমর্থন করে না তাই অ্যারে বলা একটি স্থানীয় ফাইলে সংরক্ষণ করা হয় l.txt ফাইল

— downrep_nation
সূত্র
0

টিএসকিউএল, 132 বাইট

এটি অন্যান্য জবাবগুলির থেকে কিছুটা আলাদা - বর্গক্ষেত্রের অ্যারে নেই, স্কয়ারের স্পষ্ট ইনপুটটি একটি টেবিল table

Golfed:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT REPLICATE(v+' ',COUNT(*))FROM(SELECT i,i-row_number()over(partition
by v order by i)x,v FROM @)z GROUP BY x,v ORDER BY max(i)

Ungolfed:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT
  REPLICATE(v+' ',COUNT(*))
FROM 
  (
     SELECT
       i,
       i-row_number()over(partition by v order by i)x,
       v
     FROM @
  )z
GROUP BY
  x,v
ORDER BY
  max(i)

বেহালা

— t-clausen.dk
সূত্র
0

পাইক, 2 বাইট (প্রতিযোগিতামূলক নয়)

শুধুমাত্র পূর্ণসংখ্যার সমর্থন করে

$f

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

split_at(input, delta(input))

স্প্লিট_এটি নোড যুক্ত হয়েছে, ২ য় আর্গ সত্যবাদী হলে ইনপুট বিভক্ত হয়

— নীল
সূত্র
0

সেড, 33 23 + 1 = 24 বাইট

s/([^ ]+)( \1)* */&\n/g

এটি -rবিকল্প প্রয়োজন।

ব্যবহারের উদাহরণ:

$ echo '1 1 1 2 2 3 3 3 4 9 9' | sed -r 's/([^ ]+)( \1)* */&\n/g'
1 1 1 
2 2 
3 3 3 
4 
9 9
— মার্কো
সূত্র
0

জাভাস্ক্রিপ্ট (ES6), 56

ইনপুট: সংখ্যা বা স্ট্রিংয়ের অ্যারে

আউটপুট: অ্যারে এর অ্যারে

গল্ফড কোডটিতে প্রথমবারের মতো নির্ভুল তুলনা ব্যবহার করা

a=>a.map(x=>x!==p?o.push(g=[p=x]):g.push(x),p=o=g=[])&&o
— edc65
সূত্র
0

Clojure, 19 বাইট

#(partition-by + %)

এটি একটি অন্তর্নির্মিত, তবে এটি ম্যাপিংয়ের কাজ করে takes এই ক্ষেত্রে, +একটি পরিচয় ফাংশন হিসাবে কাজ করে।

— MattPutnam
সূত্র
0

জাভাস্ক্রিপ্ট (বাহ্যিক গ্রন্থাগার ব্যবহার করে) (178 বাইট)

(s)=>_.From(s).Aggregate((t,e)=>{if(0===t.Items.length)return t.Items.push([e]),t;var s=t.Items[t.Items.length-1];return s[0]===e?(s.push(e),t):(t.Items.push([e]),t)},{Items:[]})

দাবি অস্বীকার: আমি লিনাকু সি # থেকে জেএসে প্রয়োগের জন্য লিখেছিলাম একটি লাইব্রেরি ব্যবহার করছি। এটি আমাকে জিততে সহায়তা করে নি তবে ওহ ভাল

ভাবমূর্তি

Image2

— applejacks01
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.