สามแถวของคีย์บอร์ดที่มีqwertyuiop, และasdfghjkl zxcvbnmงานของคุณคือค้นหาคำที่ยาวที่สุดที่สามารถพิมพ์ได้โดยใช้เพียงแถวเดียวของแป้นพิมพ์จากรายการคำที่กำหนด

ตัวอย่างอินพุต 1

artist
home
gas
writer
geology
marine
twerp

เอาท์พุต

writer

(จากคำที่กำหนดเท่านั้นgas, writerและtwerpสามารถเขียนได้โดยใช้แถวเดียวและwriterเป็นที่ยาวที่สุด)

คำอาจไม่เป็นคำที่แท้จริง (ดังนั้นอย่าถือว่าแถวที่สามไม่ถูกต้อง) อย่างไรก็ตามคุณสามารถสันนิษฐานได้ว่าจะมีคำตอบเดียวเสมอ (ไม่มากไม่น้อย)

ตัวอย่างอินพุต 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

เอาท์พุต

bxnzmmx

เครื่องหมายวรรคตอนและช่องว่างเพิ่มเติมสามารถระบุได้ในอินพุต (ตามข้อกำหนดภาษา) อย่างไรก็ตามไม่ควรให้เอาต์พุตพิเศษ อินพุตและเอาต์พุตเป็นตัวพิมพ์เล็ก รหัสที่สั้นที่สุดชนะ

Python 2, 84 ไบต์

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

ค้นหาmaxอินพุตจากการเปรียบเทียบด้วยแถวแป้นพิมพ์ที่น้อยลงที่ขยายออกไปจากนั้นเพิ่มความยาว ค่าของแถวคีย์บอร์ดถูกแยกโดย"asdfghjklzxcvbnm".find(c)/9ซึ่งจะนำแถวกลางไป0ที่แถวด้านล่าง1และแถวบนสุดซึ่งไม่รวมอยู่ใน-1เนื่องจากfindจะให้-1ค่าที่ขาดหายไป

ความพยายามอื่น ๆ :

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 32ไบต์

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

ทดสอบออนไลน์! อินพุตเป็นอาร์เรย์ของสตริง

มันทำงานอย่างไร

;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+ และ 3, 93 bytes

ต้องทดสอบจำนวนสโตรกสำหรับวิธีนี้ สิ่งนี้ใช้ความจริงที่ว่าa.strip(b)ผลลัพธ์ในสตริงว่างเปล่าหากaประกอบด้วยตัวอักษรที่เกิดขึ้นใน

ฟังก์ชันรับรายการสตริงและส่งคืนสตริง

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

เรติน่า 73 ไบต์

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

ลองออนไลน์!

สรุป: จอประสาทตาต้องมีขั้นตอนการเรียงลำดับ

คำอธิบาย

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

นี่คือระยะ grep: มันเก็บเฉพาะเส้นที่จับคู่โดย regex นั่นคือสิ่งที่เกิดขึ้นจากคลาสตัวละครเหล่านั้นเท่านั้น

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

ตอนนี้เราเพียงแค่ต้องค้นหาสตริงที่ใหญ่ที่สุดที่เหลืออยู่ เราทำสิ่งนี้โดยการจับคู่คำทั้งหมดที่อย่างน้อยก็ยาวกว่าคำทั้งหมดหลังจากนั้น นี่1เป็นส่วนเพิ่มเติมใหม่สำหรับ Retina (เปิดตัวสองวันที่ผ่านมา) ซึ่ง จำกัด ระยะการแข่งขันนี้เพื่อพิจารณาเฉพาะการแข่งขันครั้งแรกเท่านั้น และ!สั่งให้ Retina พิมพ์การจับคู่ (แทนที่จะนับ)

Java, 154 142 หรือ142 130 ไบต์

เพราะคุณรู้ชวา

C # สำหรับการเปรียบเทียบสำหรับการเปรียบเทียบ

146 ไบต์ถ้าอินพุตต้องเป็นสตริงเดี่ยวที่มีค่าคั่นด้วย\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 ไบต์ถ้าฉันสามารถสมมติว่าอินพุตเป็นสตริง [] แทน:

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

ungolfed เล็กน้อย:

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

Function<String[],String>แลมบ์ดาที่สองคือ

เยลลี่40 34 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

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

บันทึก 5 ไบต์ขอบคุณเควิน
บันทึกแล้ว 3 ไบต์ขอบคุณ PM 2Ring
บันทึกแล้ว 3 ไบต์ขอบคุณ Antti Haapala

เดรัจฉานบังคับให้มันในขณะนี้ ฉันกรองคำให้เหลือเพียงคำที่มีอยู่ในแถวเดียวแล้วเรียงลำดับความยาวสตริงสูงสุด

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

กรณีทดสอบ:

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 ไบต์

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

รับอินพุตผ่านอาร์กิวเมนต์บรรทัดคำสั่งเป็น$argsจากนั้นใช้-matchโอเปอเรเตอร์ที่มี regex เพื่อเลือกเฉพาะคำที่ประกอบขึ้นเป็นหนึ่งแถวคีย์บอร์ดโดยเฉพาะ เราท่อผลเหล่านั้นเป็นประเภทที่ว่าด้วยทรัพย์สินSort-Object Lengthเราสามารถทำสิ่งนี้ได้เนื่องจากสตริงใน PowerShell เป็นSystem.Stringประเภททั้งหมดซึ่งรวมถึง.Lengthคุณสมบัติที่สามารถเรียงลำดับได้ นี่จะเรียงสตริงเป็นลำดับขึ้นตามความยาวดังนั้นเราจึงนำสตริงสุดท้ายมาด้วย[-1]ไปไว้กับไปป์ไลน์และเอาท์พุทก็เป็นนัย

ตัวอย่าง

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

Pyth, 45 35 ไบต์

ขอบคุณ @FryAmThe ​​Eggman ที่ช่วยฉันได้ไบต์!

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

ลองที่นี่!

รับอินพุตเป็นรายการของคำ

คำอธิบาย

elDf} k-LTc. "... " \ `Q # Q = รายการคำที่ป้อนทั้งหมด

   f Q # กรองอินพุตด้วย T เป็นตัวแปรแลมบ์ดา
         c. "... " \ `# รายการแถวแป้นพิมพ์ทั้งหมด
      -LT # ลบตัวอักษรทั้งหมดของแถวอินพุตปัจจุบันออกจากอินพุตปัจจุบัน
                      # คำ ส่งผลให้รายการ 3 สตริงโดยหนึ่งจะว่างเปล่าถ้า
                      # คำสามารถพิมพ์ด้วยหนึ่งแถว
    } k # ตรวจสอบว่ารายการมีสตริง emtpy หรือไม่
elD # รายการผลการสั่งซื้อตามความยาวและใช้ล่าสุด

ทับทิม, 88 82 69

หากฉันไม่ได้รับอนุญาตให้รับรายการสตริงและต้องใช้สตริงหลายบรรทัดให้เพิ่ม +12 ไปยังคะแนนและเพิ่ม.split('\n')สิทธิ์ก่อนการ.grepโทร

ขอบคุณ CatsAreFluffy ที่สอนฉันเกี่ยวกับ stambby lambdas ใน Ruby และการเพิ่มประสิทธิภาพเพิ่มเติมจาก manatwork

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

C #, 141/112 / (120 ไบต์)

ภาษาคู่แข่งที่เลวร้ายที่สุดสำหรับเหตุผลที่ชัดเจน ใช้โลแคล "my" กับ qwertz แทนที่จะเป็น qwerty แต่ใช้งานได้ดี

โปรแกรมเต็มรูปแบบโดยไม่ต้องที่ไหน:

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

เอาต์พุตเท่านั้นโดยไม่มีที่ไหน:

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

เอาต์พุตเท่านั้น (ดั้งเดิม):

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

bash, 105 ไบต์

และสาธารณูปโภคอื่น ๆ อีกมากมายแน่นอน

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

awk, 92 84 81 ไบต์

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

บันทึก 3 ไบต์ด้วยคำแนะนำ @Wolfgang

MATL , 54 ไบต์

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

ใช้ได้กับภาษา / คอมไพเลอร์รุ่นปัจจุบัน (14.0.0)

รูปแบบอินพุตคือ (ตัวอย่างแรก)

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

หรือ (ตัวอย่างที่สอง)

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

ลองออนไลน์!

คำอธิบาย

[]               % 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 ไบต์

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

สัญลักษณ์ถึงตัวอักษรนับค่อนข้างสูง

Groovy, 65 ตัวอักษร

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

วิ่งตัวอย่าง:

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

โปรดทราบว่าการแสดงออกปกติที่ใช้โดย.grep()ไม่ต้องมีการยึดเพื่อให้สามารถสำรองการจัดกลุ่มได้เช่นกัน:

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