কুইপাস হ'ল একটি প্রাচীন ডিভাইস যা ইনকা কর্তৃক প্রাকোলম্বিয়ান যুগে কর্ডের উপরে নটের বেস দশটি অবস্থানীয় সিস্টেমে সংখ্যা রেকর্ড করতে ব্যবহৃত হয়, যা নিম্নলিখিত হিসাবে কাজ করে:

গিঁটের প্রতিটি ক্লাস্টার একটি ডিজিট এবং সেখানে মূলত তিনটি ধরণের নট থাকে: সরল ওভারহ্যান্ড নট; "দীর্ঘ নট", এক বা একাধিক অতিরিক্ত টার্ন সহ ওভারহ্যান্ড গিঁট নিয়ে গঠিত; এবং চিত্র আট নট।

দশটির শক্তি স্ট্রিং বরাবর অবস্থান অনুসারে দেখানো হয় এবং এই অবস্থানটি ধারাবাহিক স্ট্র্যান্ডের মধ্যে একত্রিত হয়।

10 এবং উচ্চতর শক্তির পজিশনে অঙ্কগুলি সহজ নটগুলির ক্লাস্টার দ্বারা প্রতিনিধিত্ব করা হয় (উদাহরণস্বরূপ, 40 "দশকে" অবস্থানের মধ্যে একটি সারিতে চারটি সহজ নট)।

"বেশী" পজিশনের অঙ্কগুলি দীর্ঘ নট দ্বারা প্রতিনিধিত্ব করা হয় (উদাহরণস্বরূপ, 4 চারটি টার্নযুক্ত একটি গিঁট)। যেভাবে গিঁট বাঁধা হয়েছে, সেই কারণে 1 সংখ্যাটি এভাবে দেখানো যায় না এবং আট-নট দ্বারা আটকে থাকা এই অবস্থানটিতে প্রতিনিধিত্ব করা হয়।

জিরো উপযুক্ত অবস্থানে একটি গিঁটের অনুপস্থিতি দ্বারা প্রতিনিধিত্ব করা হয়।

বিস্তারিত

এই চ্যালেঞ্জের জন্য, কুইপুর প্রতিটি স্ট্র্যান্ড একটি একক সংখ্যক প্রতিনিধিত্ব করে (যদিও উইকিপিডিয়া নিবন্ধ অনুসারে, আপনি একটি স্ট্র্যান্ডে অনেকগুলি সংখ্যাকে উপস্থাপন করতে পারেন , এই চ্যালেঞ্জের মধ্যে আমরা তা করব না)।

নট

প্রতিটি গিঁটকে একটি একক ASCII চরিত্র দ্বারা উপস্থাপন করা হবে।

. একটি সহজ গিঁট প্রতিনিধিত্ব করে
: একটি দীর্ঘ গিঁটের একটি পালা উপস্থাপন করে
8 একটি চিত্র-আট নট প্রতিনিধিত্ব করে
| একটি গিঁটের অভাবে পাশাপাশি অঙ্কগুলির মধ্যে একটি ডিলিমিটার উপস্থাপন করে।

কুইপাস নির্মাণ

এই বিধিগুলি অনুসরণ করে কুইপু নির্মিত হয়।

স্ট্র্যান্ডগুলি পজিশনের অবতরণ ক্রমে শীর্ষ থেকে নীচে চলেছে (যেমন, ইউনিটের অঙ্কগুলি কোনও স্ট্র্যান্ডের নীচের প্রান্তে থাকবে)। একটি স্ট্র্যান্ড সহ অঙ্কগুলি অক্ষর দ্বারা পৃথক করা হয় ( |)।
10 ডিজিটের প্রতিনিধিত্ব করে এমন শক্তি আমাদের স্ট্র্যান্ডের সাথে একইভাবে তার অবস্থান দ্বারা নির্ধারিত হয় 10 এর সাথে একটি সংখ্যার দশকের শক্তিটি আমাদের সংখ্যা সিস্টেমের সাথে একটি সংখ্যায় তার সূচকটি ব্যবহার করে গণনা করা হবে। অর্থাৎ 24একটি সঙ্গে 2দশ জায়গায় এবং 4ইউনিট জায়গায়, দুই নট, একটি বিভেদক (দ্বারা প্রতিনিধিত্ব করা হবে না |), তারপর চার নট।
একই পজিশনের অঙ্কগুলি স্ট্র্যান্ডের নীচের দিকে প্রান্তিক হয়। যদি কোনও পজিশনে একটি অঙ্কের একই পজিশনে অন্যান্য সংখ্যার অন্যান্য সংখ্যার তুলনায় কম নট থাকে তবে এই নটগুলির অনুপস্থিতি ( |) দ্বারা প্রতিনিধিত্ব করা হয় ।
ধারাবাহিক সরল নট ( .) তাদের অবস্থানে একটি মান উপস্থাপন করে।
প্রতিটি অঙ্ক কমপক্ষে 1 টি অক্ষর দ্বারা প্রতিনিধিত্ব করা হয়। যখন একটি কুইপুতে সমস্ত সংখ্যার জন্য একটি সংখ্যার মান 0 হয়, এটি কোনও গিটার ( |) এর অনুপস্থিতি দ্বারা প্রতিনিধিত্ব করা হয় ।
ইউনিট স্থান বিশেষভাবে চিকিত্সা করা হয়। ইউনিটগুলির মধ্যে একটিতে চিত্র-আট নট ( 8) দ্বারা প্রতিনিধিত্ব করা হয় । ইউনিট স্থানে দুই বা ততোধিকের একটি মান ক্রমাগত দীর্ঘ নট দ্বারা প্রতিনিধিত্ব করা হয় ( :)।
ইউনিট ডিজিট যখন একটি কুইপুতে সমস্ত সংখ্যার জন্য 0 হয় তখন কোনও গিঁটের অনুপস্থিতি মুদ্রিত হয় না তবে দশকের অঙ্কের জন্য অনুবর্তী ডিলিমিটার সংরক্ষণ করা হয়।
ইউনিট সংখ্যা অনুসরণ করে কোন ডিলিমিটার নেই।

বিধি

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

সর্বদা হিসাবে, সমস্যাটি যদি অস্পষ্ট হয় তবে দয়া করে আমাকে জানান। শুভকামনা এবং ভাল গল্ফিং!

উদাহরণ

ইনপুট:

5 3 1 0

আউটপুট:

:|||
:|||
::||
::||
::8|

ইনপুট:

50 30 10 0

আউটপুট:

.|||
.|||
..||
..||
...|
||||

ইনপুট:

আউটপুট:

.
.
.
|
.
.
.
|

ইনপুট:

204 1

আউটপুট:

.|
.|
||
||
||
:|
:|
:|
:8

ইনপুট:

201 0 100 222

আউটপুট:

.||.
.|..
||||
|||.
|||.
||||
|||:
8||:

ইনপুট:

1073741823 2147483647

আউটপুট:

|.
..
||
|.
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
..
||
|.
|.
..
||
.|
.|
..
..
..
..
..
..
||
|.
|.
..
..
||
|:
|:
|:
|:
::
::
::

ইনপুট:

আউটপুট:

দীর্ঘ পরীক্ষার কেস

আরও পড়া

code-golf number

— Sherlock9
সূত্র

মায়ার সংখ্যা সম্পর্কিত একটি চ্যালেঞ্জ

— ফ্যাটালাইজ করুন

3

পাইথ, 64 বাইট

=QjRTQjCmj\|+:R"[8:]"\.PdedCmm+*\|-h.MZdk*?tk\:\8kdC.[L0h.MZlMQQ

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

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

=QjRTQ   Converts each number in input to decimal (as a list)
         123 becomes [1,2,3]

----

jCmj\|+:R"[8:]"\.PdedCmm+*\|-h.MZdk*?tk\:\8kdC.[L0h.MZlMQQ

                                              .[L0       Q  0-leftpad each #
                                                  h.MZlMQ   (max length) times

                                             C              transpose

                      mm                    d    for each digit:
                        +                        [convert to] sum of
                         *\|                     "|" repeated
                            -                    the difference of
                             h.MZd               maximum digit in same row
                                  k              and itself.. that many times
                                   *?tk\:\8      and (digit > 1 then ":" or "8") repeated
                                           k     itself many times


the list:
[11,23,52]
->[[1,1],[2,3],[5,2]]
->[[1,2,5],[1,3,2]]
->[["||||8","|||::",":::::"],["||8",":::","|::"]]

                     C      transpose

->[["||||8","||8"],["|||::",":::"],[":::::","|::"]]

  m                          for each number
      +                      [convert to] sum of
                 Pd          every element but the last
       :R"[8:]"\.            with "8" and ":" replaced by "."
                   ed        and the last element
   j\|                       joined with "|"

  C                          transpose
 j                           join (with newlines)

— ফুটো নুন
সূত্র

এটি একটি সমস্যা ব্যতীত একটি দুর্দান্ত উত্তর। চূড়ান্ত গিঁট সবসময় একটি চিত্র-আট নট হয় না 8। আসলে, এটি কেবলমাত্র একটি 8গিঁট যখন শেষ অঙ্কটি 1 হয় (নিয়ম 6 দেখুন)। আপনি সমস্ত চূড়ান্ত নটকে রূপান্তর করছেন এবং এটি অনুমানটির সাথে মেলে না। এছাড়াও, আপনার অনলাইন চেষ্টা করুন! লিঙ্কটির এখানে আলাদা আলাদা কোড রয়েছে যা এখানে পোস্ট করা হয়েছে, দৃশ্যত

— শার্লক

22

অপঠনযোগ্য , 3183 3001 বাইট

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

এর প্রথম সংস্করণটি 4844 বাইট ছিল, আমি আপনাকে কতটা গল্ফ দিয়েছিলাম তার একটি ধারণা দেওয়ার জন্য।

প্রোগ্রামটি পূর্ণসংখ্যার কমা-বিচ্ছিন্ন তালিকা হিসাবে ইনপুটটি প্রত্যাশা করে । কোনও স্পেস বা নিউলাইন নেই। এগুলি ব্যবহার করা অপরিজ্ঞাত আচরণ তৈরি করবে।

' "" "" ""' "" ' ""' "" ' ""' "" ' "" "'" "" "" " '" ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" "" "" ' ""' "" ' ""' "" ' ""' "" ' "" "'" " ' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" '"" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" "" "" ' " "" "" "" " '" ""' "" ' ""' "" ' ""' "" ' "" "" ""' "" ' "" "'" " '" "'" " ' "" ' ""' "" ' ""' "" ' "" "'" "" "" ' "" "" ""' "" " '" "" "" "" "'" "" """ " '" ""' "" "" "" ' "" "" "" ""' "" " '" "'" " '" "" "" ""' "" "" "" "" ' "" "'" "" "" ' ""' "" "" "" ' ""' "" ' ""' "" " '" "" "" "" "" "'" "" " ' "" "" "" ' ""' "" ' "" "'" "" "" "" ' ""' "" ' ""' "" ' ""' "" ' "" "'""" "" "" "" ' "" "" ""' "" "" "" ' ""' "" " '" "'" "" "" "" ' ""' "" " '" " ' "" "" "'" "" "" " '" "'" " '" ""' "" "" "" "" ' "" "" "" "'" " '" "'" "" ' "" "" ""' "" ' ""' "" ' "" "'" "" "" "" " '" "" "" ""' "" ' ""' "" ' """ ' "" "" ""' "" "" "" ' "" "'" "" "" "" " '" "" "" ""' "" " '" ""' "" "" "" ' "" "'" "" "" "" " '" ""' "" "" "" ' ""' "" ' "" "'" "" "" ' "" "" "" " ' "" "" "" "'" "" ' "" "" ""' "" " '" "" "" "" "'" "" "" "" ' "" "'" """ " '" "" "" "'" "" ' ""' "" "" "" " '" ""' "" "" ' "" "" ""' "" ' ""' "" ' "" "'" "" "" "" " '" ""' "" "" " '" "" "" "" "'" "" "" " '" "" "" ""' "" " '" "'" "" "" "" ' "" "" "" "'" "" ' "" "" "" "" "'" "" "" "" "" ' """" "" " '" "" "" ""' "" " '" ""' "" "" "" "" " '" "'" "" "" "" ' "" "'" "" ' "" "" "" ""' "" " '" "" "'" "" " '" "" "" "'" " '" ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" " '" "" ""' "" "" "" " '" "" "" "'" " '" ""' "" ' """ "" "" ' ""' "" " '" "" "'" "" " '" "" ""' "" "" "" ' ""' "" ' ""' "" ' " " '" "'" " '" ""' "" "" "" ' ""' "" ' ""' "" ' "" "'" "" "" "" ' "" "" ""' "" ' "" "'" " '" "" "" ""' "" ' "" "'" "" ' "" "" "'" "" "" "" ' "" "" "" '" "'" "" ' "" "" "" ""' "" "" "" " '" "'" "" ' "" "" "" "" "'" "" "" "" " '" "" "" ""' "" "" "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" " '" "" "" "" " ' "" "" "" "'" " '" "'" " '" "'" " '" "'" " '" ""' "" "" "" "" " '" "" """ "" ' "" "" "" ""' "" "" "" " '" "" "" ""' "" " '" "" "" "" ""' "" "" "" " '" "'" " '" "'" "" ' "" "" ""' "" ' ""' "" ' ""' "" " '"' "" "" "" "" " ' "" ' "" "" "" "'" "" "" "" ' ""' "" " '" "" "" "" ""' "" ' ""' "" "" """ ' "" "" "" "'" " '" ""' "" "" ' "" "" ""' "" "" "" " '" "'" "" ' "" "" " "" "" ' "" "" "" "" "'" " '" "" "" ""' "" " '" ""' "" "" "" "" " '" "'" " ' "" "" "" " '" "" "" ""' "" " '" ""' "" "" "" "" " '" "'" " '" "'" "" """ " '" "" "" ""' "" ' "" "'" "" ' "" "" "" ""' "" " '" "'" "" "" "" ' "" " "" "" ' ""' "" " '" "" "" "" "'" "" "" "" " '" ""' "" "" "" " '" "" "" "" " ' "" "'" "" "" "" "" ' "" "" "" "'" "" "" "" ' "" "'" "" "" "" "" ' ""' "" "" "" "'" "" ' "" "" "" "'" " '" "'" " '" "'" " '" "'" "" ' ""' "" ' " "" "" "" ' ""' "" ' ""' "" ' ""' "" " '" "" "" ""' "" "" "" "" ' "" "'" "" "" "" ' ""' "" ' ""' "" ' ""' "" " '" "" "'" "" "" "" "" ' "" "" "" "" "' ""' "" "" " '" "" "" ""' "" "" "" ' ""' "" ' "" "'" "" "" "" " '" "" "" " " '" "'" " '" ""' "" "" "" ' "" "" "" "'" " '" ""' "" "" "" "" ' "" "" "" " ' "" "" "" "'" " '" ""' "" " '" "" "" "" ""' "" "" "" " '" "'" " '" "'"" '" "'" "" "" "" ' ""' "" ' "" "'" "" ' "" "" "" "" "'" " '" "" "" ""' "" " '" ""' "" "" "" "" ' "" "'" "" "" " '" "" "" ""' "" ' "" "'" "" "" "" " ' "" "" "" " '" "" "" ""' "" ' "" "'" "" ' "" "" "'" "" "" "" ' "" "" ""' ""' "" ' "" "'" " '" "" "" ""' "" ' ""' "" " '" ""' "" "" ' "" ""' "" "" " '" "" "" "'" "" "" "" ' ""' "" " '" "" "" "" "'" "" "" "" ' "" "" "" "'" " '" ""' "" "" "" ' "" "" ""' "" ' ""' "" " '" "" "" "" "'" "" "" "" ' "" '" "'" "" ' "" "'" "" "" ' "" "" "" "'" "" "" " '" "'" " '" ""' "" ' "" " "" "" ' ""' "" ' "" "'" "" "" " '" "" "" ""' "" ' "" "'" " '" "" "" ""' "" "" "" " '" "'" "" ' "" "" "" "" "'" " '" "" "" ""' "" " '" "" "" "'" """" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" ' ""' "" ' "" " ' "" "'" "" ' "" "'" "" "" "" "" ' "" "" "'" "" "" "" ' "" "" ""' "" ' "" " ' ""' "" "" "" " '" "'" "" ' "" "" "" "'" " '" "'" " '" "'" "" ' "" "'""" "" "" "" ' "" "" "" "'" " '" "'" " '" ""' " '" "" "" ""' "" "" "" "" ' " "" ' "" "'" "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" " '" "" "" ""' "" " '" "" "" "" ""' "" "" "" " '" "'" " '" "'" "" ' "'"" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' "" "'" "" ' "" "" ""' "" "" "" " ' "" " '" "" "" "" "'" "" "" " '" "'" " '" "'" "" ' "" "" "'" "" "" "" ' "" " "" " '" "'" " '" ""' "" "" "" "" ' "" "" "" "'" " '" "'" "" ' "" "" ""'"" "" "" " '" ""' "" "" "" "" ' "" "" "" "'" "" "" "" ' "" "'" ""

ব্যাখ্যা

প্রোগ্রামটি কীভাবে সুনির্দিষ্ট ইনপুটটি প্রসেস করে তা দেখিয়ে কীভাবে কাজ করে তা আমি আপনাকে চলতে যাচ্ছি 202,100,1।

শুরুতে, আমরা কয়েকটি মান তৈরি করি যা আমাদের পরে প্রয়োজন হবে - বেশিরভাগ অক্ষরগুলির ASCII কোড যা আমরা আউটপুট করব।

আপনি দেখতে পারেন '8'এবং '.'ইতিমধ্যে উপলব্ধ। '|'তবে, এটি সত্যিই 124, 14 নয় We 124 পেতে এটিতে স্লট # 1 এর দ্বিগুণ অস্থায়ী মান যুক্ত করতে আমরা কিছুক্ষণ লুপ ব্যবহার করি (যা 14 + 55 × 2, কারণ লুপটি 56−1 = 55 এর জন্য চালিত হয়) পুনরাবৃত্তিও)। এটি কিছু বাইট সংরক্ষণ করে কারণ বড় বড় পূর্ণসংখ্যার লিটারেলগুলি 124 এর মতো সত্যই দীর্ঘ। নিম্নলিখিত চিত্রটিতে, আমি প্রোগ্রামটি ব্যবহার করে প্রতিটি ভেরিয়েবলের অবস্থান প্রদর্শন করি।

এরপরে, আমরা সমস্ত অক্ষর ইনপুট করতে চাইছি এবং সেল # 12 থেকে শুরু হওয়া টেপটিতে এগুলি সংরক্ষণ করতে চাই ( পি এটির জন্য চলমান পয়েন্টার)। একই সাথে, আমরা জানতে চাই যে দীর্ঘতম সংখ্যাটি কত দীর্ঘ (কতগুলি সংখ্যা)। এটি অর্জনের জন্য, আমরা সেল # −1 থেকে শুরু করে বাম দিকে বাঁকানো মোট চালিয়ে রাখি (আমরা রান পয়েন্টার হিসাবে q ব্যবহার করি )। প্রথম ইনপুট নম্বর ( 202) পরে, টেপটি এখন এমন দেখাচ্ছে:

আপনি লক্ষ করেছেন যে সংখ্যাগুলি 4 দ্বারা বন্ধ রয়েছে Well আচ্ছা, আমরা যখন প্রথমবার তাদের ইনপুট করি তখন সেগুলি তাদের ASCII মান হয়, সুতরাং তারা 48 দ্বারা "অফ" হয় এবং কমাটি 44 হয় each প্রতিটি অক্ষরের জন্য আমরা 46 টির অনুলিপি করি '.'মধ্যে R এবং তারপর যখন একটি লুপ (যা 45 subtracts) সঙ্গে এটি বিয়োগ এবং তারপর আমরা 1. যোগ আমরা যাতে কমা (আমাদের বিভাজক) 0, তাই আমরা একটি শর্তাধীন ব্যবহার করতে পারেন এটি স্বীকার করতে পারি না।

এছাড়াও, আপনি খেয়াল করতে পারেন যে আমরা # 11 এ সেল রেখেছি 0 আমাদের প্রথম সংখ্যার সীমানা সনাক্ত করতে হবে।

পরবর্তী অক্ষরটি একটি কমা হবে, সুতরাং আমরা # 15 এ 0 সঞ্চয় করি তবে অবশ্যই এবার আমরা q অগ্রিম করব না । পরিবর্তে, আমরা q কে 0 এ সেট করে দিয়েছি এবং ইতিমধ্যে 1 টি রেখেছি "ওভাররাইটিং" শুরু করি।

বাকী সমস্ত অক্ষর প্রক্রিয়া করার পরে, আমরা এটি পাই:

আপনি দেখতে পাচ্ছেন, q দ্বারা লেখা 1s এখন দীর্ঘতম সংখ্যার দৈর্ঘ্য (একাকারে) নির্দেশ করে।

একেবারে বামে q সরাতে আমরা এখন কিছুক্ষণ লুপ ব্যবহার করি এবং তারপরে সেখানে অন্য পয়েন্টার রাখি যা আমি r2 বলব । R2 এর উদ্দেশ্য পরে স্পষ্ট হয়ে উঠবে।

এই মুহুর্তে, আমি পরিভাষাটি স্পষ্ট করে বলি যে আমি এটি জুড়ে ব্যবহার করব।

দ্বারা সংখ্যা , আমি ইনপুট সংখ্যা যে কমা দ্বারা পৃথক করা হয় এক মানে। আমাদের উদাহরণে, তারা 202, 100 এবং 1।
দ্বারা অঙ্ক , আমি সংখ্যার একটি নির্দিষ্ট এক একটি একক অঙ্ক মানে। প্রথম সংখ্যাটিতে 3 টি সংখ্যা রয়েছে।
দ্বারা জায়গা , আমি বেশী জায়গা, দশ জায়গা শত শত জায়গা, ইত্যাদি সুতরাং এর অর্থ যদি আমি বলি "বর্তমান জায়গায় ডিজিটের", এবং বর্তমান স্থান বেশী জায়গা, যারা সংখ্যা 2, 0 যে হয়, এবং অন্য 1 অর্ডার।

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

আমরা সেল Q পয়েন্টগুলিতে বৃদ্ধি (যা, * কিউ ) বাড়িয়ে এগিয়ে চলেছি ।

আমরা এখন শতাধিক জায়গার জন্য "দ্বিতীয় পর্যায়ে" আছি। এই পর্যায়ে, আমরা খুঁজে পাবেন যে শত জায়গায় সমস্ত সংখ্যার মধ্যে বৃহত্তম অঙ্কটি কী। আমরা এই জন্য একই ইউনারী কাউন্টিং কৌতুক ব্যবহার করেন, এই সময় পয়েন্টার বলা হয় ব্যতীত R এবং পয়েন্টার R2 চিহ্ন তার শুরু অবস্থানে যা আমরা এটা প্রত্যেক সময় আমরা পরবর্তী সংখ্যা উপর সরানো পুনরায় সেট করার প্রয়োজন।

প্রথম সংখ্যা দিয়ে শুরু করা যাক। আমরা পি তে 11 সেট করে শুরু করি (সমস্ত সংখ্যার হার্ড-কোডিং শুরুর অবস্থান)। তারপরে আমরা সংখ্যার শেষটি খুঁজে পেতে কিছুক্ষণ লুপ ব্যবহার করি এবং অবস্থানটি চিহ্নিত করতে সেখানে পি 2 সেট করি। একই সময়ে, আমরা কিউ 2 থেকে 0:

কিউ 2 টি ভার্সগুলিতে ইঙ্গিত করছে এই বিষয়টি দ্বারা বিচলিত হবেন না। আমাদের শূন্য কোষের কোনও প্যাডিং নেই কারণ আমরা শূন্যের সংখ্যাটি শূন্যের কারণেই আমরা # 0 সেল সনাক্ত করতে পারি।

এর পরে, আমরা পি এবং কিউ 2 হ্রাস করে বর্তমান সংখ্যাটি অতিক্রম করব যতক্ষণ না * পি শূন্য হয়। প্রতিটি জায়গায়, * কিউ 2 এর মান আমাদের কী করতে হবে তা আমাদের জানায়। 1 এর অর্থ "কিছুই করবেন না", তাই আমরা চালিয়ে যাচ্ছি। শেষ পর্যন্ত আমরা # #3 সেলটিতে 2 টির মুখোমুখি হই। প্রতিবার * q2 1 এর সমান নয়, Q2 সর্বদা q এর সমান হয় না ।

আমি ইতিমধ্যে বলেছি, দ্বিতীয় ধাপটি "এই জায়গার বৃহত্তম সংখ্যা নির্ধারণ করুন"। সুতরাং আমরা সেট R থেকে R2 , হ্রাস করার জন্য একটি লুপ ব্যবহার * পি এবং পদক্ষেপ দ বামমুখী এবং 1s সঙ্গে টেপ পূরণ করুন, এবং তারপর যখন পদক্ষেপ লুপ অন্যটি ব্যবহার R ডান এবং বৃদ্ধি ফিরে * পি আবার মান পুনরুদ্ধার করতে। মনে রাখবেন যে প্রতিটি সময়ে লুপটি আমরা যে মানটি ব্যবহার করি তার চেয়ে কম পুনরাবৃত্তির জন্য চলে; এ কারণে, লিখিত 1s এর সংখ্যাটি ডিজিটের মানের চেয়ে 3 টি বেশি (4 টির চেয়ে বেশি) হবে এবং চূড়ান্ত মান * পিতে সঞ্চিত 2 আরও হবে। সুতরাং, এটি কার্যকরভাবে * পি 2 দ্বারা হ্রাস পেয়েছে ।

এর পরে, আমরা p2 এর মান পি সেট করেছিলাম এবং তারপরে আমরা আবার সব করি। দ্বিতীয়বারের জন্য, Q2 থেকে 0 নির্ধারণ করুন , পি ডান দিকে সরানোর মাধ্যমে সংখ্যার শেষটি সন্ধান করুন এবং তারপরে পি এবং কিউ 2 একসাথে কমিয়ে এই সংখ্যাটির সংখ্যাগুলি দিয়ে যান । আবার আমরা কক্ষ # −3 তে 2 টির মুখোমুখি হব এবং লিখব যে * আর এর অনেক 1 টি বামে রয়েছে ।

তৃতীয় সংখ্যার ক্ষেত্রে আমরা কিছুই না করে শেষ করি কারণ এর শত জায়গা নেই (সুতরাং q2 কখনই Q তে পৌঁছায় না ) তবে এটি ঠিক আছে কারণ এটি সর্বোচ্চ সংখ্যার মান গণনাকে প্রভাবিত করে না।

আমরা * (আর - 4) সেলটিও সেট করেছিলাম, যা আমি এখানে শিরোনামহীন তীর দিয়ে চিহ্নিত করেছি 1 (যদিও এটি ইতিমধ্যে 1 এ রয়েছে)। আমি আপনাকে এখনও কেন বলব না, তবে সম্ভবত আপনি ইতিমধ্যে অনুমান করেছেন?

* কিউ এর পরবর্তী বৃদ্ধি আমাদের তিন ধাপে নিয়ে যায়, যা "বর্তমান জায়গায় সমস্ত অঙ্ক থেকে সর্বাধিক অঙ্কটি বিয়োগ করে"। আগের মতো, আমরা পি 11 টি এবং কিউ 2 থেকে 0 তে রিসেট করি এবং তারপরে আমরা আগের পর্যায়ে যেমন করেছি সমস্ত সংখ্যার মধ্য দিয়ে যেতে পারি; এই সময় ছাড়া, * কুই = 3 পরিবর্তে 2. প্রতিটি সময় Q2 পূরণ করে কুই এবং পি একটি শত শত জায়গায় হয়, আমরা ব্যবহার কিছুদিনের হ্রাস করার লুপ * পি সেখানে ব্লক বাম 1s হয় অনেক বার হিসাবে * R2 (5 আমাদের উদাহরণে) r ব্যবহার করেএকটি চলমান পয়েন্টার হিসাবে। আমরা আসলে এর চেয়ে আরও একবার এটি হ্রাস করেছি যাতে বৃহত্তম অঙ্কটি শেষ হয় −2 এ, যে কারণে পরে স্পষ্ট হবে:

আমরা সমস্ত সংখ্যা প্রক্রিয়া করার পরে, আমরা এখন ৩ য় পর্যায়ে এসেছি Here এখানে আমরা দুটি একক জিনিস সম্পাদন করি।

প্রথমত, আমরা আরো আকার বিয়োগ R থেকে -block (প্লাস 1) * কুই কিন্তু ব্যবহার R2 পয়েন্টার, যা বাম পাতার করুন। * q এভাবে নেতিবাচক হয়ে ওঠে। আমাদের ক্ষেত্রে, আর- ব্লকটিতে পাঁচটি 1 রয়েছে, সুতরাং * কিউ −3 হয়ে যায়।
দ্বিতীয়ত, আমরা একটি পরিবর্তনশীল সেট আউট নির্দেশ করে আমরা এখন আউটপুট পর্যায় ঢুকছে একটি অ শূন্য মান হতে। (প্রযুক্তিগতভাবে, * কিউ ইতিবাচক যে ইতিমধ্যে আউটপুট পর্যায়ে ইঙ্গিত দেয়, কিন্তু এটি পরীক্ষা করা খুব কঠিন, তাই অতিরিক্ত ভেরিয়েবল।)

আপনি এখন বুঝতে পেরেছেন যে আমরা সংখ্যার মধ্য দিয়ে চলেছি, প্রতিটি স্থানের মধ্যে বর্তমান স্থানটি ( * q এর অ -1 মান দ্বারা নির্দেশিত ) সন্ধান করব এবং * কিউ এর মানের উপর নির্ভর করে কিছু করব । আমরা দেখতে পাই যে * q প্রথমে 2 (= সর্বাধিক অঙ্কের মান গণনা করা) করতে উন্নত হয়, তারপরে 3 (এই জায়গার প্রতিটি অঙ্কের থেকে সর্বাধিক অঙ্কের মানটি বিয়োগ) এবং তারপরে আমরা এটিকে বিয়োগ করে তুলি। সেখান থেকে, এটি 1-এ পৌঁছা পর্যন্ত এটি অবিরত থাকবে, এভাবে "কিছু না করা" এর অর্থ পুনরুদ্ধার করা। এই মুহুর্তে, আমরা পরের স্থানে চলে যাই।

এখন, যখন * q নেতিবাচক হয়, আমরা আউটপুট আউট করি। * কিউ হুবহু সঠিক মানের যাতে আমরা 1 টির আগে পৌঁছে যাওয়ার আগে অক্ষরের সারিগুলির সঠিক সংখ্যা আউটপুট করব; বৃহত্তম অঙ্কটি যদি 2 হয় তবে আমাদের 3 টি সারি আউটপুট করতে হবে। আসুন দেখে নেওয়া যাক * কিউ এর প্রতিটি মূল্যে কী ঘটে :

* কি = −2:
- প্রথম সংখ্যার জন্য, * পি = 2, যা সূচিত করে যে আমাদের একটি '.'(বিন্দু) বা একটি ':'(কোলন) আউটপুট করতে হবে to আমরা q এর দিকে তাকিয়ে কোনটি ঠিক করি : যদি এটি −1 হয় তবে আমরা সেই স্থানে থাকি, সুতরাং আউটপুট করুন ':'(যা আমরা '8'+2 হিসাবে গণনা করি ), অন্যথায় ক '.'।
- দ্বিতীয় সংখ্যার জন্য, * পি = −3। −২ নয় এমন যে কোনও কিছু অর্থ আমরা একটি '|'(পাইপ) আউটপুট পাই এবং তারপরে মান বৃদ্ধি করি। এইভাবে এটি সঠিক জায়গায় −2 এ পৌঁছে যাবে এবং তারপরে আমরা সেই অঙ্কের বাকি অংশের জন্য '.'s / ':'s আউটপুট করব ।
- প্রতিটি ক্ষেত্রে, আমরা সংখ্যাটি প্রক্রিয়া করার আগে একটি চলক পিডি 0 তেও সেট করেছিলাম এবং আমরা একটি অক্ষর মুদ্রণ করেছি তা বোঝাতে পিডি (= "মুদ্রিত") একটি শূন্যহীন মানতে সেট করেছিলাম।
- তৃতীয় নম্বরের জন্য, কোনও প্রক্রিয়াজাতকরণ ঘটে না কারণ তৃতীয় নম্বরে শত স্থান নেই। এই ক্ষেত্রে, সংখ্যাটি প্রক্রিয়া করার পরে পিডি এখনও 0 হবে, ইঙ্গিত দেয় যে আমাদের এখনও আউটপুট করতে হবে '|'(তবে কেবল আউট শূন্য হয় না, কারণ অন্যথায় আমরা এখনও ২ বা 3 পর্যায়ে আছি)।
- সমস্ত সংখ্যা প্রক্রিয়াজাতকরণের পরে, যদি শূন্যের বাইরে হয় তবে একটি নতুন লাইন আউটপুট দিন। নোট করুন যে আমাদের আউট ভেরিয়েবলের প্রয়োজন যাতে আমরা স্টেজ 2 বা 3 এ নতুন লাইন আউটপুট না করি।
* q = −1: আগের মতো একই, পি প্রথম দুটি সংখ্যা * 2ব্যতীত, সুতরাং উভয় আউটপুট একটি'.'(এবং তৃতীয়টি'|'পূর্বে যেমনআউটপুট দেয়)।
* কিউ = 0: যখন * কিউ 0 হয়, এর অর্থ হ'ল আমরা যদি সেই জায়গায় থাকি তবে কিছুই করবেন না, অন্যথায় * পি'|' নির্বিশেষেএকটি সারির আউটপুট আউট করুন। এইভাবে আমরা অঙ্কগুলির মধ্যে প্যাডিং পাই।

এখন আমরা বৃদ্ধি কুই পরবর্তী জায়গা, দশ জায়গা, এবং বৃদ্ধিতে উপর সরানো * কুই নেই। দ্বিতীয় পর্যায়টির শুরুতে, টেপটি দেখতে এমন দেখাচ্ছে:

তারপরে আমরা স্টেজ 2 পারফর্ম করি ঠিক আগের মতোই। মনে রাখবেন যে কার্যকরভাবে এই জায়গাটিতে প্রতিটি অঙ্ক থেকে 2 বিয়োগ করে এবং সর্বোচ্চ সংখ্যাকে নির্দেশ করে * r2 এর একটি অবিচ্ছিন্ন সংখ্যা ছেড়ে যায়। আমরা পূর্ববর্তী ইউনারি নম্বরটি একা রেখেছি এবং কেবল টেপটি বামদিকে প্রসারিত করে চলেছি; এটি "ক্লিন আপ" এর জন্য অপ্রয়োজনীয় অতিরিক্ত কোডের জন্য ব্যয় করবে। যখন আমরা শেষ হয়ে যাই এবং আমরা * কিউ বৃদ্ধি করি , স্টেজ 3 এর শুরুতে টেপটি এখন:

আসলে, এটি একটি মিথ্যা। এর আগে মনে রাখবেন যেখানে আমি বলেছিলাম যে আমরা * (আর - 4) 1 তে সেট করেছি এবং কেন আপনাকে বলিনি? এখন আমি আপনাকে বলব কেন। এটি এর মতো মামলার ক্ষেত্রে, যেখানে বৃহত্তম অঙ্কটি আসলে 0 হয়, যার অর্থ এই জায়গার সমস্ত অঙ্ক 0 হয় ting উপরের লেবেলযুক্ত তীর দ্বারা নির্দেশিত সেটিং * (আর - 4) 1 টি অবিচ্ছিন্ন সংখ্যাটি 1 দ্বারা প্রসারিত করে, তবে শুধুমাত্র এই বিশেষ ক্ষেত্রে। এইভাবে আমরা ভান করি যেন বৃহত্তম অঙ্কটি 1, যার অর্থ আমরা একটি অতিরিক্ত সারি আউটপুট করব।

পর্যায় 3 পরে (অতিরিক্ত স্থানে সমস্ত অঙ্ক থেকে সর্বাধিক অঙ্ক বিয়োগ করুন), * কিউকে নেতিবাচক করে তোলে এমন অতিরিক্ত পদক্ষেপ সহ , টেপটি দেখতে দেখতে এমনটি দেখাবে। গতবারের বৃহত্তম অঙ্কটি * পি ব্লকে −২ দ্বারা প্রতিনিধিত্ব করা হয়েছিল , তবে এবার তারা সবাই −3 কারণ তারা সবাই আসলে শূন্য কিন্তু আমরা ভান করছি যে সর্বোচ্চ সংখ্যাটি 1 হ'ল।

এখন আসুন দেখুন কি কি * 1 এর দিকে অগ্রসর হওয়ার সাথে সাথে ঘটে :

যখন * q = −1 হয়, * পি মানগুলি সমস্ত −3 হয়, যার অর্থ আমরা আউটপুট '|'গুলি করব এবং সেগুলি বৃদ্ধি করব।
যখন * কুই = 0, আমরা আউটপুট '|'কারণ যে আমরা কি সবসময় কি করতে যখন * কুই = 0, নির্বিশেষে * পি ।

সুতরাং, আমরা পাইপ দুটি সারি পাই।

পরিশেষে, আমরা * q এর জায়গায় চলে যাই । এটি একটি আকর্ষণীয় হয়ে যায় কারণ ':'আসল অঙ্কটি 1 ছাড়া আর কিছু হলে আমাদের আউটপুট দরকার , তবে '8'এটি যদি 1 হয় তবে প্রোগ্রামটি কীভাবে এগিয়ে যায় তা দেখা যাক। প্রথমত, আমরা পর্যায় 2 শুরু করার জন্য * কিউ বৃদ্ধি করি :

দ্বিতীয় পর্যায় ("সর্বাধিক অঙ্কের মান গণনা করুন") পরে, আমরা এইটি দিয়ে রেখেছি:

মঞ্চ 3 পরে ("বর্তমান স্থানে সমস্ত অঙ্ক থেকে সর্বাধিক অঙ্কের মানটি বিয়োগ করুন") টেপটি দেখতে এমন দেখাচ্ছে:

এবার আসুন * কিউ এর প্রতিটি পুনরাবৃত্তি ঘুরে:

* কি = −2:
- প্রথম সংখ্যা: ইতিমধ্যে −2 এ, সুতরাং আউটপুট একটি ':'( '.'কারণ q = −1 এর চেয়ে বেশি ) output
- দ্বিতীয় সংখ্যা: −4 এ, সুতরাং আউটপুট এ '|'এবং ইনক্রিমেন্ট।
- তৃতীয় সংখ্যা: −3 এ, তাই আউটপুট এ '|'। তবে, এবার ইনক্রিমেন্টের পরিবর্তে একটি বিশেষ কেস ট্রিগার করে। কেবলমাত্র যদি আমরা শেষ স্থান ( q = −1) আউটপুট করে থাকি এবং আমরা এর জন্য দ্বিতীয় প্রান্তের ( * q = −2), এবং অঙ্কটি আসলে 1 ( * p = −3) হয় , তারপরে এটিকে −2 এ বাড়ানোর পরিবর্তে আমরা এটিকে −1 এ সেট করি। অন্য কথায়, আমরা ite1 কে একটি বিশেষ মান হিসাবে ব্যবহার করি তা বোঝাতে যে পরবর্তী পুনরাবৃত্তিতে আমাদের '8'পরিবর্তে আউটপুট প্রয়োজন ':'।
* কিউ = −1:
- প্রথম সংখ্যা: ইতিমধ্যে −2 এ, সুতরাং আউটপুট এ ':'।
- দ্বিতীয় সংখ্যা: −3 এ, সুতরাং আউটপুট এ '|'। বিশেষ শর্তটি ট্রিগার করে না কারণ * q আর −2 থাকে না। সুতরাং, বৃদ্ধি।
- তৃতীয় সংখ্যা: −1 এ, তাই আউটপুট '8'।
* কিউ = 0: সাধারণত , আমরা'|'এখানেপ্যাডিং সারি আউটপুট করব, কিন্তু বিশেষ ক্ষেত্রে যেখানে আমরা একই জায়গায় আছি ( q = −1), আমরা এড়িয়ে চলেছি।

এর পরে, কিউ 0 তে বাড়ানো হয় এবং লুপটি শেষ হয়।

এখন আপনি জানেন কীভাবে কোনও ইনপুট 202,100,1কাজ করে। যাইহোক, আরও একটি বিশেষ ক্ষেত্রে রয়েছে যা আমরা এখনও আচ্ছাদন করি নি। আপনি মনে রাখতে পারেন যে আমরা শেষ স্থানটি প্রক্রিয়া করার সময়, যখন * পি −3 ছিল তখন আমরা এটির জন্য −1 সেট করেছিলাম 1(এটি it2 বাড়ানোর পরিবর্তে) যাতে পরবর্তী পুনরাবৃত্তিটি তার '8'পরিবর্তে আউটপুট দেয় । এটি কেবলমাত্র কাজ করে কারণ আমাদের একটি পুনরাবৃত্তি রয়েছে যাতে * পি = is3 এবং আমরা এটি বৃদ্ধি করব বা সেটাকে −1 এ সেট করব কিনা সে বিষয়ে আমরা সিদ্ধান্ত নিই। আমরা না যেমন একটি পুনরাবৃত্তির আছে যদি সব বেশী জায়গায় ডিজিটের 0 বা 1. হয় এইরকম ক্ষেত্রে সব * পি 1s হবে মান শুরু -2 এ; এটিকে −1 এ সেট করার সিদ্ধান্ত নেওয়ার কোনও সুযোগ নেইবরং −3 থেকে বাড়ানো । এ কারণে, স্টেজ 3 এর ভিতরে আরও একটি বিশেষ-কেসিং শর্ত রয়েছে ("বর্তমান জায়গায় প্রতিটি অঙ্ক থেকে সর্বাধিক অঙ্কটি বিয়োগ করুন")। আমি দাবি করেছি যে প্রতিটি অঙ্ক থেকে সর্বাধিক অঙ্কের মান বিয়োগের পরে (যার পয়েন্টে সর্বাধিক অঙ্ক at1 এ থাকে), আমরা কেবল এটি আরও একবার হ্রাস করেছি, তবে আসলে এটির উপর একটি শর্ত রয়েছে যা নিম্নলিখিত হিসাবে চলেছে:

আমরা যে অঙ্কটি দেখছি এটি যদি এই জায়গায় সর্বাধিক অঙ্কের সমান হয় ( * পি = −1), এবং এই জায়গাটি স্থান ( Q = −1) হয় এবং সর্বাধিক অঙ্ক 1 ( * (r +) হয় 5) = 0, অর্থাত ইউনারী ব্লক এ অতি বাম মাত্র 5 কোষ দীর্ঘ) হয়, শুধুমাত্র তারপর আমরা চলে * পি এ -1 ইঙ্গিত শুধুমাত্র আউটপুট আবশ্যক আউটপুট একটি এর পুনরাবৃত্তির যে '8'। অন্যান্য সমস্ত ক্ষেত্রে আমরা আরও একবার এটি হ্রাস করে থাকি।

সম্পন্ন. শুভ নব বর্ষ!

সম্পাদনা 1 (3183 → 3001): কিছু শুভ নববর্ষ গল্ফিং! আমি সম্পূর্ণরূপে পি 2 এবং r2 ভেরিয়েবলগুলি থেকে মুক্তি পেতে সক্ষম হয়েছি ! সংখ্যার শুরু এবং শেষ সন্ধানের জন্য p এখন পিছনে দৌড়, তবে এটি কোডটি সংক্ষিপ্ত বলে মনে হচ্ছে। আমি পাশাপাশি Q2 থেকে মুক্তি পাওয়ার চেষ্টা করেছি, তবে আমি কোডটি সেভাবে ছোট করতে পারি না।

আমি আরও কয়েকটি জায়গা পেয়েছি যেখানে আমি লুপের শেষ মানটিকে পুনরায় ব্যবহারের মতো সাধারণ অপঠনযোগ্য গল্ফিং কৌশলগুলি প্রয়োগ করতে পারি। পরিবর্তে, একটি উদাহরণ দিতে
```
while *(++p) { 1 }         // just increment p until *p is 0; the 1 is a noop
if (pd) { x } else { y }   // where pd is a variable
```
আমি '""""(প্রথমটি করবো, তারপরে দ্বিতীয়টি করব) এবং '"""(ধ্রুবক 1) এমনভাবে লিখে এটি সংরক্ষণ করতে পারি যা এটির মতো
```
if (while *(++p) { pd }) { x } else { y }
```
অবশ্যই, এটি কেবল তখনই কাজ করে যদি আমি জানতে পারি যে লুপটি কমপক্ষে একটি পুনরাবৃত্তির জন্য চলবে তবে যদি এটি হয় তবে এর রিটার্নের মান পিডি হয় তাই আমি যদি এটির জন্য শর্ত হিসাবে ব্যবহার করতে পারি।

— Timwi
সূত্র

"অপঠনযোগ্য" অবশ্যই একটি যথাযথ নাম ...

— অ্যালেক্স এ

9

-1 পর্যাপ্ত ব্যাখ্যা নেই

— দ্য গেট উইথ দ্য হাট

7

জাভাস্ক্রিপ্ট (ES6) 750 744 690 604 498 346 245 234 বাইট

আমি পিপিসি-তে নতুন এবং আমি ভেবেছিলাম যে আমি এটির চেয়ে বরং সহজ বলে ভেবে চেষ্টা করব। ছেলে আমি কি ভুল ছিলাম !! আমি এটির জন্য কিছুক্ষণ কাজ করছি এবং আমার প্রচুর গল্ফ করতে হচ্ছে ...
পরামর্শগুলি উত্সাহিত হয়! - যদিও এটি উপলব্ধি করা সহজ কাজ হবে না।

যখন ইনপুটটি সংখ্যার একটি অ্যারে হয় (যেমন [204, 1]:) op

a=>(o=m=s="",l=a.map(n=>(s+="|",l=(n+"").length)>m?m=l:l),h=[],a=a.map((n,i)=>[..."0".repeat(m-l[i])+n].map((d,j)=>d<h[j]?d:h[j]=d)),h.map((n,i)=>{i?o+=s+`
`:0;for(j=n;j--;o+=`
`)a.map(d=>o+="|.:8"[d[i]-j<1?0:i<m-1?1:d[i]-1?2:3])}),o)

ব্যাখ্যা

a=>(

  o=m=s="",                      // m = max number of digits in a number, s = separator string         
  l=a.map(n=>(                   // l = lengths of each number
      s+="|",                    // set the separator string
      l=(n+"").length                 // convert each number to a string
    )>m?m=l:l                    // get max length
  ),
  h=[],
  a=a.map((n,i)=>
    [..."0".repeat(m-l[i])+n]    // add leading 0s to make all same length
    .map((d,j)=>d<h[j]?d:h[j]=d) // set each digit of h to max
  ),

  h.map((n,i)=>{
    i?o+=s+`
`:0;
    for(j=n;j--;o+=`
`)
      a.map(d=>
        o+=
          "|.:8"[
            d[i]-j<1?0
            :i<m-1?1
            :d[i]-1?2:
            3
          ]
      )
  }),
  o
)

উদাহরণ

ইনপুট: সংখ্যার অ্যারে: [4,8,15,16,23,42]
আউটপুট:

|||||.
|||||.
||||..
||....
||||||
|:||||
|:||||
|:|:||
|:::||
::::||
:::::|
::::::
::::::

— Aᴄʜᴇʀᴏɴғᴀɪʟ
সূত্র

+1 চিত্তাকর্ষক গল্ফিং। আপনি কি ইনপুট এবং আউটপুট সহ একটি উদাহরণ অন্তর্ভুক্ত করবেন?

— ডেভিডসি

@ ডেভিডসি ধন্যবাদ! এবং উদাহরণ অন্তর্ভুক্ত করা হয়। কনসোল থেকে এটিকে কল করুন এবং এটি একটি স্ট্রিং দেয়। :)

— Aᴄʜᴇʀᴏɴғᴀɪʟ

7

পাইথন 3, 624 598 595 574 561 535 532 527 525 426 345 328 324 294 288 286 283 280 267 265 255 251 245 238 235 234 230 228 বাইট

z=input().split();v=max(map(len,z));d=''.join(i.zfill(v)for i in z);x=['']*len(z)
for k,c in enumerate(d):j=k%v;m=int(max(d[j::v]));c=int(c);x[k//v]+="|"*(m-c+0**m+(j>0))+":8."[(c<2)|-(j<v-1)]*c
for r in zip(*x):print(*r,sep='')

ঠিক আছে, যেহেতু এই প্রশ্নের একটি উত্তর প্রয়োজন, আমি এখানে একটি সরবরাহ করেছি, যেখানে ইনপুটটি সংখ্যার ফাঁক দিয়ে পৃথক হওয়া স্ট্রিং হওয়া উচিত "204 1"। ছেলে, এটা কি অনেক দীর্ঘ? কোনও গল্ফিং পরামর্শ (বা আরও ভাল উত্তর) স্বাগত।

সম্পাদনা করুন: ট্যাব এবং স্পেসগুলি মিশ্রিত করে বাইটস সংরক্ষণ করা হয়েছে।

সম্পাদনা: আমি একটি সংরক্ষিত অনেক পরিবর্তন কীভাবে আমি একটি সংখ্যা সংখ্যার প্রাপ্ত (পরে কোডের শরীরে, সংখ্যা শূন্য প্যাডেড স্ট্রিং থেকে একটি তালিকা তৈরি করুন, TRANSPOSE শত শত সংখ্যা, দশ ডিজিটের, ইত্যাদি পেতে দ্বারা বাইটের ।)

সম্পাদনা করুন: এবং আমি শেষ :8লুপটিকে মূল কুইপু লুপের সাথে অন্তর্ভুক্ত করে আরও কিছু সঞ্চয় করেছি । ~~এখন যদি আমি বুঝতে পারি কেন b=d[j*v+i]==m(d[i::v])কাজ করবে না।~~ এটি নির্ধারণ করা হয়েছে এবং সমাধানটি অনেকগুলি বাইট নেয়। (এছাড়াও বাইট গণনাটি হ্রাস পেয়েছে কারণ কোনওভাবে ট্যাবগুলি চারটি স্পেসে পরিণত হয়েছিল It এটি সম্ভবত এই সাইটে কোড ব্লকের ফর্ম্যাটিং ছিল))

সম্পাদনা করুন: কীভাবে ক্যুইপাস তৈরি হয়েছিল তা আমি পুনর্গঠিত করেছি। এখন এটি একবারে একটি স্ট্র্যান্ড তৈরি করে, তারপরে মুদ্রণের জন্য স্থানান্তর করে।

সম্পাদনা করুন: আরও কিছু বাইট সংরক্ষণ করার জন্য আমার উত্তরটিকে পাইথন 3 প্রোগ্রামে ফিরিয়েছে।

সম্পাদনা: আমি আমার কোডে একটি বাগ পেয়েছি যা এটি তৈরি করেছে যাতে এটি সংখ্যার মাঝখানে সঠিকভাবে শূন্যগুলি প্রিন্ট না করে ( 204 1উপরের টেস্টের কেসটি দেখুন )। এটি ঠিক করার সময়, আমি এটি গল্ফ করেছিলাম :)

সম্পাদনা করুন: আমি 10 বাইট সংরক্ষণ করতে মুদ্রণ পরিবর্তন করেছি। এবং আমি পুরানো বাইট সমস্ত গণনা ফিরে রেখেছি, ঠিক কারণ।

সম্পাদনা করুন: চার বাইট vব্যবহারের mapজন্য অ্যাসাইনমেন্টটি গল্ফ করেছেন । কার্পেট পাইথনকে ক্রেডিট , যেমন আমি এখানে তাদের উত্তর থেকে ধারণা পেয়েছি ।

সম্পাদনা: মাঝামাঝিটিকে "লুপের জন্য লুপের জন্য" লুপের জন্য ছয় বাইটের জন্য একটিতে রূপান্তরিত করে

সম্পাদনা: এখন ব্যবহার enumerate। আর ব্যবহার হচ্ছে না l=len(z)। টার্নারিটিকে if-elseএকটি তালিকা বার্ষিকীতে পরিণত করেছে । বিস্তারিত জানার জন্য নীচে দেখুন।

সম্পাদনা: Sp3000 এটিকে সম্পাদনা printএবং বার্নারিক শর্তে একটি সম্পাদনা প্রস্তাব করেছে যা প্রতিটি বাইট সংরক্ষণ করে।

Ungolfed:

s = input()
z = s.split()
v = max(map(len, z))                # the amount of digits of the largest number
d = ''.join(i.zfill(v) for i in z)  # pad zeroes until every number is the same length
                                     # then join the numbers into one string
x = ['']*len(z)                     # a list of strings for the output, one for each number

for k,c in enumerate(d):          # for every digit in every number
    i,j = divmod(k, v)            # i is the index of the number we're on
                                   # j is the index of the digit of the number we're on
    m = int(max(d[j::v]))         # the largest of all the digits in the j-th place
    c = int(c)                    # the digit in j-th place of the i-th number
    x[i] += "|"*(m-c+0**m+(j>0))  # pad | to size m-c, until the knots are correctly spaced
                                  # add a | if m<1, all j-th place digits are 0
                                  # add a | if j>0, if it's not at the start, as delimiters
    x[i] += ":8."[(c<2)|-(j<v-1)] * c
    # this is essentially the following code
    # if j<v-1:
    #     x[i] += "."*c      # . knots if not in the units place
    # else:
    #     if c == 1:
    #         x[i] += "8"*c  # 8 knots for ones in the units place
    #     else:
    #         x[i] += ":"*c  # : knots for something else is in the units place

for r in zip(*x):       # transpose so all the rows (the quipu strings) now hang down
    print(*r, sep='')    # join the strings together at each knot
                         # and print each on a separate line

— Sherlock9
সূত্র

পাইথন 3 এর সাথে এখানে কি নির্দিষ্ট কিছু রয়েছে ? যদি তা না হয় তবে পাইথন 2 এ রূপান্তর করা বেশ কয়েকটি বাইট সংরক্ষণ করতে পারে

— সাইয়েস

@ কোয়েস খুব বেশি কিছু পাইথন 3 নির্দিষ্ট নয়। আমি পাইথন 3 এ সবে শুরু করেছি কারণ এটি আমার কাছে সংস্করণ। আমি আইডিয়োন বা অন্য কিছুতে পাইথন 2 সংস্করণ পরীক্ষা করব।

— শার্লক 9

@ মাল্টেসেন এটি এমন ইনপুটগুলির সাথে কাজ করে না 0যেমন শুরু হয় 0 12 4।

— শার্লক 9

পাইথন ২ তে ইনডেন্টেশনের জন্য ট্যাব এবং স্পেসগুলি পরিবর্তিত করে আপনি কিছু বাইট সংরক্ষণ করতে পারেন। আমি বিশ্বাস করি 1 টি ট্যাব অক্ষর == 8 পাইথনের ইন্ডেন্টেশন পার্সার অনুযায়ী স্পেস

— সাইওস

for r in zip(*x):print(''.join(r))->print(''.join(r)for r in zip(*x))

— লিকি নুন

4

সি, 238 235 বাইট

কোডটি যত তাড়াতাড়ি সংক্ষিপ্ত করতে সি প্রিপ্রোসেসরের উপর প্রচুর নির্ভরযোগ্য। পার্শ্ব প্রতিক্রিয়া হিসাবে, এটিকে বেশ পঠনযোগ্য করে তোলে।

#define l strlen(a[i])
#define d l<k||a[i][l-k]-48
#define m(e) for(i=1;a[i];e<=r?i++:r++);
#define p(e) {m(!putchar(e?'|':k>1?46:d<2?56:58))puts("");}
k,r;main(int i,char**a){m(l)for(k=r,r=1;k;r=k>1){m(d)for(;r;r--)p(d<r)if(--k)p(1)}}

উবুন্টু 14.04 এ, আপনি কোডটি একটি সোজাসুজি দিয়ে সংকলন করতে পারেন gcc quipu.c(দয়া করে সতর্কতাগুলি উপেক্ষা করুন)। এক্সিকিউটেবল চালনার উদাহরণ:

$ ./a.out 1 2 3 2 1
||:||
|:::|
8:::8

সমস্ত ওপির পরীক্ষার মামলার বিরুদ্ধে পরীক্ষিত।

অবিকৃত উত্স কোড:

// Standard library; leaving out the includes still gives executable code despite the warnings.
#include <stdio.h>
#include <string.h>

// 4 preprocessor macros.
// Note: some of these actually make use of the fact that parentheses have been left out

// l: length of argument i
#define l     strlen(a[i])

// d: shorthand for a digit
#define d     l<k || a[i][l-k]-'0'

// m: loop across all arguments; calculates r as the maximum of expression e
#define m(e)  for (i=1; a[i]; e<=r ? i++ : r++);

// p: prints one line of output
// note: intentionally does not use the r++ code branch of m;
//       putchar always returns a non-zero number here, so !putchar is zero,
//       which is always <=r (because r is never negative)
// note: the semicolon after m(...) is redundant;
//       the definition of m already contains a semicolon
// note: puts("") outputs a newline
#define p(e)  { m(!putchar(e ? '|' : k > 1 ? '.' : d < 2 ? '8' : ':')); puts(""); }

// k: knot position; 1 for units, 2 for tens, 3 for hundreds...
int k;

// r: input and output value for m
// note: the first time we call m, we need r to be zero;
//       by defining it outside main, it is automatically initialized as such
int r;

// function main
// note: parameter i (normally named argc by convention) is not needed
//       (the last element of argv is known; it is followed by a NULL pointer)
//       but we cannot leave it out (otherwise we cannot access argv)
//       so it serves as a local variable (to loop through arguments; see m)
// note: parameter a (normally named argv by convention)
//       is the array of arguments (starting from index 1)
int main(int i, char **a)
{
    // Determine the longest argument; store its length in r.
    // This is the number of knot positions to consider.
    m(l)

    // Iterate k through the knot positions from top to bottom.
    // Note: k > 0 has been abbreviated to k.
    // Note: for each iteration, we also initialize r with either 0 or 1.
    //       0 = suppress printing when all knots are zero
    //       1 = always print, even when all knots are zero
    for (k = r, r = 1; k > 0; r = k > 1)
    {
        // Determine the highest digit at this knot position.
        // Note: due to the absence of parentheses, d mixes up with <=r into:
        // (l < k) || (a[i][l-k]-'0' <= r)
        m(d)

        // Count the digits down.
        for (; r; r--)
        {
            // Print a single line of output.
            // When d (the digit in the current strand) is less than the counter,
            // then print a '|', otherwise print a knot.
            p(d < r)
        }

        // Decrement k (go to next knot position).
        // If this was not the last iteration...
        if (--k > 0)
        {
            // Print separator line.
            p(1)
        }
    }

    // Return exit code zero; redundant.
    return 0;
}

— রুড হেল্ডারম্যান
সূত্র

অভিনন্দন! অনুগ্রহকালীন সময়ের মধ্যে সংক্ষিপ্ত উত্তর হিসাবে পোস্ট করা, আপনি আমার অনুগ্রহ +50 প্রতিনিধি পেয়েছেন। চমৎকার উত্তর! :)

— অ্যালেক্স এ।

4

গণিত 436 453 357 352 347 বাইট

t=Transpose;y=ConstantArray;a=Table;
g@j_:=(s=t[PadLeft[#,Max[Length/@i]]&/@(i=IntegerDigits@#)]&;p_~u~o_:=(m=Max@p;c=If[o==-2,":","."];w=If[o==-2,"8","."];p//.{0->a["|",Max@{1,m}],1->Join[a["|",{m-1}],{w}],n_/;MemberQ[2~Range~9,n]:>Join[y["|",m-n ],c~y~n]});t[Join@@@t@Join[u[#,0]&/@Most@#,u[#,-2]&/@{#[[-1]]}]]&[Riffle[(s@j),{a[0,Length@j]}]]//Grid)

সর্বোপরি

প্রতিটি সংখ্যাকে অঙ্কের তালিকায় বিভক্ত করে ব্যবহার করে IntegerDigits; বামে শূন্য সহ প্রতিটি সংখ্যা প্যাড (সমান ব্যবধান নিশ্চিত করার জন্য); প্রতিটি ইনপুট নম্বর, এখন অঙ্কগুলিতে বিভক্ত, একটি অ্যারের এক সারিতে অনুরূপ; প্রতিটি কলাম একটি স্থান মানের প্রতিনিধিত্ব করে। অ্যারে স্থানান্তরিত হয়।
প্যাডিং সহ নটগুলির একটি তালিকা সহ অঙ্কগুলি প্রতিস্থাপন করে। ইউনিটগুলির জন্য কিছুটা আলাদা প্যাটার্ন-মিলের রুটিন ব্যবহার করা হয়।

উদাহরণ

g[Range[0, 50]]

— DavidC
সূত্র

Transpose@Join? এটা ঠিক আছে?

— ক্যালকুলেটরফলাইন

হ্যাঁ. এটি ধরার জন্য ধন্যবাদ।

— ডেভিডসি

ঠিক তার আগে স্পেস।

— ক্যালকুলেটরফলাইন

1

আর - 446 444

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

function(x){r=nchar(max(x));c=length(x);m=matrix(0,r,c);for(i in 1:c){t=as.numeric(strsplit(as.character(x[i]),"")[[1]]);m[(r+1-length(t)):r,i]=t};Q=c();for(i in 1:r){d=m[i,];z=ifelse(max(d)>0,max(d),1);q=matrix("|",z,c);for(j in 1:c){v=m[i,j];if(i==r){if(v==1)q[z,j]=8;if(v>1)q[(z-v+1):z,j]=rep(":",v)};if(i<r){if(v>0)q[(z-v+1):z,j]=rep(".",v)}};if(i!=1&sum(d)>0)q=rbind(rep("|",c),q);Q=rbind(Q,q)};for(i in 1:nrow(Q))cat(Q[i,],sep="",fill=T)}

Ungolfed

# Some test data
test <- c(201, 0, 100, 222, 53)

# Define function
quipu <- function (x) {

    # Create matrix with a row for each digit and a column for each number
    r=nchar(max(x));c=length(x);m <- matrix(0,r,c)
    for(i in 1:c) {
        t=as.numeric(strsplit(as.character(x[i]),"")[[1]])
        m[(r+1-length(t)):r,i]=t
    }

    # Loop through each row (digit) starting at the top of the quipu
    Q=c() # Empty matrix to store quipu 
    for(i in 1:r){

        d=m[i,]
        z=ifelse(max(d)>0,max(d),1)
        q=matrix("|",z,c)

        # Loop through each column (number in the vector) starting at the leftmost quipu
        for(j in 1:c){

            # The digit
            v=m[i,j]

            # If it is the last segment of the quipu
            if(i==r){
                if(v==1){q[z,j]=8} # If unit digit =1
                if(v>1){q[(z-v+1):z,j]=rep(":",v)} # If unit digit >1               
            }

            # If it is not the last segment of the quipu
            if(i<r){
                if(v>0){q[(z-v+1):z,j]=rep(".",v)} # If non-unit digit >0   
            }
        }

        # Add segment to Q
        if(i!=1 & sum(d)>0){q=rbind(rep("|",c),q)}
        Q=rbind(Q,q)    
    }

    # Print quipu
    for(i in 1:nrow(Q)) {cat(Q[i,], sep="", fill=T)}
}

# Test
quipu(test)

— ধীর লরিস
সূত্র

if(v>0)আপনার if(i<r)ধারাতে কি দরকার ? আর z+1:zকখন কি আর কোন ব্যাপ্তি গ্রহণ করে v==0? যদি q[z+1:z,j]তা কিছুতেই প্রভাবিত না হয়, আমি ভাবব। এছাড়াও, আর এর কী elseকীওয়ার্ড এবং কিছু ধরণের else ifকীওয়ার্ড রয়েছে? যদি তা হয় তবে আপনি এই শর্তাবলীর কয়েকটি গল্ফ করতে সক্ষম হবেন।

— শার্লক

if(v>0)প্রয়োজন কারণ যদি v=0, সূচকটি সীমা ছাড়িয়ে যায় (যেমন, সারি ন্রো + 1 পাওয়ার চেষ্টা করে)। আর এর আছে elseএবং আমি আপনার পরামর্শটি চেষ্টা করেছি এবং elseযেখানে সম্ভব সেখানে ব্যবহার করেছি , তবে এটি একই সংখ্যক বাইটে পরিণত হয়েছে।

— ধীর লরিস

কুইপু গণনা: নতুন বিশ্বে বেস 10

বিস্তারিত

বিধি

উদাহরণ

আরও পড়া

পাইথ, 64 বাইট

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

অপঠনযোগ্য , 3183 3001 বাইট

ব্যাখ্যা

জাভাস্ক্রিপ্ট (ES6) 750 744 690 604 498 346 245 234 বাইট

ব্যাখ্যা

উদাহরণ

পাইথন 3, 624 598 595 574 561 535 532 527 525 426 345 328 324 294 288 286 283 280 267 265 255 251 245 238 235 234 230 228 বাইট

সি, 238 235 বাইট

গণিত 436 453 357 352 347 বাইট

আর - 446 444

Ungolfed