Dato un set di stringhe non vuoto e un elenco di stringhe, scopri quante volte il set si presenta nell'elenco, ovvero quante volte è possibile creare il set con elementi dall'elenco. Ogni elemento dell'elenco può essere utilizzato una sola volta.

Suggerimento: un set è un elenco non ordinato di elementi unici.

Si applicano le regole di input / output predefinite .

Non sono consentite librerie esterne. Le librerie standard del compilatore / interprete sono a posto. Questo è il golf del codice, quindi la soluzione più breve conta.

Casi 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: rimossa una frase in cui si afferma che i parametri di input sono definiti nell'ambito locale. Ciò contraddice le regole IO predefinite collegate sopra.

Python, 30 byte

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

Provalo online!

Gelatina , 4 byte

⁼þSṂ

Provalo online!

Come?

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

Gelatina , 6 5 4 byte

ċ@€Ṃ

Provalo online!

Il primo argomento del programma è l'insieme e il secondo argomento è l'elenco.

Spiegazione

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

-1 byte di nuovo grazie a @ETHproductions

JavaScript (ES6), 56 byte

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

Provalo online

JavaScript (ES6), 64 byte

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

Presuppone entrambi se lsono matrici di oggetti. Utilizza l'uguaglianza rigorosa di JavaScript per i confronti, quindi ad esempio [] === []è falso.

Haskell , 37 34 byte

Grazie a @Laikoni per la rasatura di tre byte.

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

Chiama da (set::[a]) # (list::[a])dove aderiva qualsiasi tipo Eq.

CJam , 11 byte

q~f{\e=}:e<

Provalo online!

Spiegazione

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 byte

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

Funzione pura che prende due liste come argomenti nell'ordine suggerito e restituisce un numero intero non negativo. Tallyconta quante occorrenze di ciascun simbolo si verificano nell'elenco di input e #/.Rule@@@converte ogni elemento dell'insieme di input nel numero di occorrenze corrispondente.

T-SQL, 62 59 byte

La versione precedente non funzionava per i set senza corrispondenze

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

Con s come tabelle e colonne denominate uguali alla tabella

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

Rapido, 39 byte

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

spiegazione:

s.map{} passa attraverso ogni parola in se produce una serie di conteggi

w in nomina la parola mappata da utilizzare nel filtro successivo

l.filter{} applica un filtro all'array l

$0==w è la parola di corrispondenza del filtro condizione w

.count fornisce il numero di elementi di l che soddisfano la condizione

.min() restituisce il conteggio più basso nel risultato mappato

APL (Dyalog) , 9 byte

⌊/+/⎕∘.≡⎕

Provalo online!

⎕ ottenere input valutati (elenco di stringhe)

⎕∘.≡ ottenere input valutati (set di stringhe non vuoto) e creare una tabella di equivalenza

+/ aggiungere attraverso

⌊/ minimo attraverso

Perl 6 ,  37  18 byte

37

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

Provalo

Allargato:

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

Vedi Set, Borse e Mix per ulteriori informazioni.

18

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

Provalo

Spiegazione:

@^b.Bagcreare un Bag dalla
{@^a}chiave dei valori in quel Bag (restituisce un elenco di conteggi)
.minottenere il valore minimo dell'elenco risultante

Assioma, 42 byte

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

codice di prova e risultati

(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

Grazie a @Quentin per aver salvato due 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;}}

Provalo online!

PHP, 74 byte

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

Casi test

PHP, 108 byte

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

Casi test

Pyth, 5 byte

hS/LF

Prende l'elenco per primo e il secondo impostato. Suite di test.

Spiegazione:

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

ne hsono string[]e l'output è un int.

Provalo online!

Questa risposta è ispirata dalla logica di @ovs e @Alberto Rivera. Grazie!

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

Questa è la mia prima sfida e risposta per il golf del codice, quindi non sono sicuro del formato. Deve essere un programma di compilazione completo? Devo definire i parametri? Suggerimenti apprezzati.

EDIT : codice avvolto in una funzione. Grazie @Steadybox

05AB1E , 7 byte

v²y¢})W

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

Tio in arrivo

Spiegazione

• crea la variabile locale m.

• mappa il set su uno stream.

• per ogni elemento, se il numero di occorrenze dell'elemento nell'elenco è inferiore a m, m è impostato su quel valore.

• ritorna m, che è il numero di versioni complete dell'insieme

R 54 byte

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

Spiegazione: creazione di una tabella dei conteggi dei soli valori nell'elenco che appaiono anche nell'elenco secondario.

Trasformo quindi la variabile in un fattore per generare zeri se un valore che appare nell'elenco secondario non compare nell'elenco. Infine, prendo il minimo dei conteggi.

R, 61 57 44 byte

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

Funzione anonima. Apparentemente non devi definire una funzione per questa sfida. Risparmiato 13 byte grazie al conteggio.

Spiegazione:

sum(l%in%x))restituisce il numero di volte in cui sviene trovata una stringa l.

lapply(s,function(x))applica questo a ciascuna stringa sseparatamente e restituisce un elenco di somme.

min() restituisce il più piccolo da quell'elenco.

JavaScript (ES6), 59 byte

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

Provalo

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