एक सूची में एक सेट की घटनाओं को गिनें

Question

स्ट्रिंग के गैर-खाली सेट और स्ट्रिंग्स की एक सूची को देखते हुए, यह पता करें कि सूची में सेट कितनी बार होता है, यानी आप सूची से आइटम के साथ सेट को कितनी बार बना सकते हैं। सूची से प्रत्येक तत्व केवल एक बार उपयोग किया जा सकता है।

संकेत: एक सेट अद्वितीय वस्तुओं की एक अनियंत्रित सूची है।

डिफ़ॉल्ट इनपुट / आउटपुट नियम लागू होते हैं।

किसी भी बाहरी पुस्तकालय की अनुमति नहीं है। संकलक / दुभाषिया मानक काम ठीक है। यह कोड गोल्फ है, इसलिए सबसे छोटा समाधान मायने रखता है।

---

परीक्षण के मामलों:

["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: एक वाक्य को यह कहते हुए हटा दिया कि इनपुट पैराम्स को स्थानीय दायरे में परिभाषित किया गया है। यह ऊपर दिए गए डिफ़ॉल्ट IO नियमों का खंडन करता है।

Comments

हाँ जो इसे स्पष्ट करता है। हालांकि मैं तीसरे वाक्य पर थोड़ा लटका हुआ हूं। "ऑब्जेक्ट्स हैंडल नहीं करता है" से आपका क्या मतलब है?

— पोस्ट रॉक गार्फ हंटर

@WheatWizard कुछ भाषाएँ ऑब्जेक्ट-ओरिएंटेड नहीं हैं और मनमानी वस्तुओं की तुलना करने की अवधारणा को नहीं जानती हैं।

— ह्यूबर्ट ग्रेज्सकोविआक

आपको शायद इसे ऑब्जेक्ट-ओरिएंटेड में बदलना चाहिए क्योंकि हर भाषा से मैं वाकिफ हूं, भले ही ऑब्जेक्ट्स एक बंद क्लास हैं। मुझे यह भी बताना चाहिए कि भाषाओं का एक अच्छा सौदा है जो तार भी नहीं संभाल सकता है।

— पोस्ट रॉक गार्फ हंटर

@HeatWizard ठीक है, अद्यतन विवरण। वह अनुच्छेद सी, असेंबलर या मेपल जैसी भाषाओं के लिए था।

— ह्यूबर्ट ग्रेज्सकोविआक

ऑब्जेक्ट ओरिएंटेड कौन सी भाषाएं हैं? तार नहीं तो उन्हें क्या उपयोग करना चाहिए? मुझे लगता है कि सबसे आसान काम सिर्फ स्ट्रिंग्स तक सीमित रखना होगा। या, वैकल्पिक रूप से, केवल पूर्णांक। सबसे सरल प्रकार का उपयोग करने पर इस सलाह को देखें जो पर्याप्त है।

— xnor

Answer 1

पायथन, 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

अच्छा है। मानचित्र का उपयोग करने के बारे में नहीं सोचा था। आप एक लैम्ब्डा बीटीडब्ल्यू को परिभाषित करने के बजाय प्रिंट का उपयोग करके थोड़ा बचा सकते हैं।

— ह्यूबर्ट ग्रेज्सकोविआक

@HubertGrzeskowiak बदलने lambdaएक करने के लिए printबाइट क्योंकि दोनों में से 37 अप करने के लिए गिनती लाता input()आवश्यक है।

— रॉक गार्फ हंटर

@HeatWizard चुनौती में कहा गया है, स्थानीय दायरे में परिभाषित इनपुट पर विचार करें। आपको फ़ंक्शन पार्म्स या उपयोगकर्ता इनपुट के रूप में स्पष्ट रूप से परिभाषित इनपुट की आवश्यकता नहीं है।

— ह्यूबर्ट ग्रेज्सकोविआक

@HubertGrzeskowiak अगर इसका कोई अच्छा कारण नहीं है, तो आपको इनपुट और आउटपुट लेने के लिए हमारी चूक को नहीं लिखना चाहिए और कोडगॉल्फ सबमिशन के लिए

— ovs

@ ओह, मुझे उस पोस्ट की जानकारी नहीं थी। धन्यवाद।

— ह्यूबर्ट ग्रेज्सकोविआक

Answer 2

जेली , 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)

Answer 3

जेली , 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 बाइट @ @Hproductions के लिए धन्यवाद

-1 बाइट फिर से @ETHproductions को धन्यवाद

Comments

बहुत अच्छा! आप लिंक को एक पंक्ति में जोड़कर एक बाइट बचा सकते हैं: ⁹ċ$€Ṃमुझे लगता है कि अंतर्निहित सही तर्क का उपयोग करके कम किया जा सकता है ⁹...

— ETHproductions

मुझे लगता है कि ċ@€Ṃ एक और बाइट को बचाने के लिए काम करता है ... ( @तर्कों को उलट देता है ċ)

— ETHproductions

@ETHproductions जहाँ तक मैंने परीक्षण किया है, सही ढंग से काम करता है।

— फायरफ्लेम 241

यह पिछले साल के 12 मई तक मौजूद नहीं था, लेकिन Ɱइसके स्थान पर @€(कार्यक्रम के लिए उल्टे तर्क के साथ) एक और बाइट बचाता है: ऑनलाइन प्रयास करें!

— असंबंधित स्ट्रिंग

Answer 4

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

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

इसे ऑनलाइन आज़माएं

Comments

अनाम फ़ंक्शन का उपयोग करके 2 बाइट्स सहेजें और मापदंडों को क्यूर करके एक और: n=>h=>Math.min(...n.map(c=>h.filter($=>$==c).length))53 बाइट्स के लिए

— झबरा

Answer 5

जावास्क्रिप्ट (ईएस 6), 64 बाइट्स

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

दोनों मानता है sऔर lवस्तुओं के सरणियाँ हैं। तुलना के लिए जावास्क्रिप्ट सख्त समानता का उपयोग करता है, इसलिए उदाहरण के [] === []लिए गलत है।

Comments

बहुत ही रोचक उपाय। कृपया परिणाम लौटाएं या प्रिंट करें। AFAIK यह एक अनाम फ़ंक्शन देता है।

— ह्यूबर्ट ग्रॉस्स्कोविआक

@HubertGrzeskowiak कोड जैसा कि दिखाया गया है एक अनाम फ़ंक्शन का मूल्यांकन करता है। जब कहा जाता है, फ़ंक्शन वांछित के रूप में गिनती लौटाता है।

— नील

Answer 6

हास्केल , ३ 37 34 bytes

तीन बाइट्स से शेविंग करने के लिए @Laikoni को धन्यवाद।

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

Call with (set::[a]) # (list::[a]) where a is any type deriving Eq.

Comments

Instead of length[y|y<-l,y==x] you can use sum[1|y<-l,y==x].

— Laikoni

@Laikoni, are you sure about that? I think I would need to use something like sum[1|y<-l,y==x,_<-y], which comes out to two bytes longer—I could definitely be missing something there, though

— Julian Wolf

Never mind, you're definitely right. Good call.

— Julian Wolf

Answer 7

CJam, 11 bytes

q~f{\e=}:e<

Try it online!

Explanation

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

Answer 8

Mathematica, 24 bytes

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

Pure function taking two lists as arguments in the suggested order and returning a nonnegative integer. Tally counts how many occurrences of every symbol occur in the input list, and #/.Rule@@@ converts each element of the input set into the corresponding number of occurrences.

Answer 9

T-SQL, 62 59 bytes

Previous version didn't work for sets with no matches

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

With s and l as tables and columns named the same as the table

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

Answer 10

Swift, 39 bytes

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

explanation:

s.map{} goes through each word in s and will produce an array of counts

w in names the mapped word for use in the next filter

l.filter{} aplies a filter to the l array

$0==w is the filter condition matching word w

.count gives the number of elements of l that met the condition

.min() returns the lowest count in the mapped result

Comments

Welcome to PPCG! I've added code formatting for your solution. You can do this by prepending 4 spaces to lines that contain code.

— Mego

Answer 11

APL (Dyalog), 9 bytes

⌊/+/⎕∘.≡⎕

Try it online!

⎕ get evaluated input (list of strings)

⎕∘.≡ get evaluated input (non-empty set of strings) and create equivalency table

+/ add across

⌊/ minimum across

Answer 12

Perl 6,  37  18 bytes

37

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

Try it

Expanded:

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

See Sets, Bags, and Mixes for more information.

---

18

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

Try it

Explanation:

@^b.Bag create a Bag from the values
{@^a} key into that Bag (returns a list of counts)
.min get the minimum value of the resulting list

---

Comments

Neat answers, but neither of these look like functions / complete programs

— Julian Wolf

@JulianWolf I was under the impression that snippets were allowed based on the statements “Consider both inputs being defined in the current scope as s and l.” and “You don't need to define a function.” I went and edited it anyway.

— Brad Gilbert b2gills

Ah, you're completely right. That must've been edited into the question after I read it. In any case, I like the aesthetic of this version even more than the last—Perl's syntax will always be a mystery to me.

— Julian Wolf

@JulianWolf This isn't really a good example of Perl 6 code. I would recommend seeing Ovid's 1hr talk Perl 6 — Why People Are So Excited, or looking at the Resources tab on Perl6.org.

— Brad Gilbert b2gills

Yeah, sorry for the confusion. This is my first chllenge and I didn't know there already are rules for input and output. I changed it because most answers were using these rules even while it wasn't required.

— Hubert Grzeskowiak

Answer 13

Axiom, 42 bytes

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

test code and results

(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

Answer 14

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!

Comments

L.begin() -> begin(L) saves one byte :)

— Quentin

Also, using T=std::vector<std::string>; saves another! Who knew modern pretty syntax could also help golfing.

— Quentin

@Quentin I tried that at first. Probably there was some simple typo I didn't notice.

— Steadybox

Answer 15

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

Answer 16

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

Answer 17

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!

Answer 18

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

Comments

An answer can be a full program, a function or some other function-like construct. You can take the parameters for example as arguments to a function or from standard input.

— Steadybox

Answer 19

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.

Answer 20

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

Answer 21

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.

Answer 22

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.

Comments

Could be brought down to 40 Bytes with a for-loop: z=c();for(i in s)z[i]=sum(l%in%i);min(z)

— count

Or even further to 37 bytes with sapply: min(sapply(s,function(x)sum(l%in%x)))

— count

Brilliant, I always forget you can sum booleans. I'll edit that in later. I've been told I need that print() if it's not a function.

— BLT

Answer 23

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