Tiga baris keyboard qwerty adalah qwertyuiop, asdfghjkldan zxcvbnm. Tugas Anda adalah menemukan kata terpanjang yang dapat diketik hanya menggunakan satu baris keyboard, dari daftar kata yang diberikan.

Masukan sampel 1

artist
home
gas
writer
geology
marine
twerp

Keluaran

writer

(Dari kata-kata yang diberikan, hanya gas, writerdan twerpdapat ditulis menggunakan satu baris, dan writeryang terpanjang)

Kata-kata itu mungkin bukan kata-kata aktual (jadi jangan menganggap baris ketiga tidak valid). Namun, Anda dapat mengasumsikan bahwa akan selalu ada satu jawaban (tidak lebih, tidak kurang).

Masukan sampel 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Keluaran

bxnzmmx

Tanda baca dan spasi putih tambahan dapat diberikan dalam input (sesuai persyaratan bahasa). Namun, tidak ada output tambahan yang harus diberikan. Input dan output dalam huruf kecil. Kode terpendek menang.

Python 2, 84 byte

lambda l:max(l,key=lambda w:(-len({"asdfghjklzxcvbnm".find(c)/9for c in w}),len(w)))

Menemukan maxinput, membandingkan dengan lebih sedikit baris keyboard yang terbentang, kemudian bertambah panjang. Nilai baris keyboard diekstraksi oleh "asdfghjklzxcvbnm".find(c)/9, yang membawa baris tengah ke 0, baris bawah ke 1, dan baris atas, yang dikecualikan, untuk -1, karena findmemberikan -1nilai yang hilang.

Upaya lain:

lambda l:max((-len({"asdfghjklzxcvbnm".find(c)/9for c in w}),len(w),w)for w in l)[2]
lambda l:max(l,key=lambda w:len(w)-1./len({"asdfghjklzxcvbnm".find(c)/9for c in w}))
lambda l:max([w for w in l if len({"asdfghjklzxcvbnm".find(c)/9for c in w})<2],key=len)

Japt, 32 30 byte

;Uf_¬£DbXu)f10Ãä¥ eÃn@Yl -XlÃg

Uji secara online! Input adalah larik string.

Bagaimana itu bekerja

;Uf_  ¬ £  DbXu)f10Ã ä¥  eà n@  Yl -Xlà g
;UfZ{Zq mX{DbXu)f10} ä== e} nXY{Yl -Xl} g

         // Implicit: U = input array of strings
;        // Reset variables A-L to various values.
         // D is set to the string "QWERTYUIOP\nASDFGHJKL\nZXCVBNM".
UfZ{   } // Take U and filter to only the items Z that return truthily to this function:
Zq       //  Split Z into chars, then
mX{    } //  map each char X by this function:
DbXu)    //   Return D.indexOf(X.toUpperCase()),
f10      //   floored to a multiple of 10.
         //  This maps each char to 0 for the top row, 10 for the middle, 20 for the bottom.
q ä==    //  Split the resulting string into chars and check each pair for equality.
e        //  Check that every item in the result is truthy. This returns true if all chars
         //  are on the same row; false otherwise.
         // Now we have only the words that are entirely on one row.
nXY{   } // Sort by passing each two args X and Y into this function:
Yl -Xl   //  Return Y.length - X.length. Sorts the longest to the front.
g        // Get the first item in the resulting array. Implicitly output.

Python 2.5+ dan 3, 93 byte

Harus menguji berapa pukulan untuk pendekatan ini; ini menggunakan fakta yang a.strip(b)menghasilkan string kosong jika ahanya terdiri dari karakter yang terjadi pada b.

Fungsi mengambil daftar string dan mengembalikan string.

lambda a:max(a,key=lambda x:(~all(map(x.strip,['qwertyuiop','asdfghjkl','zxcvbnm'])),len(x)))

Retina , 73 byte

G`^([eio-rtuwy]+|[adfghjkls]+|[bcmnvxz]+)$
1!`(.)+(?!\D+(?<-1>.)+(?(1)!))

Cobalah online!

Kesimpulan: Retina membutuhkan tahap penyortiran.

Penjelasan

G`^([eio-rtuwy]+|[adfghjkls]+|[bcmnvxz]+)$

Ini adalah tahap grep: ia hanya menyimpan garis yang cocok dengan regex. Yaitu mereka yang dibentuk secara eksklusif dari salah satu kelas karakter tersebut.

1!`(.)+(?!\D+(?<-1>.)+(?(1)!))

Sekarang kita hanya perlu menemukan yang terbesar dari string yang tersisa. Kami melakukan ini dengan mencocokkan semua kata yang setidaknya sepanjang dari semua kata setelahnya. Ini 1adalah tambahan baru untuk Retina (dirilis dua hari lalu), yang membatasi tahap pertandingan ini hanya untuk mempertimbangkan pertandingan pertama yang seperti itu. Dan !menginstruksikan Retina untuk mencetak pertandingan (bukannya menghitungnya).

Java, 154 142 atau 142 130 byte

Karena, Anda tahu, Jawa.

C #, untuk perbandingan .

146 byte jika input harus berupa string tunggal dengan nilai yang dipisahkan oleh \n:

s->java.util.Arrays.stream(s.split("\n")).filter(g->g.matches("[wetyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()

134 byte jika saya dapat menganggap input sebagai String [] sebagai gantinya:

s->java.util.Arrays.stream(s).filter(g->g.matches("[wetyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()

Sedikit tidak berbulu:

UnaryOperator<String> longestQwertyStr = s -> 
        java.util.Arrays.stream(s.split("\n")) // Split string input over `\n` and convert to Stream<String>
                .filter(g->g.matches("[wetyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")) // Filter to Strings that only use characters from a single row
                .max((a,b)->a.length()-b.length()) // Find the max by comparing String length
                .get(); // Convert from Optional<String> to String and implicit return single statement lambda

Lambda kedua adalah a Function<String[],String>.

Jelly, 40 34 byte

p“£vẈ¬ḣ“£AS°GƤg“£ḷḳƤ²ƤȤḤ»f/€fµL€Mị

Cobalah online!

Bagaimana itu bekerja

p“£vẈ¬ḣ“£AS°GƤg“£ḷḳƤ²ƤȤḤ»f/€fµL€Mị

 “£vẈ¬ḣ“£AS°GƤg“£ḷḳƤ²ƤȤḤ»           Use dictionary compression to yield
                                    ['quipo twyer', 'adj flash jg', 'bcmnz xv'].
p                                   Cartesian product; for all pairs of an input
                                    string and one of the rows.
                         f/€        Reduce each pair by filter, keeping only the
                                    letters in the input string that are on that
                                    particular keyboard row.
                            f       Filter the results, keeping only filtered words
                                    that occur in the input.
                             µ      Begin a new chain.
                              L€    Get the length of each kept word.
                                M   Get the index corr. to the greatest length.
                                 ị  Retrieve the word at that index.

Python 3, 98

Disimpan 5 byte berkat Kevin.
Disimpan 3 byte berkat PM 2Ring.
Disimpan 3 byte berkat Antti Haapala.

Brute memaksanya saat ini. Saya memfilter kata-kata ke hanya yang terkandung oleh satu baris, dan kemudian mengurutkan untuk panjang string maksimal.

lambda a:max(a,key=lambda x:(any(map(set(x).__le__,['qwertyuiop','asdfghjkl','zxcvbnm'])),len(x)))

Kasus uji:

assert f(['asdf', 'qwe', 'qaz']) == 'asdf'
assert f('''artist
home
gas
writer
geology
marine
twerp'''.splitlines()) == 'writer'
assert f('''wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt'''.splitlines()) == 'bxnzmmx'

PowerShell v2 +, 72 byte

($args-match"^([qwertyuiop]+|[asdfghjkl]+|[zxcvbnm]+)$"|sort Length)[-1]

Mengambil input melalui argumen baris perintah $args, lalu menggunakan -matchoperator dengan regex untuk memilih hanya kata-kata yang secara eksklusif dibuat dari satu baris keyboard. Kami menyalurkan hasil tersebut ke Sort-Objectproperti tersebut Length. Kita bisa melakukan ini karena string di PowerShell adalah semua System.Stringtipe, yang termasuk .Lengthsebagai properti yang dapat diurutkan. Ini memilah string menjadi urutan naik dengan panjang, jadi kami mengambil yang terakhir [-1], meninggalkannya di pipa, dan output tersirat.

Contoh

PS C:\Tools\Scripts\golfing> .\longest-word-qwerty-keyboard.ps1 asdf qwe zxc typewriter halls establishment
typewriter

Pyth, 45 35 byte

Terima kasih kepada @FryAmThe ​​Eggman karena telah menyelamatkan saya beberapa byte!

elDf}k-LTc."`z:I¿Ç  Ì(T4²ª$8·"\`Q

Coba di sini!

Mengambil input sebagai daftar kata.

Penjelasan

elDf} k-LTc. "..." \ `Q # Q = daftar semua kata input

   f Q # Memfilter input dengan T sebagai variabel lambda
         c. "..." \ `# Daftar semua baris keyboard
      -LT # Hapus semua huruf dari baris input saat ini dari input saat ini
                      # kata. Menghasilkan daftar 3 string dengan satu kosong jika
                      # kata tersebut dapat diketik dengan satu baris
    } k # Periksa apakah daftar berisi string emtpy
# hasil urutan panjang dan ambil yang terakhir

Ruby, 88 82 69

Jika saya tidak diizinkan untuk mengambil daftar string dan harus mengambil string multiline, tambahkan +12 ke skor dan tambahkan .split('\n')tepat sebelum .greppanggilan.

Terima kasih CatsAreFluffy untuk mengajari saya tentang lambdas yang stabby di Ruby, dan optimisasi lebih lanjut dari manatwork

->x{x.grep(/^([o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+)$/).max_by &:size}

C #, 141/112 / (120 byte)

Pesaing untuk bahasa golf terburuk, untuk alasan yang jelas. Menggunakan lokal "saya" dengan qwertz alih-alih qwerty tetapi berfungsi dengan baik jika tidak.

Program lengkap tanpa tempat:

static void Main(string[]a){Console.WriteLine(a.OrderBy(x=>x.Length).Last(x=>Regex.IsMatch(x,"^([qwertzuiop]+|[asdfghjkl]+|[yxcvbnm]+)$")));}

Hanya keluaran tanpa Tempat:

Console.WriteLine(a.OrderBy(x=>x.Length).Last(x=>Regex.IsMatch(x,"^([qwertzuiop]+|[asdfghjkl]+|[yxcvbnm]+)$")));

Hanya keluaran (asli):

Console.WriteLine(a.Where(x=>Regex.IsMatch(x,"^([qwertzuiop]+|[asdfghjkl]+|[yxcvbnm]+)$")).OrderBy(x=>x.Length).Last());

bash, 105 byte

Dan berbagai utilitas lainnya, tentu saja.

egrep -x '[wetyuio-r]+|[asdfghjkl]+|[zxcvbnm]+'|awk '{print length($0)"\t"$0;}'|sort -n|cut -f2|tail -n1

awk, 92 84 81 byte

(/^([wetyuio-r]+|[asdfghjkl]+|[zxcvbnm]+)$/)&&length>length(a){a=$0}END{print a}  

disimpan 3 byte berkat saran @ Wolfgang

MATL , 54 byte

[]y"@Y:nh]2$SP"@Y:!t'asdfghjkl'mw'zxcvbnm'myy+~hhAa?@.

Ini bekerja dengan versi saat ini (14.0.0) dari bahasa / kompiler.

Format input adalah (contoh pertama)

{'artist' 'home' 'gas' 'writer' 'geology' 'marine' 'twerp'}

atau (contoh kedua)

{'wrhuji' 'bxnzmmx' 'gllwssjjd' 'vnccbb' 'lrkjhgfdsa' 'tttttt'}

Cobalah online!

Penjelasan

[]               % push empty array. Will be used for concatenation
y                % take input array implicitly at bottom of stack, and copy onto top
"                % for each string
  @Y:            %   push current string
  nh             %   get its length. Concatenate with array of previous lengths
]                % end for each
2$S              % sort the original copy of input array by increasing string length
P                % flip: sort by decreasing length
"                % for each string in decreasing order of length
  @Y:!           %   push that string as a column char vector
  t'asdfghjkl'm  %   duplicate. Tru for chars in 2nd row of keyboard
  w'zxcvbnm'm    %   swap. True for chars in 3rd row of keyboard
  yy+~           %   duplicate top two arrays, sum, negate: true for chars in 1st row
  hh             %   concatenate horizontally twice
  Aa             %   true if any column has all true values
  ?              %   if that's the case
    @            %     push string  
    .            %     break for each loop
                 %   end if implicitly
                 % end for each
                 % display implicitly

Perl, 81 byte

$a=$1 if/^([wetyuio-r]+|[asdfghjkl]+|[zxcvbnm]+)$/&&1<<y///c>$a=~y///c;END{say$a}

Simbol untuk menghitung huruf cukup tinggi.

Groovy, 65 karakter

{it.grep(~/[o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+/).max{it.size()}}

Contoh dijalankan:

groovy:000> ({it.grep(~/[o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+/).max{it.size()}})(['wrhuji', 'bxnzmmx', 'gllwssjjd', 'vnccbb', 'lrkjhgfdsa', 'tttttt'])
===> bxnzmmx

Perhatikan bahwa ekspresi reguler yang digunakan oleh .grep()tidak memerlukan penahan, memungkinkan untuk mengesampingkan pengelompokan juga:

groovy:000> ['ab', 'ac', 'bc', 'abc', 'aca', 'bbc'].grep ~/[ac]+|b+/
===> [ac, aca]