Dado un conjunto de cadenas no vacío y una lista de cadenas, averigüe cuántas veces se produce el conjunto en la lista, es decir, cuántas veces podría crear el conjunto con elementos de la lista. Cada elemento de la lista solo se puede usar una vez.

Sugerencia: un conjunto es una lista desordenada de elementos únicos.

Se aplican las reglas predeterminadas de entrada / salida .

No se permiten bibliotecas externas. Las bibliotecas estándar del compilador / intérprete están bien. Este es el código de golf, por lo que la solución más corta cuenta.

Casos de prueba:

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

EDITAR: eliminó una oración que indica que los parámetros de entrada están definidos en el ámbito local. Esto contradice las reglas de IO predeterminadas vinculadas anteriormente.

Python, 30 bytes

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

Pruébalo en línea!

Jalea , 4 bytes

⁼þSṂ

Pruébalo en línea!

¿Cómo?

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

ċ@€Ṃ

Pruébalo en línea!

El primer argumento del programa es el conjunto, y el segundo argumento es la lista.

Explicación

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

-1 byte nuevamente gracias a @ETHproductions

JavaScript (ES6), 56 bytes

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

Pruébalo en línea

JavaScript (ES6), 64 bytes

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

Asume ambos sy lson matrices de objetos. Utiliza la igualdad estricta de JavaScript para las comparaciones, por lo que, por ejemplo, [] === []es falso.

Haskell , 37 34 bytes

Gracias a @Laikoni por reducir tres bytes.

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

Llame con (set::[a]) # (list::[a])donde ase deriva cualquier tipo Eq.

CJam , 11 bytes

q~f{\e=}:e<

Pruébalo en línea!

Explicación

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]&

Función pura que toma dos listas como argumentos en el orden sugerido y devuelve un entero no negativo. Tallycuenta cuántas ocurrencias de cada símbolo ocurren en la lista de entrada y #/.Rule@@@convierte cada elemento del conjunto de entrada en el número correspondiente de ocurrencias.

T-SQL, 62 59 bytes

La versión anterior no funcionaba para sets sin coincidencias

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

Con s y l como tablas y columnas con el mismo nombre que la tabla

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 bytes

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

explicación:

s.map{} pasa por cada palabra en sy producirá una serie de recuentos

w in nombra la palabra asignada para usar en el siguiente filtro

l.filter{} aplica un filtro a la matriz l

$0==w es la condición de filtro que coincide con la palabra w

.count da el número de elementos de l que cumplen la condición

.min() devuelve el recuento más bajo en el resultado asignado

APL (Dyalog) , 9 bytes

⌊/+/⎕∘.≡⎕

Pruébalo en línea!

⎕ obtener entrada evaluada (lista de cadenas)

⎕∘.≡ obtener una entrada evaluada (conjunto de cadenas no vacío) y crear una tabla de equivalencia

+/ agregar a través

⌊/ mínimo a través

Perl 6 ,  37  18 bytes

37

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

Intentalo

Expandido:

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

Ver Conjuntos, Bolsas y Mezclas para más información.

18 años

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

Intentalo

Explicación:

@^b.Bagcree una bolsa a partir de la
{@^a}clave de valores en esa bolsa (devuelve una lista de recuentos)
.minobtenga el valor mínimo de la lista resultante

Axioma, 42 bytes

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

código de prueba y resultados

(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

¡Gracias a @Quentin por guardar dos 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;}}

Pruébalo en línea!

PHP, 74 bytes

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

Casos de prueba

PHP, 108 bytes

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

Casos de prueba

Pyth, 5 bytes

hS/LF

Toma la lista primero y el segundo set. Banco de pruebas.

Explicación:

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

ny hson string[]y la salida es un int.

Pruébalo en línea!

Esta respuesta está inspirada en la lógica de @ovs y @Alberto Rivera. ¡Gracias!

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

Este es mi primer código de desafío y respuesta de golf, así que no estoy seguro sobre el formato. ¿Tiene que ser un programa completo de compilación? ¿Necesito definir los parámetros? Sugerencias apreciadas.

EDITAR : código envuelto en una función. Gracias @Steadybox

05AB1E , 7 bytes

v²y¢})W

Pruébalo en línea!

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 próximamente

Explicación

• crea la variable local m.

• asigna el conjunto a una secuencia.

• para cada elemento, si el número de ocurrencias del elemento en la lista es menor que m, m se establece en ese valor.

• devuelve m, que es el número de versiones completas del conjunto

R 54 bytes

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

Explicación: crear una tabla de los recuentos de solo los valores de la lista que también aparecen en la sublista.

Luego convierto la variable en un factor para generar ceros si un valor que aparece en la sublista no aparece en la lista. Finalmente, tomo el mínimo de los recuentos.

R, 61 57 44 bytes

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

Función anónima. Aparentemente no tienes que definir una función para este desafío. Guardado 13 bytes gracias a contar.

Explicación:

sum(l%in%x))devuelve el número de veces que se encuentra una cadena sen l.

lapply(s,function(x)) aplica eso a cada cadena en s separado y devuelve una lista de sumas.

min() devuelve el más pequeño de esa lista.

JavaScript (ES6), 59 bytes

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

Intentalo

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