给定一个非空的字符串集和一个字符串列表，请找出该字符串集在列表中出现的次数，即可以使用列表中的项创建该字符串集的次数。列表中的每个元素只能使用一次。

提示：集合是唯一项的无序列表。

默认输入/输出规则适用。

不允许外部库。编译器/解释器标准库是可以的。这是代码高尔夫，因此最短的解决方案很重要。

测试用例：

["apple", "banana"], ["apple", "pear", "apple", "banana", "banana"] => 2

["apple", "banana"], ["apple", "pear", "apple", "banana", "apple"] => 1

["apple", "banana", "pear"], ["apple", "banana", "kiwi", "apple"] => 0

["coconut"], [] => 0

编辑：删除了一个句子，指出输入参数是在本地范围内定义的。这与上面链接的默认IO规则相矛盾。

Python，30个字节

lambda s,l:min(map(l.count,s))

在线尝试！

果冻，4 字节

⁼þSṂ

在线尝试！

怎么样？

⁼þSṂ - Main link: list theSet, list theList
 þ   - outer product using the dyadic operation:
⁼    -     is equal? (non-vectorising)
  S  - sum (vectorises) (yields the number of times each element of theSet appears in theList)
   Ṃ - minimum (can only make the minimum as a multiple)

果冻，6 5 4字节

ċ@€Ṃ

在线尝试！

程序的第一个参数是集合，第二个参数是列表。

说明

ċ@€Ṃ
ċ@   -- Create a link which finds the number of occurrences of 
          its left argument in its right argument (the list)
  €  -- Map this link over each element in the first argument
          of the program (the set)
   Ṃ -- Minimum value of this.

-1个字节感谢@ETHproductions

-1字节再次感谢@ETHproductions

JavaScript（ES6），56个字节

f=(n,h)=>Math.min(...n.map(c=>h.filter($=>$==c).length))

在线尝试

JavaScript（ES6），64字节

(s,l)=>l.map(e=>m[s.indexOf(e)]++,m=s.map(e=>0))&&Math.min(...m)

假定s和l均为对象数组。使用JavaScript严格相等进行比较，因此例如[] === []为false。

Haskell，37 34字节

感谢@Laikoni削减了三个字节。

s#l=minimum[sum[1|y<-l,y==x]|x<-s]

调用带有派生类型的(set::[a]) # (list::[a])where 。aEq

CJam，11个字节

q~f{\e=}:e<

在线尝试！

说明

q~           e# Read and eval the input
  f{\e=}     e# Map each item in the set to the number of times it appears in the list
        :e<  e# Find the minimum of the resulting list

Mathematica，24个字节

Min[#/.Rule@@@Tally@#2]&

以建议的顺序将两个列表作为参数并返回一个非负整数的纯函数。Tally计算输入列表中每个符号出现的次数，#/.Rule@@@并将输入集中的每个元素转换为相应的出现次数。

T-SQL，62 59字节

先前版本不适用于没有匹配项的集合

select top 1(select count(*)from l where l=s)from s order by 1

使用s和l作为表，并使用与表相同的列

select top 1         -- return only the first result
    (select count(*) -- count of rows
     from l          -- from table l
     where l=s)      -- for each l equal
from s               -- to each from s
order by 1           -- sort by count ascending

迅捷，39个字节

s.map{w in l.filter{$0==w}.count}.min()

说明：

s.map{} 遍历s中的每个单词，并将产生一个计数数组

w in 命名要在下一个过滤器中使用的映射词

l.filter{} 将过滤器应用于l数组

$0==w 是过滤条件匹配词w

.count 给出满足条件的l的元素数

.min() 返回映射结果中的最低计数

APL（Dyalog），9字节

⌊/+/⎕∘.≡⎕

在线尝试！

⎕ 获取评估输入（字符串列表）

⎕∘.≡ 获取评估的输入（非空字符串集）并创建等效表

+/ 加上

⌊/ 最小跨度

Perl 6的， 37  18个字节

37

{+(($_=@^a⊍@^b)≽@a)&&.values.min}

尝试一下

展开：

{
  +( # turn into a 0 if False

    (
      $_ =        # store into $_ the result of
        @^a ⊍ @^b # use the baggy multiplication operator
    ) ≽ @a        # is that the baggy superset of the set
  )

  &&          # if that is True

  .values.min # get the minimum value from the Bag in $_
}

有关更多信息，请参见套装，袋子和混合物。

18岁

{@^b.Bag{@^a}.min}

尝试一下

说明：

@^b.Bag从values 键创建一个Bag
{@^a}到那个Bag中（返回计数列表），
.min获取结果列表的最小值

公理，42字节

f(a,b)==reduce(min,[count(x,b)for x in a])

测试代码和结果

(28) -> f(["1","2"], ["1", "2", "1", "1", "7"])
   (28)  1
                                                    Type: PositiveInteger
(29) -> f(["apple","banana"],["apple","pear","apple","banana","banana"])
   (29)  2
                                                    Type: PositiveInteger
(30) -> f(["apple","banana"],["apple","pear","apple","banana","apple"])
   (30)  1
                                                    Type: PositiveInteger
(31) -> f(["apple","banana","pear"],["apple","banana","kiwi","apple"])
   (31)  0

C ++，203201字节

感谢@Quentin节省了两个字节！

#import<vector>
#import<string>
using T=std::vector<std::string>;
int f(T S,T L){for(int j,b,i=0;;++i)for(auto s:S){for(b=j=0;j<L.size();++j)if(L[j]==s){b=1;L.erase(begin(L)+j);break;}if(!b)return i;}}

在线尝试！

PHP，74字节

<?foreach($_GET[0]as$v)$t[]=array_count_values($_GET[1])[$v];echo+min($t);

测试用例

PHP，108字节

<?[$x,$y]=$_GET;echo($a=array_intersect)($x,$y)==$x?min(($a._key)(array_count_values($y),array_flip($x))):0;

测试用例

Pyth，5个字节

hS/LF

首先获取列表，然后获取列表。 测试套件。

说明：

    F  Expand the input into l and s (not literally, 
                  since those are function names in Pyth, but...)
   L   for d in s:
  /        Count instances of d in l
   L   Package all the results as a list
 S     Sort the results smallest-first
h      grab the smallest element

C＃，36个字节

f=(n,h)=>n.Min(c=>h.Count(x=>x==c));

n和h是string[]，输出为int。

在线尝试！

@ovs和@Alberto Rivera的逻辑启发了这个答案。谢谢！

Java，135个字节

int f(List<String> s,List<String> l){int n=0,i=0;while(i<s.size()){if(!l.remove(s.get(i++)))break;if(i==s.size()){n++;i=0;}};return n;}

这是我的第一个高尔夫挑战代码，答案是，所以不确定格式。是否需要一个完整的编译程序？我需要定义参数吗？建议表示赞赏。

编辑：将代码包装在函数中。谢谢@Steadybox

05AB1E，7个字节

v²y¢})W

在线尝试！

v   }   # For each item in the first list...
 ²y¢    # Count the occurances in the second list.
     )W # Take the minimum occurrence count, return.

Java，114字节

<T>int a(Set<T>b,List<T>c){int m=2e32;b.stream().map(i->{int j=java.util.Collections.frequency(c,i);m=j<m?j:m;});return m;}

Tio即将推出

说明

• 创建局部变量m。

• 将集合映射到流。

• 对于每个元素，如果列表中该元素的出现次数小于m，则将m设置为该值。

• 返回m，它是集合的完整版本数

R 54 Bytes

f<-function(s,l) min(table(factor(l[l%in%s],levels=s)))

Explanation: creating a table of the counts of only the values in the list that also appear in the sublist.

I then turn the variable into a factor in order to generate zeros if a value that appears in the sublist does not appear in the list. Finally, I take the minimum of the counts.

R, 61 57 44 bytes

print(min(sapply(s,function(x)sum(l%in%x))))

Anonymous function. Apparently you don't have to define a function for this challenge. Saved 13 bytes thanks to count.

Explanation:

sum(l%in%x)) returns the number of times a string in s is found in l.

lapply(s,function(x)) applies that to each string in s separately and returns a list of sums.

min() returns the smallest from that list.

JavaScript (ES6), 59 bytes

a=>b=>a.reduce((x,y)=>(l=b.filter(s=>s==y).length)>x?x:l)|0

尝试一下

f=

a=>b=>a.reduce((x,y)=>(l=b.filter(s=>s==y).length)>x?x:l)|0

console.log(f(["apple","banana"])(["apple","pear","apple","banana","banana"]))
console.log(f(["apple","banana"])(["apple", "pear", "apple", "banana", "apple"]))
console.log(f(["apple","banana","pear"])(["apple","banana","kiwi","apple"]))
console.log(f(["coconut"])([]))