27

ইন প্যানকেক বাছাই কেবল অনুমোদিত অপারেশন ক্রম কিছু উপসর্গ উপাদান বিপরীত হয়। বা, প্যানকেকগুলির একটি স্ট্যাকের কথা ভাবেন: আমরা স্ট্যাকের কোথাও একটি স্প্যাটুলা sertোকা এবং স্প্যাটুলার উপরে সমস্ত প্যানকেকগুলি ফ্লিপ করি।

উদাহরণস্বরূপ, 6 5 4 1 2 3প্রথম 6উপাদানগুলিকে (পুরো ক্রমটি) উল্টিয়ে মধ্যবর্তী ফলাফল উত্পন্ন করে 3 2 1 4 5 6এবং তারপরে প্রথম 3উপাদানগুলিকে উল্টিয়ে , এ পৌঁছনোর মাধ্যমে ক্রমটি বাছাই করা যায় 1 2 3 4 5 6।

যেহেতু কেবলমাত্র একটি অপারেশন রয়েছে, সম্পূর্ণ বাছাই প্রক্রিয়াটি পূর্ণসংখ্যার ক্রমিক দ্বারা বর্ণিত হতে পারে, যেখানে প্রতিটি পূর্ণসংখ্যা পিআর ফ্লিপ অন্তর্ভুক্ত করার জন্য উপাদান / প্যানকেকের সংখ্যা। উপরের উদাহরণের জন্য, বাছাইয়ের ক্রম হবে 6 3।

আর একটি উদাহরণ: এর 4 2 3 1সাথে বাছাই করা যায় 4 2 3 2। মধ্যবর্তী ফলাফল এখানে:

         4 2 3 1
flip 4:  1 3 2 4
flip 2:  3 1 2 4
flip 3:  2 1 3 4
flip 2:  1 2 3 4

কাজটি:

একটি প্রোগ্রাম লিখুন যা পূর্ণসংখ্যার একটি তালিকা নেয় এবং একটি বৈধ প্যানকেক বাছাইয়ের ক্রম প্রিন্ট করে।

বাছাইয়ের তালিকাটি স্টিডিনের থেকে পৃথক পৃথক তালিকা হতে পারে, বা কমান্ড লাইন আর্গুমেন্ট। তালিকাটি প্রিন্ট করুন তবে এটি সুবিধাজনক, যতক্ষণ না এটি কিছুটা পাঠযোগ্য।

এই কোডগল্ফ!

সম্পাদনা:

আমি মন্তব্যে যেমন বলেছি, আপনাকে আউটপুটটি অনুকূল করতে হবে না (সংক্ষিপ্ত ক্রমটি এনপি-হার্ড সন্ধান করা )। তবে , আমি কেবল বুঝতে পেরেছি যে আপনি পছন্দসই ফলাফল (একটি [নতুন?] প্রকারের বোগোসর্ট) না পাওয়া পর্যন্ত একটি সস্তা সমাধান এলোমেলো সংখ্যা ছুঁড়ে ফেলা হবে। এখনও অবধি কোনও উত্তর এটি করেনি, তাই আমি এখন ঘোষণা করছি যে আপনার অ্যালগরিদম কোনও (ছদ্ম-) এলোমেলোভাবে নির্ভর করা উচিত নয় ।

আপনি সবাই নিজেকে লাথি মারার সময়, এটিকে ঘষতে এখানে রুবি ২.০ (characters০ টি অক্ষর) এর একটি বোগোপানকেকোর্ট বৈকল্পিক রয়েছে:

a=$*.map &:to_i
a=a[0,p(v=rand(a.size)+1)].reverse+a[v..-1]while a!=a.sort

— daniero
সূত্র

1

কোনও বৈধ ক্রম, বা এটি ন্যূনতম দৈর্ঘ্য হওয়া উচিত?

— পিটার টেলর

ক্ষুদ্র টাইপো: দ্বিতীয় উদাহরণটি 4 3 2 1পরিবর্তে প্রদর্শিত হবে4 2 3 1

— beary605

4

(আমি এটি সম্পাদনা করার চেষ্টা করার সাথে সাথে আমার ইন্টারনেট নিচে নেমেছে, তাই আমি এটি আবার পোস্ট করি) @ পিটারটেলর আমাকে এর মধ্যে একরকম অপ্টিমাইজেশান অন্তর্ভুক্ত করার জন্য প্রলুব্ধ করেছিলেন, কিন্তু তা বেছে নিই নি। ন্যূনতম অনুক্রমের দৈর্ঘ্য সন্ধান করা আসলে এনপি-হার্ড , অন্যদিকে সরল-সরল-এগিয়ে থাকা অ্যালগরিদম এমন একটি সমাধান খুঁজে পেতে পারে যা বেশিরভাগ 2n দীর্ঘ হবে। আমি কীভাবে কোড-চ্যালেঞ্জ / সর্বোত্তম আউটপুট জিনিস হিসাবে এটি বিচার করব তা আমি সত্যই জানি না এবং আমি কেবল প্লেইন কোডগল্ফকে বেশি পছন্দ করি :)

— ড্যানিয়েরো

আমি ভাবছি যে কেউ যদি এই চ্যালেঞ্জ থেকে তাদের প্রবেশ পোস্ট করে ।

— grc

ক্রমটি কি সংলগ্ন মান হতে পারে? 2 7 5 একটি বৈধ ইনপুট?

6

গল্ফস্ক্রিপ্ট, 34/21 অক্ষর

(ধন্যবাদ 4 পিটার কাটা কাটার জন্য পিটারটেলর)

~].{,,{1$=}$\}2*${.2$?.p)p.@\-+}/,

অনলাইন পরীক্ষা

একটি সংক্ষিপ্ত, 21 অক্ষর সংস্করণ কেবল অনন্য আইটেম সহ তালিকার জন্য কাজ করে

~].${.2$?.p)p.@\-+}/,

অনলাইন পরীক্ষা

উভয় সংস্করণ উপ-অনুকূল সমাধান উত্পাদন করে।

সংক্ষিপ্ত সমাধানের জন্য ব্যাখ্যা:

~]         # read input from stdin
.$         # produce a sorted copy from lowest to highest
{          # iterate over the sorted list
  .2$?     # grab the index of the element
  .p       # print the index
  )p       # increment and print the index
  .@\-+    # move the element to the front
}/
,          # leave the length of the list on the stack
           # this flips the reverse sorted list to become sorted

এটি পোস্ট করা অন্যান্যদের বেশিরভাগের জন্য একটি পৃথক অ্যালগরিদম ব্যবহার করে। মূলত এটি তালিকার ক্ষুদ্রতম উপাদানটি ধরে ফেলে এবং দুটি ফ্লিপ সহ এটি অন্যান্য উপাদানের ক্রম সংরক্ষণ করে সামনের দিকে নিয়ে যায়।

নবম উপাদানটিকে সামনে নিয়ে যেতে:

1 2 3 4 5 6 7   # let's move the 3rd (0-based) element to the front
# flip the first 3 elements
3 2 1 4 5 6 7
# flip the first 3+1 elements
4 1 2 3 5 6 7

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

আসলে অ্যালগরিদম হল 90-চর পাইথন দ্রবণটির একটি পরিবর্তন (আমার নিজের অবশ্যই)

d=map(int,raw_input().split());i=0
while d:n=d.index(max(d));d.pop(n);print n+i,n-~i,;i+=1

— অবিশ্বাস
সূত্র

2

আমি দেখতে পাচ্ছি যে আপনি গল্ফস্ক্রিপ্টের কোনও দরকারী কের্কসটি দেখতে পান নি: আপনি কোনও টোকেনকে ভেরিয়েবল হিসাবে ব্যবহার করতে পারেন। আপনি ব্যবহার করছেন না &যে কোন জায়গায়, তাই আপনি প্রতিস্থাপন করতে সক্ষম হওয়া উচিত sযখন &এবং হোয়াইটস্পেস মুছে ফেলুন।

— পিটার টেলর

@ পিটারটেলর হু, আমি ভাবছিলাম যে আপনি ^ফাইবোনাকির চ্যালেঞ্জের ক্ষেত্রে কেন ভেরিয়েবল হিসাবে ব্যবহার করতে পারেন ;) টিপটির জন্য ধন্যবাদ!

— অস্থিরতা

ইনপুট জন্য 3 2 1আমি পেয়েছি 131211যা সঠিক নয়।

— হাওয়ার্ড

@Howard এখন কাজ করতে পেয়েছি

— উদ্বায়ীতামূলক

@ ভোলাটিলিটি সর্বশেষ পরিবর্তনটি কিছুটা বেশি ছিল ;-) যেমন তালিকাগুলির তালিকা 2 1 1আর আর বাছাই করা যায় না।

— হাওয়ার্ড

11

পাইথন, 91 90 টি অক্ষর

L=map(int,raw_input().split())
while L:i=L.index(max(L));print-~i,len(L),;L=L[:i:-1]+L[:i]

শীর্ষে বৃহত্তম প্যানকেক ফ্লিপ করুন, তারপরে পুরো স্ট্যাকটি ফ্লিপ করুন। নীচে থেকে বৃহত্তম প্যানকেক সরান এবং পুনরাবৃত্তি করুন।

iবৃহত্তম প্যানকেকের সূচক। প্যানকেকগুলি L=L[:i:-1]+L[:i]ফ্লিপ করে, i+1প্যানকেকগুলি ফ্লিপ করে len(L), তারপরে শেষ প্যানকেকটি ড্রপ করে।

— কিথ র্যান্ডাল
সূত্র

1

আমি ভেবেছিলাম আপনাকে কেবল ফ্লিপ তৈরি করার অনুমতি দেওয়া হয়েছিল। (এটি, আমি মনে করি না যে আপনি স্ট্যাক থেকে প্যানকেকস নামাতে পারেন)। আমি কি বিধি ভুল বুঝেছি? হুম। আবার উইকির পাতা পড়তে যান নির্বিশেষে, দুর্দান্ত কাজ :) ১০০ টিরও কম অক্ষর আমার কাছে বেশ আশ্চর্যজনক!

— ওয়েন্দিকিড

@ ওয়েন্ডিকিড আসলে, তার অর্থ হ'ল যে নীচে সবচেয়ে বড়টি ফ্লিপ করার পরে, তিনি কেবল এটিকে উপেক্ষা করছেন এবং এর উপরে প্যানকেকগুলি নিয়ে নিজের সম্পর্কে।

— এজেম্যানসফিল্ড

@ এজেম্যানসফিল্ড আহ, আমি দেখছি! ধন্যবাদ, এটি উপলব্ধি করে। আমি কোডটি পড়তে পারি না (আমি পাইথনে খুব নতুন) তাই আমি ব্যাখ্যাটি ভুল বুঝেছি :) ধন্যবাদ!

— ওয়েন্দিকিড

2

আমি এর আগে যা লিখেছিলাম তা নিয়ে অনেক বিবর্তন। আমি উপাদানগুলি অপসারণের কথা ভাবিনি কারণ শুরুর দিকে আমাকে আউটপুটটির সঠিকতা পরীক্ষা করতে হয়েছিল (অর্থাত্ তালিকাকে পরে সাজানো হয়েছে?)। উপায় দ্বারা: আমি বিশ্বাস করি যে কমাটি print

— অপসারণযোগ্য আউটপুটটি অপঠনযোগ্য

@ ওয়েন্ডিকিড প্রকৃতপক্ষে, আরও পরিদর্শন করার পরে, এটি সত্যই প্যানকেকগুলি সরিয়ে ফেলবে; এটি কেবল ফ্ল্যাপের ক্রম কী তা নির্ধারণ করতে হবে, আসলে অ্যারেটি বাছাই করা নয়।

— এজেম্যান্সফিল্ড

6

রুবি 1.9 - 109 88 79 টি অক্ষর

কিথের দুর্দান্ত অজগর সমাধানের উপর ভিত্তি করে আরও অনেক কমপ্যাক্ট সংস্করণ:

a=$*.map &:to_i;$*.map{p v=a.index(a.max)+1,a.size;a=a[v..-1].reverse+a[0,v-1]}

মূল সংস্করণ:

a=$*.map &:to_i
a.size.downto(2){|l|[n=a.index(a[0,l].max)+1,l].map{|v|v>1&&n<l&&p(v);a[0,v]=a[0,v].reverse}}

যদি আপনি উদ্বুদ্ধ অপারেশনগুলির বিষয়ে চিন্তা না করেন (1 মাপের স্ট্যাকগুলি বিপরীত করে, বা একই স্ট্যাকটি একপর্যায়ে দু'বার বিপরীত করে) আপনি এটিকে কিছুটা খাটো করতে পারেন (96 অক্ষর):

a=$*.map &:to_i
a.size.downto(2){|l|[a.index(a[0,l].max)+1,l].map{|v|p v;a[0,v]=a[0,v].reverse}}

ক্রমবিহীন তালিকাটি কমান্ড-লাইন আর্টস হিসাবে গ্রহণ করে। ব্যবহারের উদাহরণ:

>pc.rb 4 2 3 1
4
2
3
2

— পল প্রেস্টিজ
সূত্র

6

গল্ফস্ক্রিপ্ট, 31 29 টি অক্ষর

~].${1$?).p.2$.,p>-1%\@<+)}%,

আরেকটি GolfScript সমাধান, এছাড়াও পরীক্ষা করা সম্ভব অনলাইন ।

পূর্ববর্তী সংস্করণ:

~].$-1%{1$?).2$>-1%@2$<+.,\);}/

এটি কীভাবে কাজ করে: এটি বৃহত্তম আইটেমটি শীর্ষে এবং তারপরে তালিকার শেষ স্থানে চলে যায়। যেহেতু এটি এখন সঠিক অবস্থানে রয়েছে তাই আমরা এটিকে তালিকা থেকে সরাতে পারি।

~]         # Convert STDIN (space separated numbers) to array
.$-1%      # Make a sorted copy (largest to smallest)
{          # Iterate over this copy
  1$?)     # Get index of item (i.e. largest item) in the remaining list,
           # due to ) the index starts with one
  .        # copy (i.e. index stays there for output)
  2$>      # take the rest of the list...
  -1%      # ... and reverse it 
  @2$<     # then take the beginning of the list
  +        # and join both. 
           # Note: these operations do both flips together, i.e.
           # flip the largest item to front and then reverse the complete stack
  .,       # Take the length of the list for output
  \);      # Remove last item from list
}/

— হাওয়ার্ড
সূত্র

4

পার্ল, 103 100 টি অক্ষর

কমান্ড লাইনে ইনপুট আশা করে।

for(@n=sort{$ARGV[$a]<=>$ARGV[$b]}0..$#ARGV;@n;say$i+1,$/,@n+1)
{$i=pop@n;$_=@n-$_-($_<=$i&&$i)for@n}

সমাধান যেগুলি মুদ্রণ করে তা স্থিরভাবে সাব-অনুকূল হয়। (আমার প্রায় 24 টি অক্ষর আগে খুব ভাল আউটপুট সহ একটি প্রোগ্রাম ছিল ....)

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

— রুটির ঝুরি
সূত্র

3

পাইথন 2 (254)

সাধারণ বিএফএস-অনুসন্ধান, কিছু স্টাফ ইনলাইনড, সম্ভবত অনুসন্ধানের স্টাইলটি পরিবর্তন না করে আরও সংকুচিত করা যেতে পারে। আশা করি এটি সম্ভবত কীভাবে কিছুটা গল্ফ করা শুরু করবেন (একটি সাধারণ মন্তব্যে খুব বেশি) shows

ব্যবহার করুন:

python script.py 4 2 3 1

(2 স্পেস = ট্যাব)

import sys
t=tuple
i=t(map(int,sys.argv[1:]))
g=t(range(1,len(i)+1))
q=[i]
p={}
l={}
while q:
 c=q.pop(0)
 for m in g:
  n=c[:m][::-1]+c[m:]
  if n==g:
   s=[m]
   while c!=i:s+=[l[c]];c=p[c]
   print s[::-1]
   sys.exit()
  elif n not in p:q+=[n];p[n]=c;l[n]=m

— মাইল
সূত্র

1

আপনি এর sys.exit()সাথে প্রতিস্থাপন করতে পারেন 1/0(কোডগল্ফে আপনি স্টার্ডারে কী মুদ্রিত হয় তার কোনও যত্ন নেই ...)।

— বাকুরিউ

অবশ্যই, আমি print s[::-1];1/0কয়েক অক্ষর শেভ করতে পারি

— মাইল 7

বিএফএস খুব আকর্ষণীয়, তবে এটি দিয়ে 4 2 3 1দেয় 2 3 2 4, যা আসলে অবৈধ।

— ডানিরো

1

@ ডানিরো কিভাবে এই আউটপুটটি অবৈধ? 4 2 3 1-> 2 4 3 1-> 3 4 2 1-> 4 3 2 1->1 2 3 4

— গ্যারেথ

@ গ্যারেথ আমার কোন ধারণা নেই! এবং আমি এটি দুটিবারও পরীক্ষা করে দেখেছি .. ওহ ভাল, তবে কিছু নয়) :) চমৎকার সমাধান, মাইল টি।

— ডানিরো

3

পাইথন 2: 120

L=map(int,raw_input().split())
u=len(L)
while u:i=L.index(max(L[:u]))+1;L[:i]=L[i-1::-1];L[:u]=L[u-1::-1];print i,u;u-=1

এটি দক্ষ নয়: এটি সর্বাধিক বাছাইয়ের ক্রমটি খুঁজে পাবে না এবং প্রদত্ত ক্রমটি কোনও অপস (যেমন প্রথম প্রথম উপাদানটিকে উল্টানো )ও ধারণ করতে পারে, তবুও আউটপুটটি বৈধ।

আউটপুট ফর্ম দেওয়া হয়:

n_1 n_2
n_3 n_4
n_5 n_6
...

কোনটি ফ্লিপ ক্রম পঠিত হিসেবে করা উচিত: n_1 n_2 n_3 n_4 n_5 n_6 ...। আপনি যদি একটি আউটপুট পেতে চান:

n_1 n_2 n_3 n_4 n_5 n_6 ...

printবিবৃতিতে কেবল একটি কমা যুক্ত করুন ।

— Bakuriu
সূত্র

[:i][::-1]-> [i-1::-1], [:u][::-1]-> [u-1::-1], 2 টি অক্ষর বাঁচায়

— অস্থিরতা

প্রকৃতপক্ষে, L[:i]=L[i-1::-1];L[:u]=[u-1::-1]আরও 3 টি অক্ষর সংরক্ষণ করে

— অস্থিরতা

@ উদ্বিগ্নতা টিপস জন্য ধন্যবাদ। অন্তর্ভুক্ত।

— বাকুরিউ

3

পাইথন - 282 টি অক্ষর

import sys
s=sys.argv[1]
l=s.split()
p=[]
for c in l:
 p.append(int(c))
m=sys.maxint
n=0
while(n==(len(p)-1)):
 i=x=g=0
 for c in p:
  if c>g and c<m:
   g=c
   x=i
  i+=1
 m=g
 x+=1
 t=p[:x]
 b=p[x:]
 t=t[::-1]
 p=t+b
 a=len(p)-n;
 t=p[:a]
 b=p[a:]
 t=t[::-1]
 p=t+b
 print p
 n+=1

আমার প্রথম কোড গল্ফ; আমি কোন বিভ্রমের মধ্যে নেই আমি জিতব , তবে আমি খুব মজা পেয়েছি। সবকিছুকে একটি-চরিত্রের নাম দেওয়া নিশ্চিতভাবে পড়লে তা ভয়ঙ্কর হয়ে যায়, আমি আপনাকে বলি! এটি কমান্ড লাইন থেকে চালিত হয়, নীচে নমুনা বাস্তবায়ন:

Python PancakeSort.py "4 2 3 1"
[1, 3, 2, 4]
[2, 1, 3, 4]
[1, 2, 3, 4]

আমি যেভাবে চলেছি সে সম্পর্কে বিশেষ বা উদ্ভাবনী কিছুই নেই, তবে এফএএইউ আগ্রহী পাঠকদের জন্য একটি নন-গল্ফ সংস্করণ পোস্ট করার পরামর্শ দেয়, তাই আমি নীচে এটি করেছি:

import sys

pancakesStr = sys.argv[1]
pancakesSplit = pancakesStr.split()
pancakesAr = []
for pancake in pancakesSplit:
    pancakesAr.append(int(pancake))

smallestSorted = sys.maxint
numSorts = 0

while(numSorts < (len(pancakesAr) - 1)):
    i = 0
    biggestIndex = 0
    biggest = 0
    for pancake in pancakesAr:
        if ((pancake > biggest) and (pancake < smallestSorted)):
            biggest = pancake
            biggestIndex = i
        i += 1

    smallestSorted = biggest  #you've found the next biggest to sort; save it off.
    biggestIndex += 1   #we want the biggestIndex to be in the top list, so +1.

    top = pancakesAr[:biggestIndex]
    bottom = pancakesAr[biggestIndex:]

    top = top[::-1] #reverse top to move highest unsorted number to first position (flip 1)
    pancakesAr = top + bottom   #reconstruct stack

    alreadySortedIndex = len(pancakesAr) - numSorts;

    top = pancakesAr[:alreadySortedIndex]
    bottom = pancakesAr[alreadySortedIndex:]

    top = top[::-1] #reverse new top to move highest unsorted number to the bottom position on the unsorted list (flip 2)
    pancakesAr = top + bottom   #reconstruct list

    print pancakesAr    #print after each flip

    numSorts += 1

print "Sort completed in " + str(numSorts) + " flips. Final stack: "
print pancakesAr

আমি যে বেসিক অ্যালগরিদমটি ব্যবহার করেছি তা হ'ল প্রশ্নের সাথে লিঙ্কিত উইকি নিবন্ধে উল্লিখিত :

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

— WendiKidd
সূত্র

1

গল্ফ করার জন্য কিছু টিপস: ইনডেন্টেশনের জন্য চারটি স্থান ব্যর্থ। আরও ভাল: একটি জায়গা ব্যবহার করুন; আরও ভাল: আরও কিছুটা কাটাতে ট্যাব এবং স্পেসগুলি একত্রিত করুন।

— জন ডিভোরাক

1

t=p[:x] t=t[::-1](16 + ইনডেন্টেশন) t=p[:x][::-1](13) বা এমনকি t=p[x-1::-1](12) এ হ্রাস করা যেতে পারে । আপনি যা কিছু করতে পারেন তা ইনলাইন করুন:p=p[x-1::-1]+p[x:]

— জন ডিভোরাক

পিছন থেকে গণনা করতে নেতিবাচক সূচকগুলি ব্যবহার করুন। len(a)-nহয়ে যায় -n; p=p[-n-1::-1]+p[-n:]। সঠিক ক্রিয়াকলাপগুলি ব্যবহার করে আরও গল্ফ:p=p[~n::-1]+p[-n:]

— জন ডভোরাক

1

উম্ম ... আপনি কেবল শেষ ফলাফল নয়, পুরো ফ্লিপিং ক্রম মুদ্রণ করার কথা।

— জন ডিভোরাক

জান ডভোরাক যা বললেন। উপায় দ্বারা কোডগল্ফ স্বাগতম। আপনি কিছু সহজ পদক্ষেপের সাহায্যে চরিত্রের সংখ্যাটি সহজেই অর্ধেকে কাটাতে পারেন; তাদের কিছু উল্লেখ করা হয়েছে। এছাড়াও, মধ্যবর্তী ভেরিয়েবলগুলি ভাল নয়। তালিকা বোধগম্যতা দুর্দান্ত । তবে আপনি যদি sys.argv ব্যবহার করছেন তবে প্রতিটি ইনপুটটির পাশাপাশি একটি যুক্তি হতে পারে তবে map(int,sys.argv[1:])আপনার 6 টি প্রথম লাইন এখন যা করে তা করে does i=x=g=0কাজ করে, তবে আপনার যাইহোক ভেরিয়েবলের পরিমাণ হ্রাস করা উচিত। যদিও আমি আপনাকে একটি জিনিস দেব: এটি একমাত্র অজগর প্রবেশ যা আমি কমপক্ষে বুঝতে পারি: ডি

— ড্যানিরো

3

সি # - ~~264 259 252~~ 237 টি অক্ষর

সবচেয়ে সহজ অ্যালগরিদম ব্যবহার করে এবং রিন্ডানড ফ্লিপ ছাড়াই সঠিক আউটপুট উত্পাদন করে। আমি যদি আউটপুটে 1 এর (নন-ফ্লিপগুলি) অন্তর্ভুক্ত করার অনুমতি দিই তবে 7 টি অক্ষর শেভ করতে পারি, তবে এটি কুৎসিত।

আমি gotoসর্বাধিক গল্ফেজ ব্যবহার করে অবলম্বন করেছি। কিছু অক্ষর এটি অ-ফ্লিপগুলি সম্পাদন করে (তবে সেগুলি মুদ্রণ করে না) সংরক্ষণ করে।

সর্বশেষ উন্নতি: ইনপুট রূপান্তরিত না করে ইনপুট অ্যারেটিকে স্ট্রিং হিসাবে রাখছে।

using System.Linq;class P{static void Main(string[]a){var n=a.ToList();for(int p
=n.Count;p>0;p--){int i=n.IndexOf(p+"")+1;if(i<p){f:if(i>1)System.Console.Write
(i);n=n.Take(i).Reverse().Concat(n.Skip(i)).ToList();if(i!=p){i=p;goto f;}}}}}

Ungolfed:

using System.Linq;
class Program
{
    static void Main(string[] args)
    {
        var numbers = args.ToList();

        for (int pancake = numbers.Count; pancake > 0; pancake--)
        {
            int index = numbers.IndexOf(pancake+"") + 1;
            if (index < pancake)
            {
                flip:

                if (index > 1)
                    System.Console.Write(index);

                numbers = numbers.Take(index)
                                 .Reverse()
                                 .Concat(numbers.Skip(index))
                                 .ToList();

                if (index != pancake)
                {
                    index = pancake;
                    goto flip;
                }
            }
        }
    }
}

নিখরচায় আমার 262 টি প্রাথমিক সমাধান এখানে রয়েছে (264 অক্ষর গল্ফ করেছেন):

using System.Linq;
using System;

class Program
{
    static void Main(string[] args)
    {
        var numbers = args.Select(int.Parse).ToList();

        Action<int> Flip = howMany =>
        {
            Console.Write(howMany);
            numbers = numbers.Take(howMany)
                             .Reverse()
                             .Concat(numbers.Skip(howMany))
                             .ToList();
        };

        for (int pancake = numbers.Count; pancake > 0; pancake--)
        {
            int index = numbers.IndexOf(pancake) + 1;
            if (index < pancake)
            {
                if (index > 1)
                    Flip(index);
                Flip(pancake);
            }
        }
    }
}

— ইগবি লার্জম্যান
সূত্র

অ-সামঞ্জস্যপূর্ণ ক্রমগুলি পরিচালনা করে না - সেই ইনপুটগুলির সাথে ভুল ফলাফল দেয়।

@ হ্যাচেট: আপনার অর্থ কী তা আমি নিশ্চিত নই। তুমি কি আমাকে একটা উদাহরণ দিতে পারবে?

— ইগবি লার্জম্যান

1 22 এর ইনপুট দেওয়া, ফলাফলটি বলেছে যে একটি অদলবদল হবে যার ফলস্বরূপ 22 টি হবে would 1 আমি মনে করি আপনার কোডটি ধারাবাহিক সংখ্যা অন্তর্ভুক্ত করার ক্রমটি প্রত্যাশা করে (উদাহরণস্বরূপ: 2 4 1 3), তবে ইনপুটগুলির মতো আশা করে না ( 2 24 5 5 990)।

@ হ্যাচেট: প্রকৃতপক্ষে, আমি ধারাবাহিকতায় ফাঁকগুলি সমর্থন করার কোন চেষ্টা করি নি, কারণ এটির কোনও মানে হবে না। প্যানকেক বাছাইয়ের ধারণা হ'ল বস্তুর স্ট্যাক বাছাই করা, স্বেচ্ছাসেবী সংখ্যার একটি গ্রুপ নয়। প্রতিটি বস্তুর সাথে যুক্ত নম্বরটি স্ট্যাকের মধ্যে তার যথাযথ অবস্থান চিহ্নিত করে। অতএব সংখ্যাগুলি সর্বদা 1 দিয়ে শুরু হবে এবং স্বচ্ছল হবে।

— ইগবি লার্জম্যান

আমি নিশ্চিত ছিলাম না, কারণ প্রশ্নটি "সিকোয়েন্স" বলেছিল, এবং গণিতে, {1, 22 a একটি বৈধ ক্রম, তবে উভয় উদাহরণই সংগত সংখ্যা ছিল। তাই আমি ওপি থেকে স্পষ্টতা চেয়েছি (প্রশ্নের মন্তব্য দেখুন)। আমি মনে করি এখানে বেশিরভাগ উত্তর ফাঁকা ঠিকঠাক পরিচালনা করবে।

2

হাস্কেল , 72 71 বাইট

h s|(a,x:b)<-span(<maximum s)s=map length[x:a,s]++h(reverse b++a)
h e=e

এটি অনলাইন চেষ্টা করুন! সর্বাধিক সন্ধান করে, এটি পিছনে পিছলে যায় এবং পুনরাবৃত্তভাবে বাকী তালিকাটিকে সাজান।

সম্পাদনা: -1 বাইট ধন্যবাদ BMO

— Laikoni
সূত্র

2

পার্ল 5.10 (বা উচ্চতর), 66 বাইট

সহ +3জন্য Perl 5.10 বিনামূল্যে বিবেচনা করা হয় স্তর ভাষা আনতে-nuse 5.10.0

#!/usr/bin/perl -n
use 5.10.0;
$'>=$&or$.=s/(\S+) \G(\S+)/$2 $1/*say"$. 2 $."while$.++,/\S+ /g

এসটিডিআইএন-এ এক লাইন হিসাবে ইনপুটটি চালান:

flop.pl <<< "1 8 3 -5 6"

বারবার যে কোনও বিবর্তন সন্ধান করে তালিকাটি সাজান, সামনে এটিকে উল্টিয়ে ফিরুন এবং তারপরে উল্টোটি উল্টান এবং সবকিছুকে তার পুরানো অবস্থানে ফিরিয়ে আনুন। এবং যে তাই আমি বিপরীত প্রয়োজন হবে না বিপর্যয় সোয়াপিং সমতূল্য (যা স্ট্রিং উপর বিশ্রী যেহেতু এটি মূল্যবোধের ডিজিটের বিপরীত হবে রূপান্তর যেমন 12করতে 21)

— টন হসপেল
সূত্র

1

সি # - 229

using System;using System.Linq;class P{static void Main(string[] a){
var n=a.ToList();Action<int>d=z=>{Console.Write(z+" ");n.Reverse(0,z);};
int c=n.Count;foreach(var s in n.OrderBy(x=>0-int.Parse(x))){
d(n.IndexOf(s)+1);d(c--);}}}

পাঠযোগ্য সংস্করণ

using System;
using System.Linq;
class P {
    static void Main(string[] a) {
        var n = a.ToList();
        Action<int> d = z => { Console.Write(z + " "); n.Reverse(0, z); };
        int c = n.Count;
        foreach (var s in n.OrderBy(x => 0 - int.Parse(x))) {
            d(n.IndexOf(s) + 1); d(c--);
        }
    }
}

প্যানকেকস উল্টানো

কাজটি:

সম্পাদনা:

গল্ফস্ক্রিপ্ট, 34/21 অক্ষর

পাইথন, 91 90 টি অক্ষর

রুবি 1.9 - 109 88 79 টি অক্ষর

গল্ফস্ক্রিপ্ট, 31 29 টি অক্ষর

পার্ল, 103 100 টি অক্ষর

পাইথন 2 (254)

পাইথন - 282 টি অক্ষর

হাস্কেল , 72 71 বাইট

পার্ল 5.10 (বা উচ্চতর), 66 বাইট