バッグもマルチセットと呼ばれるには、順不同コレクションです。重複を許可するセット、または順序付け/インデックス付けされていないリスト（または配列）を呼び出すことができます。この課題では、加算、差、乗算、除算、カウント、および等価テストのバッグ操作を実装するよう求められます。

操作

指定された操作は従来のものではない場合があります。

• さらに、2つのバッグを1つに結合して、各値の合計数を節約します
  [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
• 同等性テストでは、2つのバッグに各要素の番号が同じかどうかを確認します
  [1,2,2,3] == [3,2,1,2] = truthy [1,2,3] == [1,2,2,3] = falsy（=これにも使用できます）

演算子に独自のシンボルを使用している場合は、指定してください。

書式

バッグはフォームのリストとして表示されます[1,1,2,3,4]。角かっこ以外のブラケットを使用することも、引用符を使用することも、まったく使用しないこともできます。intこの質問の目的のために、要素は整数（必ずしも数学ではなく）になります。バッグを分類する必要はありません。

入力フォーマットは、オペレータと、2個のバッグ又はバッグの整数です。これらの3つが含まれている限り、独自の形式を指定できます。

出力フォーマットは同じ形式の単一のバッグであるべきです。

ルール

• これらを既に実装している組み込み関数、操作、またはライブラリ（標準ライブラリを含む）は使用できません。リストの連結と乗算はバッグ操作ではなく定義リスト操作であるため、リスト連結と乗算を使用しても大丈夫です（基本的に同じことを行います）
• 標準的な抜け穴が適用されます
• 最短回答が勝ちます

テストケース

[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

説明

添加

‚˜,}

1つの袋を別の袋に入れて、平らにして1つの袋にします。

乗算

и˜Qis}

番号がスタックの一番上にあることを確認してください。これをXと呼びます。

GD})˜,}

バッグをX回複製し、1つのバッグに参加します。

カウント

³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... :：さらに、
    • ⍺,⍵：2つのリストを結合する
    • R[⍋R←... ]：結果をソートします
  • '-'=O:：減算の場合、
    • ⍺{... }⍵：次の再帰関数を実行します。
      • ⍵≡⍬:⍺：減数が空の場合、被減数を返します
      • ⍺/⍨(⍳⍴⍺)≢⍺⍳⊃⍵∇1↓⍵：それ以外の場合、減数と減数の両方から減数の最初の要素を削除し、再試行してください
  • (⍬=⍴⍵)∧K←'×'=O: 乗算の場合、および正しい引数がバッグでない場合：
    • ⍵/⍺：左引数の各要素を右引数で複製します
  • K:：...そして正しい引数がバッグの場合：
    • ⍺/⍵：右引数の各要素を左引数で複製します（これにより、乗算が可換になります）
  • '÷'=O:：除算の場合、
    • ⍵≤⍺∘.+⍺：⍺のどの要素が少なくとも⍵回出現するかを確認し、
    • ⍺/⍨：fromから選択し、
    • ∪：そして、そのリストからすべての重複を削除します
  • '⊂'=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つのパラメーターを取ります。最初のパラメーターは配列、2番目は演算子、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。

18バイトを節約してくれたLuis Mendoに感謝します。

操作は次のとおりです。

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]。

加算は、要素の結合として簡単に定義されます。

2つのバッグの違いに関する特別なルールが定義されています（以下で説明します）。以前のバージョンには、formの式の補助記号がありました-bag。

次に、乗算（n正の整数である限り）が再帰的に定義されn*b[...] = b[...] + (n-1)*b[...]、最終的に単純な合計になります。

特別なルールb[...] - b[...]は、バッグの合計内の個別の要素の数をカウントし、その結果から2回減算されるバッグを減算し​​ます。より簡単に説明：

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。KeyValueMapwith Tableは各回のリストを作成しますKey Value。（Max[...,0]負の長さのテーブルの作成を試みないためにもあります）。これは次のようになります。

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

これは平坦化され、頭部Listはに置き換えられbます。

整数による除算は、使用される関数で多少似ています。これは、整数による要素カウントの単純なフロア除算です。

セットによる除算またはカウント最初の実装以降に変更しました。現在、次のように再帰的に実行されます。バッグb1をb2（ゴルフのコードではcandでaそれぞれ除算します。ifの場合(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、最小値を返します。

ソートされた配列表現が等しい場合、2つのバッグは等しくなります。

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

ルビー、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;}

説明

バッグを（value、count）のマップとして実装します。基本的な操作は、カウントを操作することで実装できます。減算と整数除算では、カウントがゼロになった要素をすべて削除する必要があるため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自己引数は何でも置き換えることができます
• インデントは単一のスペースである必要があります
• ビルトインソート-ファンクション（私はそれを見たことは知っていましたが、リストのメソッドだと思っていました）
• __ radd __は必要ありません（とにかくB-objects（Bag-type）の追加のみをサポートしています）

編集：さらに、関数をラムダに置き換えてスペースを節約し、改行とインデントをさらにセミコロンに置き換えました。

コード：

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

いつか基本としてセットでもう一度試してみるかもしれません。編集：たぶん私は機能だけで試してみるでしょう。