দীর্ঘতম সমান উপসর্গ

18

সংজ্ঞা

  • একজন subsequence সংলগ্ন নাও হতে পারে, উদাঃ [1, 1, 1]একটি subsequence হয় [1, 2, 1, 2, 1]।
  • একটি সমান সাবকোয়েন্স হ'ল একটি অনুচ্ছেদ যা প্রতিটি উপাদান সমান।
  • দীর্ঘতম সমান অনুচ্ছেদটি অনন্য হতে পারে না, উদাহরণস্বরূপ [1, 1]এবং [2, 2]উভয়ই দীর্ঘতম সমান অনুচ্ছেদ [2, 1, 1, 2]।

ইনপুট

নীচের বিন্যাসের মধ্যে একটিতে ইতিবাচক পূর্ণসংখ্যার একটি খালি খালি তালিকা:

  • আপনার ভাষায় ইতিবাচক পূর্ণসংখ্যার অ্যারের নেটিভ বাস্তবায়ন হিসাবে
  • দশমিকের সাথে নিউলাইন-বিভাজিত পূর্ণসংখ্যার একটি স্ট্রিং হিসাবে
  • অ্যানারিতে নিউলাইন-বিচ্ছিন্ন পূর্ণসংখ্যার একটি স্ট্রিং হিসাবে
  • অন্য কোনও যুক্তিসঙ্গত বিন্যাস

আউটপুট

নীচের বিন্যাসগুলির মধ্যে যে কোনও ক্রমের দীর্ঘতম সমান উপসর্গ সমস্ত:

  • আপনার ভাষায় 2D নেস্টেড অ্যারে হিসাবে (যদি ইনপুটটি অ্যারে হয়)
  • সমতুল্য উপাদানগুলির সাথে সমতল হওয়ার সাথে একটি সমতল অ্যারে হিসাবে
  • অন্য কোনও যুক্তিসঙ্গত বিন্যাস

স্কোরিং

যদিও আমরা দীর্ঘ কিছু খুঁজছি, ব্যবহৃত কোডটি বাইটের সংখ্যার ক্ষেত্রে যতটা সম্ভব সংক্ষিপ্ত হওয়া উচিত, যেহেতু এটি কোড-গল্ফ

Testcases

ইনপুট:

[1, 2, 3]
[1, 2, 2, 1]
[1, 2, 3, 2, 1]
[1, 2, 1, 2, 3, 4, 1]

আউটপুট:

[[1], [2], [3]]
[[1, 1], [2, 2]]
[[1, 1], [2, 2]]
[[1, 1, 1]]

নোট করুন যে উপরের আউটপুটগুলির জন্য, কোনও অর্ডার বৈধ।

সমতুল্য উপাদানগুলি যতক্ষণ না সুস্পষ্ট ততক্ষণ একটি সমতল অ্যারেও বৈধ।

code-golf  array-manipulation 
— ফুটো নুন
সূত্র
4
আইএমও "সর্বাধিক ঘন ঘন উপাদানসমূহ" সম্পর্কে কথা বলা সহজ হবে: ক্রমটি গুরুত্বপূর্ণ যখন অর্ডারগুলি গুরুত্বপূর্ণ হয় তবে ব্যবহৃত হয়, তবে এখানে, প্রতিটি ইনপুটটির যথাযথ আউটপুটগুলির একই সেট থাকে।
— শ্রীভাতসার
@ শ্রীভতসারআর দুঃখিত, আমি প্রশ্নটি সম্পাদনা করেছি।
— ফাঁস নুন
ফ্ল্যাট তালিকা আউটপুট জন্য কাজ করে? যেমন 1 2 3, 1 1 2 2, 1 1 2 2, 1 1 1?
— কনর ও'ব্রায়েন
@ কনরও'ব্রায়েন হ্যাঁ বলে এখানে বেশিরভাগ উত্তর অকার্যকর করে দেবে ...
— লিকি নুন
@ লেকিউন হিসাবে আছে, এটি কি গ্রহণযোগ্য বিকল্প?
— কনর ও'ব্রায়েন

উত্তর:

8

জেলি , 5 বাইট

ĠLÐṀị

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

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

ĠLÐṀị  Main link. Argument: A (array)

Ġ      Group; partition the indices of A by their corresponding values.
 LÐṀ   Select all index arrays with maximal length.
    ị  Unindex; retrieve the items of A at the specified indices.
— ডেনিস
সূত্র
আমি ভেবেছিলাম জেলির সর্বোচ্চ তাত্পর্য নেই ...
— লিকি নুন
এটি প্রযুক্তিগতভাবে সর্বাধিক দ্রুত, তবে হ্যাঁ, এটি হয়।
— ডেনিস
5

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

⊇ᶠ=ˢlᵍh

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

ব্যাখ্যা

⊇ᶠ=ˢlᵍh
⊇ᶠ        Find all subsequences
  =ˢ      Keeping only those for which all elements are equal
    lᵍ    Group by length
      h   Take the first group

⊇এর প্রাকৃতিক শৃঙ্খলা প্রথমে দীর্ঘতম উপগোষ্ঠী উত্পন্ন করে, সুতরাং এগুলিই প্রথম গ্রুপে শেষ হয়।

1
ওহে আরে, আরেকজন ব্র্যাচলজিস্ট।
— ফাঁস নুন
1
কোনভাবেই আপনি এবং আমি ব্র্যাচল্যাগ চ্যাটে বার বার একে অপরকে মিস করেছি; আমি কয়েক মাস ধরে এটি ব্যবহার করে আসছি এবং অবাক হয়ে জানতে পেরেছিলাম যে ফ্যাটালাইজ ছাড়াও সম্ভবত অন্য কেউ ছিলেন।
5

পাইথ, 5 বাইট

S.M/Q

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

ব্যাখ্যা:

এটি স্পষ্টভাবে হয় S.M/QZQ। .Mসর্বাধিক ফাংশন, তাই .M/QZQসমস্ত উপাদান নির্বাচন করে যেখানে ইনপুটটিতে /QZউপাদানটির উপস্থিতিগুলির সংখ্যা গণনা করা হয়, সর্বাধিক। Sতারপরে তালিকাটি সাজান যাতে অভিন্ন উপাদানগুলি সামঞ্জস্যপূর্ণ হয়।

— isaacg
সূত্র
3

বাশ, 66 বাইট

sort|uniq -c|sort -rn|awk 'NR==1{a=$1}$1==a{for(i=a;i--;)print$2}'

এটি মনে হয় এটি আরও ছোট হওয়া উচিত, তবে কীভাবে তা আমি বুঝতে পারি না।

sort                  # sort the input
|uniq -c              # group runs of identical lines and prefix with count
|sort -rn             # sort by count, with largest at top
|awk '                # pipe to awk...
  NR==1{a=$1}         # on the first line, set the variable "a" to field 1
  $1==a{              # on any line, if first field is a (max count)...
    for(i=a;i--;)     # a times...
    print$2           # print the second field
  }
'

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

লিকি নুনকে 3 বাইটের জন্য ধন্যবাদ !

— ডোরকনব
সূত্র
— লিকি নুন
আপনার ব্যাখ্যা আপডেট করার বিষয়ে বিবেচনা করুন
— লিকি নুন
3

পাইথন 2 , 68 63 বাইট

lambda x:sorted(n for n in x if x.count(n)/max(map(x.count,x)))

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

— ডেনিস
সূত্র
পাইথন 3: পি-তে একটি উত্তর দেখতে চাই
— লিকি নুন
1
এটিকে পোর্ট করা তুচ্ছ । এটির printসাথে প্রতিস্থাপন করুন return।
— ডেনিস
ওহ, আমি ভেবেছিলাম পাইথন 3 নেই map।
— ফাঁস নুন
এটি 3 এ কিছুটা আলাদা (কোনও জেনারেটর ফেরত দেয় এবং দু'বার বেশি আর্গুমেন্ট থাকলে দীর্ঘতর পুনরাবৃত্ত হয়), তবে এটি সেখানে।
— ডেনিস
আমি ভেবেছিলাম পাইথনের একটি বিল্ট-ইন রয়েছে
— বিটা ডেকায়
2

গণিত, 42 31 25 বাইট

ধন্যবাদ 5 গ্রেটমার্টিনকে 5 বাইটের জন্য এবং @ মার্টিনইেন্ডার অন্য একটি বাইটের জন্য! 

MaximalBy[Length]@*Gather

ব্যাখ্যা

MaximalBy[Length]@*Gather  (*                       {1, 2, 3, 2, 1}       *)
                   Gather  (* Gather same numbers:  {{1, 1}, {2, 2}, {3}} *)
                 @*        (* Function composition                        *)
MaximalBy[Length]          (* Find longest:         {{1, 1}, {2, 2}}      *)
— জংহওয়ান মিন
সূত্র
1
এর সাহায্যে 5 টি বাইট সংরক্ষণ করতে পারবেন Gather@#~MaximalBy~Length&।
— গ্রেগ মার্টিন
2
@ গ্রেগমার্টিন এবং তারপরে MaximalBy[Length]@*Gather।
— মার্টিন ইন্ডার
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
2

স্ট্যাকড , 55 52 43 বাইট

sorted rle toarr:[1#]map MAX@K[1#K=]YES rld

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

ইনপুটটি রান-লেংথ এনকোডিং, ঘটনা অনুসারে বাছাই করা, সংঘটনগুলির সংখ্যা সর্বাধিক, এবং রান দৈর্ঘ্যের ডিকোডিংয়ের কাজ করে। চ্যালেঞ্জ হিসাবে গ্রহণযোগ্য হিসাবে একটি সমতল তালিকা মাধ্যমে আউটপুট ,.

— কনর ও ব্রায়ান
সূত্র
2

আসলে , 23 বাইট

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS

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

ওয়াই-বাইট উন্নতি দেখানোর জন্য লিকি নুনকে ধন্যবাদ যা সত্যই আমার কাছে স্পষ্ট হওয়া উচিত ছিল

রিলাক্সড আউটপুট ফর্ম্যাট থেকে -3 বাইট

ব্যাখ্যা:

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS
;╗                        save a copy of the input to register 0
  ⌠;╜ck⌡M                 for each value in the input list:
   ;                        make a copy on the stack
    ╜c                      count the occurrences in the input list (from register 0)
      k                     make a list: [value, count]
         ;♂N             make a copy, take last value of each list in the 2D list
            M╗           store the maximum count in register 0
              ⌠N╜=⌡░     filter the other copy of the list of [value, count] lists:
               N╜=         take items where the count equals the maximum count
                    ♂FS  take first items (values) and sort them
— ঐ মেগো
সূত্র
1

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

lambda l:[[x[0]]*x[1] for x in next(__import__('itertools').groupby(__import__('collections').Counter(l).most_common(),lambda x:x[1]))[1]]
— ফ্রান্সিসকো কুজো
সূত্র
itertoolsকখনই সংক্ষিপ্ত নয়: পি
— লিকি নুন
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
1

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

3#XMg1bX"&

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

ব্যাখ্যা

আমার অষ্টাভ উত্তর অনুরূপ। [10, 20, 30, 20, 10]উদাহরণ হিসাবে ইনপুট বিবেচনা করুন ।

3#XM   % Three-output version of mode function. Gives the first mode, the
       % number of repetitions, and a cell array with all modes
       % STACK: 10, 2, {10; 20}
g      % Convert from cell array to matrix
       % STACK: 10, 2, [10; 20]
1      % Push 1
       % STACK: 10, 2, [10; 20], 1
b      % Bubble up in the stack
       % STACK: 10, [10; 20], 1, 2
X"     % Repeat those number of times vertically and horizontally
       % STACK: 10, [10, 10; 20, 20]
&      % Specify that implicit display will show only the top of the stack.
       % Since this is singleton cell array that contains a matrix, that 
       % matrix is directly displayed
— লুইস মেন্ডো
সূত্র
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
@ লেকিউন আমাকে জানাতে ধন্যবাদ
— লুইস মেন্ডো
এটা আমার দায়িত্ব।
— ফাঁস নুন
1

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

[~,b,c]=mode(input(0));disp([repmat(c,1,b){:}])

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

ব্যাখ্যা

mode(হিসাবে প্রাপ্ত [~,b,c]=mode(...)) এর দ্বিতীয় এবং তৃতীয় আউটপুটগুলি যথাক্রমে পুনরাবৃত্তির সংখ্যা ( b) এবং cইনপুট ( input(0)) এর মধ্যে সবচেয়ে পুনরাবৃত্ত উপাদানগুলির একটি কলাম সেল অ্যারে ( ) দেয়। এর পরে সেল অ্যারেটি cঅনুভূমিকভাবে পুনরাবৃত্তি হয় b( repmat(c,1,b)), একটি কমা-বিচ্ছিন্ন তালিকায় রূপান্তরিত হয় ( {:}) এবং অনুভূমিকভাবে সংক্ষিপ্ত আকারে ( [...]) একটি সংখ্যার ম্যাট্রিক্স দেয় যা প্রদর্শিত হয় ( disp(...))।

— লুইস মেন্ডো
সূত্র
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
1

05 এ বি 1 ই , 8 5 বাইট

ক্রমে একটি ফ্ল্যাট তালিকা আউটপুট

.M¹Ã{

05AB1E এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!

— আদনান
সূত্র
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
@LakakyNun বিজ্ঞপ্তিটির জন্য ধন্যবাদ :)
— আদনান
1

সিজেম , 22 বাইট

{$e`z~\__:e>f=.*\]ze~}

এটি একটি বেনামে ব্লক (ফাংশন) যা স্ট্যাকের শীর্ষ থেকে ইনপুট নেয় এবং আউটপুট দিয়ে এটি পুনরায় স্থান করে। আউটপুটটি একটি সমতল ধরণের অ্যারে ওয়াইভুয়াল উপাদানগুলি সংলগ্ন।

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

ব্যাখ্যা

[10 20 30 20 10 ]উদাহরণ হিসাবে ইনপুট বিবেচনা করুন ।

{      e# Begin block
       e#   STACK: [10 20 30 20 10]
  $    e#   Sort
       e#   STACK: [10 10 20 20 30]
  e`   e#   Run-length encoding
       e#   STACK: [[2 10] [2 20] [1 30]]
  z    e#   Zip
       e#   STACK: [[2 2 1] [10 20 30]]
  ~    e#   Dump array contents onto the stack
       e#   STACK: [2 2 1] [10 20 30]
  \    e#   Swap
       e#   STACK: [10 20 30] [2 2 1]
  __   e#   Duplicate twice
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] [2 2 1]
  :e>  e#   Fold maximum over array. Gives the maximum of the array
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] 2
  f=   e#   Map "is equal" with number (2) over the array ([2 2 1])
       e#   STACK: [10 20 30] [2 2 1] [1 1 0]
  .*   e#   Vectorized multiplication
       e#   STACK: [10 20 30] [2 2 0]
  \    e#   Swap
       e#   STACK: [2 2 0] [10 20 30]
  ]    e#   Pack into array
       e#   STACK: [[2 2 0] [10 20 30]]
  z    e#   Zip
       e#   STACK: [[2 10] [2 20] [0 30]]
  e~   e#   Run-length decoding
       e#   STACK: [10 10 20 20]
}      e# End block
— লুইস মেন্ডো
সূত্র
0

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

দরকার ⎕ML←3যা অনেক সিস্টেমে পূর্বনির্ধারিত।

কার্যক্রম: s/⍨(⌈/=⊢)≢¨s←⊂⍨(⍋⊃¨⊂)⎕

⎕ সংখ্যার (মূল্যায়ন) ইনপুট পান

(…  পুরো অ্যারে  থেকে প্রতিটি বাছাই করা  আরোহণের আইটেমের সূচকগুলিকে ) সক্রিয় করুন
 ⍋
 ⊃¨
 ⊂

⊂⍨ এর বৃদ্ধি কাটা দ্বারা বিভাজন

s←এস  হিসাবে সঞ্চয়

≢¨ ট্যালি প্রতিটি

(… ) স্বতন্ত্র ফাংশন
 ⌈/ সর্বাধিক (ট্যালি)
 = সমান
 ⊢ আর্গুমেন্টের (টালিজ)

s/⍨ ফিল্টার এস সঙ্গে

ফাংশন: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{… } যুক্তি যেখানে বেনাম ফাংশন⍵

⍵[⍋⍵] বাছাই করুন (লিট। উপরে আরোহণের আইটেমের সূচকগুলি সহ)

⊂⍨ এর বৃদ্ধি কাটা দ্বারা বিভাজন

s←এস  হিসাবে সঞ্চয়

≢¨ ট্যালি প্রতিটি

(… ) স্বতন্ত্র ফাংশন
 ⌈/ সর্বাধিক (ট্যালি)  আর্গুমেন্টের
 = সমান
 ⊢(টালিজ)

s/⍨ ফিল্টার গুলি যে সঙ্গে এটি অনলাইন ব্যবহার করে দেখুন!

— আদম
সূত্র
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
0

পিএইচপি, 69 বাইট

<?print_r(preg_grep("#".max($r=array_count_values($_GET))."#",$r));

অনলাইন সংস্করণ

আউটপুট ফরমেট

কী = মান, মান = গণনা

Array
(
    [1] => 2
    [2] => 2
)

পিএইচপি, 96 বাইট

<?foreach($_GET as$v)$r[$m[]=count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;print_r($r[max($m)]);

অনলাইন সংস্করণ

আউটপুট ফরমেট

1 ডি কী = মান

2 ডি কী = প্রতিটি মানের জন্য ইনপুট অ্যারেতে অবস্থান

Array
(
    [1] => Array
        (
            [0] => 1
            [4] => 1
        )

    [2] => Array
        (
            [1] => 2
            [3] => 2
        )

)

পিএইচপি, 97 বাইট

<?foreach($_GET as$v)$r[count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;ksort($r);print_r(end($r));
— জার্গ হালসারম্যান
সূত্র
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
0

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

একটি বাছাই করা সমতল ধরণের অ্যারে প্রদান করে।

a=>a.sort().filter((_,i)=>b[i]==Math.min(...b),b=a.map(i=>a.filter(j=>i-j).length))

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
@LakakyNun বিজ্ঞপ্তির জন্য ধন্যবাদ।
— আর্নল্ড
0

সিজেম, 24 বাইট

{$e`_$W=0=\{0=1$=},e~\;}

আমি 05ab1e এ এটি করতে চেয়েছিলাম, কিন্তু আমি ছেড়ে দিয়েছি: পি

এটি একটি ব্লক। ইনপুট এবং আউটপুট স্ট্যাকের অ্যারে হয়।

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

ব্যাখ্যা:

{                      e# Stack:                | [1 2 3 2 1]
 $                     e# Sort:                 | [1 1 2 2 3]
  e`                   e# RLE encode:           | [[2 1] [2 2] [1 3]]
    _$W=               e# Copy elements:        | [[2 1] [2 2] [1 3]] [2 1]
       0=              e# First element:        | [[2 1] [2 2] [1 3]] 2
         \             e# Swap:                 | 2 [[2 1] [2 2] [1 3]]
          {0=1$=},     e# Filter where x[0]==2: | 2 [[2 1] [2 2]]
                  e~   e# RLE decode:           | 2 [1 1 2 2]
                    \; e# Delete back:          | [1 1 2 2]
                      }
— ফল ফল
সূত্র
ক্ষুদ্রতম পূর্ণসংখ্যার সর্বাধিক সাধারণ উপাদানগুলির সাথে সম্পর্কিত হলে এটি কাজ করে। $W=প্রথমটির পরিবর্তে আপনার প্রয়োজন হবে 0=।
— মার্টিন এন্ডার
আমি আরেকটি গ্রহণযোগ্য বিকল্প যুক্ত করেছি যা আপনাকে কিছু বাইট বন্ধ করে দেওয়া গল্ফকে সহায়তা করতে পারে।
— লিকি নুন
0

Clojure, 65 বাইট

#(let[P partition-by C count](last(P C(sort-by C(P +(sort %))))))

Ungolfed:

(def f #(->> %
             (sort-by      identity)   ; sort so that identical values are one after another, same as sort
             (partition-by identity)   ; partition by identity (duh!)
             (sort-by      count)      ; sort by item count
             (partition-by count)      ; partition by item count
             last))                    ; get the last partition
— NikoNyrh
সূত্র
0

সি #, 145 বাইট

l=>{var t=Enumerable.Range(0,l.Max()+1).Select(i=>l.Count(a=>a==i));return t.Select((a,i)=>Enumerable.Repeat(i,a)).Where(d=>d.Count()==t.Max());}

এটি অবশ্যই আরও ভাল হওয়া সম্ভব, তবে আমি একরকম আটকে রয়েছি।

ব্যাখ্যা

l =>                                                   //Takes the list
{                                                      //...
    var t = Enumerable.Range(0, l.Max() + 1)           //Makes a range till the count, so that the items together with their indices are double defined (i.e. the items are 0,1,2,3... and the indices are the same)
                      .Select(i =>                     //Takes the items
                          l.Count(a => a == i));       //And replaces them with the count of themselves in the list (so the item has the index with its old value and the count as it's actual value)
    return t.Select((a, i) =>                          //Then it takes this list and selects the items together with the indices
        Enumerable.Repeat(i, a))                       //Repeats them as often as they appeared in the list
                  .Where(d => d.Count() == t.Max());   //And just keeps those which appear the maximum amount of times
};                                                     //...

সম্ভবত একটি সম্পূর্ণ ভিন্ন পদ্ধতির পরিমাণ আরও খাটো হবে, সুতরাং সি # চ্যালেঞ্জ এখনও খোলা আছে :)

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