ব্যাগ অপারেশন প্রয়োগ করুন

Question

একটি ব্যাগ , একটি মাল্টিসেটও বলা হয়, একটি আনর্ডারড সংগ্রহ। আপনি এটিকে এমন সেট বলতে পারেন যা সদৃশ, বা একটি তালিকা (বা একটি অ্যারে) যা আদেশ / সূচিযুক্ত নয় allows এই চ্যালেঞ্জে আপনাকে ব্যাগ অপারেশনগুলি প্রয়োগ করতে বলা হবে: সংযোজন, পার্থক্য, গুণ, ভাগ, গণনা এবং সমতা পরীক্ষা।

অপারেশনস

নির্দিষ্ট অপারেশনগুলি প্রচলিত হতে পারে না।

• সংযোজন দুটি ব্যাগকে এক সাথে সংযুক্ত করে প্রতিটি মানের মোট সংখ্যা সংরক্ষণ করে
  [1,2,2,3] + [1,2,4] = [1,1,2,2,2,3,4]
• পার্থক্য ব্যাগ থেকে অন্য ব্যাগের প্রতিটি উপাদান সরিয়ে দেয় বা এ জাতীয় উপাদান না থাকলে কিছুই করে না
  [1,2,2,4] - [1,2] = [2,4] [1,2,3] - [2,4] = [1,3]
• গুণটি ব্যাগের প্রতিটি উপাদানকে গুণ করে।
  [1,2,3,3,4] * 3 = [1,1,1,2,2,2,3,3,3,3,3,3,4,4,4] 2 * [1,3] = [1,1,3,3]
• বিভাগ একটি অস্বাভাবিক এক: প্রতিটি এন সমতুল্য উপাদানগুলি n সমান নতুন ব্যাগগুলিতে রাখা হয়, যে উপাদানগুলি এন-গ্রুপ গঠন করতে পারে না তা ব্যাগে থাকে remain এন ব্যাগের যে কোনও একটি ফেরত দিন।
  [1,1,2,2,2] / 2 = [1,2] [1,2,2,3,3,3] / 3 = [3]
• কাউন্টিং গন্য কত ভাজক ব্যাগ লভ্যাংশ ব্যাগ থেকে হতে পারে- যেমন
  [1,1,2,2,2,2,3,3,3] c [1,2,3] = 2
• দুই ব্যাগের প্রতিটি উপাদানের সমান সংখ্যক সংখ্যা রয়েছে কিনা তা সমতা পরীক্ষা করে দেখুন
  [1,2,2,3] == [3,2,1,2] = truthy [1,2,3] == [1,2,2,3] = falsy (এটিও এর =জন্য ব্যবহার করতে পারেন )

আপনি যদি অপারেটরগুলির জন্য নিজস্ব প্রতীক ব্যবহার করেন তবে দয়া করে নির্দিষ্ট করুন।

ফর্ম্যাট

ব্যাগগুলি ফর্মের তালিকা হিসাবে প্রদর্শিত হবে [1,1,2,3,4]। আপনি বর্গক্ষেত্রের তুলনায় অন্য কোনও ব্র্যাকেট ব্যবহার করতে পারেন, বা এমনকি উদ্ধৃতিগুলি বা কোনও কিছুই ব্যবহার করতে পারেন। এই প্রশ্নের প্রয়োজনে উপাদানগুলি পূর্ণসংখ্যার (গাণিতিকভাবে, প্রয়োজনীয়ভাবে নয় int) হবে। ব্যাগগুলি বাছাই করতে হবে না।

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

আউটপুট ফরম্যাট একই বিন্যাসে একটি একক ব্যাগ হওয়া উচিত।

বিধি

• আপনি অন্তর্নির্মিত ফাংশন, অপারেশন বা লাইব্রেরি (স্ট্যান্ডার্ড লাইব্রেরি সহ) ব্যবহার করতে পারবেন না যা ইতিমধ্যে এগুলি প্রয়োগ করে; এটি তালিকা সংক্ষিপ্তকরণ এবং গুণগুলি ব্যবহার করার জন্য ঠিক আছে যেহেতু সেগুলি ব্যাগ ক্রিয়াকলাপ নয়, সংজ্ঞায়িত তালিকা অপারেশন দ্বারা হয় (যা মূলত একই জিনিসটি ঘটে)
• স্ট্যান্ডার্ড লুফোলস প্রযোজ্য
• সংক্ষিপ্ত উত্তর জেতা

পরীক্ষার মামলা

[1,2,2,3] + [1,2,4]
[1,1,2,2,2,3,4]

[1,2,2,4] - [1,2]
[2,4]

[1,2,3] - [2,4]
[1,3]

[1,2,3,3,4] * 3
[1,1,1,2,2,2,3,3,3,3,3,3,4,4,4]

2 * [1,3]
[1,1,3,3]

[1,1,2,2,2] / 2
[1,2]

[1,2,2,3,3,3] / 3
[3]

[1,1,2,2,2,2,3,3,3] c [1,2,3]
2

[3,2,1,2] == [1,2,2,3]
truthy

[1,2,3] == [1,2,2,3]
falsy

Comments

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

— লুইস মেন্ডো

@ লুইস মেন্ডো স্প্লিট অন অন স্পেসটি পার্স করার পক্ষে যথেষ্ট, যদি আপনার কাছে এমন ভাষা আছে যা স্ট্রিংগুলিকে তালিকাগুলির হিসাবে মূল্যায়ন করতে পারে তবে তা কি ভাবেন না? আমি চ্যালেঞ্জ পোস্ট করার ক্ষেত্রে অনভিজ্ঞ, তাই দয়া করে আমাকে আলোকিত করুন :-)

— বুসুক্সুয়ান

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

— লুইস মেন্ডো

@ লুইস মেন্ডো এটি এখন মূলত নিখরচায়। এবং পূর্ণসংখ্যা সম্পর্কে, আমি কেবল বোঝাতে চেয়েছিলাম যে গাণিতিক অর্থে, ডেটা টাইপ নয়।

— বুসুক্সুয়ান

@ লুইস মেন্ডো না, প্রতীকগুলি কিছুটা হলেও বিবেচনা করা দরকার। ভাল, আপনি সমতা পরীক্ষার জন্য এক = ব্যবহার করতে পারেন।

— বুসুক্সুয়ান

Answer 1

05AB1E, 92 87 83 82 77 বাইট

>i‚˜,}¹iи˜Qis}GD})˜,}¹<i³v²y¢O}){0è,}¹Íi{s{Q,}¹Í<iÙv²y¢O³‹_iy}}),}svy†¬yQi¦}}

অপারেশন দ্বারা বিভক্ত

>i                      # if 0
  ‚˜,}                  # addition
¹i                      # if 1
  и˜Qis}GD})˜,}        # multiplication
¹<i                     # if 2
   ³v²y¢O}){0è,}        # count
¹Íi                     # if 3
   {s{Q,}               # equality
¹Í<i                    # if 4
   Ùv²y¢O³÷Fy}}),}      # division
                        # else
   svy†¬yQi¦}}          # difference

ব্যাখ্যা

সংযোজন

‚˜,}

একটি ব্যাগ অন্যটিতে রাখুন এবং একটি ব্যাগে চ্যাপ্টা করুন।

গুণ

и˜Qis}

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

GD})˜,}

এক্স বার বার ব্যাগটি সদৃশ করুন এবং একটি ব্যাগে যোগ দিন।

গণনা

³v²y¢O}){0è,}

বিভাজক ব্যাগের প্রতিটি উপাদানের জন্য, লভ্যাংশ ব্যাগে উপস্থিতির সংখ্যা গণনা করুন।
সর্বনিম্ন গণনাটি আমরা করতে পারি ব্যাগের সংখ্যা।

সমতা

 {s{Q,}

উভয় ব্যাগ বাছাই করুন এবং তারা সমান কিনা তা পরীক্ষা করুন।

বিভাগ

Ùv²y¢O³÷Fy}}),}

ব্যাগটিতে প্রতিটি অনন্য উপাদান কতবার ঘটে তা গণনা করুন।
যদি এটি বিভাজকের হিসাবে কমপক্ষে বহুবার ঘটে থাকে। (Nr_of_copies_total // বিভাজক) কপিগুলি ব্যাগে রাখুন।

পার্থক্য

svy†¬yQi¦}} 

Subtrahend প্রতিটি উপাদান জন্য, এটি minuend সামনের দিকে সাজান।
যদি বর্তমান সাবট্রেন্ডটি যদি মিন্যুন্ডের প্রথম উপাদানের সমান হয় তবে এটি মিনিট থেকে সরান।

Answer 2

এপিএল (155)

∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕

এটি একটি অপারেটরকে ∆'ব্যাগ' সংজ্ঞায়িত করে, যা প্রদত্ত ফাংশনগুলির জন্য ব্যাগ ক্রিয়াকলাপ সংজ্ঞায়িত করে। অর্থাৎ +∆সংযোজন হবে। এরপরে এটি কীবোর্ড থেকে একটি লাইন পড়ে এবং এপিএল এক্সপ্রেশন হিসাবে মূল্যায়ন করে।

ফাংশনগুলি হ'ল:

• +∆, সংযোজন
• -∆, বিয়োগ
• ×∆, গুণ
• ÷∆, বিভাগ
• ⊂∆গণনা
• ≡∆সমতুল্যতা (যদিও গল্ফিংয়ের কারণে কোনও স্বীকৃত ফাংশন সমতুল্যতা করবে)

ব্যাখ্যা:

• ∆←{... }: একটি অপারেটর সংজ্ঞায়িত ∆:

  • O←⍺⍺: প্রদত্ত ফাংশনটিতে সংরক্ষণ করুন O( সরাসরি ⎕CRসাথে কাজ করবে না ⍺⍺)
  • O←⎕CR'O': ফাংশনটির স্ট্রিং প্রতিনিধিত্ব পান
  • '+'=O... :: অতিরিক্ত হিসাবে,
    • ⍺,⍵: দুটি তালিকা একসাথে যোগ দিন
    • R[⍋R←... ]: এবং ফলাফলটি বাছাই করুন
  • '-'=O:: বিয়োগের জন্য,
    • ⍺{... }⍵: নিম্নলিখিত পুনরাবৃত্ত ফাংশন চালান:
      • ⍵≡⍬:⍺: সাবট্রেন্ডটি যদি খালি থাকে তবে মিনিটটি ফিরিয়ে দিন
      • ⍺/⍨(⍳⍴⍺)≢⍺⍳⊃⍵∇1↓⍵: অন্যথায়, সাবট্রেন্ডের প্রথম উপাদানটি সাবট্রেন্ড এবং মিনিট উভয় থেকেই সরান এবং আবার চেষ্টা করুন
  • (⍬=⍴⍵)∧K←'×'=O: গুণনের জন্য, এবং যদি সঠিক যুক্তি ব্যাগ না থাকে:
    • ⍵/⍺: বাম আর্গুমেন্টে প্রতিটি উপাদানকে ডান আর্গুমেন্টে প্রতিলিপি করুন
  • K:: ... এবং যদি ডান যুক্তি হল একটি ব্যাগ:
    • ⍺/⍵: বাম আর্গুমেন্ট দ্বারা প্রতিটি উপাদানকে ডান আর্গুমেন্টে প্রতিলিপি করুন (এটি এমন হয় যে গুণটি পরিবর্তনীয় হয়)
  • '÷'=O:: বিভাগের জন্য,
    • ⍵≤⍺∘.+⍺: কমপক্ষে ⍵ বার elements এর মধ্যে থাকা উপাদানগুলি দেখুন,
    • ⍺/⍨: এগুলি those থেকে নির্বাচন করুন,
    • ∪: এবং তালিকা থেকে সমস্ত নকল সরান
  • '⊂'=O:: গণনার জন্য,
    • ⍵{... }⍺: নিম্নলিখিত পুনরাবৃত্ত ফাংশন চালান:
      • (∪⍺)≢∪⍵:0: যদি একটি তালিকায় অন্য উপাদান থাকে না তবে ফলাফলটি 0 হয়
      • 1+⍺∇⍵-∆⍺: অন্যথায়, বিভাজকের থেকে লভ্যাংশ বিয়োগ করুন, আবার চেষ্টা করুন, এবং ফলাফল বৃদ্ধি করুন।
  • ⋄: উপরের কেউ না থাকলে সমতা পরীক্ষা করুন:
    • ⍺[⍋⍺]≡⍵[⍋⍵]: উভয় তালিকাগুলি বাছাই করুন এবং দেখুন যে তারা সমান কিনা

• ⎕: কীবোর্ড থেকে একটি অভিব্যক্তি পড়ুন, এটি মূল্যায়ন, এবং ফলাফল আউটপুট।

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

      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 2 2 3 +∆ 1 2 4
1 1 2 2 2 3 4
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 2 2 4 -∆ 1 2
2 4
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 2 3 -∆ 2 4
1 3
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 2 3 3 4 ×∆ 3
1 1 1 2 2 2 3 3 3 3 3 3 4 4 4
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      2 ×∆ 1 3
1 1 3 3
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 1 2 2 2 ÷∆ 2
1 2
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 2 2 3 3 3 ÷∆ 3
3
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 1 2 2 2 2 3 3 3 ⊂∆ 1 2 3
2
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      3 2 1 2 ≡∆ 1 2 2 3
1
      ∆←{O←⍺⍺⋄'+'=O←⎕CR'O':R[⍋R←⍺,⍵]⋄'-'=O:⍺{⍵≡⍬:⍺⋄(⍺/⍨(⍳⍴⍺)≠⍺⍳⊃⍵)∇1↓⍵}⍵⋄(⍬≡⍴⍵)∧K←'×'=O:⍵/⍺⋄K:⍺/⍵⋄'÷'=O:∪⍺⌿⍨⍵≤+/⍺∘.=⍺⋄'⊂'=O:⍵{(∪⍺)≢∪⍵:0⋄1+⍺∇⍵-∆⍺}⍺⋄⍺[⍋⍺]≡⍵[⍋⍵]}⋄⎕
⎕:
      1 2 3 ≡∆ 1 2 2 3
0

Comments

সত্যিই পেশাদার সমাধান এবং দুর্দান্ত লেখার আপ! +1

আপনার লিখনআপ এবং ব্যাখ্যা সত্যিই কঠিন! যদিও একটি জিনিস: বিভাগের জন্য, আমি বিশ্বাস করি যে অনুমানটি এমনভাবে দেওয়া [2,2,2,2,2,2]/3উচিত যা দেওয়া উচিত [2,2], তবে আপনার দেওয়া মনে হয় [2]।

— মূল্য

আপনাকে আরপিএল কোড করার দরকার নেই। আপনি যদি কেবল সংজ্ঞায়িত করেন ∆তবে ব্যবহারকারীকে এপিএল এর স্থানীয় আরপিএল এ ফেলে দেওয়া হবে যেখানে ∆এখন বৈধ is আমি মনে করি আপনি বিয়োগকে শেষের দিকে সরিয়ে কিছু বাইট সংরক্ষণ করতে পারেন কারণ এটির জন্য কেবল দুটি লাইনের প্রয়োজন। এর পরিবর্তে, গণনা প্রতীক হিসাবে ⎕CRব্যবহার করুন *এবং করুন O←⍺⍺2, তারপরে 2=O:আরও, 1=Oবহু, 0=O:সমতুল্য, 7<O:গণনার জন্য, এবং বিভাজনের জন্য 0<O:( 0>O:সাবট্রের জন্য বোঝানো)।

— অ্যাডম

Answer 3

জাভাস্ক্রিপ্ট (ES6), 260 বাইট

(x,o,y,a=a=>a.reduce((r,e,i)=>[...r,...Array(e).fill(i)],[]),b=(a,r=[])=>a.map(e=>r[e]=-~r[e])&&r)=>[z=>a(b(y,z)),z=>y.map(e=>z[e]&&z[e]--)&&a(z),z=>a(z.map(e=>e*y)),z=>a(z.map(i=>i/y|0)),z=>b(y).map((e,i)=>r=Math.min(r,z[i]/e),r=1/0)|r,z=>``+z==b(y)][o](b(x))

3 পরামিতি লাগে। প্রথম প্যারামিটারটি একটি অ্যারে, দ্বিতীয়টি অপারেটর, তৃতীয়টি অপারেটরের উপর নির্ভর করে। ব্যাগগুলি অ-নেতিবাচক পূর্ণসংখ্যার ধারণ করতে হবে।

[...] 0 [...] -> addition
[...] 1 [...] -> difference
[...] 2 <n> -> multiplication
[...] 3 <n> -> division
[...] 4 [...] -> counting
[...] 5 [...] -> equality

Ungolfed:

function do_bag_op(lhs, op, rhs) {
    function bag2array(bag) {
        return bag.reduce(function (result, entry, index) {
            return result.concat(Array(entry).fill(index));
        }, []);
    }
    function array2bag(array, bag) {
        if (!bag) bag = [];
        array.forEach(function (entry) {
            if (bag[entry]) bag[entry]++;
            else bag[entry] = 1;
        }
        return bag;
    }
    var bag = array2bag(lhs);
    switch (o) {
    case 0: // addition
        return bag2array(array2bag(rhs, bag));
    case 1: // difference
        rhs.forEach(function(entry) {
            if (bag[entry]) bag[entry]--;
        });
        return bag2array(bag);
    case 2: // multiplication
        return bag2array(bag.map(function (entry) {
            return entry * rhs;
        }));
    case 3: // division
        return bag2array(bag.map(function (entry) {
            return Math.floor(entry / rhs);
        }));
    case 4: // counting
        return Math.floor(array2bag(rhs).reduce(function (count, entry, index) {
            return Math.min(count, bag[index] / entry);
        }, Infinity));
    case 5: // equality
        return String(bag) == String(array2bag(rhs));
    }
}

Answer 4

অক্টাভা, 253 244 226 বাইট

function r=f(a,b,o)
u=union(a,b);p=hist(a,u);q=hist(b,u);m=d=0;if(numel(b)==1)m=p.*b;d=p/b;elseif(numel(a)==1)m=a.*q;end
r={p+q,p-q,m,d,min(fix(p./q)),isequal(p,q)}{o};if(o<5)r=[arrayfun(@(x,y)repmat(y,1,x),r,u,'un',0){:}];end

এই ফাংশনটি একটি ফাইলে থাকতে হবে। কমান্ড উইন্ডোতে ফাংশনটি লিখতে আপনাকে অবশ্যই ব্যবহার করতে হবে endfunctionবা end।

18 বাইট সংরক্ষণের জন্য লুইস মেন্ডোকে ধন্যবাদ ।

অপারেশনগুলি হ'ল:

1 = addition
2 = difference
3 = multiplication
4 = division
5 = counting
6 = equality test

ব্যবহারের উদাহরণ:

>> f([1,2,2,3], [1,2,4], 1)
ans = 1   1   2   2   2   3   4

>> f([1,2,2,4], [1,2], 2)
ans = 2   4

>> f([1,2,3], [2,4], 2)
ans = 1   3

>> f([1,2,3,3,4], 3, 3)
ans = 1   1   1   2   2   2   3   3   3   3   3   3   4   4   4

>> f(2, [1,3], 3)
ans = 1   1   3   3

>> f([1,1,2,2,2], 2, 4)
ans = 1   2

>> f([1,2,2,3,3,3], 3, 4)
ans =  3

>> f([1,1,2,2,2,2,3,3,3], [1,2,3], 5)
ans =  2

>> f([3,2,1,2], [1,2,2,3], 6)
ans =  1

>> f([1,2,3], [1,2,2,3], 6)
ans = 0

Ungolfed:

function r = f(a,b,o)
    u = union(a,b);
    p = hist(a,u);
    q = hist(b,u);
    m = d = 0;
    if (numel(b)==1)
        m = p.*b;
        d = p/b;
    elseif (numel(a)==1) 
        m = a.*q;
    end
    r = {p+q, p-q, m, d, min(fix(p./q)), isequal(p,q)}{o};
    if (o<5)
        r = [arrayfun(@(x,y) repmat(y, 1, x), r, u, 'un', 0){:}];
    end
end

Answer 5

ম্যাথামেটিকাল, 387 347 300 284 বাইট

k=KeyValueMap[Table,#]&;j=b@@Join@@#&;l=List;q=Counts
b~SetAttributes~Orderless
a_b+c_b^:=j@{a,c}
c_b-a_b^:=j@k@Merge[q/@(l@@@{a+c,2a}),-Min[0,+##2-#]&@@#&]
a_b*n_Integer/;n>0^:=a+a*(n-1)
a_Rational c_b^:=j@k[⌊a#⌋&/@q@*l@@c]
a_b==d_b^:=l@@a==l@@d
c_b/a_b^:=If[(c-a)+a==c,1+(c-a)/a,0]

সামান্য ডিগল্ফড (ওরফে পুরানো সংস্করণ), সমতা পরীক্ষার জন্য সম্পূর্ণ সমর্থন ছিল না (সত্যবাদী মানগুলি প্রত্যাবর্তন করেছে, তবে মিল না থাকা ব্যাগগুলির জন্য মূল্যহীন রেখে গেছে)।

SetAttributes[b,Orderless]
b/:-a_b:=d@@a
b/:a_b+c_b:=Join[a,c]
d/:a_b+c_d:=b@@Join@@KeyValueMap[Table,Merge[Counts/@(List@@@{a+b@@c,b@@c+b@@c}),Max[0,#-(+##2)]&@@#&]]
b/:Rational[1,a_]c_b:=b@@Join@@KeyValueMap[Table,Floor[#/a]&/@Counts@*List@@c]
b/:(a_b)^-1:=c@@a
c/:a_b d_c:=Min@Merge[Counts/@(List@@@{a,d}),If[+##2==0,\[Infinity],#/+##2]&@@#&]
b/:a_b*n_Integer:=a+a*(n-1)

মাথা সহ প্রয়োজনীয় ডেটা টাইপ কার্যকর করে b।

প্রথম bহতে সংজ্ঞায়িত করা হয় Orderless। bশিরোনাম সহ কার্নেলের কাছে যে কোনও বস্তু তার আর্গুমেন্টগুলি স্বয়ংক্রিয়ভাবে সাজিয়ে তুলবে। সুতরাং b[3,2,1]টাইপ করা হলেও , মূল্যায়নকারী ছাড়া আর কিছুই দেখতে পাবে না b[1,2,3]।

সংযোজনকে তুচ্ছভাবে উপাদানগুলিতে যোগদান হিসাবে সংজ্ঞায়িত করা হয়।

দুটি ব্যাগের পার্থক্যের জন্য একটি বিশেষ নিয়ম সংজ্ঞায়িত করা হয়েছে (নীচে ব্যাখ্যা করা হয়েছে)। ফর্মের এক্সপ্রেশনগুলির জন্য পূর্ববর্তী সংস্করণে একটি সহায়ক প্রতীক ছিল -bag।

তারপরে গুণন (যতক্ষণ nধনাত্মক পূর্ণসংখ্যার হয়) পুনরাবৃত্তভাবে সংজ্ঞায়িত করা হয় n*b[...] = b[...] + (n-1)*b[...]যা অবশেষে একটি সাধারণ যোগফল হ্রাস পাবে।

b[...] - b[...]ব্যাগের যোগফলের স্বতন্ত্র উপাদানগুলির সংখ্যা গণনা করার জন্য বিশেষ বিধি এবং সেই ফলাফল থেকে ব্যাগটিকে দুটিবার বিয়োগ করতে হবে। আরও সহজ ব্যাখ্যা:

b[1,2,3,4,5] - b[2,3,6]
Element counts in sum of bags: <|1->1, 2->2, 3->2, 4->1, 5->1, 6->1|>
Element counts in 2x second bag:     <|2->2, 3->2, 6->2|>
Subtracting the corresponding values:
                               <|1->1, 2->0, 3->0, 4->1, 5->1, 6->-1|>

উপরে একটি তালিকা Keys->Values। KeyValueMapসঙ্গে Tableপ্রতিটি তালিকা তৈরি করে Key Valueবার। ( Max[...,0]নেতিবাচক দৈর্ঘ্যের টেবিলগুলি তৈরি করার চেষ্টা না করার জন্য এখানেও রয়েছে)। এটি প্রকাশিত হয়:

{{1},{},{},{4},{5},{}}

যা চ্যাপ্টা হয় এবং মাথাটি Listপ্রতিস্থাপন করা হয় b।

পূর্ণসংখ্যা দ্বারা বিভাজন ব্যবহৃত ফাংশনগুলিতে কিছুটা অনুরূপ, এটি কেবলমাত্র পূর্ণসংখ্যার দ্বারা মৌলিক সংখ্যাগুলির মেঝে বিভাজন।

আসল প্রয়োগের পরে আমি সেটগুলি বা গণনা দ্বারা বিভাগ পরিবর্তন করেছি। এটি এখন নিম্নলিখিত হিসাবে পুনরাবৃত্তভাবে সম্পন্ন করা হয়। বলুন, আমরা ব্যাগ ভাগ b1দ্বারা b2(যা golfed কোডে হয় cএবং aযথাক্রমে। যদি (b1-b2) + b2 == b1, তারপর 1 যোগ এবং যে বিভাজক ফল যোগ (b1-b2)/b2। যদি তা না হয়, 0 ফিরে যান এবং পুনরাবৃত্তির থেকে প্রস্থান করুন।

ব্যাগ মিললে, বিল্ট-ইন ==দেয় True। শেষ লাইনটি জোর করে Falseযদি তা না করে।

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

Input:
b[1, 2, 2, 3] + b[1, 2, 4]
b[1, 2, 2, 4] - b[1, 2]
b[1, 2, 3] - b[2, 4]
b[1, 2, 3, 3, 4]*3
2*b[1, 3]
b[1, 1, 2, 2, 2]/2
b[1, 2, 2, 3, 3, 3]/3
b[1, 1, 2, 2, 2, 2, 3, 3, 3] /b[1, 2, 3]
b[3, 2, 1, 2] == b[1, 2, 2, 3]
b[1, 2, 3] == b[1, 2, 2, 3]

Output:
b[1, 1, 2, 2, 2, 3, 4]
b[2, 4]
b[1, 3]
b[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4]
b[1, 1, 3, 3]
b[1, 2]
b[3]
2
True
False

Answer 6

প্রশ্ন - 219 টি অক্ষর

a:(,)
s:{[x;y]x((!:)(#:)x)except(,/)({.[(#);x]}')flip(7h$(({(+/)x=y}[y]')(?:)y);(({where x=y}[x]')y))}
m:{(,/)$[0>(@:)x;(#[x]')y;(#[y]')x]}
d:{(?:)x(&:)({y<=(+/)x=z}[x;y]')x}
c:{min({(+/)x=y}[x]')y}
e:{(asc x)~asc y}

aঅতিরিক্ত হিসাবে, sপার্থক্যের জন্য (বিয়োগ), mগুণনের dজন্য, বিভাগের cজন্য, গণনার eজন্য, সমতার জন্য

সংযোজন অ্যালগরিদম সুস্পষ্ট এক, কেবল ব্যাগগুলিতে যোগদান করা।

ইনপুট ব্যাগে বিয়োগফল ফাংশন সূচকগুলি (অ্যারের হিসাবে উপস্থাপিত) পুরো সূচক পরিসীমা সহ, nপ্রতিটি উপাদানের সমতা দ্বারা গঠিত প্রতিটি সমতুল্য শ্রেণীর প্রথম সূচকগুলি বাদে yযেখানে nসেই প্রতিনিধির অনুলিপিগুলির সংখ্যা রয়েছে y। সম্ভাব্য সদৃশগুলিকে এতে পরিচালনা করা yএটি একটি ফাংশনের আসল দানব করে তোলে।

গুণটির ফাংশন xপ্রতিটিের কাছ থেকে মান গ্রহণ করে y, yএকটি অ্যারের পরিবর্তে এটি একক মান হিসাবে, এটি কেবল তাদের প্রতিলিপি করে।

বিভাগ ফাংশনটি এমন মানগুলি তৈরি করে যার অ্যারেতে গণনা তার চেয়ে বেশি yএবং তারপরে নকলগুলি সরিয়ে দেয়।

গণনা কার্যটি প্রতিটি উপাদানের গণনা গণনা করে yএবং তারপরে সর্বনিম্ন প্রদান করে।

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

Answer 7

রুবি, শ্রেণি সংজ্ঞা উত্তর, 323 291 বাইট

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

আমি সম্ভবত একটি আরও গুরুতর গল্ফিং উত্তর করব যা আগামীকাল অপারেশনগুলি মোকাবেলায় কোনও ফাংশন ব্যবহার করবে। আমি খুব ক্লান্ত হয়ে পড়েছি এবং এর সাথে আমি খুব মজা পেয়েছি যদিও Number * Bagসঠিকভাবে কাজ করার জন্য আমি সংখ্যার শ্রেণির সংজ্ঞাটি নিয়ে ঝগড়া করতে হয়েছিলাম তবে এটি তৈরি করার জন্য সহকারী ফাংশনটি প্রযোজনা করলাম না তাই আমি সংখ্যার শ্রেণি সংজ্ঞাটি মেসে নেওয়ার দরকার নেই

এটি অনলাইন চেষ্টা করুন! (হোয়াইটস্পেস রুবিতে কিছু যায় আসে না, তাই কোডটি কিছুটা অবসরপ্রাপ্ত))

class B<Array
def == o
sort==o.sort
end
def + o
B.new super
end
def - o
r=to_a
o.map{|i|r[r.index(i)||size]=p}
B.new r-[p]
end
def * i
B.new super
end
def / i
B.new uniq.map{|o|[o]*(count(o)/i)}.flatten
end
def c o
o.map{|i|count i}.min
end
def inspect
sort
end
def coerce o
[self,o]
end
end

Answer 8

রুবি, 201 বাইট

আমার অন্য উত্তরে প্রতিশ্রুতি হিসাবে, এখানে একটি নতুন ক্লাস তৈরির পরিবর্তে ফাংশন ব্যবহার করে। আমি 200 বাইট চিহ্ন লঙ্ঘনের খুব কাছে ... অনলাইনে চেষ্টা করে দেখুন

এটি তার জাভাস্ক্রিপ্ট উত্তরে @ নীলের মতো একই ওপকোড এবং একই ক্রমের যুক্তি (এলএইচএস, অপকোড, আরএইচএস) ব্যবহার করে

0: Addition
1: Difference
2: Multiplication
3: Division
4: Counting
5: Equality

---

কোড:

->x,o,y{[->{(x+y).sort},->r=[*x]{y.map{|i|r[r.index(i)||x.size]=p};r-[p]},->{(x==[*x]?x*y :y*x).sort},->{x.uniq.map{|i|[i]*(x.count(i)/y)}.flatten},->{y.map{|i|x.count i}.min},->{x.sort==y.sort}][o][]}

Answer 9

সি ++, 555 551 বাইট

(পঠনযোগ্যতার জন্য লাইন ব্রেকগুলি যুক্ত করা হয়েছে - কেবল প্রথম নতুন লাইনটি প্রয়োজনীয় এবং গণনা করা হবে)

#include<map>
struct B:std::map<int,int>{
B(std::initializer_list<int>l){for(auto i:l)++(*this)[i];}};
B operator+(B a,B b){for(auto m:b)a[m.first]+=m.second;return a;}
B operator-(B a,B b){for(auto m:b){int&x=a[m.first];x-=x>m.second?m.second:x;if(!x)a.erase(m.first);};return a;}
B operator*(B b,int n){for(auto m:b)b[m.first]*=n;return b;}
B operator*(int n,B b){return b*n;}
B operator/(B b,int n){for(auto m:b)if(!(b[m.first]/=n))b.erase(m.first);return b;}
int operator/(B a,B b){auto r=~0u;for(auto m:b){int x=a[m.first]/m.second;r=r>x?x:r;}return r;}

ব্যাখ্যা

আমরা আমাদের ব্যাগটিকে মান (মান, গণনা) হিসাবে প্রয়োগ করি। মৌলিক ক্রিয়াকলাপগুলি গণনাগুলি পরিচালনা করে প্রয়োগ করা যেতে পারে; বিয়োগ এবং পূর্ণসংখ্যা বিভাগকে এমন কোনও উপাদানও সরিয়ে ফেলতে হবে যার গণনা শূন্যে পৌঁছেছে, তাইstd::map::operator== এটি সমতা পরীক্ষা হিসাবে কাজ করবে।

নীচের সম্প্রসারিত কোডটি উপরের জেনেরিক সংস্করণ, খুব কম গল্ফড: আমরা s()কোনও শূন্য-গণনা মানকে আলাদা করতে পৃথক ব্যবহার করি এবং আমরা constআইডিয়োমেটিক সি ++ উপায়ে অ্যাসাইনমেন্ট অপারেটরের ক্ষেত্রে ক্রিয়াকলাপগুলি বাস্তবায়ন করি । আমরা সত্যিকারের খালি ব্যাগ (যোগ করে পরীক্ষা করা ) ফেরত দিয়ে s()গুণন করতেও ব্যবহার করি ; মূলটি এই পরীক্ষায় ব্যর্থ হয় এবং এটি প্রয়োজন কিনা তা পরিষ্কার নয়।0(B{1}*0 != B{})main()

template<class T>
struct Bag{
    std::map<T,int>b;
    Bag(const std::initializer_list<T>& l){for(auto i:l)++b[i];}
    Bag&s(){for(auto i=b.begin();i!=b.end();i=i->second?++i:b.erase(i));return*this;}
    Bag&operator+=(const Bag& o){for(auto m:o.b)b[m.first]+=m.second;return*this;}
    Bag&operator-=(const Bag& o){for(auto m:o.b){auto&x=b[m.first];x-=x>m.second?m.second:x;}return s();}
    Bag&operator*=(int n){for(auto m:b)b[m.first]*=n;return s();}
    Bag&operator/=(int n){for(auto m:b)b[m.first]/=n;return s();}
    auto operator/=(const Bag& o){auto r=~0u;for(auto m:o.b){int x=b[m.first]/m.second;r=r>x?x:r;}return r;}
    bool operator==(const Bag& o)const{return b==o.b;}

    Bag operator+(Bag o)const{return o+=*this;}
    Bag operator-(const Bag& o)const{Bag t=*this;return t-=o;}
    Bag operator*(int n)const{Bag t=*this;return t*=n;}
    friend Bag operator*(int n,const Bag& b){return b*n;}
    auto operator/(auto n)const{Bag t=*this;return t/=n;}
    bool operator!=(const Bag& o)const{return b!=o.b;}
};

using B = Bag<int>;

টেস্ট

bool operator!=(B a,B b){return!(a==b);}
int main()
{
    return 0
        + (B{1,2,2,3}+B{1,2,4}  !=  B{1,1,2,2,2,3,4})
        + (B{1,2,2,4}-B{1,2}  !=  B{2,4})
        + (B{1,2,3}-B{2,4}  !=  B{1,3})
        + (B{1,2,3,3,4}*3  !=  B{1,1,1,2,2,2,3,3,3,3,3,3,4,4,4})
        + (2*B{1,3}  !=  B{1,1,3,3})
        + (B{1,1,2,2,2}/2  !=  B{1,2})
        + (B{1,2,2,3,3,3}/3  !=  B{3})
        + (B{1,1,2,2,2,2,3,3,3}/B{1,2,3} != 2)
        + (B{3,2,1,2}  !=  B{1,2,2,3})
        + (B{1,2,3}  ==  B{1,2,2,3})
        ;
}

Comments

চমৎকার উত্তর! +1 টি। আপনার কোড পোস্টে সঠিক বিন্যাস প্রয়োজন।

— ইয়াতসি

আমি ইচ্ছাকৃতভাবে কোডটি মোড়ানোর জন্য চেয়েছিলাম, যাতে আপনি এটি সমস্ত দেখতে পারেন। বিকল্পটি ছিল লাইন ব্রেকগুলি যুক্ত করা।

— টবি স্পিড 10

লাইন ব্রেকগুলি যুক্ত করা হয়েছে - আমি মনে করি এটি আরও ভাল, কারণ এখন প্রশংসাপূর্ণ কাজ করে।

— টবি স্পিড

Answer 10

পাইথন 2.7 - 447 বি (ফাইলাইজ)

কোডগল্ফে এটি আমার প্রথম চেষ্টা, আমি আশা করি এটি সন্তুষ্ট হবে। আমার 2 ঘন্টা প্রয়োজন (তবে আমি এখনও পাইথনের একটি শিক্ষানবিস)

সম্পাদনা করুন: "কেভিন লাউ - কেনি নয়" এগুলি দেখানোর জন্য ধন্যবাদ:

• ক্লাসে অজগরগুলির স্ব-যুক্তি যে কোনও কিছু দ্বারা প্রতিস্থাপন করা যেতে পারে
• ইনডেন্টেশন কেবল একটি একক স্থান হতে হবে
• বিল্টিন সাজানো - ফানকিশন (আমি জানতাম) আমি এটি দেখেছি, তবে আমি এটি তালিকায় একটি পদ্ধতি হিসাবে ভেবেছিলাম)
• __ র‌্যাড __ এর প্রয়োজন নেই (আমি কেবল বি-অবজেক্টগুলি (ব্যাগ-প্রকার) যুক্ত করেই সমর্থন করি)

সম্পাদনা করুন: অতিরিক্তভাবে আমি ল্যাম্বডাস এবং নতুন লাইন এবং আরও সেমিকোলনগুলির সাথে ইন্ডেন্টেশনগুলি প্রতিস্থাপন করে স্থান সংরক্ষণ করেছি।

কোড:

class B:
 def __init__(S,L=[]):S.L=sorted(list(L));S.p=lambda:[[i]*S.L.count(i)for k,i in enumerate(S.L)if i!=S.L[k-1]];S.__eq__=lambda o:S.L==o.L;S.__rmul__=S.__mul__=lambda o:B(S.L*o);S.__add__=lambda o:B(S.L+o.L);S.__sub__=lambda o:B([i for k in S.p()for i in k[:max(0,S.L.count(k[0])-o.L.count(k[0]))]]);S.__div__=lambda o:B([i for k in S.p()for i in k[::o][:[-1,None][len(k)%o==0]]]);S.c=lambda o:min([S.L.count(i)//o.L.count(i)for i in o.L])

চেক:

print B([1,2,2,3]) + B([1,2,4]) == B([1,1,2,2,2,3,4]) # Add

print B([1,2,2,4]) - B([1,2]) == B([2,4]) #Substract
print B([1,2,3])   - B([2,4]) == B([1,3]) #Substract

print B([1,2,3,3,4]) * 3 == B([1,1,1,2,2,2,3,3,3,3,3,3,4,4,4])#Multiply
print 2 * B([1,3]) == B([1,1,3,3])                            #

print B([1,1,2,2,2])   /2 == B([1,2]) #Divide
print B([1,2,2,3,3,3]) /3 == B([3])   #

print B([1,1,2,2,2,2,3,3,3]).c(B([1,2,3]))==2 #Contained n times

print B([3,2,1,2]) == B([1,2,2,3]) # Equal
print B([1,2,3])   == B([1,2,2,3]) # Unequal

আউটপুট:

True
True
True
True
True
True
True
True
True
False

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

Comments

পিপিসিজিতে আপনাকে স্বাগতম! পাইথন সম্পর্কে একটি বিষয় লক্ষণীয় হ'ল শ্রেণীর ফাংশনগুলিতে আপনাকে প্রথম পরামিতিগুলি কল করার দরকার নেই self- এর মতো কিছু ঠিক Sতেমনভাবে করতে হবে। আরেকটি কৌশলটি হ'ল অন্তর্নির্মিত sortedফাংশনটি আপনার নতুন ফাংশন থেকে ঠিক কী করতে চান sতাই আপনি ফাংশন সংজ্ঞাটি বর্জন করতে পারেন (আপনি কেবল একবার এটি ব্যবহার করেছেন এমনটি দেখে)। __radd__আপনার কখনই প্রয়োজন হয় না কারণ আপনি কখনও ব্যাগ সহ নন-ব্যাগ যুক্ত করেন না, যদিও আপনার এখনও প্রয়োজন __rmul__। অবশেষে, আপনার কেবলমাত্র চারটির পরিবর্তে একটি স্থানের ইনডেন্টের প্রয়োজন, যা আপনার বাইট গণনাটিকে কিছুটা কমিয়ে দেয়

— মান কালি