Finden Sie bei einer nicht leeren Menge von Zeichenfolgen und einer Liste von Zeichenfolgen heraus, wie oft die Menge in der Liste vorkommt, dh wie oft Sie die Menge mit Elementen aus der Liste erstellen könnten. Jedes Element aus der Liste kann nur einmal verwendet werden.

Hinweis: Ein Set ist eine ungeordnete Liste einzigartiger Gegenstände.

Es gelten die Standard- Ein- / Ausgaberegeln .

Keine externen Bibliotheken erlaubt. Compiler / Interpreter-Standardbibliotheken sind in Ordnung. Dies ist Codegolf, daher zählt die kürzeste Lösung.

Testfälle:

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

BEARBEITEN: Ein Satz wurde entfernt, der besagt, dass die Eingabeparameter im lokalen Bereich definiert sind. Dies widerspricht den oben verknüpften Standard-E / A-Regeln.

Python, 30 Bytes

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

Probieren Sie es online!

Gelee , 4 Bytes

⁼þSṂ

Probieren Sie es online!

Wie?

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

Jelly , 6 5 4 Bytes

ċ@€Ṃ

Probieren Sie es online!

Das erste Argument des Programms ist die Menge, und das zweite Argument ist die Liste.

Erläuterung

ċ@€Ṃ
ċ@   -- 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 dank @ETHproductions

Nochmals -1 Byte dank @ETHproductions

JavaScript (ES6), 56 Byte

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

Probieren Sie es online aus

JavaScript (ES6), 64 Byte

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

Nimmt beides an sund list ein Array von Objekten. Verwendet JavaScript für Vergleiche mit strikter Gleichheit, ist also beispielsweise [] === []falsch.

Haskell , 37 34 Bytes

Vielen Dank an @Laikoni für das Abschneiden von drei Bytes.

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

Rufen Sie mit (set::[a]) # (list::[a])woher akommt irgendein Typ Eq.

CJam , 11 Bytes

q~f{\e=}:e<

Probieren Sie es online!

Erläuterung

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 Bytes

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

Reine Funktion, die zwei Listen als Argumente in der vorgeschlagenen Reihenfolge verwendet und eine nicht negative Ganzzahl zurückgibt. Tallyzählt, wie viele Vorkommen jedes Symbols in der Eingabeliste vorkommen, und #/.Rule@@@konvertiert jedes Element der Eingabemenge in die entsprechende Anzahl von Vorkommen.

T-SQL, 62-59 Bytes

Die vorherige Version funktionierte nicht für Sets ohne Übereinstimmungen

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

Mit s und l als Tabellen und Spalten mit demselben Namen wie die Tabelle

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

Schnell, 39 Bytes

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

Erläuterung:

s.map{} Durchläuft jedes Wort in s und erzeugt eine Reihe von Zählungen

w in Benennt das zugeordnete Wort zur Verwendung im nächsten Filter

l.filter{} Wendet einen Filter auf das Array l an

$0==w ist das Filterbedingungs-Übereinstimmungswort w

.count gibt die Anzahl der Elemente von l an, die die Bedingung erfüllen

.min() Gibt die niedrigste Anzahl im zugeordneten Ergebnis zurück

APL (Dyalog) , 9 Bytes

⌊/+/⎕∘.≡⎕

Probieren Sie es online!

⎕ ausgewertete Eingabe abrufen (Liste der Zeichenfolgen)

⎕∘.≡ ausgewertete Eingabe abrufen (nicht leerer Satz von Zeichenfolgen) und Äquivalenztabelle erstellen

+/ hinzufügen über

⌊/ Minimum über

Perl 6 ,  37  18 Bytes

37

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

Versuch es

Erweitert:

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

Siehe Sets, Beutel und MischungenWeitere Informationen finden .

18

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

Versuch es

Erläuterung:

@^b.BagErstellen Sie einen Beutel aus dem Werteschlüssel
{@^a}in diesem Beutel (gibt eine Liste mit Zählwerten zurück),
.minum den Mindestwert der resultierenden Liste zu erhalten

Axiom, 42 Bytes

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

Testcode und Ergebnisse

(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

Vielen Dank an @Quentin für das Speichern von zwei 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;}}

Probieren Sie es online!

PHP, 74 Bytes

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

Testfälle

PHP, 108 Bytes

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

Testfälle

Pyth, 5 Bytes

hS/LF

Nimmt die Liste zuerst und den Satz an zweiter Stelle. Testsuite.

Erläuterung:

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

nund hsind string[]und der Ausgang ist ein int.

Probieren Sie es online!

Diese Antwort ist inspiriert von @ovs und @Alberto Riveras Logik. Vielen Dank!

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

Dies ist meine erste Code Golf Herausforderung und Antwort, also nicht sicher über das Format. Muss es ein vollständiges Kompilierungsprogramm sein? Muss ich die Parameter definieren? Vorschläge geschätzt.

EDIT : Code in eine Funktion eingebunden . Vielen Dank @Steadybox

05AB1E , 7 Bytes

v²y¢})W

Probieren Sie es 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 kommt bald

Erläuterung

• Erzeugt die lokale Variable m.

• ordnet das Set einem Stream zu.

• Wenn für jedes Element die Anzahl der Vorkommen des Elements in der Liste kleiner als m ist, wird m auf diesen Wert gesetzt.

• gibt m zurück, das ist die Anzahl der vollständigen Versionen der Menge

R 54 Bytes

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

Erläuterung: Es wird eine Tabelle mit den Zählwerten nur der Werte in der Liste erstellt, die auch in der Unterliste enthalten sind.

Ich wandle die Variable dann in einen Faktor um, um Nullen zu erzeugen, wenn ein Wert, der in der Unterliste erscheint, nicht in der Liste erscheint. Schließlich nehme ich das Minimum der Zählungen.

R 61 57 44 Bytes

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

Anonyme Funktion. Anscheinend müssen Sie für diese Herausforderung keine Funktion definieren. 13 Bytes gespart dank count.

Erläuterung:

sum(l%in%x))Gibt zurück, wie oft ein String in sgefunden wurde l.

lapply(s,function(x))Wendet dies auf jede Zeichenfolge sseparat an und gibt eine Liste der Summen zurück.

min() gibt den kleinsten Wert aus dieser Liste zurück.

JavaScript (ES6), 59 Byte

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

Versuch es

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