Sebuah pangram adalah string yang berisi setiap surat a- zdari bahasa Inggris alfabet, kasus-sensitif. (Tidak apa-apa jika pangram berisi lebih dari satu salinan surat, atau jika berisi karakter bukan huruf di samping surat-surat itu.)

Tulis program atau fungsi yang inputnya adalah daftar string, dan yang menghasilkan satu atau lebih string yang memiliki properti berikut:

• Setiap string keluaran harus berupa pangram.
• Setiap string output harus dibentuk dengan menggabungkan satu atau lebih string dari daftar input, dipisahkan oleh spasi.
• Setiap string keluaran harus yang terpendek, atau diikat untuk yang terpendek, di antara semua string dengan properti ini.

Banyak program akan memilih untuk hanya menghasilkan satu string; Anda hanya ingin menghasilkan lebih dari satu string jika Anda harus menulis kode tambahan untuk membatasi output.

Anda dapat berasumsi bahwa input tidak mengandung karakter atau spasi yang tidak dapat dicetak, dan tidak ada kata di dalamnya yang lebih dari (26 kali logaritma natural dari panjang daftar) karakter. (Namun, Anda tidak boleh berasumsi bahwa input hanya berisi huruf, atau hanya huruf kecil; tanda baca dan huruf besar sepenuhnya mungkin.)

Input dan output dapat diberikan dalam format apa pun yang masuk akal. Untuk menguji program Anda, saya sarankan menggunakan dua test case: kamus kata-kata bahasa Inggris (kebanyakan komputer memiliki satu), dan case berikut (yang pangram sempurna (26 huruf) tidak mungkin, jadi Anda harus menemukan satu berisi surat rangkap):

abcdefghi
defghijkl
ijklmnop
lmnopqrs
opqrstuvw
rstuvwxyz

Anda harus menyertakan sampel hasil program Anda bersama dengan kiriman Anda. (Ini mungkin berbeda untuk orang yang berbeda karena menggunakan daftar kata yang berbeda.)

Kondisi kemenangan

Ini adalah tantangan kode-golf dengan kompleksitas terbatas . Pemenangnya adalah program terpendek (dalam byte) yang berjalan dalam waktu polinomial . (Rangkuman untuk orang-orang yang tidak tahu apa artinya: jika Anda menggandakan ukuran daftar kata, program harus menjadi lebih lambat tidak lebih dari faktor konstan. Namun, faktor konstan yang dipermasalahkan bisa sebesar Anda. seperti. Misalnya, itu berlaku untuk menjadi empat kali lebih lambat, atau delapan kali lebih lambat, tetapi tidak untuk itu menjadi lebih kecil oleh faktor panjangnya daftar kata; faktor melalui mana ia menjadi lebih lambat harus dibatasi.)

Ruby 159 (berulang-ulang)

Rubi 227 220 229 227 221 (rekursif)

Solusi iteratif baru (berdasarkan algoritma yang dijelaskan oleh @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

Solusi rekursif lama:

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

Pengukuran byte didasarkan pada meninggalkan baris baru terakhir dalam file, yang tidak masalah ruby 2.3.1p112. Hitungan byte naik kembali setelah memperbaiki bug kecil (menambahkan.downcase .upcase untuk case-insensitivity seperti yang dipersyaratkan oleh pernyataan masalah).

Ini adalah versi sebelumnya dari sebelum memperpendek pengidentifikasi dan semacamnya:

#!/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]);

Bagaimana cara kerjanya? Itu pada dasarnya mempertahankan satu set karakter masih untuk menutupi dan hanya berulang pada kata jika itu akan mengurangi set terbuka. Selain itu, hasil rekursi juga dicatat. Setiap subset dari 2 ^ 26 sesuai dengan entri tabel memoisasi. Setiap entri tersebut dihitung dalam waktu sebanding dengan ukuran file input. Jadi semuanya O(N)(di mana Nukuran file input), meskipun dengan konstanta besar.

JavaScript (ES6), 249 248 byte, mungkin bersaing

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]

Penjelasan: Mengubah array dengan mengubah huruf menjadi bitmask, menyimpan hanya kata terpendek untuk setiap bitmask di peta. Kemudian beralih di atas salinan peta, tambahkan peta dengan menambahkan setiap bitmask gabungan jika string yang dihasilkan akan lebih pendek. Akhirnya kembalikan string yang disimpan untuk bitmap yang sesuai dengan pangram. (Kembali undefinedjika tidak ada string seperti itu.)

Python 3, 98 , 94 , 92 byte

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

Iterasi melalui representasi ASCII dari alfabet dan tambahkan 1 ke daftar jika huruf ditemukan dalam string. Jika jumlah daftar lebih besar dari 25, itu berisi semua huruf alfabet dan akan dicetak.