ใช้งานกระเป๋า

20

ถุงเรียกว่ายังเป็น MultiSet เป็นคอลเลกชันเรียงลำดับ คุณสามารถเรียกมันว่าชุดที่อนุญาตให้ทำซ้ำหรือรายการ (หรืออาร์เรย์) ที่ไม่ได้เรียงลำดับ / จัดทำดัชนี ในความท้าทายนี้คุณจะถูกขอให้ดำเนินการเกี่ยวกับกระเป๋า: การเพิ่มการทดสอบการแตกการหารการนับและการทดสอบความเสมอภาค

การดำเนินงาน

การดำเนินการที่ระบุอาจไม่ธรรมดา

  • นอกจากนี้รวมสองถุงเป็นหนึ่งเดียวรักษาจำนวนรวมของแต่ละค่า
    [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
    [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
code-golf  data-structures 
— busukxuan
แหล่งที่มา
2
อาจผ่อนคลายรูปแบบอินพุตหรือไม่ ตัวอย่างเช่นอนุญาตให้ใช้ถุงกระเป๋า / หมายเลขและโอเปอเรเตอร์เป็นอาร์กิวเมนต์แยกต่างหากหรือในรูปแบบฟรี มิฉะนั้นส่วนที่สำคัญของความท้าทายคือการแยกวิเคราะห์อินพุตซึ่งไม่น่าสนใจโดยเฉพาะ
— Luis Mendo
@LuisMendo การแยกพื้นที่ว่างเพียงพอที่จะแยกวิเคราะห์สิ่งนี้ถ้าคุณมีภาษาที่สามารถประเมินสตริงเป็นรายการได้ทั้งหมดคุณไม่คิดเหรอ? ฉันไม่มีประสบการณ์ในการโพสต์ความท้าทายดังนั้นโปรดช่วยสอนฉันด้วย :-)
— busukxuan
ฉันไม่พบเมตาโพสต์ที่เกี่ยวข้อง แต่ดูตัวอย่างถ้อยคำที่นี่ : คุณสามารถอ่านจำนวนเต็มแทนทศนิยมการแสดงเอก (ใช้อักขระที่คุณเลือก) อาร์เรย์ไบต์ (endian เล็กหรือใหญ่) หรือไบต์เดียว (ถ้าเป็นภาษาของคุณชนิดข้อมูลที่ใหญ่ที่สุด) หรือที่นี่ : รูปแบบอินพุตและเอาต์พุตมีความยืดหยุ่นตามปกติ (อาร์เรย์รายการลิสต์ของรายการสตริงที่มีตัวคั่นเหมาะสม ฯลฯ )
— Luis Mendo
@ LuisMendo มันฟรีโดยทั่วไปแล้ว และเกี่ยวกับจำนวนเต็มฉันแค่หมายความว่าในแง่คณิตศาสตร์ไม่ใช่ประเภทข้อมูล
— busukxuan
1
@ LuisMendo ไม่จำเป็นต้องใช้สัญลักษณ์ให้เข้าใจถึงแม้ว่าจะมีเพียงเล็กน้อย คุณสามารถใช้หนึ่ง = สำหรับการทดสอบความเท่าเทียมกัน
— busukxuan

คำตอบ:

3

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}

ตรวจสอบให้แน่ใจว่าหมายเลขนั้นอยู่ด้านบนสุดของสแต็ก เรียก X นี้

GD})˜,}

ทำซ้ำถุง X และเข้าร่วมกับหนึ่งถุง

นับ

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

สำหรับแต่ละองค์ประกอบในถุงหารให้นับจำนวนที่เกิดขึ้นในถุงเงินปันผล
จำนวนขั้นต่ำจะเป็นจำนวนถุงที่เราสามารถทำได้

ความเท่าเทียมกัน

 {s{Q,}

เรียงถุงทั้งสองและตรวจสอบว่าพวกมันเท่ากันหรือไม่

แผนก

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

นับจำนวนชิ้นส่วนที่ไม่ซ้ำกันในกระเป๋า
ถ้ามันเกิดขึ้นอย่างน้อยก็หลายครั้งเท่า ๆ กับตัวหาร เก็บสำเนา (nr_of_copies_total // divisor) ไว้ในถุง

ข้อแตกต่าง

svy†¬yQi¦}}

สำหรับแต่ละองค์ประกอบใน subtrahend เรียงลำดับไปที่ด้านหน้าของ minuend
หาก subtrahend ปัจจุบันถ้าเท่ากับองค์ประกอบแรกใน minuend ให้ลบออกจาก minuend

— Emigna
แหล่งที่มา
9

APL (155)

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

สิ่งนี้กำหนดผู้ดำเนินการ∆'ถุง' ซึ่งกำหนดการทำงานของกระเป๋าสำหรับฟังก์ชั่นที่กำหนด เช่น+∆จะเพิ่ม จากนั้นอ่านบรรทัดจากคีย์บอร์ดและประเมินว่าเป็นนิพจน์ APL

ฟังก์ชั่นคือ:

  • +∆, ส่วนที่เพิ่มเข้าไป
  • -∆การลบ
  • ×∆การคูณ
  • ÷∆, แผนก
  • ⊂∆กำลังนับ
  • ≡∆, ความเท่าเทียมกัน (แม้ว่าจะเกิดจากการเล่นกอล์ฟฟังก์ชั่นใด ๆ ที่ไม่รู้จักจะทำสมดุล)

คำอธิบาย:

  • ∆←{... }: กำหนดโอเปอเรเตอร์∆:

    • O←⍺⍺: เก็บฟังก์ชันที่กำหนดไว้ในO( ⎕CRจะไม่ทำงาน⍺⍺โดยตรง)
    • O←⎕CR'O': รับการแทนค่าสตริงของฟังก์ชันนั้น
    • '+'=O... :: นอกจากนี้
      • ⍺,⍵: เข้าร่วมรายการทั้งสองเข้าด้วยกัน
      • R[⍋R←... ]: และจัดเรียงผลลัพธ์
    • '-'=O:: สำหรับการลบ
      • ⍺{... }⍵: เรียกใช้ฟังก์ชันเรียกซ้ำต่อไปนี้:
        • ⍵≡⍬:⍺: ถ้า subtrahend ว่างเปล่าให้ส่งคืน minuend
        • ⍺/⍨(⍳⍴⍺)≢⍺⍳⊃⍵∇1↓⍵: มิฉะนั้นให้ลบองค์ประกอบแรกของ subtrahend ออกจากทั้ง subtrahend และ minuend แล้วลองอีกครั้ง
    • (⍬=⍴⍵)∧K←'×'=O: สำหรับการคูณและถ้าอาร์กิวเมนต์ที่ถูกต้องไม่ใช่ถุง:
      • ⍵/⍺: ทำซ้ำแต่ละองค์ประกอบในอาร์กิวเมนต์ซ้ายโดยอาร์กิวเมนต์ขวา
    • K:: ... และถ้าอาร์กิวเมนต์ที่ถูกต้องคือกระเป๋า:
      • ⍺/⍵: ทำซ้ำแต่ละองค์ประกอบในการโต้แย้งที่ถูกต้องโดยอาร์กิวเมนต์ซ้าย (นี่คือการคูณที่เป็น commutative)
    • '÷'=O:สำหรับการแบ่ง
      • ⍵≤⍺∘.+⍺: ดูว่าองค์ประกอบใดใน⍺เกิดขึ้นอย่างน้อย⍵ครั้ง
      • ⍺/⍨: เลือกสิ่งเหล่านั้นจาก⍺,
      • ∪: และลบรายการที่ซ้ำทั้งหมดออกจากรายการ
    • '⊂'=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
— marinus
แหล่งที่มา
โซลูชั่นระดับมืออาชีพและการเขียนที่ยอดเยี่ยมจริงๆ! +1
การเขียนและคำอธิบายของคุณนั้นแข็งแกร่งจริงๆ! สิ่งหนึ่งที่แม้ว่า: สำหรับการแบ่งผมเชื่อว่าสเปคเป็นคำพูดในทางที่[2,2,2,2,2,2]/3ควรจะให้แต่คุณดูเหมือนว่าจะให้[2,2] [2]
— หมึกมูลค่า
คุณไม่จำเป็นต้องใช้รหัส REPL หากคุณเพิ่งกำหนด∆ผู้ใช้จะถูกทิ้งลงใน REPL ดั้งเดิมของ APL ซึ่ง∆ตอนนี้ใช้ได้ ฉันคิดว่าคุณสามารถบันทึกไบต์ได้ด้วยการย้ายการลบไปยังจุดสิ้นสุดเนื่องจากเป็นเพียงการเดียวที่ต้องใช้สองบรรทัด แทนการ⎕CRใช้*เพื่อเป็นสัญลักษณ์นับและทำO←⍺⍺2แล้ว2=O:สำหรับบวก1=Oสำหรับ mult 0=O:สำหรับ equiv 7<O:สำหรับการนับและ0<O:div (โดยนัย0>O:สำหรับ subtr)
— อดัม
6

JavaScript (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));
    }
}
— นีล
แหล่งที่มา
6

อ็อกเทฟ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

ฟังก์ชั่นนี้จะต้องอยู่ในไฟล์ การเขียนฟังก์ชั่นในหน้าต่างคำสั่งที่คุณต้องใช้หรือendfunctionend

ขอบคุณLuis Mendoสำหรับการบันทึก 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
— มาร์โก
แหล่งที่มา
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]

degolfed เล็กน้อย (หรือที่รู้จักกันในเวอร์ชั่นเก่า) ไม่ได้รับการสนับสนุนอย่างเต็มที่สำหรับการทดสอบความเท่าเทียม (คืนค่าความจริงกลับคืน แต่ไม่ได้รับการประเมินค่าสำหรับถุงที่ไม่เข้าคู่)

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},{}}

ซึ่งเป็นบี้และศีรษะถูกแทนที่ด้วยListb

การหารด้วยจำนวนเต็มค่อนข้างคล้ายกันในฟังก์ชั่นที่ใช้มันเป็นเพียงการแบ่งพื้นขององค์ประกอบที่นับโดยจำนวนเต็ม

หารด้วยชุดหรือนับฉันเปลี่ยนไปตั้งแต่การใช้งานดั้งเดิม ตอนนี้จะทำซ้ำดังนี้ บอกว่าเราแบ่งถุง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
— LLlAMnYP
แหล่งที่มา
2

Q - 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แล้วส่งกลับค่าต่ำสุด

กระเป๋าสองใบมีค่าเท่ากันหากการเรียงลำดับอาร์เรย์เรียงกันเท่ากัน

— C. Quilley
แหล่งที่มา
2

Ruby คำตอบคำจำกัดความของคลาส323 291 ไบต์

ส่วนใหญ่ต้องการเพียงแค่ทำให้Bagชั้นเรียนจริงเนื่องจากรูบี้มีความยืดหยุ่นในชั้นเรียน ในกรณีนี้มันสืบทอดมาArrayเพราะมันสั้นกว่าไม่ต้องเริ่มต้นอาร์เรย์ภายในและจัดการกับสิ่งอื่น ๆ

ฉันอาจจะทำคำตอบกอล์ฟที่จริงจังกว่านี้ซึ่งใช้ฟังก์ชั่นเพื่อจัดการกับการปฏิบัติการในวันพรุ่งนี้ ฉันเหนื่อยมากและฉันก็สนุกกับมันมากแม้ว่าฉันจะต้องโต้เถียงกับคำจำกัดความของคลาสตัวเลขเพื่อให้Number * Bagทำงานได้อย่างถูกต้องสรรเสริญฟังก์ชั่นการบังคับใช้สำหรับการทำมันดังนั้นฉันไม่จำเป็นที่จะ

ลองออนไลน์! (ช่องว่างไม่สำคัญใน Ruby ดังนั้นโค้ดจึงไม่ได้รับการแก้ไขเล็กน้อย)

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
— หมึกมูลค่า
แหล่งที่มา
1

ทับทิม, 201 ไบต์

ตามที่สัญญาไว้ในคำตอบอื่น ๆ ของฉันนี่คือสิ่งที่ใช้ฟังก์ชั่นแทนการสร้างคลาสใหม่ ฉันใกล้จะละเมิดเครื่องหมาย 200 ไบต์แล้ว ... ลองออนไลน์

สิ่งนี้ใช้ opcodes เดียวกันกับ @Neil ในคำตอบ JavaScript ของเขาและคำสั่งเดียวกันของอาร์กิวเมนต์ (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][]}
— หมึกมูลค่า
แหล่งที่มา
1

C ++, 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==จะทำงานเป็นแบบทดสอบความเท่าเทียมกัน

โค้ดที่ขยายเพิ่มดังต่อไปนี้เป็นเวอร์ชันทั่วไปของด้านบนซึ่งน้อยมาก golfed: เราใช้การแยกs()เพื่อบีบค่า zero-count ใด ๆ และเราใช้constการดำเนินการในแง่ของผู้ประกอบการที่ได้รับมอบหมายในวิธีการ C ++ เรายังใช้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})
        ;
}
— Toby Speight
แหล่งที่มา
คำตอบที่ดี! +1 รหัสของคุณต้องการการจัดรูปแบบที่เหมาะสมในโพสต์
— Yytsi
ฉันต้องการให้โค้ดห่อดังนั้นคุณจึงเห็นได้ทั้งหมด ทางเลือกคือการเพิ่มตัวแบ่งบรรทัด
— Toby Speight
1
เพิ่มตัวแบ่งบรรทัด - ฉันคิดว่ามันดีกว่าเพราะตอนนี้ prettify ใช้ได้ผล
— Toby Speight
1

Python 2.7 - 447B (ขนาดไฟล์)

นี่เป็นครั้งแรกที่ฉันลอง Codegolf ฉันหวังว่ามันจะเป็นที่พอใจ ฉันต้องการ 2 ชั่วโมง (แต่ฉันยังเป็นผู้เริ่มต้นที่ Python)

แก้ไข: ขอบคุณ "Kevin Lau - ไม่ใช่ Kenny" สำหรับการชี้สิ่งเหล่านี้:

  • การถกเถียงด้วยตนเองของงูเหลือมในชั้นเรียนสามารถถูกแทนที่ด้วยสิ่งใดก็ได้
  • การเยื้องจะต้องมีพื้นที่เดียว
  • builtin เรียงลำดับ - funktion (ฉันรู้ว่าฉันเคยเห็นมัน แต่ฉันคิดว่ามันจะเป็นวิธีการในรายการ)
  • ไม่จำเป็นต้อง __ radd __ (ฉันรองรับเฉพาะการเพิ่มวัตถุ B (ประเภทถุง) เท่านั้น)

แก้ไข: นอกจากนี้ฉันประหยัดพื้นที่ด้วยการแทนที่ฟังก์ชั่นด้วย lambdas และบรรทัดใหม่และการเยื้องด้วยอัฒภาคมากขึ้น

รหัส:

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

ฉันอาจลองอีกครั้งโดยตั้งเป็นพื้นฐานบางครั้ง แก้ไข: บางทีฉันอาจจะลองใช้ฟังก์ชั่นเท่านั้น

— Teck ประหลาด
แหล่งที่มา
ยินดีต้อนรับสู่ PPCG! สิ่งที่ควรทราบเกี่ยวกับ Python ก็คือคุณไม่จำเป็นต้องเรียกพารามิเตอร์ตัวแรกในฟังก์ชั่นการเรียนself- สิ่งที่ต้องการSจะทำได้เช่นกัน เคล็ดลับอีกอย่างคือsortedฟังก์ชั่นในตัวทำหน้าที่ตรงตามที่คุณต้องการจากฟังก์ชั่นใหม่ของคุณsดังนั้นคุณจึงสามารถละทิ้งคำจำกัดความของฟังก์ชั่นได้ คุณไม่จำเป็นต้อง__radd__เพราะคุณไม่เคยเพิ่มถุงไม่ใช่กับถุง __rmul__แต่คุณยังคงต้อง ในที่สุดคุณต้องการเพียงหนึ่งช่องว่างของการเยื้องแทนสี่ซึ่งจดจ้องนับไบต์ของคุณค่อนข้างน้อย
— Value Ink
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.