क्वेर्टी कीबोर्ड की एकल पंक्ति का उपयोग करते हुए सबसे लंबा शब्द

Question

क्वर्टी कीबोर्ड की तीन पंक्तियाँ हैं qwertyuiop, asdfghjklऔर zxcvbnm। आपका काम सबसे लंबे शब्द को ढूंढना है जिसे शब्दों की दी गई सूची से, कीबोर्ड की केवल एक पंक्ति का उपयोग करके टाइप किया जा सकता है।

नमूना इनपुट 1

artist
home
gas
writer
geology
marine
twerp

उत्पादन

writer

(दिए गए शब्दों में, केवल gas, writerऔर twerpएक पंक्ति का उपयोग करके लिखा जा सकता है, और writerसबसे लंबा है)

शब्द वास्तविक शब्द नहीं हो सकते हैं (इसलिए तीसरी पंक्ति को अमान्य नहीं मानें)। हालांकि, आप मान सकते हैं कि हमेशा एक ही उत्तर होगा (कोई और अधिक, कोई कम नहीं)।

नमूना इनपुट 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

उत्पादन

bxnzmmx

इनपुट में अतिरिक्त विराम चिह्न और व्हाट्सएप प्रदान किया जा सकता है (भाषा आवश्यकताओं के अनुसार)। हालांकि, कोई अतिरिक्त आउटपुट नहीं दिया जाना चाहिए। इनपुट और आउटपुट कम मामले में हैं। सबसे छोटा कोड जीतता है।

Comments

@ मार्टिनबटनर मैं वास्तव में यह देखना चाहूंगा कि यह रेटिना के साथ कैसे हल किया जा सकता है। क्या आपको लगता है कि यह आसानी से हो गया है?

— जेरी जेरेमिया

क्या इनपुट शब्द हमेशा लोअरकेस में होते हैं?

— नीमी

@ निम्मी हां, वे हैं।

— घोस्ट_इन_थे_कोड

@ghosts_in_the_code आपको स्पष्टता के लिए चुनौती में यह बताना चाहिए कि

— लुइस मेंडो

प्रासंगिक xkcd: what-if.xkcd.com/75

— जॉन ड्वोरक

Answer 1

पायथन 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)

Comments

/पाइथन 3 के लिए 1 चरित्र अधिक;)

— एंटि हापाला

मुझे नहीं पता था कि व्याकरण के बीच कोई 9for

— व्हाट्सएप

यह अब तक मेरा पसंदीदा उत्तर है।

— SBI

@ जोगलोरन, जब तक कि सिन्थेर एक नहीं है, Eया eआप एक नंबर और एक चर नाम / कीवर्ड के बीच

— wnnmaw

@wnnmaw यह पायथन के नए संस्करणों के लिए अब सच नहीं है, उदाहरण के लिए २. 3.5.११ 4if 0else 2और ३.५.१ में मान्य है (और शायद पहले कुछ संस्करणों के लिए मान्य है)

— Sp3000

Answer 2

जाप, 32 30 बाइट्स

;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.

Comments

वाह, क्या आपने सिर्फ डेनिस को पछाड़ दिया?

— मॉर्गन थ्रैप

इसे हराना मुश्किल है

— अदनान

क्या आपके पास "QWERTYUIOP\nASDFGHJKL\nZXCVBNM"पूर्वनिर्धारित शाब्दिक है? अच्छी तरह से खेला :-)

— लुइस मेन्डो

मैं जहां यह कहा गया है कि खोजने के लिए नहीं कर पा रहे Dकरने के लिए सेट कर दिया जाता QWERTYUIOP\nASDFGHJKL\nZXCVBNMहै, भले पेज आप का उल्लेख राज्य रहा हैVariables <...> D 13

— sukhmel

;कार्यक्रम की शुरुआत में @sukhmel A A-Lविभिन्न मूल्यों के लिए चर को रीसेट करता है । Dकीबोर्ड स्ट्रिंग पर सेट किया गया है। आप अधिक जानकारी यहाँ पा सकते हैं ।

— ETHproductions

Answer 3

पायथन 2.5+ और 3, 93 बाइट्स

इस दृष्टिकोण के लिए कितने स्ट्रोक का परीक्षण करना था; यह इस तथ्य का उपयोग करता है कि a.strip(b)यदि रिक्त स्ट्रिंग में परिणाम हैa केवल बी में होने वाले वर्णों के होते हैं।

फ़ंक्शन स्ट्रिंग की सूची लेता है और एक स्ट्रिंग लौटाता है।

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

Comments

PPCG में आपका स्वागत है, अच्छी पहली पोस्ट :)

— FryAmTheEggman

keyचर क्यों है ? मुझे लगता है कि आप इसे हटा सकते हैं।

— कैलकुलेटरफाइनल

@CatsAreFluffy नहीं, यह संभव नहीं है। keyका तर्क maxसमारोह कीवर्ड केवल-है।

— अंती हापाला

Ack, मैं kwargs के बारे में भूल गया।

— कैलकुलेटरफाइनल

Answer 4

रेटिना , 73 बाइट्स

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

इसे ऑनलाइन आज़माएं!

निष्कर्ष: रेटिना को एक छंटाई चरण की आवश्यकता होती है।

व्याख्या

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

यह एक grep स्टेज है: यह केवल उन पंक्तियों को रखता है जो रेगेक्स द्वारा मेल खाते हैं। यानी जो विशेष रूप से उन चरित्र वर्गों में से एक से बनते हैं।

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

अब हमें केवल शेष स्ट्रिंग्स में से सबसे बड़ा खोजने की आवश्यकता है। हम सभी शब्दों का मिलान करके ऐसा करते हैं जो उनके बाद के सभी शब्दों से कम से कम लंबे हैं। 1रेटिना (दो दिन पहले जारी किया गया) है, जो केवल इस तरह की पहली मैच पर विचार करने के लिए इस मैच चरण को सीमित करता है के लिए एक नया है। और !रेटिना को मैच को प्रिंट करने (इसे गिनने के बजाय) करने का निर्देश देता है।

Comments

यह अच्छा है! मुझे कुछ समय संतुलित समूहों को देखना होगा। हालांकि उन्हें समझना मुश्किल लगता है। मैं कोशिश की है इस (और यह की तरह यह काम करता है दिखता है), लेकिन मैं अपने जवाब के लिए इंतजार करना आप कुछ ऐसी बातें क्या पैदा करेगा देखना चाहती थी।

— daavko

@daavko आत्म-प्रचार के लिए क्षमा करें, लेकिन क्या आपने संतुलन समूहों पर मेरे स्टैक ओवरफ्लो पोस्ट को पढ़ा है ? मुझे बताया जा रहा है कि यह एक अच्छा परिचय है। अवधारणा ही वास्तव में जटिल नहीं है, खासकर यदि आप (?<a-b>...)वाक्यविन्यास का उपयोग नहीं करते हैं जो कोड गोल्फ में शायद ही कभी आवश्यक होता है।

— मार्टिन एंडर

मुझे नहीं लगता कि मैंने वह पोस्ट देखी है। सबसे अधिक संभावना है क्योंकि मैं स्टैक ओवरफ्लो को अक्सर ब्राउज़ नहीं करता हूं। लिंक के लिए धन्यवाद, मैं इसे बुकमार्क करूंगा और इसे पढ़ूंगा।

— दावको

शायद एक टिप्पणी के लिए विषय बंद है, लेकिन संतुलन समूहों के बारे में मेरे ज्ञान का बहुत अधिक 100% आपकी पोस्ट को पढ़ने से आता है। मुझे लगता है कि आप किसी भी समय इसे स्वयं-प्रचारित कर सकते हैं, यह एक बड़ी मदद है :) किसी भी विषय पर अधिक काम करना, सबसे लंबे इनपुट के साथ लाइन प्राप्त करने के लिए <code> O-1`। * </ Code> जैसा कुछ काम करेगा? हो सकता है कि यह लिप्यंतरण की तरह काम करे और इसमें एक से अधिक बैकटिक अलग-अलग क्षेत्र हों, जिन्हें विभाजित करने के लिए एक रेगीक्स और एक को गिनना हो? वास्तव में शायद यह भी चैट में है ... ¯_ (_) _ /

— F

कभी नहीं सोचा होगा o-r, भयानक।

— इमानुएल विंटिलो

Answer 5

जावा, 154 142 या 142 130 बाइट्स

क्योंकि, फिर पता है, जावा।

तुलना के लिए सी # ।

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()

थोड़ा अपराजित:

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>।

Comments

मेरा अपडेट किया गया संस्करण अब छोटे लैम्बडा को भी पूर्ण कार्यक्रम के रूप में

— SBI

@SBI लानत जावा की लंबी विधि का आह्वान! (सभी अच्छे मजे में)

— CAD97

खुद एक जावा डेवलपर होने के नाते, एक क्रिया भाषा देखना अच्छा है जो एक ही समय में संक्षिप्त होने का प्रबंधन करता है :)

— SBI

यदि हम एक इनपुट धारणा बनाने जा रहे हैं, तो हमें वह बनाने में मदद करता है, जो इनपुट में सबसे अधिक मदद करता है, इनपुट एक सूची के रूप में आता है <string>: l->l.stream().filter(g->g.matches("[wertyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()(116 वर्ण)

— Andreas

@ और मेरा हालिया मेटा चर्चा के अनुसार , यदि एक लंबोदर सूची लेता है, तो आपको import java.util.*;बाइट गिनती में शामिल करना होगा, जिसका अर्थ है कि सूची में -16 बाइट्स एक सूची लेने के लिए है, लेकिन सूची को आयात करने के लिए +19 है। फिर भी, आप -7 बाइट्स के maxबजाय का उपयोग कर वहाँ पकड़ लिया reduce।

— सीएडी 97

Answer 6

जेली, 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.

Answer 7

पायथन 3, 98

केविन की बदौलत 5 बाइट्स बची।
पीएम 2Ring के लिए 3 बाइट्स सहेजे गए।
एंटी हापाला के लिए धन्यवाद 3 बाइट्स बचाए।

फिलहाल इसे मजबूर करें। मैं केवल एक पंक्ति द्वारा शामिल किए गए शब्दों को नीचे फ़िल्टर करता हूं, और फिर अधिकतम स्ट्रिंग लंबाई के लिए सॉर्ट करता हूं।

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'

Answer 8

PowerShell v2 +, 72 बाइट्स

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

कमांड-लाइन दलीलों के माध्यम से इनपुट लेता है $args, फिर -matchऑपरेटर के साथ regex का उपयोग करता है केवल उन शब्दों का चयन करने के लिए जो विशेष रूप से एक कीबोर्ड पंक्ति से बने होते हैं। हम Sort-Objectसंपत्ति द्वारा उन परिणामों को उस तरह से पाइप करते हैं Length। हम ऐसा कर सकते हैं क्योंकि पावरशेल में तार सभी System.Stringप्रकार के होते हैं, जिसमें .Lengthएक छांटने योग्य संपत्ति के रूप में शामिल होता है। यह लंबाई के आधार पर बढ़ते क्रम में तारों को छाँटता है, इसलिए हम अंतिम को साथ लेते हैं[-1] , इसे पाइप लाइन पर छोड़ देते हैं, और आउटपुट निहित है।

उदाहरण

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

Answer 9

पायथ, 45 35 बाइट्स

कुछ बाइट्स बचाने के लिए @FryAmThe ​​Eggman को धन्यवाद!

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

यहाँ कोशिश करो!

शब्दों की सूची के रूप में इनपुट लेता है।

व्याख्या

elDf} k-LTc। "..." \ _ Q # Q = सभी इनपुट शब्दों की सूची

   f Q # लैम्बडा वेरिएबल के रूप में T के साथ फिल्टर इनपुट
         c। "..." \ _ # सभी कीबोर्ड पंक्तियों की सूची
      -LT # वर्तमान इनपुट पंक्ति के सभी अक्षरों को वर्तमान इनपुट से हटा दें
                      # शब्द। यदि रिक्त हो तो 3 स्ट्रिंग की सूची में परिणाम
                      # शब्द को एक पंक्ति के साथ टाइप किया जा सकता है
    } k # जांचें कि क्या सूची में एक एमटीआई स्ट्रिंग है
elD # ऑर्डर रिजल्ट लिस्ट को लंबाई के हिसाब से लें और आखिरी लें

Answer 10

रूबी, 88 82 69

अगर मुझे स्ट्रिंग्स की एक सूची लेने की अनुमति नहीं है और एक बहुस्तरीय स्ट्रिंग लेनी चाहिए, तो स्कोर में +12 जोड़ें और जोड़ें .split('\n').grep कॉल से ठीक पहले ।

रूबी में मुझे स्टैम्बी लैम्ब्डा के बारे में सिखाने के लिए कैट्सअरेफली का शुक्रिया, और मैनटवर्क से आगे की आशाएँ

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

Comments

नहीं, आप .split('\n')पहले जोड़ते हैं .select, है ना? और कोई छुरा लांबा क्यों नहीं?

— कैलकुलेटरफाइनल

जब तक आपने इसका उल्लेख नहीं किया, तब तक मैं अब तक के लम्बे लम्बे के बारे में नहीं जानता था। धन्यवाद!

— वैल्यू इंक

क्या आप -88- और 82 के बीच एक स्थान जोड़ सकते हैं?

— कैलक्यूलेटरफलाइन

इसे एक चर को निर्दिष्ट करने की आवश्यकता नहीं है, अनाम कार्यों की अनुमति है; यदि केवल .selectकोड ब्लॉक के अंदर करने के लिए एक नियमित अभिव्यक्ति के खिलाफ मैच है, .grepतो अधिक उपयुक्त है; कॉल श्रृंखला में अंतिम विधि के मापदंडों के आसपास कोष्ठक लगाने की आवश्यकता नहीं है; .lengthएक छोटा उपनाम है .size,:->x{x.grep(/^([o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+)$/).max_by &:size}

— मैनटवर्क

Answer 11

सी #, 141/112 / (120 बाइट्स)

स्पष्ट कारणों से सबसे बुरी गोल्फ भाषा के लिए दावेदार। क्वर्टी के बजाय क्वर्टीज़ के साथ "माय" लोकेल का उपयोग करता है, लेकिन अन्यथा ठीक काम करता है।

पूरा कार्यक्रम जहां बिना:

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());

Comments

चुनौती कहती है कि आपको क्वर्टी का उपयोग करना होगा और चूंकि आप इसे वैसे भी हार्डकोड कर रहे हैं, इसलिए मुझे इसे बदलने का कोई कारण नहीं दिखता है। इसके अलावा, आप कुछ बाइट्स को बचाने के लिए एक पूर्ण कार्यक्रम के बजाय एक फ़ंक्शन (शायद एक लैम्ब्डा भी) का उपयोग कर सकते हैं। यह हमेशा अनुमति दी जाती है जब तक कि चुनौती में स्पष्ट रूप से मना नहीं किया जाता है।

— डेन्कर

अपने लेआउट पर गर्व होना: पी, ऐसा नहीं है कि मेरे पास सी # का उपयोग करके वैसे भी जीतने का मौका है। एक संस्करण में संपादित किया गया है जो केवल आउटपुट है।

— एसबीआई

एक अन्य विकल्प जोड़ा गया, जहां उपयोग करने के बजाय एक विधेय के साथ अंतिम का उपयोग कर। यह एक और 8 बाइट्स को बंद कर देता है।

— एसबीआई

Answer 12

bash, 105 बाइट्स

और विभिन्न अन्य उपयोगिताओं, निश्चित रूप से।

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

Comments

awkकोड के रूप में कम लिखा जा सकता है $0=length"\t"$0।

— मैनेटवर्क

Answer 13

awk, 92 84 81 बाइट्स

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

@Wolfgang सुझाव के लिए 3 बाइट्स सहेजे गए

Comments

आप [wetyuio-r]इसके बजाय का उपयोग करके एक बाइट घटाना कर सकते हैं , और भी दो के /^(expr|expr|expr)$/बजाय `/ ^ expr $ | ^ expr $ | ^ expr $ /

— वुल्फगैंग

@Wolfgang: टिप के लिए धन्यवाद। मैंने पहले से ही 2 की कोशिश की और मेरे जागने पर इसने मुझे सही के बजाय सबसे लंबा शब्द दिया ... मैं फिर से कोशिश करूँगा। मैं पहले एक से सहमत हूं, हालांकि 1 बाइट बचाता है

— ओलिवियर दुलक

@ वोल्फगैंग: हम्म, इस समय काम करता है (मैंने अपने परीक्षण, फ्राइडे पर कोष्ठक को फूँक दिया होगा)। मैं आपके सुझावों को संपादित करता हूं, धन्यवाद।

— ओलिवियर दुलक

क्या आप सुनिश्चित हैं कि नियमित अभिव्यक्ति के आसपास कोष्ठक आवश्यक हैं? gawkऔर mawkउनके बिना खुश हैं।

— मैनेटवर्क

@ मैनटवर्क: भीतर वाले जरूरी हैं, बाहरी मैं उन्हें तर्क और मूल्यांकन आदेश सुनिश्चित करने के लिए पसंद करता हूं। .. शायद 2 चरों की "लागत" पर

— ओलिवियर दुलक

Answer 14

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

Answer 15

पर्ल, 81 बाइट्स

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

अक्षर को उच्च गिनने का प्रतीक।

Answer 16

ग्रूवी, 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]