ให้ชุดของสตริงที่ไม่ว่างเปล่าและรายการของสตริงหาจำนวนครั้งที่ชุดเกิดขึ้นในรายการเช่นกี่ครั้งที่คุณสามารถสร้างชุดที่มีรายการจากรายการ ทุกองค์ประกอบจากรายการสามารถใช้ได้เพียงครั้งเดียว

คำแนะนำ: ชุดเป็นรายการที่ไม่ซ้ำของรายการที่ไม่ซ้ำกัน

ใช้กฎอินพุต / เอาต์พุตเริ่มต้น

ไม่อนุญาตให้ใช้ไลบรารีภายนอก libs มาตรฐานของคอมไพเลอร์ / ล่ามก็โอเค นี่คือรหัสกอล์ฟดังนั้นจึงนับเป็นการแก้ปัญหาที่สั้นที่สุด

กรณีทดสอบ:

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

แก้ไข:ลบประโยคที่ระบุว่าอินพุต params ถูกกำหนดในขอบเขตโลคัล สิ่งนี้ขัดแย้งกับกฎ 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 สำหรับการเปรียบเทียบดังนั้นตัวอย่างเช่น[] === []เป็นเท็จ

Haskell , 37 34 ไบต์

ขอบคุณ @Laikoni สำหรับการตัดสามไบต์

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

โทรกับ(set::[a]) # (list::[a])ที่อยู่ในประเภทใดที่ได้รับ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

Swift, 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สร้างกระเป๋าจาก
{@^a}คีย์ค่าลงในกระเป๋า (ส่งคืนรายการการนับ)
.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++, 203 201 bytes

Thanks to @Quentin for saving two bytes!

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

Try it online!

PHP, 74 Bytes

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

Testcases

PHP, 108 Bytes

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

Testcases

Pyth, 5 bytes

hS/LF

Takes the list first and the set second. Test suite.

Explanation:

    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 bytes

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

n and h are string[] and the output is an int.

Try it online!

This answer is inspire by @ovs and @Alberto Rivera's logic. Thank you!

Java, 135 bytes

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

This is my first code golf challenge and answer, so not sure about the format. Does it need to be a full compiling program? Do I need to define the parameters? Suggestions appreciated.

EDIT: wrapped code in a function. Thanks @Steadybox

05AB1E, 7 bytes

v²y¢})W

Try it online!

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 Bytes

<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 coming soon

Explanation

• creates local variable m.

• maps the set to a stream.

• for each element, if the number of occurances of the element in the list is less than m, m is set to that value.

• returns m, which is the number of complete versions of the set

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

Try it

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