উপ-অনুচ্ছেদে মোড়ানো

Question

ভূমিকা

এই চ্যালেঞ্জে আপনার কাজটি হল স্ট্রিংগুলির সাধারণীকরণের উপসর্গগুলি সন্ধান করা। উত্তরোত্তরগুলি অগত্যা সংগত নয়, এবং তারা স্ট্রিংটি "প্রায় মোড়ানো" করতে পারে, এর শেষ পেরিয়ে যায় এবং শুরু থেকে আবার শুরু করে। যদিও আপনি মোড়কের সংখ্যা হ্রাস করতে চান।

আরো আনুষ্ঠানিকভাবে যাক uএবং vকোন দুটি স্ট্রিং, এবং হতে k ≥ 0একটি পূর্ণসংখ্যা। আমরা যে uএকটি হল k-wrapping subsequence এর v, যদি সেখানে স্বতন্ত্র সূচকের হয় যেমন যে , এবং সবচেয়ে সূচকের সন্তুষ্ট । এর অর্থ এই যে ভিতরে পাওয়া যাবে যাচ্ছে বাঁ দিক থেকে ডানদিকে পথে তার অক্ষরের কিছু বাছাই করার, এবং মোড়ানো সর্বাধিক প্রায় দ্বারা বার (equivalently, সর্বাধিক করছেন জুড়ে sweeps )। নোট করুন যে কোনও চরিত্রকে একবারে একাধিকবার বেছে নেওয়া যায় না এমনকি একটি মোড়কের চারপাশের পরেও, এবং সেই- মোড়কের অনুচ্ছেদগুলি হ'ল সাধারণ অনুচ্ছেদ যা আমরা সকলেই পরিচিত।i1, i2, ..., ilen(u)u == v[i1] v[i2] ... v[ilen(u)]kijij > ij+1uvkk+1v0

কাজটি

তোমার ইনপুট দুই খালি নয় এমন আলফানিউমেরিক স্ট্রিং হয় uএবং v, এবং আপনার আউটপুট পূর্ণসংখ্যা সবচেয়ে ছোট kযেমন যে uএকটি হল kএর -wrapping subsequence v। যদি এরকম কোনও kউপস্থিত না থাকে তবে আউটপুট হবে -1।

উদাহরণ

ইনপুট u := xyzyxzzxyxএবং বিবেচনা করুন v := yxzzazzyxxxyz। আমরা যদি অক্ষর খুঁজছেন শুরু uমধ্যে vএকটি অর্থগৃধ্নু ফ্যাশন, আমরা 3 বার চারপাশে মোড়ানো হবে:

 yxzzazzyxxxyz
>─x─────y────z┐
┌─────────────┘
└y───────x────┐
┌─────────────┘
└──zz─────x─y─┐
┌─────────────┘
└──────────x──>

সুতরাং সঠিক আউটপুট সর্বাধিক ৩. নোট করুন যে কীভাবে বাম-সর্বাধিক অক্ষরটি xএকবার নির্বাচিত হয় এবং তারপরে দ্বিতীয় ঝাড়ুতে উপেক্ষা করা হয়, কারণ এটি পুনরায় ব্যবহার করা যায় না। তবে, কেবল দুটি মোড়কের চারপাশে একটি ছোট পদ্ধতি রয়েছে:

 yxzzazzyxxxyz
>──────────xyz┐
┌─────────────┘
└yxzz────x────┐
┌─────────────┘
└───────y─x───>

দেখা যাচ্ছে যে একটি মোড়কের চারপাশে (এটি দুটি সুইপ) যথেষ্ট নয়, তাই সঠিক আউটপুট 2।

বিধি ও বোনাস

আপনি কোনও ফাংশন বা একটি সম্পূর্ণ প্রোগ্রাম লিখতে পারেন, এবং প্রয়োজনের সাথে ইনপুটগুলির ক্রমও পরিবর্তন করতে পারেন। সর্বনিম্ন বাইট গণনা জয়, এবং মান লুফোলগুলি অনুমোদিত নয়।

একটা হল -10% বোনাস অধীনে 10 সেকেন্ডের মোট পরীক্ষার বিষয় সব কম্পিউটিং জন্য। আমি আমার মেশিনে অস্পষ্ট মামলাগুলি পরীক্ষা করব; পাইথনে আমার রেফারেন্স বাস্তবায়ন প্রায় 0.6 সেকেন্ড সময় নেয়। আমার 7 বছরের পুরানো ল্যাপটপ রয়েছে 1.86 গিগাহার্টজ ডুয়াল কোর সিপিইউ, যা আপনি বিবেচনায় নিতে চাইতে পারেন।

পরীক্ষার কেস

"me" "moe" -> 0
"meet" "metro" -> -1
"ababa" "abaab" -> 1
"abaab" "baabaa" -> 1
"1c1C1C2B" "1111CCCcB2" -> 3
"reverse" "reserved" -> 2
"abcdefg" "gfedcba" -> 6
"xyzyxzzxyx" "yxzzazzyxxxyz" -> 2
"aasdffdaasdf" "asdfddasdfsdaafsds" -> 2

Comments

উদাহরণস্বরূপ এটি কি কোনও বৈধ সমাধান হতে পারে? এটি একটি লোভী পদ্ধতির।

— orlp

@orlp এটি বৈধ নয়, কারণ প্রথমটি xতিনটি স্বতন্ত্র সুইপগুলিতে ব্যবহৃত হয়। এটি কেবল একবার ব্যবহার করা যেতে পারে।

— জাগারব

আহ, আমি এখন দেখছি।

— orlp

Answer 1

পাইথ, 34 বাইট

Mh+Smssm>.ukC,[e-mail]_1

এটি একটি ফাংশন সংজ্ঞায়িত করে g, যা প্যারামিটার হিসাবে দুটি স্ট্রিং নেয়। এটি অনলাইনে ব্যবহার করে দেখুন: পাইথ কমপাইলার / এক্সিকিউটার

এই কোডটি খুব অদক্ষ। এটির একটি সময় এবং স্মৃতি জটিলতা রয়েছে len(v)!/(len(v)-len(u))!। এটি 10 ​​সেকেন্ডের নীচে দীর্ঘতর পরীক্ষার কেসগুলি সমাধান করতে সক্ষম হয় না। (এটি খুব সম্ভবত ক্র্যাশ হবে, যেহেতু এটির স্মৃতিশক্তি শেষ হয়ে যাবে))

M                                    define g(G, H): return _
                          .PUHlG        all permutations of [0, 1, ..., len(H)-1] of length len(G)
                 fqGsm@HkT              filter the permutations which form the string G
    mssm>.ukC,dtd                       compute the number of wraps for each of the remaining permutations
  +S                            _1      sort the numbers and append -1
 h                                      return the first element

Answer 2

হাস্কেল, 160 * 0.9 = 144 বাইট

a#(-1)=a
a#b=min a b
f y=w(y++" ")0$length y
w _ n _[]=n
w(c:d)n o g@(a:b)|n>o=(-1)|a==c=z#w y n z g|c==' '=w y(n+1)o g|1<2=w y n o g where z=w d n o b;y=d++[c]

সমস্ত পরীক্ষার মামলার সময় (নোট: আর্গুমেন্টগুলি উল্টানো হয়):

*Main> map (uncurry f) [
             ("moe", "me"),
             ("metro", "meet"),
             ("abaab", "ababa"),
             ("baabaa", "abaab"),
             ("1111CCCcB2", "1c1C1C2B"),
             ("reserved", "reverse"),
             ("gfedcba", "abcdefg"),
             ("yxzzazzyxxxyz", "xyzyxzzxyx"),
             ("asdfddasdfsdaafsds", "aasdffdaasdf")]
[0,-1,1,1,3,2,6,2,2]
(0.08 secs, 25794240 bytes)

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

আমার প্রথম সংস্করণটির তুলনায় প্রচুর বাইট সংরক্ষণ করা হয়েছে, মূলত কারণ আমি একটি সম্পূর্ণ প্রোগ্রাম থেকে কোনও ফাংশনে স্যুইচ করেছি।

কিছু মন্তব্য এবং যথাযথ ব্যবধানের সাথে গল্ফযুক্ত হাস্কেল বেশ পঠনযোগ্য:

-- a minimum function that ignores a -1 in the right argument to prevent
-- "not solvable" cases in parts of the recursive search to dominate low numbers
-- of solvable parts. If the case isn't solvabale at all, both arguments are
-- -1 and are carried on.
a # (-1) = a
a # b    = min a b

-- the main function f calls the worker funktion w with arguments
-- * the string to search in (STSI), appended by a space to detect cycles
-- * the number of cycles so far
-- * the minimum of cycles needed so far, starting with the length of STSI
-- * the string to search for (STSF) (partial applied away and therefore invisible)
f y = w (y++" ") 0 (length y)

-- the worker function 
w _ n _ [] = n          -- base case: if STSF is empty the work is done and the 
                        -- number of cycles is returned

w (c:d) n o g@(a:b)     -- "c" is first char of STSI, "d" the rest
                        -- "n" number of cycles, "o" minimum of cycles so far
                        -- "g" is the whole STSF, "a" the 1st char, "b" the rest
  | n>o    = (-1)             -- if current cycle is more than a previous result,
                              -- indicate failure
  | a==c   = z # w y n z g    -- if there's a character match, take the min of
                              -- using it and skipping it
  | c==' ' = w y (n+1) o g    -- cycle detected, repeat and adjust n
  | 1<2    = w y n o g        -- otherwise try next char in STSI

  where                 -- just some golfing: short names for common subexpressions
  z = w d n o b;        -- number of cycles if a matching char is used
  y = d ++ [c]          -- rotated STSI

রেফারেন্সের জন্য: পুরানো সংস্করণ, সম্পূর্ণ প্রোগ্রাম, 187 বাইট

main=interact$show.f.lines
a#(-1)=a
a#b=min a b
f[x,y]=w x(y++" ")0 0
w[]_ n _=n
w g@(a:b)(c:d)n m|a==c=w b d n 1#y|c==' '&&m==1=w g(d++" ")(n+1)0|c==' '=(-1)|1<2=y where y=w g(d++[c])n m

Comments

@ জাগারব: আমার সমাধানটি পুনরায় কাজ করেছে। এটি এখন দ্রুত এবং খাটো।

— নিমি

সংজ্ঞায়িত করার সময় 0.6 সেকেন্ডে চলমান, সংকলিত 0.01 সেকেন্ডে।

— জাগারব

Answer 3

জাভাস্ক্রিপ্ট (ES6) 174 (193 - 10%)

@ নিমির উত্তরের মতো পুনরাবৃত্ত অনুসন্ধান, মিনিট মোড়কে রেখে। সমাধানের স্থানটি বড় (শেষের উদাহরণে সর্বোপরি) তবে বর্তমানে পাওয়া সর্বনিম্ন অনুসন্ধানে কাটা সময় কম রাখে। সম্পাদনা 1 একটি অনুপস্থিত পরীক্ষার কেস যুক্ত করুন, কিছুটা সংক্ষিপ্ত করে সম্পাদনা করুন 2 পেরাম ডাব্লু পাস করার দরকার নেই, এটি ঠিক হয়েছে

K=(w,s,x)=>
  ~-(R=(r,l,p=0,q=1,z=w[p],i=0)=>
  {
    if(z&&!(q>x)){
      if(~(r+l).indexOf(z))
        for(t=l?R(l+r,'',p,q+1):x;x<t?0:x=t,i=~r.indexOf(z,-i);)
          t=R(r.slice(-i),l+r.slice(0,~i),p+1,q);
      q=x
    }
    return q
  })(s,'')

Ungolfed

K=(word, astring)=>
{
  var minWraps // undefined at first. All numeric comparison with undefined give false 
  var R=(right, left, pos, wraps)=>
  {
    var cur = word[pos]
    var i,t;
    if (! cur) // when all chars of word are managed
      return wraps;
    if (wraps > minWraps) // over the minimum wrap count already found, stop search
      return wraps; 
    if ( (right+left).indexOf(cur) < 0 ) // if the current char is not found in the remaining part of the string
      return minWraps; // return the current min, could still be undefined (that means 'no way')
    if ( left ) // if there is a left part, try a wrapping search with the current char
    {
      t = R(left+right, '', pos, wraps+1)
      if ( !(minWraps < t)) minWraps = t; // set current min if t is less than current min or current min is still undefined
    }
    // find all occurrences of current char in the remaining part
    // for each occurrence, start a recursive search for the next char
    for(i = 0; (i = right.indexOf(cur, i)) >= 0; i++)
    {
      var passed = right.slice(0,i) // the passed chars go in the left part
      var rest = right.slice(i+1) 
      t = R(rest, left+passed, pos+1, wraps) // try next char in the remaining part, no wrap
      if ( !(minWraps < t)) minWraps = t; // set current min if t is less than current min or current min is still undefined
    }
    return minWraps
  }
  var result = R(astring, '', 0, 1) // start with right=string and left empty
  return ~-result; // decrement. convert undefined to -1
}

টেস্ট সালে ফায়ারফক্স / ফায়ারবাগ কনসোলটি

time=~new Date;
[['me','moe']
,['meet','metro']
,['ababa','abaab']
,['abaab','baabaa']
,['1c1C1C2B','1111CCCcB2']
,['reverse','reserved']
,['abcdefg','gfedcba']
,['xyzyxzzxyx','yxzzazzyxxxyz']
,['aasdffdaasdf','asdfddasdfsdaafsds']]
.forEach(s=>console.log(s,r=K(...s)))
time-=~new Date

আউটপুট (শেষ লাইনটি এমএসে কার্যকর হওয়ার সময়)

["আমি", "মো" "0
[" মিলিত "," মেট্রো "] -1
[" আববা "," আবআব "] 1
[" আবআব "," বাবা "] 1
[" 1c1C1C2B "," 1111CCcB2 "] 3
["বিপরীত", "সংরক্ষিত"] 2
["abcdefg", "gfedcba"] 6
["xyzyxzzxyx", "yxzzazzyxxxyz"] 2
["asdffdaasdf", "এসএসডিএফডিএসডিএফএসডিএফএসডিএস]] 2
116

Comments

ফায়ারব্যাগ দিয়ে পরীক্ষিত, আমার মেশিনে 175 মিমি চালিত।

— জাগারব

@ জাগারব তখন উন্নতির জন্য জায়গা আছে: আমি এটিকে আরও ধীর এবং খাটো করার চেষ্টা করব

— edc65