Đưa ra một bộ chuỗi không trống và một danh sách các chuỗi, tìm hiểu số lần bộ đó xảy ra trong danh sách, tức là bạn có thể tạo bộ bao nhiêu lần với các mục từ danh sách. Mỗi yếu tố từ danh sách chỉ có thể được sử dụng một lần.

Gợi ý: một bộ là một danh sách không có thứ tự các mục duy nhất.

Mặc định quy tắc đầu vào / đầu ra áp dụng.

Không cho phép thư viện bên ngoài. Trình biên dịch / trình thông dịch libs ổn. Đây là mã golf, vì vậy giải pháp ngắn nhất tính.

Các trường hợp thử nghiệm:

["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

EDIT: đã xóa một câu cho biết các thông số đầu vào được xác định trong phạm vi cục bộ. Điều này mâu thuẫn với các quy tắc IO mặc định được liên kết ở trên.

Python, 30 byte

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

Hãy thử trực tuyến!

Thạch , 4 byte

⁼þSṂ

Hãy thử trực tuyến!

Làm sao?

⁼þ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)

Thạch , 6 5 4 byte

ċ@€Ṃ

Hãy thử trực tuyến!

Đối số đầu tiên của chương trình là tập hợp và đối số thứ hai là danh sách.

Giải trình

ċ@€Ṃ
ċ@   -- 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 byte nhờ @ETHproductions

-1 byte một lần nữa nhờ @ETHproductions

JavaScript (ES6), 56 byte

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

Dùng thử trực tuyến

JavaScript (ES6), 64 byte

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

Giả sử cả hai svà llà mảng của các đối tượng. Sử dụng JavaScript bình đẳng nghiêm ngặt để so sánh, vì vậy, ví dụ [] === []là sai.

Haskell , 37 34 byte

Cảm ơn @Laikoni đã cạo sạch ba byte.

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

Gọi với (set::[a]) # (list::[a])nơi alà bất kỳ loại bắt nguồn Eq.

Camam , 11 byte

q~f{\e=}:e<

Hãy thử trực tuyến!

Giải trình

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

Toán học, 24 byte

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

Hàm thuần túy lấy hai danh sách làm đối số theo thứ tự được đề xuất và trả về một số nguyên không âm. Tallyđếm có bao nhiêu lần xuất hiện của mỗi ký hiệu xảy ra trong danh sách đầu vào và #/.Rule@@@chuyển đổi từng phần tử của bộ đầu vào thành số lần xuất hiện tương ứng.

T-SQL, 62 59 byte

Phiên bản trước không hoạt động đối với các bộ không có kết quả khớp

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

Với s và l là các bảng và cột được đặt tên giống như bảng

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

Swift, 39 byte

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

giải trình:

s.map{} đi qua từng từ trong s và sẽ tạo ra một mảng đếm

w in Đặt tên cho từ được ánh xạ để sử dụng trong bộ lọc tiếp theo

l.filter{} áp dụng một bộ lọc cho mảng l

$0==w là điều kiện lọc phù hợp với từ w

.count đưa ra số phần tử của l đáp ứng điều kiện

.min() trả về số lượng thấp nhất trong kết quả được ánh xạ

APL (Dyalog) , 9 byte

⌊/+/⎕∘.≡⎕

Hãy thử trực tuyến!

⎕ được đánh giá đầu vào (danh sách các chuỗi)

⎕∘.≡ nhận đánh giá đầu vào (bộ chuỗi không trống) và tạo bảng tương đương

+/ thêm vào

⌊/ tối thiểu trên

Perl 6 ,  37  18 byte

37

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

Thử nó

Mở rộng:

{
  +( # 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 $_
}

Xem Bộ, Túi và Hỗn hợp để biết thêm thông tin.

18

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

Thử nó

Giải trình:

@^b.Bagtạo Túi từ
{@^a}khóa giá trị vào Túi đó (trả về danh sách số đếm)
.minlấy giá trị tối thiểu của danh sách kết quả

Tiên đề, 42 byte

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

mã kiểm tra và kết quả

(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 ++, 203 201 byte

Cảm ơn @Quentin đã lưu hai byte!

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

Hãy thử trực tuyến!

PHP, 74 byte

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

Tủ thử

PHP, 108 byte

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

Tủ thử

Bình thường, 5 byte

hS/LF

Đưa danh sách đầu tiên và thiết lập thứ hai. Bộ thử nghiệm.

Giải trình:

    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 byte

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

nvà hđược string[]và đầu ra là một int.

Hãy thử trực tuyến!

Câu trả lời này được truyền cảm hứng bởi logic của @ovs và @Alberto Rivera. Cảm ơn bạn!

Java, 135 byte

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

Đây là thử thách và câu trả lời về mã golf đầu tiên của tôi, vì vậy không chắc chắn về định dạng. Có cần phải là một chương trình biên dịch đầy đủ? Tôi có cần xác định các tham số không? Gợi ý đánh giá cao.

EDIT : bọc mã trong một chức năng. Cảm ơn @Steadybox

05AB1E , 7 byte

v²y¢})W

Hãy thử trực tuyến!

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 byte

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

Sắp có

Giải trình

• tạo biến cục bộ m.

• ánh xạ tập hợp thành một luồng.

• đối với mỗi phần tử, nếu số lần xuất hiện của phần tử trong danh sách nhỏ hơn m, m được đặt thành giá trị đó.

• trả về m, là số phiên bản hoàn chỉnh của bộ

R 54 byte

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

Giải thích: tạo bảng tổng số chỉ các giá trị trong danh sách cũng xuất hiện trong danh sách phụ.

Sau đó tôi biến biến thành một yếu tố để tạo số không nếu một giá trị xuất hiện trong danh sách con không xuất hiện trong danh sách. Cuối cùng, tôi lấy số lượng tối thiểu.

R, 61 57 44 byte

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

Chức năng ẩn danh. Rõ ràng bạn không phải xác định chức năng cho thử thách này. Lưu được 13 byte nhờ đếm.

Giải trình:

sum(l%in%x))trả về số lần một chuỗi trong sđược tìm thấy trong l.

lapply(s,function(x))áp dụng điều đó cho từng chuỗi sriêng biệt và trả về một danh sách các khoản tiền.

min() trả về giá trị nhỏ nhất từ ​​danh sách đó

JavaScript (ES6), 59 byte

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

Thử nó

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"])([]))