Étant donné un ensemble de chaînes non vide et une liste de chaînes, découvrez combien de fois l'ensemble se produit dans la liste, c'est-à-dire combien de fois vous pouvez créer l'ensemble avec des éléments de la liste. Chaque élément de la liste ne peut être utilisé qu'une seule fois.

Astuce: un ensemble est une liste non ordonnée d'articles uniques.

Les règles d'entrée / sortie par défaut s'appliquent.

Aucune bibliothèque externe autorisée. Les bibliothèques standard du compilateur / interprète sont correctes. C'est le golf de code, donc la solution la plus courte compte.

Cas de test:

["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: suppression d'une phrase indiquant que les paramètres d'entrée sont définis dans la portée locale. Cela contredit les règles d'E / S par défaut liées ci-dessus.

Python, 30 octets

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

Essayez-le en ligne!

Gelée , 4 octets

⁼þSṂ

Essayez-le en ligne!

Comment?

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

Gelée , 6 5 4 octets

ċ@€Ṃ

Essayez-le en ligne!

Le premier argument du programme est l'ensemble et le deuxième argument est la liste.

Explication

ċ@€Ṃ
ċ@   -- 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 octet grâce à @ETHproductions

-1 octet encore grâce à @ETHproductions

JavaScript (ES6), 56 octets

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

Essayez-le en ligne

JavaScript (ES6), 64 octets

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

Suppose les deux set lsont des tableaux d'objets. Utilise une stricte égalité JavaScript pour les comparaisons, donc par exemple [] === []est faux.

Haskell , 37 34 octets

Merci à @Laikoni d'avoir rasé trois octets.

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

Appelez avec (set::[a]) # (list::[a])où an'importe quel type dérivant Eq.

CJam , 11 octets

q~f{\e=}:e<

Essayez-le en ligne!

Explication

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 octets

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

Fonction pure prenant deux listes comme arguments dans l'ordre suggéré et retournant un entier non négatif. Tallycompte le nombre d'occurrences de chaque symbole dans la liste d'entrée et #/.Rule@@@convertit chaque élément de l'ensemble d'entrée en nombre d'occurrences correspondant.

T-SQL, 62 59 octets

La version précédente ne fonctionnait pas pour les ensembles sans correspondance

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

Avec s et l comme tables et colonnes nommées de la même manière que la 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

Swift, 39 octets

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

explication:

s.map{} passe par chaque mot en s et produira un tableau de comptes

w in nomme le mot mappé à utiliser dans le filtre suivant

l.filter{} applique un filtre au tableau l

$0==w est le mot correspondant à la condition du filtre w

.count donne le nombre d'éléments de l qui remplissaient la condition

.min() renvoie le nombre le plus bas du résultat mappé

APL (Dyalog) , 9 octets

⌊/+/⎕∘.≡⎕

Essayez-le en ligne!

⎕ obtenir une entrée évaluée (liste de chaînes)

⎕∘.≡ obtenir une entrée évaluée (ensemble de chaînes non vide) et créer une table d'équivalence

+/ ajouter à travers

⌊/ minimum à travers

Perl 6 ,  37  18 octets

37

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

Essayez-le

Étendu:

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

Voir Ensembles, sacs et mélanges pour plus d'informations.

18

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

Essayez-le

Explication:

@^b.Bagcréer un sac à partir de la
{@^a}clé de valeurs dans ce sac (retourne une liste de comptes)
.minobtenir la valeur minimale de la liste résultante

Axiome, 42 octets

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

code de test et résultats

(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 octets

Merci à @Quentin d'avoir économisé deux octets!

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

Essayez-le en ligne!

PHP, 74 octets

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

Cas de test

PHP, 108 octets

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

Cas de test

Pyth, 5 octets

hS/LF

Prend la liste en premier et le deuxième ensemble. Suite de tests.

Explication:

    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 octets

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

net hsont string[]et la sortie est un int.

Essayez-le en ligne!

Cette réponse est inspirée par la logique de @ovs et @Alberto Rivera. Je vous remercie!

Java, 135 octets

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

Ceci est mon premier défi et réponse de golf de code, donc je ne suis pas sûr du format. Doit-il s'agir d'un programme de compilation complet? Dois-je définir les paramètres? Suggestions appréciées.

EDIT : code encapsulé dans une fonction. Merci @Steadybox

05AB1E , 7 octets

v²y¢})W

Essayez-le en ligne!

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 octets

<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 arrive bientôt

Explication

• crée la variable locale m.

• mappe l'ensemble à un flux.

• pour chaque élément, si le nombre d'occurrences de l'élément dans la liste est inférieur à m, m est défini sur cette valeur.

• renvoie m, qui est le nombre de versions complètes de l'ensemble

R 54 octets

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

Explication: création d'un tableau des décomptes uniquement des valeurs de la liste qui apparaissent également dans la sous-liste.

Je transforme ensuite la variable en facteur afin de générer des zéros si une valeur qui apparaît dans la sous-liste n'apparaît pas dans la liste. Enfin, je prends le minimum de comptes.

R, 61 57 44 octets

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

Fonction anonyme. Apparemment, vous n'avez pas à définir de fonction pour ce défi. Enregistré 13 octets grâce au compte.

Explication:

sum(l%in%x))renvoie le nombre de fois où une chaîne sest trouvée dans l.

lapply(s,function(x)) applique cela à chaque chaîne s séparément et renvoie une liste de sommes.

min() renvoie le plus petit de cette liste.

JavaScript (ES6), 59 octets

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

Essayez-le

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