একটি অ্যারে পরিবর্তনগুলি গণনা করুন

20

আপনার আজকের কাজটি এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা পূর্ণসংখ্যার অ্যারে নেয় এবং বারের সংখ্যা গণনা করে, এটি বাম থেকে ডানদিকে পড়ে, মানটি পরিবর্তন করে। উদাহরণ সহকারে এটি দেখানো সহজ:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

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

Input           |   Output
[]              |   0
[0]             |   0
[0 1]           |   1
[0 0]           |   0
[1 2 3 17]      |   3
[1 1 1 2 2 3]   |   2
[-3 3 3 -3 0]   |   3

এটি কোড-গল্ফ , সবচেয়ে কম বাইট জয়!

code-golf  array-manipulation 
— পাভেল
সূত্র
ফলাফলটি যদি সর্বদা সঠিকভাবে গণনা করা হয় তবে আমার উত্তরটি কি বৈধ, তবে যদি 0 Falseহয় তবে পরিবর্তে মুদ্রিত হয়?
— ফ্লিপট্যাক
1
@ ফ্লিপট্যাক যা ভাষার উপর নির্ভর করে। সাধারণভাবে, যদি আমি বলতে পারি 2+Falseএবং এটির ত্রুটি হয় তবে তা ঠিক নেই, তবে আমি যদি পাই তবে তা 2ঠিক।
— পাভেল
@FlipTack ডিফল্টরূপে, এই ঐক্যমত্য নেই।
— সম্পূর্ণরূপে
খালি আউটপুট 0গ্রহণযোগ্য?
— টাইটাস
@ টিটাস হ্যাঁ এটি
— পাভেল

উত্তর:

9

পাইথন 3 , 38 বাইট

f=lambda x=0,*y:y>()and(x!=y[0])+f(*y)

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

— ডেনিস
সূত্র
2
হু, আপনি কি জানেন যে আপনি এর মতো একটি ডিফল্ট আর্গ ব্যবহার করতে পারেন, দুর্দান্ত সন্ধান।
— xnor
— এরিক দি আউটগল্ফার
@ ডেনিস অ্যারে ফাঁকা থাকলে কীভাবে ফাংশনটি रिकर्सিভ লুপ থেকে প্রস্থান করবে? আমি দেখতে পাচ্ছি না কীভাবে এটি শেষ হয় না maximum recursion depth exceeded।
— Ioannes
@ আইওননেস একবার মাত্র একটি উপাদান ( এক্স ) বাকি থাকলে, মিথ্যা হিসাবেy>() মূল্যায়ন করবে , যাতে নিম্নলিখিত কোডটি কার্যকর হয় না। and
— ডেনিস
7

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

f(a:b:r)=sum[1|a/=b]+f(b:r)
f _=0

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

বোনাস: কিছুটা কৌতূহলী বিন্দু মুক্ত গাণিতিক সংস্করণ (৪৪ বাইট)

sum.(tail>>=zipWith((((0^).(0^).abs).).(-)))

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

একটি ইনপুট দেওয়া [1,1,4,3,3,3], তাই আমরা প্রথমেই সংলগ্ন এন্ট্রি (পার্থক্য নেওয়া [0,3,-1,0,0]), তারপর abs: olute মান [0,3,1,0,0]। প্রতিটি মৌলের শক্তিতে শূন্য নিলে প্রথম বারের ফলন হয় [1,0,0,1,1]এবং দ্বিতীয়বার তালিকার বিপরীত হয়: [0,1,1,0,0]( (1-)পরিবর্তে এখানেও কাজ করবে (0^))। অবশেষে আমরা sumতালিকাটি পেতে পেতে 2।

— Laikoni
সূত্র
5

ব্রেন-ফ্লাক , 50 বাইট

([][()]){{}({}[({})]){{}<>({}())(<>)}{}([][()])}<>

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

0 এর জন্য আউটপুট কিছুই না, যা মস্তিষ্কের ফ্ল্যাঙ্কের সমতুল্য। এটি যদি গ্রহণযোগ্য না হয় তবে এটি +4বাইটগুলির জন্য যুক্ত করার চেয়ে :({})

ব্যাখ্যা:

#Push stack-height-1
([][()])

#While true:
{

    #Pop the stack-height-1 off
    {}

    #If 'a' is the element on top of the stack, and 'b' is the element underneath it, then
    #Pop 'a' off, and push (a - b)
    ({}[({})])

    #If (a-b) is not 0...
    {
        #Pop (a-b) off
        {}

        #Switch stacks
        <>

        #Increment the value on the other stack
        ({}())

        #Push a 0 back to the main stack
        (<>)

    #Endif
    }

    #Pop either (a-b) or the 0 we pushed
    {}

    #Push stack-height-1
    ([][()])

#Endwhile
}

#Toggle to the alternate stack and display the counter
<>
— ডিজেএমসিএমহেম
সূত্র
2
— রিলে
@ রিলে সুন্দরভাবে সম্পন্ন হয়েছে! :)
— ডিজেএমসিমেহেম
— গম উইজার্ড
1
@ ওয়েট উইজার্ড আমি এটি চেষ্টা করেও খালি ইনপুটটিতে চিরকালের জন্য লুপ করে দেব। -0+1 = 1
— এইচ.পি.উইজ
5

ব্রেন-ফ্লাক , 50 বাইট

(([][()]){[{}]<({}[({})])>{(<{}>)()}{}([][()])}<>)

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

# Get ready to push the answer
(

# Push stack height - 1
([][()])

# Loop until 0 (until the stack has a height of 1)
{

  # Pop the old stack height and subtract it 
  #(cancels the loop counter from the final answer)
  [{}]

  # Pop the top of the stack and subtract the next element from that
  # Don't include this in the final answer
  <({}[({})])>

  # If not 0
  {

    # Pop the difference between the last two numbers
    # Don't include this in the final answer
    (<{}>)

    # Add 1 to the final answer
    ()

  # End if
  }{}

  # Push stack height - 1
  ([][()])

# End while
}

# Switch to the off stack so we don't print anything extra
<>

# Push the total sum. This is the number of times the if was true
)
— রিলে
সূত্র
1
10 কে প্রতিনিধির জন্য অভিনন্দন!
— পাভেল
@ পাভেল ধন্যবাদ! সর্বশেষ কয়েকশো পেতে আমাকে চিরতরে লেগেছিল। আমি অন্যান্য স্টাফ নিয়ে খুব ব্যস্ত হয়েছি :(
— রিলে
আমার কাছে তা থাকত এই
— H.PWiz
@ এইচ.পি.উইজ আমার এক পর্যায়ে ছিল, তবে আমি পছন্দ করি যে কীভাবে পপ স্ট্যাকের উচ্চতার ধাক্কা বাতিল করে।
— রিলে ২
5

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

-8 বাইট H.PWiz ধন্যবাদ।

পুনরাবৃত্ত সংস্করণ দ্বারা আউট গল্ফড । হাস্কেল পুনরাবৃত্তির দিক থেকে বেশ ভাল এবং আমি এটি মিস করেছি। >: _ <

f l=sum[1|x<-zipWith(/=)l$tail l,x]

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

এই টিপটি কীভাবে কাজে লাগানো যায় তা যদি কেউ জানতে পারে তবে দুর্দান্ত লাগবে ।

বিকল্প সমাধান, 36 বাইট

f l=sum[1|True<-zipWith(/=)l$tail l]

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

— totallyhuman
সূত্র
1
— এইচপিউইজ
এই টিপটি গুরুত্বপূর্ণ কাজটি বাদ দেয় যে এটির uncurryকাজটি fকরার জন্য আপনাকে ফাংশনটির প্রয়োজন । এই sum.map fromEnum.(zipWith(/=)=<<tail)সম্ভবত নিকটতম আপনি পেতে, কিন্তু এটা সাথে কাজ করবে না []এবং 37 বাইট ..
— ბიმო
5

জাভা (ওপেনজেডিকে 8) , 65 বাইট

আমি চাই যতটা সংক্ষিপ্ত নয়, তবে এটি কেবল আপনার জন্য জাভা।

কমা বিস্মৃত তালিকা হিসাবে অ্যারে পাস করে পরীক্ষা করুন।

a->{int s=0,i=1;for(;i<a.length;s+=a[i-1]!=a[i++]?1:0);return s;}

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

— লুক স্টিভেন্স
সূত্র
2
যদি খালি অ্যারেটি কোনও পরীক্ষার কেস না হত (এবং আমি এটি সত্যিই প্রাসঙ্গিক বলে মনে করি না, তবে) একটি ব্যবহার করতে পারে: a->{int s=0,p=a[0];for(int n:a)s+=p==(p=n)?0:1;return s;}(57 বাইট)।
— অলিভিয়ার
@ অলিভিয়ারগ্রোওয়ের আমি জানি! আমি এটি লিখেছিলাম এবং ভেবেছিলাম আমি বাইটগুলি কেটে ফেলতে পেরেছি তবে এটি প্রথম ক্ষেত্রে ব্যর্থ হয়েছিল।
— লুক স্টিভেনস
3
56 বাইট:a->{int s=0;for(int i:a)s+=a[0]!=(a[0]=i)?1:0;return s;}
— নেভায়ে
4

ওল্ফ্রাম ভাষা (গণিত) , ২৩24 26 29 বাইট

Length@Split@#~Max~1-1&

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

  • -1 বাইট ধন্যবাদ মার্টিন ইন্ডারকে!
  • -২ বাইট জংহওয়ান মিনকে ধন্যবাদ! সুন্দর ব্যবহার Split[]।
  • -3 বাইট পুরোপুরি মানবিক ধন্যবাদ!

একটু ব্যাখ্যা:

Splitতালিকার তালিকার (একই উপাদানগুলির) মধ্যে একটি অ্যারে বিভক্ত করবে, যা {1, 2, 2, 3, 1, 1}রূপান্তরিত {{1}, {2, 2}, {3}, {1, 1}}। সুতরাং, Length@Split@#ক্রমাগত segement পরিমাণ। ইনপুট Max[*****-1, 0]মোকাবেলা করতে ব্যবহৃত হয় {}।

— কিউ গান
সূত্র
1
— সম্পূর্ণরূপে
1
24 বাইট:Max[Length@Split@#-1,0]&
— জংহওয়ান ন্যূনতম
23:Length@Split@#~Max~1-1&
— মার্টিন ইন্ডার
4

প্রতীক পাইথন , 120 117 বাইট

কাউন্টের +ভেরিয়েবলের জন্য পূর্ণসংখ্যার (স্পষ্টতই ইউএনআর ব্যবহার করে ) স্পষ্ট কাস্ট অপসারণ করে গল্ফড 3 বাইট - এর অর্থ হ'ল অ্যারেটিতে কোনও পরিবর্তন না হলে আউটপুট Falseপরিবর্তে হবে 0, তবে এটি মেটা দ্বারা অনুমোদিত ।

___=-~(_==_)
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___)
_=___

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

# LINE 1: Generate value '2' for utility
___=-~(_==_)

# LINE 2: Get len(input) - 1
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
   '___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)'     # Generate string '___=~-len(_)'
            `_>_`[___::___]                       #    'le' spliced from 'False'
                           +`__`[-~___]           #    'n' indexed from '<function ...>'
   '___=~-'+                           +'(_)'     #    Remaining characters in plaintext
__(                                          )    # Execute this to get len(input) - 1

# LINE 3: Main calculation loop
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___) 
__(                                               ) # Execute:
   '__=___=_>_'                                     #   Set var1, var2 to 0
               +';                           '*___  #   len(input) - 1 times do:
                       _[__]!=_[-~__]               #   Compare input[var1, var1 + 1]
                  ___+=              ;              #   Add this to var2
                                      __=-~__       #   Increment var1

# LINE 4: Set output variable ('_') to the result calculated.
_=___
— FlipTack
সূত্র
2
= _ = এই জাদুকরীটি কী?
— সম্পূর্ণরূপে
3

জেলি , 3 বাইট

ITL

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

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

আইটিএল - সম্পূর্ণ প্রোগ্রাম।

আমি - বৃদ্ধি (ডেল্টাস)।
 টি - সত্যবাদী মানগুলির সূচকগুলি পান (অ-0 উপাদানের সূচকগুলি পান)।
  এল - দৈর্ঘ্য।
— মিঃ এক্সকোডার
সূত্র
3

আর , 24 বাইট

cat(sum(!!diff(scan())))

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

এমএটিএল উত্তর হিসাবে একই, ঠিক sum(!!diff))নেই যেহেতু নেই nnz।

— : Giuseppe
সূত্র
+1 আমি ভেবেছিলাম rleব্যবহারটি আরও ছোট হবে তবে কোনও কথা নয়, length(rle()$v)অনেকগুলি অক্ষর ব্যবহার করে এবং এটি বন্ধ হয়ে যায়।
— নিল ফুল্টজ
@ নিলফুল্টজ এটি উত্তর হিসাবে পোস্ট করা সম্ভবত এখনও মূল্যবান! অন্য পদ্ধতির দেখতে সর্বদা ভাল। এবং আপনার যাইহোক sum(rle()$v|1)পরিবর্তে ব্যবহার করা উচিত length। :)
— জিউসেপ
3

কিউবিক্স , 24 বাইট

UpO@0I>I!^-u>q.uvv$!^;)p

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

নোট করুন যে কিউবিক্স 0 ব্যবহার করে এটি নির্দেশ করে যে আরও ইনপুট নেই, তাই 0 তালিকায় থাকতে পারে না।

ব্যাখ্যা

দুচোখে:

    U p
    O @
0 I > I ! ^ - u
> q . u v v $ !
    ^ ;
    ) p

আমরা 0স্টার্টের উপরে কাউন্টারটি (আরম্ভ করা 0) এবং প্রথম ইনপুট ( I) টিপতে শুরু করি।

আমরা তখন লুপটি প্রবেশ করি enter লুপের প্রতিটি পুনরাবৃত্তিতে আমরা পরবর্তী ইনপুটটি পাই I। যদি এটি 0 হয়, আমরা ইনপুটগুলি শেষ করে ফেলেছি, তাই আমরা কাউন্টারটিকে শীর্ষে ( p), Oআউটপুট এবং প্রস্থান ( @) এ ঘোরান ।

অন্যথায়, আমরা শীর্ষ দুটি উপাদানের পার্থক্য নিই। যদি এটি ননজারো হয় তবে আমরা কাউন্টারটিকে শীর্ষে ঘোরান, এটিকে বাড়িয়ে তুলি এবং এটি দিয়ে নীচে ফিরে ঘোরান p)q। তারপরে আমরা ;পরবর্তী পুনরাবৃত্তিতে যাওয়ার আগে পার্থক্যটি পপ করি ।

এখানে বর্ণিত সমস্ত অক্ষর কেবল নিয়ন্ত্রণ প্রবাহ। কিউবিক্স প্রোগ্রামগুলিতে তাদের প্রচুর প্রবণতা রয়েছে।

@ মিকিটি ভাল পদ্ধতির কথা মনে হচ্ছে তবে আপনি 1 এর চেয়ে বেশি অঙ্কের হয়ে যাচ্ছেন বলে মনে হচ্ছে আপনি একটিটির 0জন্য অদলবদল করতে পারেন (তবে এটি খালি ইনপুটটিতে ব্যর্থ।
— দুঃখিত,
3

ব্রেন-ফ্লাক , 50 বাইট

(([][()]){[{}({}[({})])]{{}()(<()>)}{}([][()])}<>)

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

যেহেতু প্রত্যেকে এখানে তাদের 50 বাইট সমাধান পোস্ট করছে আমার (আমার একটি 48 বাইট রয়েছে তবে এটি ডিজেএমসিহেমের একটি সাধারণ পরিবর্তন ছিল তাই আমি এটি পোস্ট করার মতো অনুভব করেছি)

ব্যাখ্যা

এই উত্তরটি ব্যাপকভাবে মান বাতিলকরণ ব্যবহার করে।

আন-গল্ফ লাগছে মনে হচ্ছে

([][()])({<{}({}[({})])>{<{}>()(<()>)}{}<([][()])>}<>)

এখানে আমরা ব-দ্বীপের গণনা করি যতক্ষণ না স্ট্যাকের একটি আইটেম অবশিষ্ট থাকে, প্রতিবার আমরা অভ্যন্তরীণ লুপ থেকে একটি মান সংগ্রহ করি যদি ডেল্টটি শূন্য হয় না।

এটি করার এটি বেশ সহজ সরল পথ।

এই গোলফিটি তৈরি করতে আমরা মান বাতিল করা শুরু করি। যে কোনও দৃ brain় মস্তিষ্ক-ফ্লাক গল্ফারের কাছে প্রথমটি হ'ল স্ট্যাক হাইট। এটি একটি সুপরিচিত সত্য

([])({<{}>...<([])>}{})

এটার মতই

(([]){[{}]...([])}{})

মানগুলি যখন একটি দ্বারা সংশোধন করা হয়, একই হোল্ডগুলি। এটি আমাদের দেয়

(([][()]){[{}]<({}[({})])>{<{}>()(<()>)}{}([][()])}<>)

আপনি খেয়াল করতে পারেন এটি আমাদের বাইটগুলিও সংরক্ষণ করেনি, তবে হতাশ করবেন না যে আমরা এগিয়ে যাওয়ার সাথে সাথে এটি আরও কার্যকর হয়ে উঠবে।

আপনি যদি একটি বিবৃতি দেখেন তবে আমরা অন্য হ্রাস করতে পারি

<(...)>{<{}> ...

আপনি আসলে এটি হ্রাস করতে পারেন

[(...)]{{} ...

এটি কাজ করে কারণ যদি আমরা লুপটি প্রবেশ করি [(...)]এবং {}বাতিল হয়ে যাবে, এবং যদি আমরা [(...)]ইতিমধ্যে মানটি প্রথম স্থানে শূন্য না হয় এবং বাতিল করার দরকার নেই। যেহেতু আমাদের কোডটিতে আমাদের এই প্যাটার্নটির একটি উপস্থিতি রয়েছে তাই আমরা এটি হ্রাস করতে পারি।

(([][()]){[{}][({}[({})])]{{}()(<()>)}{}([][()])}<>)

এটি আমাদের 2 বাইট সংরক্ষণ করেছে কিন্তু এটি একে অপরের পাশে দুটি নেগসও রেখেছিল। এগুলি আমাদের আরও 2 বাঁচাতে একত্রিত হতে পারে।

(([][()]){[{}({}[({})])]{{}()(<()>)}{}([][()])}<>)

এবং এটি আমাদের কোড।

— গম উইজার্ড
সূত্র
3

গাইয়া , 2 বাইট

ėl

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

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

  • ė - দৈর্ঘ্যের এনকোডিং চালান (উপরে বর্ণিত ত্রুটিযুক্ত)।
  • l - দৈর্ঘ্য।
— মিঃ এক্সকোডার
সূত্র
2

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

a=>a.filter((e,i)=>e-a[i+1]).length
— নিল
সূত্র
আমি ভাবছি যদি এটি পুনরাবৃত্তি ব্যবহার করে সংক্ষিপ্ত করা যায়। তবে আমার সর্বোত্তম f=([a,...b])=>1/a?!!(a-b[0])+f(b):0
— চেষ্টাটি
@ আরনাউল্ড আমিও এটি চেষ্টা করেছিলাম, তবে ভুল হিসাব করে দেখেছি এটি ৩৩ বাইট, অন্যথায় আমি বিকল্প হিসাবে যুক্ত করতে পারতাম।
— নীল
2

এপিএল (ডায়ালগ) , 8 বাইট

+/2≠/⊃,⊢

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

কিভাবে?

⊃,⊢ - তালিকা, একক উপাদান ক্ষেত্রে প্রথম মান পুনরাবৃত্তি সঙ্গে

2≠/ - পরিবর্তন তালিকা, প্রতি 2 উপাদান জন্য সমান নয়

+/ - যোগফল

— ঊরীয়েল
সূত্র
2

পার্ল 5 , 37 + 2 ( -ap) = 39 বাইট

$\+=$F[$_]!=$F[$_-1]for 1..$#F}{$\|=0

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

— Xcali
সূত্র
আপনার উত্তরের ভিত্তিতে 34 বাইট: এটি অনলাইনে চেষ্টা করুন! । পরিবর্তে রিজেক্স ব্যবহার করে 31 বাইট: অনলাইনে চেষ্টা করে দেখুন!
— দাদা
2

রুবি , 31 বাইট

->a{a.chunk{|x|x}.drop(1).size}

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

— জর্ডন
সূত্র
পরিবর্তে .drop(1)আপনি এটি করতে পারেন[1..-1]
— সাইয়েস
@ কয়েস দুর্ভাগ্যক্রমে dropএকটি অ্যারে নয়, একটি এনুমরেটর ফিরিয়ে দিয়েছে, যাতে এটি কার্যকর হয় না।
— জর্দান
হাহ। এটি আমার সংস্করণে একটি অ্যারে প্রদান করে।
— সাইয়েস
@ কিয়োস কোন সংস্করণ?
— জর্ডান
আমি ১.৯.৩ এ আছি তবে কেন আপনি sizeকোনওভাবে অ্যারে নিতে পারবেন না ?
— সাইয়েস
2

সি (জিসিসি 5.4.0), 61 বাইট

f(c,v)int*v;{int*p=v,s=0;for(;p<v+c-1;s+=*p++!=*p);return s;}

অনলাইনে চেষ্টা করে দেখুন!

f অ্যারের দৈর্ঘ্য এবং অ্যারের প্রথম উপাদানটির দিকে একটি পয়েন্টার গ্রহণ করে এবং অ্যারে পরিবর্তনের সংখ্যাটি ফিরিয়ে নেওয়া একটি ফাংশন;

এই জমাটি অপরিজ্ঞাত আচরণ ব্যবহার করে (*p++!=*p জমাটি অপরিজ্ঞাত , পি এটির পরিবর্তিত একটি অভিব্যক্তিতে দুবার ব্যবহৃত হয়), যা আমার মেশিনে (জিসিসি 5.4.0) এবং টিআইওতে কাজ করে, তবে অন্যান্য বাস্তবায়ন বা সংস্করণে কাজ নাও করতে পারে।

ব্যাখ্যা:

f(c,v)int*v;{ // old-style declaration for v, and implicit-int for c and return value
    int*p=v,s=0; // p is a pointer to the current item, s is the number of changes
    for(;p<v+c-1;s+=*p++!=*p); // for each consecutive pair of integers, if they are different, add one to the number of changes
    return s; // return the number of changes
}
— pizzapants184
সূত্র
আপনি কি কোনও অনলাইন পরীক্ষার পরিবেশে একটি লিঙ্ক যুক্ত করতে পারেন?
— জোনাথন ফ্রেচ 29:25
@
— জোনাথনফ্রেচ
2

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

γ¦g

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

এরিকের উত্তরের বিকল্প।

γ¦g ~ সম্পূর্ণ প্রোগ্রাম।

equal equal সমান সংলগ্ন উপাদানের রানগুলিতে গ্রুপ করুন।
 ~ The প্রথম গ্রুপটি সরান (যদি থাকে তবে)।
  g ~ দৈর্ঘ্য।
— মিঃ এক্সকোডার
সূত্র
আহ, মিস করেছিলাম যে একটি কেস ছিল।
— ম্যাজিক অক্টোপাস উরন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.