一个包，也称为多集，是一个无序的集合。您可以将其称为允许重复的集合，或者称为未排序/未索引的列表（或数组）。在这个挑战中，您需要执行袋操作：加法，差，乘法，除法，计数和相等性测试。

运作方式

指定的操作可能不是常规的。

• 另外，将两个袋子合并为一个，保留每个值的总数
  [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组的元素保留在袋子中。退回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

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 //除数）放在袋子中。

区别

svy†¬yQi¦}} 

对于替换对象中的每个元素，将其排序到被减数的前面。
如果当前减数等于减数中的第一个元素，则将其从减数中删除。

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为空，则返回被减数
      • ⍺/⍨(⍳⍴⍺)≢⍺⍳⊃⍵∇1↓⍵：否则，从次要交易量和被减数中都删除次要交易量的第一个元素，然后重试
  • (⍬=⍴⍵)∧K←'×'=O: 进行乘法运算，如果正确的参数不是一个包：
    • ⍵/⍺：通过右边的参数复制左边的参数中的每个元素
  • K:：...如果正确的参数是一个包：
    • ⍺/⍵：用左参数复制右参数中的每个元素（这样乘法是可交换的）
  • '÷'=O:：用于划分，
    • ⍵≤⍺∘.+⍺：查看which中的哪些元素发生至少⍵次，
    • ⍺/⍨：从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

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

取消高尔夫：

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));
    }
}

八度，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。

谢谢 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

取消高尔夫：

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

Mathematica， 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)

用head实现所需的数据类型b。

首先b定义为Orderless。任何带有head传递给内核的对象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。

整数除法在使用的函数中有些相似，它只是元素计数的整数除以底数。

自最初的实现以来，按组或计数进行除法我已经改变了。现在，递归执行如下。说，我们将bag b1除以b2（在高尔夫球场代码中分别为c和a。如果(b1-b2) + b2 == b1，则加1并加上除法的结果(b1-b2)/b2。否则，返回0并退出递归。

如果包装袋匹配，内置==给出True。False如果没有，最后一行强制a 。

测试用例：

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

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，然后返回最小值。

如果两个袋子的排序数组表示形式相等，则它们相等。

Ruby中，类定义的答案，323个 291字节

Bag由于Ruby具有类的灵活性，所以大多数情况下只是想使它成为实际的类。在这种情况下，它继承自，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

Ruby，201个字节

正如我在其他答案中所承诺的那样，这是一个使用函数而不是构建新类的函数。我快要突破200字节标记了...在线尝试

这在他的JavaScript答案中使用了与@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][]}

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==将其用作相等性测试。

下面的扩展代码是上述代码的通用版本，少了很多：我们使用单独的代码s()来挤出任何零计数值，并且我们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})
        ;
}

Python 2.7-447B（文件大小）

这是我在Codegolf的第一次尝试，希望它能令人满意。我需要2小时。（但我仍然是Python的初学者）

编辑：感谢“凯文·刘-不是肯尼”指出了这些：

• 类中的pythons自变量可以替换为任何东西
• 缩进只能是一个空格
• 内置的排序功能（我知道我已经看过，但是我认为它是列表中的一种方法）
• __不需要__（反正我只支持添加B对象（包类型））

编辑：另外，我通过用lambda替换函数以及用更多分号替换新行和缩进来节省空间。

码：

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

我可能会在一段时间内尝试将其作为基础。编辑：也许我什至只尝试使用函数。