Ba hàng của bàn phím qwerty là qwertyuiop, asdfghjklvà zxcvbnm. Nhiệm vụ của bạn là tìm ra từ dài nhất có thể được gõ chỉ bằng một hàng bàn phím, từ một danh sách các từ đã cho.

Mẫu đầu vào 1

artist
home
gas
writer
geology
marine
twerp

Đầu ra

writer

(Trong số các từ được, chỉ gas, writervà twerpcó thể được viết bằng một hàng duy nhất, và writerlà dài nhất)

Các từ có thể không phải là từ thực tế (vì vậy đừng cho rằng hàng thứ ba không hợp lệ). Tuy nhiên, bạn có thể cho rằng sẽ luôn có chính xác một câu trả lời (không hơn, không kém).

Mẫu đầu vào 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Đầu ra

bxnzmmx

Dấu câu và khoảng trắng bổ sung có thể được cung cấp trong đầu vào (theo yêu cầu ngôn ngữ). Tuy nhiên, không nên đưa ra đầu ra thêm. Đầu vào và đầu ra là trong trường hợp thấp hơn. Mã ngắn nhất sẽ thắng.

Python 2, 84 byte

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

Tìm maxđầu vào, so sánh bằng ít hàng bàn phím hơn, sau đó tăng chiều dài. Giá trị hàng bàn phím được trích xuất bởi "asdfghjklzxcvbnm".find(c)/9, sẽ đưa hàng giữa đến 0, hàng dưới cùng 1và hàng trên cùng, được loại trừ, do -1, findcung cấp -1cho các giá trị bị thiếu.

Những nỗ lực khác:

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

Kiểm tra nó trực tuyến! Đầu vào là một chuỗi các chuỗi.

Làm thế nào nó hoạt động

;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+ và 3, 93 byte

Phải kiểm tra có bao nhiêu nét cho phương pháp này; điều này sử dụng thực tế là a.strip(b)kết quả trong chuỗi rỗng nếu achỉ bao gồm các ký tự xảy ra trong b.

Hàm lấy danh sách các chuỗi và trả về một chuỗi.

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

Võng mạc , 73 byte

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

Hãy thử trực tuyến!

Kết luận: Retina cần một giai đoạn phân loại.

Giải trình

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

Đây là giai đoạn grep: nó chỉ giữ các dòng được khớp với biểu thức chính quy. Tức là những người được hình thành độc quyền từ một trong những lớp nhân vật đó.

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

Bây giờ chúng ta chỉ cần tìm chuỗi lớn nhất trong số các chuỗi còn lại. Chúng tôi làm điều này bằng cách kết hợp tất cả các từ ít nhất dài hơn tất cả các từ sau chúng. Đây 1là một bổ sung mới cho Retina (được phát hành hai ngày trước), điều này giới hạn giai đoạn trận đấu này chỉ xem xét trận đấu đầu tiên như vậy. Và !hướng dẫn Retina in trận đấu (thay vì đếm nó).

Java, 154 142 hoặc 142 130 byte

Bởi vì, bạn biết đấy, Java.

C #, để so sánh .

146 byte nếu đầu vào phải là một chuỗi đơn với các giá trị được phân tách bằng \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 nếu tôi có thể giả sử đầu vào là String [] thay vào đó:

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

Hơi vô dụng:

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 thứ hai là a Function<String[],String>.

Thạch, 40 34 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Trăn 3, 98

Đã lưu 5 byte nhờ Kevin.
Đã lưu 3 byte nhờ PM 2Ring.
Đã lưu 3 byte nhờ Antti Haapala.

Brute buộc nó tại thời điểm này. Tôi lọc các từ chỉ thành những từ được chứa trong một hàng và sau đó sắp xếp theo độ dài chuỗi tối đa.

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

Các trường hợp thử nghiệm:

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]

Đưa đầu vào qua các đối số dòng lệnh $args, sau đó sử dụng -matchtoán tử với biểu thức chính quy để chỉ chọn các từ được tạo thành từ một hàng bàn phím. Chúng tôi đưa những kết quả Sort-Objectđó vào loại đó theo tài sản Length. Chúng ta có thể làm điều này vì các chuỗi trong PowerShell đều thuộc System.Stringloại, bao gồm .Lengthdưới dạng một thuộc tính có thể sắp xếp. Điều này sắp xếp các chuỗi theo thứ tự tăng dần theo chiều dài, vì vậy chúng tôi lấy chuỗi cuối cùng [-1], để nó trên đường ống và đầu ra là ẩn.

Thí dụ

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

Bình thường, 45 35 byte

Cảm ơn @FryAmThe ​​Eggman đã tiết kiệm cho tôi một số byte!

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

Hãy thử nó ở đây!

Đưa đầu vào như một danh sách các từ.

Giải trình

elDf} k-LTc. "..." \ `Q # Q = danh sách tất cả các từ đầu vào

   f Q # Bộ lọc đầu vào với T là biến lambda
         c. "..." \ `# Danh sách tất cả các hàng bàn phím
      -LT # Xóa tất cả các chữ cái của hàng đầu vào hiện tại khỏi đầu vào hiện tại
                      # từ. Kết quả trong danh sách 3 chuỗi với một chuỗi trống nếu
                      # từ có thể được gõ bằng một hàng
    } k # Kiểm tra xem danh sách có chứa chuỗi emtpy không
danh sách kết quả thứ tự elD # theo độ dài và lấy cuối cùng

Ruby, 88 82 69

Nếu tôi không được phép lấy danh sách các chuỗi và phải lấy một chuỗi nhiều dòng, hãy thêm +12 vào điểm số và thêm .split('\n')ngay trước .grepcuộc gọi.

Cảm ơn MèoAreFluffy đã dạy tôi về lambdas cứng nhắc trong Ruby, và tối ưu hóa hơn nữa từ việc chế tạo

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

C #, 141/112 / (120 byte)

Đối thủ cho ngôn ngữ golf tồi tệ nhất, vì lý do rõ ràng. Sử dụng ngôn ngữ "của tôi" với qwertz thay vì qwerty nhưng hoạt động tốt.

Chương trình đầy đủ mà không cần ở đâu:

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

Chỉ xuất mà không có Trường hợp:

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

Chỉ đầu ra (bản gốc):

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

bash, 105 byte

Và nhiều tiện ích khác, tất nhiên.

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

ôi, 92 84 81 byte

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

đã lưu 3 byte nhờ đề xuất @Wolfgang

MATL , 54 byte

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

Điều này hoạt động với phiên bản hiện tại (14.0.0) của ngôn ngữ / trình biên dịch.

Định dạng đầu vào là (ví dụ đầu tiên)

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

hoặc (ví dụ thứ hai)

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

Hãy thử trực tuyến!

Giải trình

[]               % 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}

Biểu tượng để đếm chữ khá cao.

Groovy, 65 ký tự

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

Chạy mẫu:

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

Lưu ý rằng biểu thức chính quy được sử dụng bởi .grep()không yêu cầu neo, cho phép thay thế nhóm quá:

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