পারফেক্ট প্যালিনড্রোমস

25

আপনার কাজটি হ'ল একটি স্ট্রিং কতটা নিখুঁত প্যালিনড্রোম তা নির্ধারণ করা। আপনার সাধারণ প্যালিনড্রোম (যেমন 12321) একটি নিখুঁত প্যালিনড্রোম; এর নিখুঁততা 1।

স্ট্রিংয়ের নিখুঁততা নির্ধারণ করার জন্য, আপনি দেখতে পাচ্ছেন যে প্রতিটি বিভাগটি প্যালিনড্রোম যেখানে আপনি এটি কতগুলি বিভাগে বিভক্ত করতে পারেন। যদি অস্পষ্টতা থাকে যেমন এর সাথে aaaa, আপনি এটিতে বিভক্ত করতে পারেন [aa, aa]বা [aaaa]বা [a, aaa]বা [aaa, a], সংক্ষিপ্ততম সেটটি ওভাররাইড হবে, aaaa1 এর স্কোর দেবে, যা সংক্ষিপ্ততম সেটটির দৈর্ঘ্য।

অতএব, আপনাকে অবশ্যই এমন একটি প্রোগ্রাম বা ফাংশন লিখতে হবে যা একটি খালি খালি ইনপুট গ্রহণ করবে এবং আউটপুট এটি কতটা নিখুঁত হবে (যা সংক্ষিপ্ত সেটটির দৈর্ঘ্য আপনি সেটটিতে প্রতিটি উপাদান একটি প্যালিনড্রোম যেখানে বিভক্ত করতে পারেন)।

উদাহরণ:

1111 -> 1 [1111]
abcb -> 2 [a, bcb]
abcbd -> 3 [a, bcb, d]
abcde -> 5 [a, b, c, d, e]
66a -> 2 [66, a]
abcba-> 1 [abcba]
x -> 1 [x]
ababacab -> 2 [aba, bacab]
bacababa -> 2 [bacab, aba]
26600 -> 3 [2, 66, 00] [my user id] [who has a more perfect user id?]
ababacabBACABABA -> 4 [aba, bacab, BACAB, ABA]

নোট করুন যে উদাহরণগুলিতে বর্গাকার বন্ধনীগুলির মধ্যে থাকা কোনও কিছুই আউটপুটের অংশ হওয়া উচিত নয়।

code-golf  string  palindrome 
— Okx
সূত্র
খালি স্ট্রিংটি কি কোনও বৈধ ইনপুট, এবং যদি তাই হয় তবে আউটপুটটি কী হওয়া উচিত?
— জাগারব
8
ababacabএবং এর বিপরীত, bacababaভাল পরীক্ষার কেস বলে মনে হচ্ছে।
— নীল
@ নীল পাশাপাশি লিনিয়ার-টাইম অ্যালগরিদম সম্ভব কিনা তা সম্পর্কে ভাল যুক্তি।
— লিকি নুন
@ জগারব খালি স্ট্রিংটি বৈধ ইনপুট নয়।
— Okx
ababacabBACABABAএটিও একটি ভাল পরীক্ষার কেস (কিছু উত্তর এতে ব্যর্থ হয়)।
— জাগারব

উত্তর:

14

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

~cL↔ᵐLl

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

ব্যাখ্যা

~cL          Deconcatenate the input into L
  L↔ᵐL       Reversing all elements of L results in L
     Ll      Output = length(L)
— Fatalize
সূত্র
আপনি আমাকে মারলেন ... আমার প্রথম পোস্টে LOL
— Leaky Nun
7
@ ল্যাকিয়ুন আমি জানতাম আপনি এটি ব্যবহার করে দেখবেন। গত মাসে আমি শিথিল হয়ে কয়েক ঘন্টা অপেক্ষা করতে পারলাম, এখন আপনার সাথে ফিরে আমাকে তাত্ক্ষণিকভাবে উত্তর দিতে হবে!
— ফ্যাটালাইজ করুন
9

জেলি , 13 12 11 বাইট

ÞŒḂLÞŒḂ € P $ ḢfḢL 
ŒṖLÞṚ € ⁼ $ ḢfḢL
ŒṖṚ € ⁼ $ ÐfL € m
পার্টিশন প্রাপ্ত
      পার্টিশনের জন্য ফিল্টার
  Sub each প্রতিটি উপ-বিভাগ বিপরীত করার পরে
    ⁼ পার্টিশনের সমান
        প্রতিটি সফল পার্টিশনের এল € দৈর্ঘ্য
          সর্বনিম্ন

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

চশমা

  • ইনপুট: "ababacab"(যুক্তি হিসাবে)
  • আউটপুট: 2
— ফুটো নুন
সূত্র
3
@ ওকক্স ঠিক আছে আপনাকে সেগুলি থেকে বাঁচতে হবে।
— লিকি নুন
2
ঠিক আছে, আমি ব্যাকস্ল্যাশগুলি গ্রহণ করতে না পারলে এটি বৈধ বলে মনে করি না।
— Okx
14
@ ওকএক্স এটি স্ট্রিং লেখার মতো। আপনি স্ট্রিং ইনপুট নিয়ে একটি সি প্রোগ্রাম কাজ করার আশা করতে পারবেন না "\", কারণ এটি অবৈধ সিনট্যাক্স।
— কনর ও ব্রায়ান
2
ওয়েল ওয়ে, ওয়ে, :-)
— আর্নল্ড
2
দুঃখের বিষয় ababacabএটির জন্য বিভিন্ন উত্তর দেয় এবং এর বিপরীত হয় bacababa,।
— নীল
6

পাইথ, 9 বাইট

lh_I#I#./

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

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

জটিল পদক্ষেপ ব্যাখ্যা করার জন্য, এর উলটাপালটা অধীনে invariance সাথে শুরু করা যাক _I। এটি পরীক্ষা করে যে এর ইনপুটটি প্যালিনড্রোম কিনা, কারণ এটি পরীক্ষা করে যে বিপরীত মানটি পরিবর্তন করে।

এর পরে, palindromicity জন্য ফিল্টারিং: _I#। এটি কেবল তালিকার প্যালিনড্রমিক উপাদান রাখবে।

এর পরে, আমরা palindromicity জন্য ফিল্টারিং অধীনে invariance জন্য চেক: _I#I। তালিকার সমস্ত উপাদান প্যালিনড্রোম হলে এবং শুধুমাত্র যদি এটি সত্য হয়।

পরিশেষে, আমরা তালিকা যেখানে তালিকার উপাদানের সব palindromes জন্য ফিল্টার করুন: _I#I#।

— isaacg
সূত্র
আমি অনেক কিছু শিখতে পেয়েছি ...
— লিকি নুন
6

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

f s=minimum[length x|x<-words.concat<$>mapM(\c->[[c],c:" "])s,all((==)=<<reverse)x]

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

এটি স্ট্রিং পার্টিশন উত্পন্ন করার জন্য জগার্বের দুর্দান্ত টিপ ব্যবহার করে ।

f s = minimum[                               -- take the minimum of the list
    length x |                               -- of the number of partitions in x
    x<-words.concat<$>mapM(\c->[[c],c:" "])s -- where x are all partitions of the input string s
    , all((==)=<<reverse)x                   -- where each partition is a palindrome.
]
— Laikoni
সূত্র
1
কি দারুন! এই আমার মন উড়ে! আমি অবশ্যই অনেক কিছু শিখেছি।
— ম্যাপেল_শফট
5

ক্লোজার, 111 বাইট

(defn f[s](if(=()s)0(+(apply min(for[i(range(count s))[a b][(split-at(inc i)s)]:when(=(reverse a)a)](f b)))1)))

সমস্ত সম্ভাব্য অবস্থানে বিভক্ত হয় এবং প্রথম অংশটি যখন প্যালিনড্রোম হয় তখন স্ট্রিংয়ের বাকী অংশগুলির জন্য একটি বিভাজন সন্ধান করতে এগিয়ে যায়।

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

অবহেলিত, থ্রেড-লাস্ট ম্যাক্রো ব্যবহার করে ->>।

(defn f [s]
  (if (empty? s)
    0
    (let [results (for[i (range(count s))]
                      (let [[a b] (split-at (inc i) s)]
                         (when (= a (reverse a))
                           (f b))))]
      (->> results        ; Take results (a list of integers and nils),
           (filter some?) ; remove null values (they occur when "a" is not a palindrome)
           (apply min)    ; find the minium value,
           inc))))        ; and increment by one.

একটি অস্পষ্ট সংস্করণ, দয়া করে এই জাতীয় কোডটি লিখবেন না: ডি

(defn f [s]
   (->> (f b)
        (when (= a (reverse a)))
        (let [[a b] (split-at (inc i) s)])
        (for[i (range(count s))])
        (filter some?)
        (apply min)
        inc
        (if (empty? s) 0)))
— NikoNyrh
সূত্র
Would এই ডগা সাহায্য করেছিল? ক্লোজারকে আমি মোটেই জানি না।
— লিকি নুন
সাধারণত হ্যাঁ, তবে এই ক্ষেত্রে ফাংশনটি fনিজেকে: এর মধ্যে কল করে (f b)। একটি লেজ কল অবস্থান আপনি ব্যবহার করতে পারেন recur।
— নিকোনিহার
আপনি এখনও প্রতিস্থাপন করতে পারেন defnসঙ্গে fnএবং মাত্র একটি ফাংশন আছে।
— ক্লিফরুট
(fn f[s]( ... ))? ওহ সত্য। আপনি এটি দিয়ে 2 অক্ষর সংরক্ষণ করুন।
— নিকোনিহার
5

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

নীলকে ধন্যবাদ 2 বাইট সংরক্ষণ করুন

নিকোনার পদ্ধতিতে অনুপ্রাণিত ।

s=>(r=1/0,F=(s,i=1,p=0)=>s[p++]?([...o=s.slice(0,p)].reverse().join``==o&&(s[p]?F(s.slice(p),i+1):r=r<i?r:i),F(s,i,p)):r)(s)

ফর্ম্যাট এবং মন্তব্য

s => (                          // given a string 's':
  r = 1 / 0,                    // 'r' = best score, initialized to +Infinity
  F = (                         // 'F' is a recursive function that takes:
    s,                          //   - the current string 's'
    i = 1,                      //   - a substring counter 'i'
    p = 0                       //   - a character pointer 'p'
  ) =>                          //
    s[p++] ? (                  // if we haven't reached the end of the string:
      [...o = s.slice(0, p)]    //   compute 'o' = substring of length 'p'
      .reverse().join`` == o    //   if 'o' is a palindrome,
      && (                      //   then:
        s[p] ?                  //     if there are still characters to process:
          F(s.slice(p), i + 1)  //       do a recursive call on the remaining part
        :                       //     else:
          r = r < i ? r : i     //       update the score with r = min(r, i)
      ),                        //   in all cases:
      F(s, i, p)                //     do a recursive call with a longer substring
    ) :                         // else:
      r                         //   return the final score
  )(s)                          // initial call to F()

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

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

প্রাথমিক পন্থা, 173 168 বাইট

একটি দীর্ঘ দীর্ঘ পুনরাবৃত্ত ফাংশন যা ইনপুট স্ট্রিংয়ের সমস্ত সম্ভাব্য পার্টিশনগুলিকে গণনা করে।

f=(s,b=1/(k=0))=>++k>>(L=s.length)?b:f(s,(k|1<<30).toString(2).slice(-L).match(/(.)\1*/g).some(m=>[...o=s.slice(i,i+=m.length)].reverse(n++).join``!=o,n=i=0)?b:b<n?b:n)

ফর্ম্যাট এবং মন্তব্য

f = (                           // given:
  s,                            //   - a string 's'
  b = 1 / (k = 0)               //   - a best score 'b' (initialized to +Infinity)
) =>                            //   - a counter 'k' (initialized to 0)
  ++k >> (L = s.length) ?       // if 'k' is greater or equal to 2^(s.length):
    b                           //   stop recursion and return 'b'
  :                             // else:
    f(                          //   do a recursive call:
      s,                        //     using the same string 's'
      (k | 1 << 30)             //     compute an array containing the groups of identical
      .toString(2).slice(-L)    //     digits in the binary representation of 'k', padded
      .match(/(.)\1*/g)         //     with leading zeros and cut to the length of 's'
      .some(g =>                //     for each group 'g' in this array:
        [... o = s.slice(       //       compute 'o' = corresponding substring of 's',
          i, i += g.length      //       starting at position 'i' with the same length
        )]                      //       (e.g. s = 'abcd' / k = 0b1101 => 'ab','c','d')
        .reverse(n++)           //       increment the number of groups 'n'
        .join`` != o,           //       return true if this substring is NOT a palindrome
        n = i = 0               //       initialize 'n' and 'i'
      ) ?                       //     if some() returns true:
        b                       //       invalid partition -> keep the previous score 'b'
      :                         //     else:
        b < n ? b : n           //       valid partition -> use min(b, n)
    )                           //   end of recursive call

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

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

— Arnauld
সূত্র
আমি সঠিকভাবে আপনার ব্যাখ্যা বোঝা করে থাকেন, তবে আপনি ব্যবহার বাইট দুয়েক সংরক্ষণ করতে পারবেন ,p=0, s[p++]?এবং ,F(s,i,p)।
— নীল
নিল হ্যাঁ :-)
— আর্নল্ড
5

জেলি , 10 বাইট

ŒṖŒḂ€¬$ÞḢL

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

কিভাবে?

এই সত্যটি ব্যবহার করে যে
[0]<[0,0]<[0,0,0],...,<[0,...,0,1]<...
- এভাবে আমরা যদি একটি কী দ্বারা "প্রতিটি অংশের জন্য প্যালিনড্রমিক না হয়" দ্বারা পার্টিশনগুলি সাজিয়ে রাখি তবে প্রথম প্রবেশটি সমস্ত প্যালিনড্রোমিক এবং ন্যূনতম দৈর্ঘ্যের হবে।

দ্রষ্টব্য: n দৈর্ঘ্যের কোনও খালি খালি স্ট্রিংয়ের ফলাফল সর্বদা n zeros সহ এই জাতীয় কী হিসাবে তৈরি হবে, যেহেতু সমস্ত দৈর্ঘ্যের 1 টি স্ট্রিং প্যালিনড্রমিক।

ŒṖŒḂ€¬$ÞḢL - Main link: s             e.g. 'abab'
ŒṖ         - partitions of s               [['a','b','a','b'],['a','b','ab'],['a','ba','b'],['a','bab'],['ab','a','b'],['ab','ab'],['aba','b'],['abab']]
       Þ   - sort by (create the following key and sort the partitions by it):
      $    -   last two links as a monad:  (key evaluations aligned with above:)
  ŒḂ€      -     is palindromic? for €ach   [ 1 , 1 , 1 , 1 ] [ 1 , 1 , 0  ] [ 1 , 0  , 1 ] [ 1 , 1   ] [ 0  , 1 , 1 ] [ 0  , 0  ] [ 1   , 1 ] [ 0    ] 
     ¬     -     not                        [ 0 , 0 , 0 , 0 ] [ 0 , 0 , 1  ] [ 0 , 1  , 0 ] [ 0 , 0   ] [ 1  , 0 , 0 ] [ 1  , 1  ] [ 0   , 0 ] [ 1    ]
           - ...i.e.:         
           -       making the sorted keys: [[ 0 , 0   ],[ 0   , 0 ],[ 0 , 0 , 0 , 0 ],[ 0 , 0 , 1  ],[ 0 , 1  , 0 ],[ 1    ],[ 1  , 0 , 0 ],[ 1  , 1  ]]
           -  hence the sorted partitions: [['a','bab'],['aba','b'],['a','b','a','b'],['a','b','ab'],['a','ba','b'],['abab'],['ab','a','b'],['ab','ab']]
        Ḣ  - head of the result             ['a','bab']
         L - length                         2
— জোনাথন অ্যালান
সূত্র
5

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

x!(a:b)|p<-a:x=p!b++[1+f b|p==reverse p]
x!y=[0|x==y]
f=minimum.(""!)

একটি ফাংশন সংজ্ঞা দেয় f। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

ইনফিক্স সহায়ক ফাংশনটি x ! yপূর্ণসংখ্যার একটি তালিকা গণনা করে, যা অক্ষত রেখে reverse x ++ yযাওয়া প্যালিনড্রোমগুলিতে কিছু বিভক্তির দৈর্ঘ্য reverse x। yঅমানবিক হলে এটি ন্যূনতম বিভাজনের দৈর্ঘ্য ধারণের গ্যারান্টিযুক্ত । এটি কীভাবে এটি কাজ করে।

  • যদি yঅমানবিক হয় তবে একটি চর এটিকে পপ করে এনে ঠেলে দেওয়া হয় x। যদি xপ্যালিনড্রোমে পরিণত হয়, আমরা fলেজের মূল ফাংশনটি কল করি yএবং অ্যাকাউন্টে 1 যুক্ত করি x। এছাড়াও, আমরা কল !নতুন উপর xএবং yকোনো সম্ভাব্য বিভাজন মিস্ না।
  • যদি yখালি থাকে তবে আমরা ফিরে [0]আসি (দৈর্ঘ্যের 0 টির এক বিভাজন) যদি xখালি থাকে এবং []অন্যথায় (কোনও বিভাজন নেই)।

মূল ফাংশনটি fকেবল কল করে "" ! xএবং ফলাফলগুলির সর্বনিম্ন নেয়।

x!(a:b)|          -- Function ! on inputs x and list with head a and tail b,
  p<-a:x=         -- where p is the list a:x, is
  p!b++           -- the numbers in p!b, and
  [1+f b|         -- 1 + f b,
   p==reverse p]  -- but only if p is a palindrome.
x!y=              -- Function ! on inputs x and (empty) list y is
  [0|             -- 0,
   x==y]          -- but only if x is also empty.
f=                -- Function f is:
  minimum.(""!)   -- evaluate ! on empty string and input, then take minimum.
— Zgarb
সূত্র
3

জাভাস্ক্রিপ্ট (ফায়ারফক্স 30-57), 97 বাইট

f=(s,t=``,i=0)=>s?Math.min(...(for(c of s)if([...t+=c].reverse(++i).join``==t)1+f(s.slice(i)))):0

ES6 বন্দর:

f=(s,t=``)=>s?Math.min(...[...s].map((c,i)=>[...t+=c].reverse().join``==t?1+f(s.slice(i+1)):1/0)):0
<input oninput=o.textContent=f(this.value)><pre id=o>
স্নিপেট প্রসারিত করুন

এটি এমন একটি সহজ সমাধান বলে মনে হচ্ছে যে আমি ভাবতে থাকি যে আমি কিছু ভুলে গেছি তবে এটি কমপক্ষে সমস্ত পরীক্ষার ক্ষেত্রে পাস করে।

— নিল
সূত্র
1

হাস্কেল, 139 116 109 বাইট

h[]=[[]]
h x=words.concat<$>mapM(\c->[[c],c:" "])x
r x=reverse x==x
g x=minimum[length y|y<-h x,and$r<$>y]

হাস্কেল গল্ফিংয়ে এখনও সবুজ তবে এখানে আমার সেরা চেষ্টাটি আমি দ্রুত সামনে আসতে পারি।

  • এইচ এমন একটি ফাংশন যা কোনও তালিকার সমস্ত সম্ভাব্য উপসংগঠনের তালিকা তৈরি করে (স্ট্রিংয়ের মতো)। এটি ইনপুট স্ট্রিং নেয় এবং এটি জি এর জন্য ভেঙে দেয়।
  • r হল একটি সাধারণ ফাংশন যা কোনও তালিকা প্যালিনড্রোম হলে বুলিয়ান প্রদান করে
  • g হ'ল একটি প্রধান কার্য যা একটি ইনপুট তালিকা গ্রহণ করে, সংঘবদ্ধ সাবকোয়েন্স সম্ভাবনার তালিকা পেতে (and.map r)এইচকে কল করে, প্যালিনড্রোমযুক্ত সাব-তালিকাগুলি সরিয়ে ফেলতে ফিল্টার দেয় , যার তালিকায় দৈর্ঘ্যের দৈর্ঘ্য প্রয়োগ করা হয়, এবং তারপরে ফলাফলটি হয় বাছাই করা যাতে আমরা মাথা ধরতে পারি যা উত্তর।

আমি ভাবছিলাম এর চেয়ে ভাল উত্তর প্রয়োগকারীদের ব্যবহারের মাধ্যমে হাস্কেলের তালিকাগুলির অ-নিরঙ্কুশিক প্রকৃতির উপকার করতে পারে thinking আমাদের যদি কন্ট্রোল. অ্যাপ্লিকটিভ আমদানি করতে হয় তবে আবেদনকারীরা ব্যবহার করে ফাংশন এইচ থেকে অনেকগুলি বাইট শেভ করা সম্ভব হতে পারে। উন্নতির জন্য মন্তব্য স্বাগত।

UPDATE1

ন্যূনতম ফাংশন সম্পর্কে লাইকোনির অনুস্মারকের উপর ভিত্তি করে বিশাল সঞ্চয়। সাজানোর অপসারণ আসলে আমাকে ডেটা ড্রপ করার অনুমতি দেয় ist তালিকা আমদানি করুন কারণ ন্যূনতম প্রিলিডে সংজ্ঞায়িত করা হয়!

UPDATE2

ফিল্টার.ম্যাপের জন্য দরকারী প্রতিস্থাপন হিসাবে তালিকা বোধগম্যতা ব্যবহার সম্পর্কে নিমির পরামর্শের জন্য ধন্যবাদ। এটি আমাকে কয়েক বাইট বাঁচিয়েছে। এছাড়াও আমি লাইকোনিস উত্তর থেকে ঝরঝরে স্ট্রিং পার্টিশন ট্রিক ধার নিয়েছি এবং সেখানে একটি দম্পতি বাইট সংরক্ষণ করেছি।

— maple_shaft
সূত্র
1
h []=[[]]এবং h (x:y)=map ([x]:)অপ্রয়োজনীয় সাদা স্থান ধারণ করে। head.sortহয় minimum।
— লাইকনি
@ লাইকনি ধন্যবাদ! আমি আমার কম্পিউটারে ফিরে আসার পরে আপডেট করব!
— ম্যাপেল_শফট
1
একটি তালিকা বোঝাপড়া প্রায়শই filter& map: এর চেয়ে কম হয় g x=head$sort[length y|y<-h x,and$r<$>y]।
— নিমি
@ নিমি আপনাকে ধন্যবাদ, হাস্কেলের জন্য অনেকগুলি দরকারী গল্ফিং টিপস রয়েছে। আমি প্রতিবার নতুন কৌশল শিখি।
— ম্যাপেল_শফট
1

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

for(;$i<$l=strlen($s=$argn);$i++)for($j=$l-$i;$j;$j--)strrev($r=substr($s,$i,$j))!=$r?:$e[+$i][]=$r;uasort($e,function($a,$b){return strlen($b[0])<=>strlen($a[0])?:count($a)<=>count($b);});foreach($e as$p=>$v)foreach($v as$w){$s=preg_replace("#^(.{{$p}})$w#","$1".str_pad("",strlen($w),"ö"),$s,1,$c);!$c?:++$d;}echo$d;

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

সম্প্রসারিত

for(;$i<$l=strlen($s=$argn);$i++)
for($j=$l-$i;$j;$j--)strrev($r=substr($s,$i,$j))!=$r?:$e[+$i][]=$r; #Make all substrings that are palindromes for each position
uasort($e,function($a,$b){return strlen($b[0])<=>strlen($a[0])?:count($a)<=>count($b);}); # sort palindrome list high strlen lowest count for each position
foreach($e as$p=>$v)
foreach($v as$w){
    $s=preg_replace("#^(.{{$p}})$w#","$1".str_pad("",strlen($w),"ö"),$s,1,$c);
    !$c?:++$d; # raise count
}
echo$d; # Output

E_NOTICE ছাড়াই দীর্ঘ সংস্করণ এবং ফলাফলের অ্যারে আউটপুট put

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