बैग संचालन को लागू करें

Question

एक बैग , जिसे मल्टीसेट भी कहा जाता है, एक अनियोजित संग्रह है। आप इसे एक ऐसा सेट कह सकते हैं जो डुप्लिकेट, या एक सूची (या एक सरणी) की अनुमति देता है जो कि आदेशित / अनुक्रमित नहीं है। इस चुनौती में, आपको बैग संचालन को लागू करने के लिए कहा जाता है: इसके अलावा, अंतर, गुणा, भाग, गिनती और समानता परीक्षण।

संचालन

निर्दिष्ट संचालन पारंपरिक नहीं हो सकता है।

• इसके अलावा प्रत्येक मूल्य की कुल संख्या को संरक्षित करते हुए, दो बैग को एक में जोड़ा जाता है
  [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 समान तत्व n बराबर नए बैग में रखे जाते हैं, ऐसे तत्व जो n-group नहीं बना सकते हैं वे बैग में बने रहते हैं। किसी भी नए बैग को वापस करें।
  [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

शायद इनपुट प्रारूप को आराम दें? उदाहरण के लिए बैग, बैग / नंबर, और ऑपरेटर को अलग-अलग तर्क के रूप में, या एक मुफ्त प्रारूप में लेने की अनुमति दें। अन्यथा चुनौती का एक महत्वपूर्ण हिस्सा इनपुट को पार्स कर रहा है, जो विशेष रूप से दिलचस्प नहीं है

— लुइस मेंडो

@LuisMendo विभाजित-ऑन-स्पेस इसे पार्स करने के लिए पर्याप्त है, अगर आपके पास एक ऐसी भाषा है जो स्ट्रिंग्स का मूल्यांकन सूची के रूप में कर सकती है, तो आपको नहीं लगता? मैं चुनौतियों को पोस्ट करने में अनुभवहीन हूं, इसलिए कृपया मुझे

— बताएं

मुझे एक प्रासंगिक मेटा पोस्ट नहीं मिला, लेकिन उदाहरण के लिए यहां देखें : आप पूर्णांक को उसके दशमलव प्रतिनिधित्व, एकात्मक प्रतिनिधित्व (अपनी पसंद के चरित्र का उपयोग करते हुए), बाइट सरणी (बड़ा या थोड़ा अंतियान) या एकल बाइट के रूप में पढ़ सकते हैं (यदि यह आपकी भाषाओं का सबसे बड़ा डेटा प्रकार है) । या यहाँ : इनपुट और आउटपुट प्रारूप सामान्य रूप से लचीले होते हैं (सरणियाँ, सूचियाँ, सूचियों की सूची, उचित विभाजक के साथ तार, आदि )।

— लुइस मेंडू

@LuisMendo यह मूल रूप से अब मुफ्त है। और पूर्णांक के बारे में, मेरा मतलब सिर्फ यह था कि गणितीय अर्थों में, डेटा प्रकार नहीं।

— बसुक्ज़ुआन

@ लिसनमोन्डो नप, प्रतीकों को समझ बनाने की जरूरत है, भले ही थोड़ा ही हो। ठीक है, आप समानता परीक्षण के लिए एक = का उपयोग कर सकते हैं।

— बसुकक्सुआन

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 // divisor) प्रतियां रखें।

अंतर

svy†¬yQi¦}} 

सबट्रेंड में प्रत्येक तत्व के लिए, इसे minuend के सामने की ओर छाँटें।
यदि वर्तमान सबट्रेंड यदि minuend में पहले तत्व के बराबर है, तो इसे minuend से हटा दें।

Answer 2

एपीएल (155)

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

यह एक ऑपरेटर को परिभाषित करता है ∆ 'बैग' को परिभाषित करता है, जो दिए गए कार्यों के लिए बैग संचालन को परिभाषित करता है। Ie +∆अतिरिक्त होगा। यह तब कीबोर्ड से एक पंक्ति पढ़ता है और एपीएल अभिव्यक्ति के रूप में इसका मूल्यांकन करता है।

कार्य हैं:

• +∆, इसके अलावा
• -∆, घटाव
• ×∆, गुणन
• ÷∆, विभाजन
• ⊂∆, गिनती
• ≡∆, समतुल्यता (हालांकि किसी भी मान्यता प्राप्त समारोह को पूरा करने के कारण समतुल्यता होगी)

स्पष्टीकरण:

• ∆←{... }: एक ऑपरेटर को परिभाषित करें ∆:

  • O←⍺⍺: दिए गए फ़ंक्शन को स्टोर करें O( ⎕CRसाथ काम नहीं करेगा⍺⍺ सीधे )
  • O←⎕CR'O': उस फ़ंक्शन का स्ट्रिंग प्रतिनिधित्व प्राप्त करें
  • '+'=O...: : इसके अलावा,
    • ⍺,⍵: एक साथ दो सूचियों में शामिल हों
    • R[⍋R←... ]: और परिणाम को क्रमबद्ध करें
  • '-'=O:: घटाव के लिए,
    • ⍺{...}⍵ : निम्न पुनरावर्ती फ़ंक्शन चलाएँ:
      • ⍵≡⍬:⍺: यदि सबट्रेंड खाली है, तो मिनुएन्ड को वापस कर दें
      • ⍺/⍨(⍳⍴⍺)≢⍺⍳⊃⍵∇1↓⍵: अन्यथा, सबट्रेंड और minuend से सबट्रेंड के पहले तत्व को हटा दें और फिर से प्रयास करें
  • (⍬=⍴⍵)∧K←'×'=O: गुणन के लिए, और यदि सही तर्क बैग नहीं है:
    • ⍵/⍺: बाएँ तर्क में प्रत्येक तत्व को सही तर्क द्वारा दोहराएं
  • K:: ... और अगर सही तर्क है एक बैग:
    • ⍺/⍵: प्रत्येक तत्व को बाएं तर्क द्वारा सही तर्क में दोहराएं (यह इतना है कि गुणा कम्यूटेटिव है)
  • '÷'=O:: विभाजन के लिए,
    • ⍵≤⍺∘.+⍺: देखें कि: में कौन से तत्व कम से कम ⍺ बार होते हैं,
    • ⍺/⍨: select से उन का चयन करें,
    • ∪: और उस सूची से सभी डुप्लिकेट हटा दें
  • '⊂'=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]।

— वैल्यू इंक।

आपको REPL कोड करने की आवश्यकता नहीं है। यदि आप केवल परिभाषित करते हैं ∆, तो उपयोगकर्ता को एपीएल के मूल आरईपीएल में डंप किया जाएगा, जहां ∆अब वैध है। मुझे लगता है कि आप घटाव को अंत तक ले जाकर कुछ बाइट्स बचा सकते हैं क्योंकि यह केवल एक है जिसे दो लाइनों की आवश्यकता होती है। इसके बजाय ⎕CR, *गिनती का प्रतीक करने के लिए उपयोग करें, और करें O←⍺⍺2, फिर 2=O:प्लस के लिए, 1=Oबहु के 0=O:लिए, इक्विव के लिए 7<O:, गिनती के लिए, और 0<O:डिव के लिए ( 0>O:उपप्रकार के लिए निहित )।

— अड्म

Answer 3

जावास्क्रिप्ट (ईएस 6), 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(जो कि गोल्फ कोड में हैं 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 बाइट के निशान को तोड़ने के बहुत करीब हूं ... इसे ऑनलाइन आज़माएं

यह अपने जावास्क्रिप्ट उत्तर में @Neil के समान ओपकोड का उपयोग करता है, और तर्कों के समान क्रम (lhs, opcode, rhs)

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। आपके कोड को पोस्ट में उचित स्वरूपण की आवश्यकता है।

— यति

मैं जानबूझकर कोड लपेटना चाहता था, इसलिए आप यह सब देख सकते हैं। इसका विकल्प लाइन ब्रेक को जोड़ना था।

— टोबे स्पाइट

लाइन ब्रेक जोड़ा गया - मुझे लगता है कि यह बेहतर है, क्योंकि अब काम करता है।

— टोबे स्पाइट

Answer 10

पायथन 2.7 - 447B (फाइल करें)

यह कोडगॉल्फ पर मेरा पहला प्रयास है, मुझे आशा है कि यह संतुष्ट करता है। मुझे 2h चाहिए था। (लेकिन मैं अभी भी पायथन में एक शुरुआत हूं)

इन्हें इंगित करने के लिए "केविन लाउ - नहीं केनी" का धन्यवाद:

• एक कक्षा में अजगर स्व तर्क कुछ भी द्वारा प्रतिस्थापित किया जा सकता है
• इंडेंटेशन में केवल सिंगल स्पेस होना चाहिए
• बिल्ट सॉर्ट - funktion (मुझे पता था मैंने इसे देखा था, लेकिन मुझे लगा कि यह सूचियों में एक विधि है)
• __ राड __ की जरूरत नहीं है (मैं केवल बी-ऑब्जेक्ट्स (बैग-प्रकार) को जोड़ने का समर्थन करता हूं)

संपादित करें: इसके अलावा मैंने लंबोदा और नई लाइनों के साथ कार्यों की जगह और अधिक अर्धविराम के साथ इंडेंटेशन को बचाया।

कोड:

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

PPCG में आपका स्वागत है! पायथन के बारे में ध्यान देने वाली बात यह है कि आपको वास्तव में कक्षा के कार्यों में पहले मापदंडों को कॉल करने की आवश्यकता नहीं है self- कुछ ऐसा ही Sहोगा। एक और ट्रिक यह है कि बिल्ट-इन sortedफंक्शन वही करता है जो आप अपने नए फंक्शन से बाहर करना चाहते हैं s, इसलिए आप फंक्शन डेफिनिशन को देख सकते हैं (जैसा कि आप केवल एक बार इस्तेमाल करते हैं)। आपको कभी भी ज़रूरत नहीं है __radd__क्योंकि आप बैग के साथ गैर-बैग कभी नहीं जोड़ते हैं, हालांकि आपको अभी भी ज़रूरत है __rmul__। अंत में, आपको केवल चार के बजाय इंडेंट के एक स्थान की आवश्यकता होती है, जो कि आपकी बाइट की गिनती को बहुत कम करता है

— वैल्यू इंक