实施制袋作业


20

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

运作方式

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

  • 另外,将两个袋子合并为一个,保留每个值的总数
    [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

2
也许放宽输入格式?例如,允许将bag,bag / number和运算符作为单独的参数,或采用自由格式。否则,挑战的一个重要部分就是解析输入,这并不是特别有趣
Luis Mendo

@LuisMendo按空间分割足以解析此内容,如果您有一种可以将字符串作为列表求值的语言,您不觉得吗?我没有发布挑战的经验,所以请给我启发:-)
busukxuan '16

我找不到相关的元文章,但例如看到这里的措辞:您可以读取整数作为其十进制表示形式,一元表示形式(使用您选择的字符),字节数组(大或小字节序)或单字节(如果这是您的语言最大的数据类型)。或者在这里输入和输出格式像往常一样灵活(数组,列表,列表列表,带有合理分隔符的字符串等)。
Luis Mendo'7

@LuisMendo现在基本上是免费的。关于整数,我只是说从数学意义上讲,而不是数据类型。
busukxuan '16

1
@LuisMendo不行,即使只有一点,这些符号也必须有意义。好了,您可以使用一个=进行相等性测试。
busukxuan '16

Answers:


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

区别

svy†¬yQi¦}} 

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


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为空,则返回被减数
        • ⍺/⍨(⍳⍴⍺)≢⍺⍳⊃⍵∇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

真正专业的解决方案和出色的写作!+1

您的文章和解释确实扎实!不过,有一件事:对于部门划分,我相信规范的措辞[2,2,2,2,2,2]/3应该以应有的方式提供[2,2],但您的应有之有无[2]
价值墨水

您不需要编写REPL。如果仅定义,则用户将被转储到APL的本机REPL中,该本地现在有效。我认为您可以通过将减号移到末尾来节省一些字节,因为这是唯一需要两行的字节。而不是⎕CR,用于*表示count和do O←⍺⍺2,然后2=O:表示plus,1=Omult,equv 0=O:7<O:count和0<O:div(隐含0>O:subtr)。
2013年

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

取消高尔夫:

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

取消高尔夫:

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

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->ValuesKeyValueMapTable创建每次的列表Key Value。(这里还有一个Max[...,0]不尝试创建负长度表的地方)。结果如下:

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

将其展平并List用替换头部b

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

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

如果包装袋匹配,内置==给出TrueFalse如果没有,最后一行强制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

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

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


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

1

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][]}

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

下面的扩展代码是上述代码的通用版本,少了很多:我们使用单独的代码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})
        ;
}

好答案!+1。您的代码需要在帖子中使用正确的格式。
Yytsi'7

我故意要包装代码,因此您可以看到全部内容。替代方法是添加换行符。
Toby Speight

1
添加了换行符-我认为这样更好,因为美化现在可以使用。
Toby Speight

1

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

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


欢迎来到PPCG!关于Python需要注意的一件事是,您实际上不需要调用类函数中的第一个参数self-类似的事情也S可以做到。另一个技巧是,内置sorted函数完全可以在新函数中实现您想要的功能s,因此您可以放弃函数定义(因为您只使用过一次)。您永远不需要,__radd__因为即使您仍然需要,也不会在袋子中添加非袋子__rmul__。最后,您只需要一个缩进空间而不是四个缩进空间,这将使您的字节计数大大减少
Value Ink
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.