এটি খুব সহজ: আপনার প্রোগ্রাম বা ফাংশনটিতে নিম্নলিখিত পাঠ্য উত্পন্ন করা উচিত:

Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.

সূক্ষ্ম মুদ্রণ

আপনি কোনও প্রোগ্রাম বা ফাংশন লিখতে পারেন , যা আউটপুটটিকে স্ট্রিং হিসাবে ফিরিয়ে দেয় বা এটি STDOUT (বা নিকটতম বিকল্প) এ মুদ্রণ করে। আপনি আউটপুটে বিকল্পভাবে একটি একক পেছনের নতুন লাইন অন্তর্ভুক্ত করতে পারেন।

স্কোরিং

আপনার কোডে থাকা বাইটের সংখ্যাটি আপনার কোডের অনন্য বাইটের সংখ্যা দ্বারা গুণিত হয়েছে

সর্বনিম্ন স্কোর জয়।

উদাহরণস্বরূপ, একটি ব্রেইনফাক বা একটি সাদা জায়গার উত্তরের এখানে বিশাল সুবিধা হবে কারণ গুণকটি খুব কম হবে (যথাক্রমে 8 এবং 3)। তবে, সাধারণত, সেই ভাষাগুলিতে প্রোগ্রাম লেখার ফলে দীর্ঘতর কোড তৈরি হয় যা সেই সুবিধাটিকে তুচ্ছ করতে পারে।

স্ট্যান্ডার্ড লুফোলগুলি যা আর মজার নয় নিষিদ্ধ ।

code-challenge string kolmogorov-complexity

— durron597
সূত্র

আমি ধরে নিচ্ছি কেসিং ঠিক হতে হবে?

— এনগ্রেডট্যাঙ্কার

@ ক্রেজেদুদে হ্যাঁ, এটি বিন্দুর মতো

— durron597

ঠিক আছে। শুধু স্পষ্ট করা। : পি

— এনারাজেডট্যাঙ্কার

1

@ কার্পেট পাইথন স্যান্ডবক্সে এটি নিয়ে কিছুটা বিতর্ক হয়েছিল এবং শেষ পর্যন্ত আমি স্থির করেছিলাম যে খেলার মাঠে সত্যিকারের স্তরের কোনও উপায় নেই। খেয়াল করুন যে হোয়াইটস্পেস এবং অনিদ্রায় যেভাবেই সর্বোচ্চ স্কোর রয়েছে!

— durron597

2

যেমনটি আমি কোথাও লিখেছি, যদি আমরা ধরে নিই যে আরও অনন্য অক্ষরের জন্য ক্ষতিপূরণের জন্য আরও বাইট ব্যবহার করে সংখ্যাগুলিকে বিভিন্ন ঘাঁটিতে রূপান্তর করার অনুরূপ আচরণ করে, তবে প্রায় bytecount~Log(X,unique)এই সমস্যাটির জন্য এক্স সহ কিছুটা ধ্রুবক। এভাবে অনন্য ^ বাইটকাউন্ট ~ ধ্রুবক। এই স্কোর গণনা (লগ 2) দেয়

python2_mbomb007 728, python2_carpetpython 744, ruby 756, Fish 825, Insomnia 1148, cjam 1277, whitespace 1484, brainfuck 3546

। সুতরাং ব্রেইনফাকের উত্তর ছাড়া এটি তুলনামূলকভাবে ধ্রুবক ...

— ব্লুটোরেঞ্জ

7

অনিদ্রা , 575 বাইট * 4 = 2300

dyedd=dyyyye=d=yd=dddde=ded=deey=eyy=de=edd=eydyee=yeyy=yey==ddyee=eydee=y=eyeedd=dde=yddd=eede=yedde=eeyd==yeyy=yyddy=eyy=dy=dddye=dyey=ede=yddd=dde=de=yyye=yyye=ddyyy=dyy=yeyddy=eyyyde=eed=ddd=yd=edyyd=eeydd=yedd=eye=eee=eeyy=yyyedde=d=eyyyedy=d=yddyye==dyyede=ddd=eydd=yd=ddde==eeeeyy=yeyd=deyy=yyy=ydy=dy=dd=e=ey=dddddy=yeey=ey=eed=ddd=eedy=ddddde=ydeyy=edd=ydy=ddy=yeedd=ydde=dde=edyye=ded=yeed=dddddde=eedy=eyde=ydy=ydydd=eyydd=dd=dddd=ddyye=ydeey=ed=eeeye=y=ydydde=eyyd=eyee=dy=edeyed=dyed==eyyddey=dd=yddd=yddd=de=ddedy=eyydd=eeedy==eyyydeee=d=d=eydd=yey=dyy==yyyedy=

4 টি অক্ষর ব্যবহার করে dye=।

সমাধান 1 বি (অপ্রকাশিত): 783 বাইট * 3 = 2349

eeeeyeeyy=eeyy=yeyye=yyyeeyye=eeeye=yeyey=eyeyyy=eyy=eeyeye=yeyeyyy=yyeeye=yeyy=yey==yyeyeyeye=eyyey=y=yyyyyy=y=eyyeyyyyyyye=eeye=yyeeyye=eyeyeyyy==yeyy=yeyyyeyye=yyyeeyy==eeyyeee==eeyye=yyyyeyyeyyye=yyyyyyy=yeye=eyyyyy=eeye=eeyeeeeey=eyeye=eeee=yeyyye=eyyyyye=y=eeeyyy=eyyeyee=yyy=eyye=yeyeeee=yyeyeyyyy=eeyy=yyyyy=eyyyy=yyeeyye=e=eyyyyy=eyey==eyeyy=yyyyyeyeyeye=ye=yyyyyy==eeeeyy=yeye=yeyyey=yyy=eyyyeeeye==yeeyyeyy=e==yeeeyyyeyy=yeey=ey=eee=eyeyy=yyeeee=yeeyyyyy=yee=yeyyy=yeeeeyy=eyeeeeeye=eeeyy=yyeeeeyyye=yey=yyyyeeyye=yyyyyyy=yeee=eeeeyyeye=eyeeye=eeyyeyyy=eeyee=yyyyyeeyy=eee=eeyyeyyyyy=eeey=eyyeeyy=eyyeyyy=eeeeyeee=eeeye=y=yyyeyy=yyeeee=yyeyey=ey=eyyyyyeyyy=yeye==yeeyyyeyy=yeye=yyyyeeyy=eeeyyeeyyy=yeeyeyyy=eeyye=eee=eyyye==eyeyeyyyyy=e=eeyeeye=yeey=eyeyy=eyeye=ey=eyyeye=

শুধুমাত্র 3 টি অক্ষর ব্যবহার করে ey=।

সমাধান 1: 826 বাইট * 3 = 2478

yoyoy~oyoyo~oyooyy~ooyyoyy~ooyyyyoy~~yoyyo~ooyoooyooo~yoyyo~oyoyoyyy~yyo~oyyoo~~ooooy~oyyyyy~oyoyoo~~oyyyoooyy~~oyoyooyyy~yyooo~yoyo~yoyyyyo~yooyo~y~yyoyyyooyy~oyyooy~ooyoy~oyyooy~ooyyo~yoyyoo~o~ooyo~yooyyoo~yoyoy~ooyyyyooo~oyoyyo~yyoyyyoo~yyo~yyooyyo~yoyyoooy~~yoyyyooyoyy~oyoyyy~yoooyyoy~yooyy~yooyyo~yyooyyoo~oyoyo~oyyy~oyyo~oyyoyo~oyyyoo~oyoyyoo~yooyo~ooooo~~yoyyoyyoyoo~yoyyooo~y~ooooy~yyyoy~ooooyyoyyoy~oyyoo~oyyoyo~yoyyyooy~oyooo~yoyyoyy~yyyyyo~oyooy~oyoyy~yoyyyoy~ooyoy~yoyyoooy~~oyyyo~ooooooy~yooyoyyoyo~yooyyo~oooyyo~yoyooyyo~oyyy~o~yooooy~oyoyyooooy~~yoyyooyyo~oy~yyyoyyyyy~yoyyyoy~yooo~oooy~oooooyyoyyyo~yoyyo~y~oooyyyoyoo~yyooooyoyy~y~oooyyyoy~~yoy~oyyoyoyyy~yoyyyyy~oyooo~yyyyooo~yooyyoy~yooyo~yoyyyo~yyoyyyo~o~ooooooyoy~oyoyyoy~yyoooo~ooooyy~oyoyoy~ooyyo~yyoooyo~yyyyyo~oyyo~yooyyooyyoy~~ooyyyyoyyy~ooyyo~yyooo~

শুধু 3 টি অক্ষর ব্যবহার করে: yo~। এটি তৈরি করতে একটি প্রোগ্রাম ব্যবহৃত হয়।

বর্তমানে, সমস্ত প্রোগ্রাম কেবল 0, 1, 2, 6 নির্দেশাবলী ব্যবহার করে অন্য কথায়, তারা বিটগুলিকে একক বাইটে চালিত করে এবং ফলাফল মুদ্রণ করে।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
সূত্র

19

সিজেম, 266 281 456 বাইট * 14 12 7 অনন্য = 3724 3372 3192

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

14301201124204202034420112034224204431020210101232301021240204310431312122132100240400222324402030223103420431324402222132223233141443401210314023001122320404112224314302132421403301243334313000011124244441400003310332301330220022110121411122100040310110020040121444302100143202204330334033211334242120304123121024200421121232100303121022431044444423243331440434010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

ব্যাখ্যা

আমি যে কৌশলটি ব্যবহার করেছি তা হ'ল স্ট্রিংয়ের প্রতিটি চরিত্রকে বেস -১৩৩ সংখ্যা হিসাবে বিবেচনা করা এবং প্রোগ্রামটিকে দশমিক সংখ্যা হিসাবে এনকোড করা। প্রোগ্রামটি তখন সেই সংখ্যাটিকে বেস 123 এ ফিরে রূপান্তর করে এবং প্রতিটি বেস -123 ডিজিটকে একটি অক্ষরে ফিরিয়ে দেয়। প্রোগ্রামটি কেন বর্তমান অবস্থায় রয়েছে তা ব্যাখ্যা করা শক্ত কারণ, আমি এর প্রতিটি সংস্করণ ব্যাখ্যা করব।

প্রোগ্রামটির শেষটি প্রথম সংস্করণে দেখতে কেমন হয়েছিল তা এখানে:

...2068438725 123b:c

এটি কৌশলটিকে সবচেয়ে সহজভাবে কার্যকর করে। সংখ্যা, বেস 10 এ সাধারণত এনকোড করা হয়, বেস 123 এ ফিরে রূপান্তরিত হয় এবং প্রতিটি বেস -123 ডিজিটকে কোনও অক্ষরে ম্যাপ করা হয়। তবে এটি ৪ টি অনন্য অজানা অক্ষর ব্যবহার করে এবং এর মধ্যে যে কোনও একটি থেকে মুক্তি পেতে সক্ষম হওয়া কম স্ট্রেডওয়ার্ড কোড ব্যবহারের কারণে হিট সাইজের হিট হতে পারে।

প্রথমত, আমি বুঝতে পেরেছিলাম যে আমি রানার সময় এএসসিআইআই চরিত্রের মানগুলিকে একটি অক্ষরে রূপান্তরিত করেছি (ইতিমধ্যে উপস্থিত অপারেটরের সাথে) এবং অপারেটরের সাথে তাদের মূল্যায়ন করে আমি bও :অপারেটরদের থেকে মুক্তি পেতে পারি । অপারেটরের সাথে এটি করা কিছুটা জটিল হয়ে উঠল , যেহেতু নিম্নলিখিত অপারেটরের সাথে এটি একসাথে বিশ্লেষণ করতে হবে । আমি অক্ষর উত্পাদক দ্বারা এই মীমাংসিত এবং এবং তারপর উত্পাদক এবং চরিত্র মূল্যায়ন , যা স্ট্রিং মধ্যে সাবেক দুই অক্ষর concatenates যা পরে সঠিকভাবে মূল্যায়ন করা যাবে।c~:c:c+:c

দ্বিতীয়ত, আমি বুঝতে পেরেছিলাম যে ~আমি অপারেটরটির সবেমাত্র পরিচয় করিয়ে দিয়েছিলাম একটি নতুন নতুন ওভারলোডেড বৈকল্পিক: একটি নম্বর দেওয়া হলে, এটি বিটওয়াস পরিপূরক উত্পাদন করে। এটি একটি সংখ্যার পরে পর পর দুবার ব্যবহার করে, আমি উত্সটিতে টোকেন বিরতি কোনও ফলশ্রুতিগত গণনীয় প্রভাব ছাড়াই পরিচয় করিয়ে দিতে পারি, যার ফলে আমাকে পৃথক সংখ্যার সাথে পৃথক নম্বরগুলিতে ব্যবহৃত স্থানগুলি প্রতিস্থাপন করতে দেয় ~~।

চূড়ান্ত ফলাফলটি শেষে কোডের আরও 15 বাইট, তবে এই ব্যয়টি 14 টির মধ্যে 2 টি স্বতন্ত্র অক্ষর মুছে ফেলার সুবিধা দিয়ে ব্যাপকভাবে ছাড়িয়ে গেছে the দ্বিতীয় সংস্করণের সমাপ্তির সাথে প্রথম সংস্করণের সমাপ্তির তুলনা এখানে:

...2068438725  123[ b  ][   :c    ]
...2068438725~~123~~98c~58c99c43c~~

আমি যে 2 অপারেটরটি ব্যবহার করেছিলাম তার চেয়ে কম ব্যবহার করা অসম্ভব, তবে আমি এখনও কম অনন্য অক্ষর চাইছি। সুতরাং পরবর্তী পদক্ষেপটি ছিল অঙ্কগুলি দূর করা। সংখ্যার এনকোডিংটি পরিবর্তন করে যাতে প্রতিটি দশমিক অঙ্কটি সত্যই একটি বেস -5 সংখ্যার হয়ে থাকে, আমি সম্ভবত 6-9 সংখ্যাগুলি মুছতে পারি। প্রোগ্রামের প্রান্ত থেকে কিছু অপসারণ করার আগে এটি দেখতে এরকম দেখাচ্ছে:

...4010014400 10b5b123b:c

পূর্বে উল্লিখিত হিসাবে, স্থান অপসারণ করা সহজ is কিন্তু b, :এবং cএত সহজ হবে না, যেমন তাদের চরিত্র কোড আছে 98, 58এবং 99যথাক্রমে। এই সমস্ত ধারণকৃত অঙ্কগুলি নির্মূলের জন্য চিহ্নিত করা হয়েছে, সুতরাং আমি সেগুলিগুলি প্রাপ্ত করার উপায় খুঁজে বের করতে হয়েছিল। এবং একমাত্র দরকারী সংখ্যাযুক্ত অপারেটরগুলি হ'ল 5-9 নয় এমন অক্ষর মান রয়েছে হ্রাস, বৃদ্ধি, গুণ এবং যোগ।

কারণ 98, আমি প্রাথমিকভাবে ব্যবহার করেছি 100~~40c~40c~, যা 100দু'বার কমে যায় । তবে আমি বুঝতে পেরেছিলাম যে আমি ~অপারেটরের আরও একটি ব্যবহার করতে পারি , বিটওয়াইসের পরিপূরকটি আমাকে নেতিবাচক সংখ্যাগুলি পেতে দেয় যা যুক্ত হওয়ার পরে আমাকে বিয়োগফলকে অনুকরণ করতে দেয়। সুতরাং আমি তখন ব্যবহার করেছি 100~~1~43c~, যা যোগ করে 100এবং -22 বাইট ছোট। জন্য 58, আমি ব্যবহার করেছি 44~~14~~43c~, যা যোগ 44এবং 14। এবং এর জন্য 99, আমি ব্যবহার করেছি 100~~40c~, যা হ্রাস পাচ্ছে 100।

চূড়ান্ত ফলাফলটি বেশ বড় এবং অচল, তবে উল্লেখযোগ্যভাবে বৃহত্তর সংখ্যা এবং প্রসেসিং কোডের ব্যয়টি 12 এর মধ্যে 5 টি অনন্য অক্ষরকে মুছে ফেলার বড় সুবিধা দ্বারা কিছুটা বেড়ে গেছে elim eliminations:

...4010014400  10[      b      ][  5  ][     b     ]123[      b      ][            :c            ]
...4010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

— Runer112
সূত্র

ঠিক আছে, আমি এখন মুগ্ধ। বেস 6 সংখ্যাগুলি, বেস 7 অঙ্কগুলি ইত্যাদিকে কীভাবে বেস 5 এর সাথে তুলনা করতে পারি?

— durron597

@ durron597 তারা সত্যিই কম্পিউটেশন কোন সহজ, অপারেটরদের চরিত্র কোড হিসাবে আমি প্রয়োজন না ( 98, 58, এবং 99) এখনও সীমার বাইরে। এবং বেস বাড়ানো কেবলমাত্র প্রোগ্রামের মোট আকার 8-10% হ্রাস করে, যা নতুন অনন্য চরিত্রের দ্বারা প্রাপ্ত 10-15% স্কোর অর্জনের জন্য যথেষ্ট নয়। bঅপারেটরটিকে একইভাবে পুনরায় অন্তর্ভুক্ত করা উপযুক্ত নয়।

— রানার 1212

একটি সংখ্যা নিন এবং এটি বেসে রূপান্তর করুন। এর দৈর্ঘ্য হবে floor(log_b(x)+1)এবং এতে bবিভিন্ন চিহ্ন থাকবে। স্কোর তাই b*floor(log_b(x)+1)। এক্স একটি প্রদত্ত বৃহত সংখ্যা, এবং আপনি যদি খ এর জন্য এই প্লট করেন তবে আপনি খুঁজে পাবেন ন্যূনতমটি b = 3 এ অনেক বেশি। যেমন, আপনি উচ্চতর বেসগুলি (লগ) ব্যবহার করার সাথে দৈর্ঘ্যটি কিছুটা হ্রাস পায় তবে চরসেটের আকারটি রৈখিকভাবে বৃদ্ধি পায়, সুতরাং এটির পক্ষে এটি উপযুক্ত নয়। একটি সহজ হোয়াইটস্পেস প্রোগ্রাম তৈরি, কিন্তু এটা নিয়ে 4134. শুধুমাত্র একটি স্কোর পায়

— blutorange

@ ব্লুটোরেঞ্জ আপনার হোয়াইটস্পেস প্রোগ্রাম করা উচিত। 4134 দ্বিতীয় স্থানের জন্য যথেষ্ট

— durron597

16

হোয়াইটস্পেস, 1157 937 বাইট * 3 অনন্য = 3471 2811

জনপ্রিয় (?) অনুরোধের দ্বারা আমি আমার সাদা স্থান সমাধান পোস্ট করছি।

প্রয়োজনীয় কোডটি হ্রাস করার জন্য, আমি সম্পূর্ণ স্ট্রিংটিকে একটি বাইনারি সংখ্যা (প্রতিটি বাইটের জন্য 7 বিট) হিসাবে হার্ডকোড করেছি। একটি সাধারণ লুপ অক্ষরগুলি বের করে এবং মুদ্রণ করে।

Filebin.ca এ উত্স কোড।

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

হোয়াইটস্পেস প্রোগ্রাম তৈরির জন্য রুবি স্ক্রিপ্ট (l = WHITESPACE, t = TAB, u = NEWLINE, // এর পরে সমস্ত কিছু উপেক্ষা করা একটি ফাইলকে লিখে prog.h):

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'

def b2ws(bin)
    bin.chars.map{|x|x=='0' ? "l" : "t"}.join
end
def d2ws(dec,pad=0)
    b2ws(dec.to_s(2).rjust(pad,'0'))
end

bin = str.reverse.chars.map do |x|
    "  " + d2ws(x.getbyte(0),7) + " // char <#{x=="\n" ? "LF" : x}>"
end
data = "lll // pushes string as one large number\n#{bin.join("\n")}\nu"

File.open('prog.h','w') do |fout|
    fout << data << "\n"
    fout << <<-eos

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu
    eos
end

উদাহরণস্বরূপ, সাদা-স্পেস প্রোগ্রামটি মানব-পঠনযোগ্য আকারে। একটি সাধারণ স্ক্রিপ্টকে এটি একটি আসল সাদা স্থান প্রোগ্রামে রূপান্তর করতে নীচে দেখুন।

lll // pushes string as one large number
  ltltttl // char <.>
  ttltltt // char <k>
  ttltttt // char <o>
  ttltttt // char <o>
  ttlttll // char <l>
  ltlllll // char < >
  ttllllt // char <a>
  ltlllll // char < >
  ttlltlt // char <e>
  ttlttlt // char <m>
  ltlllll // char < >
  ttllttt // char <g>
  ttltttl // char <n>
  ttltllt // char <i>
  tttlttl // char <v>
  ttltllt // char <i>
  ttllttt // char <g>
  ltlllll // char < >
  ltllltl // char <">
  ltlttll // char <,>
  tlllttt // char <G>
  tlltttt // char <O>
  tllltll // char <D>
  ltlllll // char < >
  tlttllt // char <Y>
  tlttltl // char <Z>
  tlllllt // char <A>
  tllttll // char <L>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltlllll // char < >
  tltlltl // char <R>
  tllltlt // char <E>
  tltlttl // char <V>
  tlltttt // char <O>
  ltlllll // char < >
  tltlltt // char <S>
  tltllll // char <P>
  tllttlt // char <M>
  tltltlt // char <U>
  tlltltl // char <J>
  ltlllll // char < >
  tlttlll // char <X>
  tlltttt // char <O>
  tlllttl // char <F>
  ltlllll // char < >
  tlltttl // char <N>
  tltlttt // char <W>
  tlltttt // char <O>
  tltlltl // char <R>
  tlllltl // char <B>
  ltlllll // char < >
  tlltltt // char <K>
  tlllltt // char <C>
  tlltllt // char <I>
  tltltlt // char <U>
  tltlllt // char <Q>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltllltl // char <">
  ltlllll // char < >
  ltttltl // char <:>
  ltltllt // char <)>
  ttlltlt // char <e>
  ttllltt // char <c>
  ttllllt // char <a>
  ttlltlt // char <e>
  tttllll // char <p>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttlt // char <m>
  ltlllll // char < >
  tttlltl // char <r>
  ttltttt // char <o>
  ttllttl // char <f>
  ltlllll // char < >
  ttttllt // char <y>
  ttlltll // char <d>
  tttlttt // char <w>
  ttltttt // char <o>
  tttlltl // char <r>
  ltlllll // char < >
  ttltttt // char <o>
  ttltttt // char <o>
  tttltll // char <t>
  ltlllll // char < >
  tttltll // char <t>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltltl // char <j>
  ltltlll // char <(>
  ltlllll // char < >
  ttlltll // char <d>
  ttlltlt // char <e>
  tttltll // char <t>
  ttltttt // char <o>
  tttltlt // char <u>
  tttlllt // char <q>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttll // char <l>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltttt // char <o>
  ttltllt // char <i>
  ttttlll // char <x>
  ttltttt // char <o>
  ttltttl // char <n>
  ttllltl // char <b>
  ttltttt // char <o>
  ltlllll // char < >
  ttltlll // char <h>
  tttltll // char <t>
  ttlltlt // char <e>
  ttllltl // char <b>
  ttllllt // char <a>
  ttttltl // char <z>
  ttltllt // char <i>
  ttlttll // char <l>
  tllltlt // char <E>
u

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu

মূলত, আউটপুট থেকে আউটপুট একটি দীর্ঘ পূর্ণসংখ্যা এবং আপনার স্কোর হ্রাস করতে হবে।

একটি সংখ্যা নিন এবং এটি বেসে রূপান্তর করুন। এর দৈর্ঘ্য হবে floor(log_b(x)+1)এবং এতে bবিভিন্ন চিহ্ন থাকবে। স্কোর তাই b*floor(log_b(x)+1)। xএকটি প্রদত্ত বৃহত সংখ্যা, এবং আপনি যদি খ এর জন্য এই চক্রান্ত করেন, আপনি ন্যূনতমটি দেখতে পাবেন বেশ কিছুটা b=3(এবং b=2প্রায় হিসাবে ভাল)। যেমন, আপনি উচ্চতর বেসগুলি (লগ) ব্যবহার করার সাথে দৈর্ঘ্যটি কিছুটা হ্রাস পায় তবে চরসেটের আকারটি রৈখিকভাবে বৃদ্ধি পায়, সুতরাং এটির পক্ষে এটি উপযুক্ত নয়।

এইভাবে আমি কেবল 0/1 এর সাথে একটি ভাষার সন্ধান করেছি, তবে আমি কোনও পাইনি এবং তারপরে আমি মনে করেছি যে সেখানে সাদা জায়গা রয়েছে এবং এটি চেষ্টা করে দেখেছি। হোয়াইটস্পেসে, আপনি সরাসরি 0 এবং 1 এর সাথে বাইনারি সংখ্যা লিখতে পারেন।

পুরানো কোড, আরও খারাপ স্কোর তবে আরও আকর্ষণীয়

প্রাচীন কোড filebin উপর ।

প্রোগ্রামটি তৈরি করার জন্য আমি যে রুবি স্ক্রিপ্টটি ব্যবহার করেছি (l = WHITESPACE, t = TAB, u = NEWLINE, //উপেক্ষা করার পরে সবকিছু একটি ফাইলে লিখেছেন prog.h):

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.' + "\n"

def shift(x)
    (x-97)%128
end

EOS = "lttltl" #26
STACK = []

bin = str.reverse.chars.map do |x|
    byte = shift(x.getbyte(0))
    rf = STACK.index(byte)
    STACK.unshift(byte)

    y = byte.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
    ph = "lll#{y}u" # pushing directly
    if rf
        bn = rf.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
        cp = "ltll#{bn}u" # copying from stack
    end

    if STACK.size>0 && STACK[0]==STACK[1]
        "lul // dup #{x.inspect}"
    elsif cp && cp.size < ph.size
        "#{cp} // copy <#{x.inspect}> (from #{rf})"
    else
        "#{ph} // push <#{x.inspect}> (#{shift(x.getbyte(0))})"
    end
end

File.open('prog.h','w') do |fout|
    fout << "ll#{EOS}u // push EOS" << "\n"
    fout << bin.join("\n") << "\n"
    fout << <<-eos
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  ll#{EOS}u // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu
    eos
end

উদাহরণস্বরূপ, সাদা-স্পেস প্রোগ্রামটি মানব-পঠনযোগ্য আকারে। একটি সাধারণ স্ক্রিপ্টকে এটি একটি আসল সাদা স্থান প্রোগ্রামে রূপান্তর করতে নীচে দেখুন।

lllttltlu // push EOS
llltltlltu // push <"\n"> (41)
llltllttltu // push <"."> (77)
llltltlu // push <"k"> (10)
llltttlu // push <"o"> (14)
lul // dup "o"
llltlttu // push <"l"> (11)
lllttttttu // push <" "> (63)
llllu // push <"a"> (0)
ltlltu // copy <" "> (from 1)
llltllu // push <"e"> (4)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
lllttlu // push <"g"> (6)
lllttltu // push <"n"> (13)
llltlllu // push <"i"> (8)
llltltltu // push <"v"> (21)
ltlltu // copy <"i"> (from 1)
lllttlu // push <"g"> (6)
ltllttlu // copy <" "> (from 6)
llltllllltu // push <"\""> (65)
llltlltlttu // push <","> (75)
lllttllttlu // push <"G"> (102)
lllttltttlu // push <"O"> (110)
lllttlllttu // push <"D"> (99)
ltlltltu // copy <" "> (from 5)
lllttttlllu // push <"Y"> (120)
lllttttlltu // push <"Z"> (121)
lllttlllllu // push <"A"> (96)
lllttltlttu // push <"L"> (107)
ltlltllu // copy <" "> (from 4)
lllttlltllu // push <"E"> (100)
lllttlltttu // push <"H"> (103)
llltttllttu // push <"T"> (115)
ltllttu // copy <" "> (from 3)
llltttllltu // push <"R"> (113)
ltlltllu // copy <"E"> (from 4)
llltttltltu // push <"V"> (117)
ltlltttlu // copy <"O"> (from 14)
ltlltllu // copy <" "> (from 4)
llltttlltlu // push <"S"> (114)
lllttlttttu // push <"P"> (111)
lllttlttllu // push <"M"> (108)
llltttltllu // push <"U"> (116)
lllttltlltu // push <"J"> (105)
ltlltltu // copy <" "> (from 5)
llltttltttu // push <"X"> (119)
ltlltlllu // copy <"O"> (from 8)
lllttlltltu // push <"F"> (101)
ltllttu // copy <" "> (from 3)
lllttlttltu // push <"N"> (109)
llltttlttlu // push <"W"> (118)
ltlltllu // copy <"O"> (from 4)
ltlltllltu // copy <"R"> (from 17)
lllttlllltu // push <"B"> (97)
ltlltltu // copy <" "> (from 5)
lllttltltlu // push <"K"> (106)
lllttllltlu // push <"C"> (98)
lllttltlllu // push <"I"> (104)
ltllttttu // copy <"U"> (from 15)
llltttllllu // push <"Q"> (112)
ltlltltu // copy <" "> (from 5)
ltllttlltu // copy <"E"> (from 25)
ltllttttlu // copy <"H"> (from 30)
ltllttttlu // copy <"T"> (from 30)
llltllllltu // push <"\""> (65)
ltlltllu // copy <" "> (from 4)
llltlttlltu // push <":"> (89)
llltlltlllu // push <")"> (72)
llltllu // push <"e"> (4)
llltlu // push <"c"> (2)
llllu // push <"a"> (0)
llltllu // push <"e"> (4)
lllttttu // push <"p"> (15)
ltlltttu // copy <" "> (from 7)
lllttlllu // push <"y"> (24)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
llltllltu // push <"r"> (17)
llltttlu // push <"o"> (14)
llltltu // push <"f"> (5)
ltllttu // copy <" "> (from 3)
ltllttlu // copy <"y"> (from 6)
lllttu // push <"d"> (3)
llltlttlu // push <"w"> (22)
llltttlu // push <"o"> (14)
ltlltttu // copy <"r"> (from 7)
ltlltltu // copy <" "> (from 5)
ltlltlu // copy <"o"> (from 2)
lul // dup "o"
llltllttu // push <"t"> (19)
ltllttu // copy <" "> (from 3)
ltlltu // copy <"t"> (from 1)
llltlltlu // push <"s"> (18)
llltltllu // push <"u"> (20)
llltlltu // push <"j"> (9)
llltllltttu // push <"("> (71)
ltlltltu // copy <" "> (from 5)
lllttu // push <"d"> (3)
llltllu // push <"e"> (4)
ltlltttu // copy <"t"> (from 7)
llltttlu // push <"o"> (14)
ltlltttu // copy <"u"> (from 7)
llltllllu // push <"q"> (16)
ltllttlu // copy <" "> (from 6)
lllttlllu // push <"y"> (24)
llltlttu // push <"l"> (11)
llltlltlu // push <"s"> (18)
ltlltltu // copy <"u"> (from 5)
llltttlu // push <"o"> (14)
llltlllu // push <"i"> (8)
llltltttu // push <"x"> (23)
ltlltlu // copy <"o"> (from 2)
lllttltu // push <"n"> (13)
llltu // push <"b"> (1)
ltlltlu // copy <"o"> (from 2)
ltlltlttu // copy <" "> (from 11)
llltttu // push <"h"> (7)
llltllttu // push <"t"> (19)
llltllu // push <"e"> (4)
llltu // push <"b"> (1)
llllu // push <"a"> (0)
lllttlltu // push <"z"> (25)
llltlllu // push <"i"> (8)
llltlttu // push <"l"> (11)
lllttlltllu // push <"E"> (100)
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  lllttltlu // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu

এই হোয়াইটস্পেস প্রোগ্রামটি নিজেই বরং সহজ, তবে তিনটি গল্ফিং অপ্টিমাইজেশন রয়েছে:

lulএকটি সদৃশ চরিত্র আছে যখন স্ট্যাক ক্লোন করতে ব্যবহার করুন
ltlস্ট্যাকের এন-থ্রি এন্ট্রিটিকে ক্লোন করতে ব্যবহার করুন যদি এটি সরাসরি চরটি চাপানোর চেয়ে কম হয়
সমস্ত বাইট 97 দ্বারা শিফট করুন (মড 128), বাইনারি সংখ্যাগুলি আরও ছোট করে

আমার মানবীয় পঠনযোগ্য শ্বেতস্পেস কোডটিকে একটি আসল শ্বেত স্পেস প্রোগ্রামে রূপান্তর করার জন্য একটি সাধারণ রুবি স্ক্রিপ্ট (একটি ফাইল পড়ুন prog.hএবং একটি ফাইলে লেখেন prog.ws):

WHITESPACE = "l"
NEWLINE = "u"
TAB = "t"

File.open('prog.ws','w') do |fout|
    code = ""
    fin = File.read('prog.h')
    fin.each_line do |line|
        line.gsub!(/\/\/.*/,'')
        line.scan(/#{NEWLINE}|#{WHITESPACE}|#{TAB}/i) do |x|

            code << case x.downcase
            when NEWLINE.downcase
                "\n"
            when WHITESPACE.downcase
                " "
            when TAB.downcase
                "\t"
            else
                ""
            end
        end
    end
    fout << code
end

— blutorange
সূত্র

পেছনের নতুন লাইনটি isচ্ছিক, আপনি এটি মুদ্রণ না করে কয়েকটি অক্ষর সংরক্ষণ করতে পারেন।

— durron597

ধন্যবাদ, এটি পরিবর্তন। মূলত, আমি এটিকে অন্তর্ভুক্ত করেছি কারণ হাস্কেল দোভাষী কিছু ডিবাগ আউটপুট যোগ করেছেন, তবে রুবির সাথে এটি পরিষ্কার দেখাচ্ছে।

— ব্লুটোরেঞ্জ

7

রুবি 144 বাইট * 39 স্বতন্ত্র = 5616

puts"Elizabeth obnoxiously quoted (just too rowdy for my peace): \"#{'the quick brown fox jumps over the lazy dog,'.upcase}\" giving me a look."

কখনও কখনও সহজতম সেরা।

— MegaTom
সূত্র

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

— জোসে_ এক্স

6

ব্রেইনফাক, 1264 বাইট * 7 অনন্য = 8848

হ্যাঁ, এটি একটি ভয়ানক স্কোর।

++++[++++>---<]>++.-[--->+<]>.---.-[--->+<]>++.[->+++++<]>-.+.+++.[--->+<]>---.------------.--[--->+<]>--.+++++[->+++<]>.-------------.++++++++++++.+.+++++++++.[->+++<]>+.++++++.++++++.--.-------.-[--->+<]>.-[---->+<]>++.----[->++++<]>+.++++.------.+++++.+++[->+++<]>.-.-[--->+<]>-.++++++++.-----[->+++<]>+.+++++++++++.--.+.[---->+<]>+++.---[->++++<]>.-----..[--->+<]>-----.---[----->++<]>.---.++++++++.[->+++<]>-.+[--->+<]>++.-[---->+<]>++.++[->+++<]>.+++++++++.+++.[-->+++++<]>+++.+[----->+<]>.--[--->+<]>.-[---->+<]>++.[-->+++++++<]>.-----------.----.++.++.--[->+++<]>.-[-->+++<]>--.[-->+<]>+++.++.>-[--->+<]>-.------------.---.-[-->+<]>--.[-->+++++<]>+.++++.------------.------.++++++++.---[->++++<]>.+[->++<]>.>-[--->+<]>---.---.++++++++.---------.++[----->++<]>.+++[->++<]>.+++++++++.+++++++++.[--->++++<]>.+++++[->++<]>.>-[--->+<]>.--------.+++.+++.+[--->+<]>++++.[-->+++++<]>-.+++++++.--[----->+<]>+.+++++++++++++.--[----->++<]>.>-[--->+<]>-.------------.---.-[-->+<]>--.++++++[->++<]>.-----------.-----[-->+++<]>.-.+[--->+<]>++.++[->++<]>.+++++++++++.--------.--[--->++<]>--.----------.--.++[->+++<]>+.++.[->++++++<]>.[------>+<]>.+++++.-------.-[--->+<]>--.+[----->+<]>.--------.--[--->+<]>-.[->+++<]>+.-[->+++<]>.++[--->++<]>.+++..----.[->++++++++++<]>.

— mbomb007
সূত্র

আমি দেখেছি যে আরও কম অনন্য অক্ষর ব্যবহার করা সম্ভব তবে দৈর্ঘ্য হবে 10795, গুণ 5 = 53975

— mbomb007

আপনি কেবল এটির চেয়ে আরও +.ছোট হবে তা নিশ্চিত করেই এটি করতে পারেন।

— ক্যাপচারাইগ

শুধুমাত্র ব্যবহার +এবং .আমি 15018 * 2 = পেতে 30,036।

— 17:১ig এ ক্যাপচার্যাগ

6

> <> (ফিশ) - 578 বাইট * 8 অনন্য = 4624

14121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p

আমার স্কোরটি আমি যেমন আশা করেছিলাম তেমন প্রতিযোগিতামূলক নয় তবে আমি ভেবেছিলাম যে সমাধানটি পোস্ট করার পক্ষে এখনও যথেষ্ট আকর্ষণীয়।

ব্যাখ্যা

কোডের প্রথম বিভাগটি 0-4 অঙ্কের একটি দীর্ঘ স্ট্রিং যা স্ট্রিংয়ের প্রতিটি অক্ষরের জন্য 3 ডিজিটের বেস 5 প্রতিনিধিত্ব করে। অবশিষ্ট কোডটি pফিশের অপারেটরের সুবিধা নেয় যা আপনাকে প্রোগ্রাম চলাকালীন প্রোগ্রামের উত্স কোড সম্পাদনা করতে দেয়। সেই অপারেটরটি ব্যবহার করে, আমি বেস 5 অক্ষরকে বেস 10 এ আবার রূপান্তর করতে প্রয়োজনীয় ফিশ কোড তৈরি করতে সক্ষম হয়েছি এবং সেগুলি আউটপুট দিয়েছিলাম এবং তারপরে দোভাষী শেষ হওয়ার আগে ফাইলটির শুরুতে সেই কোডটি আবার উত্স কোডে রেখেছি লাইন এবং চারপাশে মোড়ানো। দোভাষী যখন লাইনের শেষ প্রান্তে পৌঁছান, কোডটি এর মতো দেখতে পরিবর্তন করা হয়েছে:

v4121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p
>55**$5*++ol?!;

কোডটি চারপাশে মোড়ানো এবং vঅপারেটরটিকে হিট করে যখন এটি দ্বিতীয় লাইনে নেমে যায়, >অপারেটরটিকে হিট করে লুপে এগিয়ে যায়, প্রতিটি সময় বেস 5 এনকোডিংটিকে বেস 10 এ্যাসকি মানটিতে রূপান্তর করে এবং সেই মানটি আউটপুট করে। যখন স্ট্যাকের কোনও মান নেই তখন ?অপারেটর এড়িয়ে যাবে ;এবং প্রোগ্রামটি শেষ হবে।

— tallestpurpl
সূত্র

5

7 , 273 বাইট × 7 অনন্য বাইট = 1911, নন-কেপটিং (ভাষা পোস্টডেটস চ্যালেঞ্জ)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

অনন্য অক্ষরগুলি নীচে রাখুন

সূক্ষ্ম মুদ্রণ

স্কোরিং

অনিদ্রা , 575 বাইট * 4 = 2300

সমাধান 1 বি (অপ্রকাশিত): 783 বাইট * 3 = 2349

সমাধান 1: 826 বাইট * 3 = 2478

সিজেম, 266 281 456 বাইট * 14 12 7 অনন্য = 3724 3372 3192

ব্যাখ্যা

হোয়াইটস্পেস, 1157 937 বাইট * 3 অনন্য = 3471 2811

পুরানো কোড, আরও খারাপ স্কোর তবে আরও আকর্ষণীয়

রুবি 144 বাইট * 39 স্বতন্ত্র = 5616

ব্রেইনফাক, 1264 বাইট * 7 অনন্য = 8848

> <> (ফিশ) - 578 বাইট * 8 অনন্য = 4624

ব্যাখ্যা

7 , 273 বাইট × 7 অনন্য বাইট = 1911, নন-কেপটিং (ভাষা পোস্টডেটস চ্যালেঞ্জ)

পাইথন 2, 163 147 145 143 বাইট * 35 36 35 অনন্য = 5705 5292 5220 5005

সম্পাদনা:

পাইথন 2, 14508 11700 11088 10164 9486 9746 7860 145 বাইট * 36 অনন্য = 5220

> <> (ফিশ) - 138 বাইট * 65 স্বতন্ত্র = 8970

05 এ বি 1 ই , 380 বাইট * 11 টি অক্ষর = 4180 স্কোর

পার্ল 6, 139 বাইট * 36 অনন্য = 5004

জাভা 8, 141 বাইট * 64 স্বতন্ত্র অক্ষর = 9,024

পার্ল 5 , 137 বাইট * 35 অনন্য = 4795

টিসিএল , 345 বাইট, 345 x 13 = 4485

টিসিএল , 337 বাইট, 337 x 15 = 5055

টিসিএল , 329 বাইট, 329 x 16 = 5264

টিসিএল , 333 বাইট, 333 x 16 = 5328

টিসিএল , 148 বাইট, 148 এক্স 37 = 5476

টিসিএল , 277 বাইট, 277 x 21 = 5817

টিসিএল , 371 বাইট, 371 x 16 = 5936

টিসিএল , 401 বাইট, 401 x 16 = 6416

টিসিএল , 403 বাইট, 403 x 16 = 6448

টিসিএল , 433 বাইট, 433 এক্স 15 = 6495

টিসিএল , 473 বাইট, 473 এক্স 14 = 6622

টিসিএল , 133 বাইট, 133 x 60 = 7980