অনুকূল বর্ণমালা পদক্ষেপ

Question

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

উদাহরণস্বরূপ, শব্দটি গ্রহণ করুন dog,। আমরা যদি 1-এর একটি পদক্ষেপ-আকার ব্যবহার করি তবে আমরা এগুলি শেষ করব:

defghijklmnopqrstuvwxyzabcdefg   Alphabet
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
defghijklmnopqrstuvwxyzabcdefg   Visited letters
d          o                 g   Needed letters

মোট 30 টি পদক্ষেপের জন্য।

তবে, যদি আমরা 11-এর একটি পদক্ষেপ-আকার ব্যবহার করি তবে আমরা পাই:

defghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefg
^          ^          ^          ^          ^          ^
d          o          z          k          v          g   Visited letters
d          o                                           g   Needed letters

মোট 6 টি পদক্ষেপের জন্য। এটি পদক্ষেপের সর্বনিম্ন পরিমাণ, সুতরাং এর জন্য ফলাফলের ফলাফলটি dogধাপ-আকার; 11।

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

"dog"      -> 11
"age"      -> 6
"apple"    -> 19
"alphabet" -> 9
"aaaaaaa"  -> 0 for 0 indexed, 26 for 1 indexed
"abcdefga" -> 1 or 9
"aba"      -> Any odd number except for 13
"ppcg"     -> 15
"codegolf" -> 15
"testcase" -> 9
"z"        -> Any number
"joking"   -> 19

বিধি

• ইনপুট একটি খালি স্ট্রিং বা শুধুমাত্র অক্ষর নিয়ে গঠিত অক্ষরের অ্যারে হবে aথেকে z(আপনি বড় হাতের বা ছোট হাতের মধ্যে নির্বাচন করতে পারেন)
• আউটপুট 0 টি সূচকযুক্ত (যেমন সীমার 0-25) বা 1 ইনডেক্সড ( 1-26) হতে পারে
• যদি কোনও টাই থাকে তবে আপনি যে কোনও ধাপের আকার বা সেগুলি আউটপুট করতে পারেন
• এটি কোড-গল্ফ , তাই প্রতিটি ভাষার জন্য সর্বনিম্ন পরিমাণ বাইট জিততে পারে!

Comments

আমাদের কি খালি ইনপুট পরিচালনা করতে হবে?

— pizzapants184

@ পিজ্জাপ্যান্টস 184 নং আমি ইনপুটটি শূন্য হবে উল্লেখ করার জন্য প্রশ্নটি আপডেট করেছি

— জো কিং

আমরা কি অক্ষরের অ্যারে হিসাবে ইনপুট নিতে পারি?

— শেগি

@ শেগি নিশ্চিত আপনি পারবেন

— জো কিং

সংখ্যার পরিবর্তে অক্ষর ব্যবহার করার কোনও কারণ আছে কি?

— গম উইজার্ড

Answer 1

কাঠকয়লা , 41 বাইট

≔ＥＥβＥθ∧μ⌕⭆β§β⁺⌕β§θ⊖μ×κξλ⎇⊕⌊ιΣι⌊ιθＩ⌕θ⌊Φθ⊕ι

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। 0-ইন্ডেক্স। ব্যাখ্যা:

Ｅβ

26 টি পদক্ষেপের আকারের উপর লুপ করুন। (আসলে আমি এখানে ছোট হাতের বর্ণমালাটি লুপ করছি এবং সূচক ভেরিয়েবলটি ব্যবহার করি))

Ｅθ∧μ

প্রথমটির পরে ইনপুটটির প্রতিটি অক্ষরের উপর লুপ করুন।

⭆β§β⁺⌕β§θ⊖μ×κξ

26 বার লুপ করুন এবং ইনপুটটির পূর্ববর্তী অক্ষরের সাথে প্রদত্ত ধাপ আকারের শুরুতে (0-সূচিযুক্ত) 26 পদক্ষেপ গ্রহণের ফলে অক্ষরের স্ট্রিং তৈরি করুন।

⌕...λ

সেই স্ট্রিংয়ে ইনপুটটির বর্তমান চরিত্রের অবস্থান, বা -1 না পাওয়া গেলে সন্ধান করুন।

Ｅ...⎇⊕⌊ιΣι⌊ι

সমস্ত অবস্থানের যোগফল নিন, যদি না পাওয়া যায় তবে এই ক্ষেত্রে -1 ব্যবহার করুন।

≔...θ

অঙ্কগুলি সংরক্ষণ করুন।

⌊Φθ⊕ι

সর্বনিম্ন অ-নেতিবাচক যোগফলটি সন্ধান করুন।

Ｉ⌕θ...

সেই অঙ্কের সাথে প্রথম পদক্ষেপের আকারটি সন্ধান করুন এবং এটি আউটপুট করুন।

Answer 2

জাভাস্ক্রিপ্ট, 143 বাইট

w=>(a=[...Array(26).keys(m=1/0)]).map(s=>~[...w].map(c=>(t+=a.find(v=>!p|(u(c,36)+~v*s-u(p,36))%26==0),p=c),p=t=0,u=parseInt)+t<m&&(m=t,n=s))|n

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

শেগিকে ধন্যবাদ, [...Array(26).keys()]9 বাইট সংরক্ষণ করুন ব্যবহার করে।

Comments

144 বাইট

— শেগি

Answer 3

জেলি , 28 26 23 বাইট

S;þḅ26ŒpṢƑƇIŻ€S:g/ƊÞḢg/

আউটপুট 0-সূচকযুক্ত। ইনপুটটি বাইস্টেরিং এবং যে কোনও ক্ষেত্রে হতে পারে তবে বড় হাতের চালকগুলি আরও দ্রুত।

একক-লেটার ইনপুট বিশেষ-ক্ষেত্রেযুক্ত হতে হবে এবং 2 বাইট ব্যয় করতে হবে। ._।

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

দ্রষ্টব্য যে এটি একটি নিষ্ঠুর শক্তি পদ্ধতির; চার বা ততোধিক অক্ষরের ইনপুট টিআইও-তে শেষ হয়ে যাবে। পরীক্ষার স্যুটটি _39 "দক্ষতা" এর জন্য প্রস্তুত করে।

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

S;þḅ26ŒpṢƑƇIŻ€S:g/ƊÞḢg/  Main link. Argument: b (bytestring)

S                        Take the sum (s) of the code points in b.
 ;þ                      Concatenate table; for each k in [1, ..., s] and each c in
                         b, yield [k, c], grouping by c.
   ḅ26                   Unbase 26; map [k, c] to (26k + c).
      Œp                 Take the Cartesian product.
        ṢƑƇ              Comb by fixed sort; keep only increasing lists.
           I             Increments; take the forward differences of each list.
            Ż€           Prepend a 0 to each list.
                         I returns empty lists for single-letter input, so this is
                         required to keep g/ (reduce by GCD) from crashing.
                   Þ     Sort the lists by the link to the left.
              S:g/Ɗ      Divide the sum by the GCD.
                    Ḣ    Head; extract the first, smallest element.
                     g/  Compute the GCD.

Answer 4

জেলি , 17 বাইট

ƓI%
26×þ%iþÇo!SỤḢ

ইনপুটটি এসটিডিআইএন-এ একটি বাইস্টেরিং, আউটপুটটি 1-সূচকযুক্ত।

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

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

ƓI%            Helper link. Argument: m (26 when called)

Ɠ              Read a line from STDIN and eval it as Python code.
 I             Increments; take all forward differences.
  %            Take the differences modulo m.


26×þ%iþÇoSSỤḢ  Main link. No arguments.

26             Set the argument and the return value to 26.
  ×þ           Create the multiplication table of [1, ..., 26] by [1, ..., 26].
    %          Take all products modulo 26.
       Ç       Call the helper link with argument 26.
     iþ        Find the index of each integer to the right in each list to the left,
               grouping by the lists.
        o!     Replace zero indices (element not found) with 26!.
               This works for strings up to 25! = 15511210043330985984000000 chars,
               which exceeds Python's 9223372036854775807 character limit on x64.
          S    Take the sum of each column.
           Ụ   Sort the indices by their corresponding values.
            Ḣ  Head; extract the first index, which corresponds to the minimal value.

Answer 5

জাভাস্ক্রিপ্ট (নোড.জেএস) ,  123 121 116  114 বাইট

s=>(i=26,F=m=>i--?F((g=x=>s[p]?s[k++>>5]?j=1+g(x+i,p+=b[p]==x%26+97):m:0)(b[p=k=0]+7)>m?m:(r=i,j)):r)(b=Buffer(s))

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

মন্তব্য

$i$$25$$26$s[k++ >> 5]$g$$32 \times L$$L$

s => (                        // main function taking the string s
  i = 26,                     // i = current step, initialized to 26
  F = m =>                    // F = recursive function taking the current minimum m
    i-- ?                     // decrement i; if i was not equal to 0:
      F(                      //   do a recursive call to F:
        (g = x =>             //     g = recursive function taking a character ID x
          s[p] ?              //       if there's still at least one letter to match:
            s[k++ >> 5] ?     //         if we've done less than 32 * s.length iterations:
              j = 1 + g(      //           add 1 to the final result and add the result of
                x + i,        //             a recursive call to g with x = x + i
                p += b[p] ==  //             increment p if
                  x % 26 + 97 //             the current letter is matching
              )               //           end of recursive call to g
            :                 //         else (we've done too many iterations):
              m               //           stop recursion and yield the current minimum
          :                   //       else (all letters have been matched):
            0                 //         stop recursion and yield 0
        )(                    //     initial call to g with p = k = 0
          b[p = k = 0] + 7    //     and x = ID of 1st letter
        ) > m ?               //     if the result is not better than the current minimum:
          m                   //       leave m unchanged
        :                     //     else:
          (r = i, j)          //       update m to j and r to i
      )                       //   end of recursive call to F
    :                         // else (i = 0):
      r                       //   stop recursion and return the final result r
)(b = Buffer(s))              // initial call to F with m = b = list of ASCII codes of s

Answer 6

রুবি , 121 114 112 108 102 89 বাইট

->s{(r=0..25).min_by{|l|p,=s;s.sum{|c|t=r.find{|i|(p.ord-c.ord+i*l)%26<1}||1/0.0;p=c;t}}}

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

0-ইন্ডেক্স। অক্ষরের অ্যারে হিসাবে ইনপুট নেয়।

12 বাইটের মূল্যের গল্ফিং আইডিয়াগুলির জন্য ASCII- কে ধন্যবাদ।

Comments

:( বন্ধ (পাইথন সমাধান ভিত্তিতে)

— ASCII-

100 , সম্ভবত কিছুটা বেশি গল্ফ করা যেতে পারে

— ASCII- শুধুমাত্র

91

— ASCII-

দুর্দান্ত ধারণা, p,=*sকৌতুক দ্বারা আরও 1 বাইট , তবে আমি হার্ডকডযুক্ত পেনাল্টি স্কোর সহ কোনও সমাধানের তাত্ত্বিক দৃ rob়তা সম্পর্কে এতটা নিশ্চিত নই ... সুতরাং, আমি ধ্রুবকটিকে অনন্তে পরিবর্তন করেছি (যদিও আপনার মানটি আরও 2 বাইট বন্ধ রাখার অনুমতি দেয়) )।

— ক্যারিল এল।

কেবলমাত্র 2 বাইট, খারাপ নয়

— ASCII-

Answer 7

পাইথন 2 , 230 222 216 194 169 বাইট

def t(s,l,S=0):
 a=ord(s[0])
 for c in s[1:]:
	while a-ord(c)and S<len(s)*26:S+=1;a=(a-65+l)%26+65
 return S
def f(s):T=[t(s,l)for l in range(26)];return T.index(min(T))

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

থেকে -22 বাইট TSH

জো কিং থেকে 39 বাইটস

ব্যাখ্যা সহ পুরানো সংস্করণ:

A=map(chr,range(65,91)).index
def t(s,l,S=0):
 a=A(s[0]) 
 for c in s[1:]:
	while a!=A(c)and S<len(s)*26:
	 S+=1;a+=l;a%=26
 return S
def f(s):T=[t(s,l)for l in range(26)];return T.index(min(T))

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

এটি একটি সংখ্যক অক্ষরের অক্ষরে ভাষায় সংক্ষিপ্ত হবে ( float('inf')অসীম লুপগুলি পরিচালনা করার প্রয়োজন হবে না )। আসলে, "জমা" এর মতো স্ট্রিংগুলি পরিচালনা করার জন্য এই জমা দেওয়ার এখনও প্রয়োজন। এই জমাটি এখন 26*len(s)উপরের বাউন্ড হিসাবে ব্যবহার করে , যা অসীম লুপগুলি থামায়।

এই জমাটি 0-সূচকযুক্ত (0 থেকে 25 সহ অন্তর্ভুক্ত মানের মান)।

f একটি (n বড় হাতের) স্ট্রিং নেয় এবং অনুকূল বর্ণমালা পদক্ষেপটি প্রদান করে

tএকটি সহায়ক ফাংশন যা স্ট্রিং এবং একটি বর্ণমালা পদক্ষেপ গ্রহণ করে এবং স্ট্রিংটি শেষ করতে (বা 26*len(s)অসম্ভব হলে) প্রয়োজনীয় হোপের সংখ্যা প্রদান করে ।

Comments

ব্যবহার করুন while a!=A(c)and S<len(s)*26:এবং আপনি মুছে ফেলতে পারেন if a==i:return float('inf'), যেহেতু len(s)*26কোনও উত্তরের উপরের আবদ্ধ।

— tsh

165

— ASCII-

বিকল্প পদ্ধতি, 166

— ASCII-

155

— ASCII-

112

— ASCII-

Answer 8

লাল , 197 বাইট

func[s][a: collect[repeat n 26[keep #"`"+ n]]m: p: 99 a: append/dup a a m
u: find a s/1 repeat n 26[v: extract u n
d: 0 foreach c s[until[(v/(d: d + 1) = c)or(d > length? v)]]if d < m[m: d p: n]]p]

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

Answer 9

05AB1E (উত্তরাধিকার) , 33 27 26 বাইট

Ç¥ε₂%U₂L<©ε®*₂%Xk'-žm:]øOWk

উত্তরাধিকার সংস্করণটি ব্যবহার করুন কারণ আপনি যখন নতুন 05AB1E সংস্করণে নেস্টেড মানচিত্রের পরে ফলাফলটি পরিবর্তন করতে / ব্যবহার করতে চান তখন কোনও বাগ রয়েছে বলে মনে হচ্ছে ..

0-ইনডেক্সড আউটপুট।

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

ব্যাখ্যা:

Ç                        # ASCII values of the (implicit) input
 ¥                       # Deltas (differences between each pair)
  ε                      # Map each delta to:
   ₂%                    #  Take modulo-26 of the delta
     U                   #  Pop and store it in variable `X`
      ₂L<                #  Push a list in the range [0,25]
         ©               #  Store it in the register (without popping)
          ε              #  Map each `y` to:
           ®*            #   Multiply each `y` by the list [0,25] of the register
             ₂%          #   And take modulo-26
                         #   (We now have a list of size 26 in steps of `y` modulo-26)
               Xk        #   Get the index of `X` in this inner list (-1 if not found)
                 '-₄:   '#   Replace the minus sign with "1000"
                         #   (so -1 becomes 10001; others remain unchanged) 
]                        # Close both maps
 ø                       # Zip; swapping rows/columns
  O                      # Sum each
   W                     # Get the smallest one (without popping the list)
    k                    # Get the index of this smallest value in the list
                         # (and output the result implicitly)

Answer 10

পাইথন 3 , 191 178 162 বাইট

আপনার সকল টিপসের জন্য সবাইকে ধন্যবাদ! এটি অনেক বেশি গল্ফের মতো দেখাচ্ছে।

*w,=map(ord,input())
a=[]
for i in range(26):
 n=1;p=w[0]
 for c in w:
  while n<len(w)*26and p!=c:
   n+=1;p+=i;
   if p>122:p-=26
 a+=[n]
print(a.index(min(a)))

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

এবং কারও আগ্রহী হলে আমার মূল কোড

শব্দটিকে ASCII মানগুলির তালিকায় পরিণত করে, তারপরে 0 থেকে 25 ধাপের মাপের মাধ্যমে পুনরাবৃত্তি করে তালিকাটি নিষ্কাশনের জন্য কতগুলি পদক্ষেপ নেয় তা পরীক্ষা করে (অসীম লুপগুলি থামানোর জন্য একটি সিলিং রয়েছে)।

পদক্ষেপের সংখ্যা তালিকায় যুক্ত হয় a ।

লুপ জন্য বড় করার পর, ক্ষুদ্রতম মান সূচক একটি ছাপা হয়। এই মান সমান আমি লুপ, Qed যে পুনরাবৃত্তির জন্য (ধাপ সাইজ)।

Comments

হাই এবং পিপিসি তে আপনাকে স্বাগতম! শুরুর জন্য, আপনার পোস্ট বাইট গণনা টিআইও তে এটির সাথে মেলে না :) এখন, বেশ কয়েকটি দ্রুত ইঙ্গিতের জন্য: range(26)যথেষ্ট - আপনার শুরুটি নির্দিষ্ট করার দরকার নেই, কারণ 0টি ডিফল্ট; a.append(n)হতে পারে a+=[n]; প্রথম লাইনটি মানচিত্র হিসাবে সংক্ষিপ্ত হবে w=list(map(ord,input()))(আসলে আপনার বর্তমান অ্যালগরিদমের সাথে, পাই 2 এ আপনি মোড়ানোও ছেড়ে দিতে list(...)পারেন); অতিরিক্ত স্পেসিং / লাইন বিরতি যতটা সম্ভব এড়ানো (যেমন, অনেলাইনারগুলিতে নতুন লাইনের প্রয়োজন নেই if p>122:p-=26)

— কিরিল এল L

এছাড়াও, এটি n>99সন্দেহজনক দেখা যাচ্ছে, তা কি অনিয়মিত লুপটি ভেঙে ফেলার জন্য এক স্বেচ্ছাসেবী? তারপরে এটি সম্ভবত 26 * লেন (ডাব্লু) এর মতো কিছু হওয়া উচিত, আপনি কখনই জানেন না যে ইনপুটটি কত বড় হবে।

— কিরিল এল।

বিটিডাব্লু, আপনি এখনও পাই 3 list(...)এ এড়াতে পারেন এবং একটি অতিরিক্ত if: 165 বাইট । এছাড়াও, এই টিপসের বিষয়টি একবার দেখুন , আমি নিশ্চিত যে আপনি সেখান থেকে পরামর্শ ব্যবহার করে আপনার দক্ষতার ব্যাপক উন্নতি করতে পারবেন!

— কিরিল এল।

আমি পাইথন বিশেষজ্ঞ নই, তবে আমি মনে করি আপনি while p!=c and n>len(w)*26:-8 বাইটের বিবৃতি দিলে আপনি এটি করতে পারেন এবং শেষটি থেকে মুক্তি পেতে পারেন।

— স্পাইটমাস্টার

যদিও এটি দেখতে ভয়ঙ্কর দেখাচ্ছে এবং পাইথন যা কিছু আছে তার বিরুদ্ধে গেলেও আপনি পরিবর্তন করতে পারেন n+=1এবং p+=iপৃথক লাইনে n+=1;p+=iএকের দিকে যেতে পারেন।

— nedla2004