Un pangrama es una cadena que contiene todas las cartas a- zdel alfabeto Inglés, entre mayúsculas y minúsculas. (Está bien si el pangrama contiene más de una copia de una letra, o si contiene caracteres que no son letras además de las letras).

Escriba un programa o función cuya entrada sea una lista de cadenas y que genere una o más cadenas que tengan las siguientes propiedades:

• Cada cadena de salida debe ser un pangrama.
• Cada cadena de salida debe formarse concatenando una o más cadenas de la lista de entrada, separadas por espacios.
• Cada cadena de salida debe ser la más corta, o estar vinculada por la más corta, entre todas las cadenas con estas propiedades.

Muchos programas elegirán generar solo una cadena; solo querría generar más de una cadena si de lo contrario tendría que escribir código adicional para limitar la salida.

Puede suponer que la entrada no contiene caracteres o espacios no imprimibles, y que ninguna palabra contiene más de (26 veces el logaritmo natural de la longitud de la lista) caracteres. (Sin embargo, no puede suponer que la entrada contiene nada más que letras, o solo letras minúsculas; los signos de puntuación y las letras mayúsculas son totalmente posibles).

La entrada y salida se pueden dar en cualquier formato razonable. Para probar su programa, le recomiendo usar dos casos de prueba: un diccionario de palabras en inglés (la mayoría de las computadoras tienen uno) y el siguiente caso (para el cual es imposible un pangrama perfecto (26 letras), por lo que tendría que encontrar uno que contiene letras duplicadas):

abcdefghi
defghijkl
ijklmnop
lmnopqrs
opqrstuvw
rstuvwxyz

Debe incluir una muestra de la salida de su programa junto con su envío. (Esto puede ser diferente para diferentes personas como resultado del uso de diferentes listas de palabras).

Condición de victoria

Este es un desafío de código restringido de golf complejo . El ganador es el programa más corto (en bytes) que se ejecuta en tiempo polinómico . (Un resumen para las personas que no saben lo que eso significa: si duplica el tamaño de la lista de palabras, el programa no debería ser más lento que un factor constante. Sin embargo, el factor constante en cuestión puede ser tan grande como usted). Por ejemplo, es válido para que sea cuatro veces más lento u ocho veces más lento, pero no para que se reduzca en un factor de la longitud de la lista de palabras; el factor a través del cual se vuelve más lento debe estar limitado).

Ruby 159 (iterativo)

Rubí 227 220 229 227 221 (recursivo)

Nueva solución iterativa (basada en el algoritmo descrito por @Niel):

c={('A'..'Z').to_a=>""}
while l=gets
d=c.clone
c.map{|k,v|j=k-l.upcase.chars
w=v+" "+l.strip
d[j]=w if !c[j]||c[j].size<w.size}
c=d
end
x=c[[]]
p x[1..-1] if x

Antigua solución recursiva:

W=[]
while l=gets
W<<l.strip
end
I=W.join(" ")+"!!"
C={[]=>""}
def o(r)if C[r]
C[r]
else
b=I
W.map{|x|s=r-x.upcase.chars
if s!=r
c=x+" "+o(s)
b=c if c.size<b.size
end}
C[r]=b
end
end
r=o ('A'..'Z').to_a
p r[0..-2] if r!=I

La medición de bytes se basa en dejar la nueva línea final en el archivo, lo que no importa ruby 2.3.1p112. El recuento de bytes volvió a subir después de corregir un pequeño error (agregando.downcase .upcase para la insensibilidad a mayúsculas y minúsculas como lo requiere la declaración del problema

Aquí hay una versión anterior de antes de acortar los identificadores y tal:

#!/usr/bin/env ruby

$words = [];

while (line=gets)
  $words << line[0..-2];
end

$impossible = $words.join(" ")+"!!";

$cache = {};

def optimize(remaining)
  return $cache[remaining] if ($cache[remaining]);
  return "" if (remaining == []);

  best = $impossible;

  $words.each{|word|
    remaining2 = remaining - word.chars;
    if (remaining2 != remaining)
      curr = word + " " + optimize(remaining2);
      best = curr if (curr.length < best.length);
    end
  };

  $stderr.puts("optimize(#{remaining.inspect})=#{best.inspect}");

  return $cache[remaining] = best;
end

result = optimize(('a'..'z').to_a);

puts(result[0..-1]);

¿Como funciona? Básicamente mantiene un conjunto de caracteres aún por cubrir y solo se repite en una palabra si reduciría el conjunto descubierto. Además, los resultados de la recursividad se memorizan. Cada subconjunto de 2 ^ 26 corresponde a una entrada de la tabla de memorización. Cada una de estas entradas se calcula en tiempo proporcional al tamaño del archivo de entrada. Entonces, todo el asunto es O(N)(¿dónde Nestá el tamaño del archivo de entrada), aunque con una gran constante.

JavaScript (ES6), 249 248 bytes, posiblemente compitiendo

a=>a.map(w=>w.replace(/[a-z]/gi,c=>b|=1<<parseInt(c,36)-9,b=0,l=w.length)&&(m.get(b)||[])[0]<l||m.set(b,[l,w]),m=new Map)&&[...m].map(([b,[l,w]])=>m.forEach(([t,s],e)=>(m.get(e|=b)||[])[0]<=t+l||m.set(e,[t+l+1,s+' '+w])))&&(m.get(-2^-1<<27)||[])[1]

Explicación: Transforma la matriz al convertir las letras en una máscara de bits, guardando solo la palabra más corta para cada máscara de bits en un mapa. Luego, iterando sobre una copia del mapa, aumente el mapa agregando cada máscara de bits combinada si la cadena resultante sería más corta. Finalmente, devuelva la cadena guardada para el mapa de bits correspondiente a un pangrama. (Devuelve undefinedsi no existe tal cadena).

Python 3, 98 , 94 , 92 bytes

print([s for s in input().split()if sum([1 for c in range(65,91)if chr(c)in s.upper()])>25])

Itera a través de la representación ASCII del alfabeto y agrega un 1 a una lista si la letra se encuentra en la cadena. Si la suma de la lista es mayor que 25, contiene todas las letras del alfabeto y se imprimirá.