Qwerty klavyenin üç sıra vardır qwertyuiop, asdfghjklve zxcvbnm. Görevin, verilen bir kelime listesinden sadece bir satır klavyeyle yazılabilecek en uzun kelimeyi bulmak.

Örnek giriş 1

artist
home
gas
writer
geology
marine
twerp

Çıktı

writer

(Verilen kelimeleri arasında yalnızca gas, writerve twerptek bir satır kullanarak yazılı ve edilebilmektedir writeren uzun)

Sözcükler gerçek kelimeler olmayabilir (bu nedenle üçüncü sıranın geçersiz olduğunu varsaymayın). Ancak, her zaman tam olarak bir cevap olacağını varsayabilirsiniz (daha fazla değil, daha az değil).

Örnek giriş 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Çıktı

bxnzmmx

Ek noktalama işaretleri ve boşluklar girişte sağlanabilir (dil gereksinimlerine göre). Ancak, fazladan bir çıktı verilmemelidir. Giriş ve çıkış küçük harflerdir. En kısa kod kazanır.

Python 2, 84 bayt

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

Yayılan maxklavyenin daha az klavye satırına göre, daha sonra artan uzunluklarla karşılaştırarak girişin değerini bulur . Klavye satır değeri tarafından ayıklanır "asdfghjklzxcvbnm".find(c)/9orta satır ulaştıracak olan 0, alt satır 1için, ve hariçtir üst satırı, -1çünkü findverir -1eksik değerler için.

Diğer girişimler:

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 bayt

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

Çevrimiçi test edin! Giriş bir dizi dizisidir.

Nasıl çalışır

;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+ ve 3, 93 bayt

Bu yaklaşım için kaç vuruş denemek zorunda kaldı; bu, yalnızca b'de meydana gelen karakterlerden oluşuyorsa a.strip(b)boş dizgeyle sonuçlanan gerçeğini kullanır a.

İşlev, dizelerin listesini alır ve bir dize döndürür.

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

Retina , 73 bayt

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

Çevrimiçi deneyin!

Sonuç: Retina'nın bir sıralama aşamasına ihtiyacı var.

açıklama

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

Bu bir grep aşamasıdır: sadece regex ile eşleşen çizgileri tutar. Yani sadece bu karakter sınıflarından birinden oluşanlar.

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

Şimdi sadece geriye kalan karakter dizilerinin en büyüğünü bulmamız gerekiyor. Bunu, en azından ondan sonraki kelimelerden daha uzun olan tüm kelimeleri eşleştirerek yapıyoruz. Bu 1, Retina'ya (iki gün önce yayınlandı) yeni bir eklentidir ve bu maç aşamasını sadece ilk karşılaşmayı dikkate alarak sınırlar. Ve !Retina'ya maçı basmasını söyler (saymak yerine).

Java, 154 142 veya 142 130 bayt

Çünkü biliyorsun Java.

Karşılaştırma için C # .

Girdi ile ayrılan değerlerin tek bir dize olması gerekiyorsa, 146 bayt \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()

Girdiyi String [] olarak kabul edebilirsem, 134 bayt:

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

Biraz 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

İkinci lambda bir Function<String[],String>.

Jöle, 40 34 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

Kevin sayesinde 5 bayt kurtardı.
PM 2Ring sayesinde 3 byte kurtarıldı.
Antti Haapala sayesinde 3 bayt kurtarıldı.

Şu anda zorla Brute. Kelimeleri yalnızca tek bir satırın içerdiği kelimelere göre filtrelendiriyorum ve sonra maksimum dize uzunluğu için sıralıyorum.

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

Test durumları:

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 bayt

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

Komut satırı argümanları üzerinden girdi alır $args, daha sonra yalnızca bir klavye satırından oluşan sözcükleri seçmek için -matchişleci bir regex ile kullanır . Bu sonuçları Sort-Objectmülkiyete göre sıralıyoruz Length. Bunu yapabiliriz, çünkü PowerShell'deki dizelerin tümü sıralanabilir özellik olarak System.Stringdahil .Lengthedilen türdedir. Bu, dizeleri uzunluğa göre artan bir sıraya göre sıralar, bu yüzden sonuncuyu [-1]boru hattında bırakırız ve çıktısı örtüktür.

Örnek

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

Pyth, 45 35 bayt

@FryAmThe ​​Eggman'e, bana bazı baytları kaydettiği için teşekkürler!

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

Burada dene!

Sözcük listesi olarak girdi alır.

açıklama

elDf} k-LTc. "..." \ `Q # Q = tüm giriş kelimelerinin listesi

   f Q # lambda değişkeni olarak T ile filtre girişi
         c. "..." \ `# Tüm klavye satırlarının listesi
      -LT # Geçerli girdi satırındaki tüm harfleri geçerli girdiden kaldır
                      # kelime. 3 string listesindeki sonuçlardan biri boş olduğunda
                      # kelime bir satır ile yazılabilir
    } k # Listede bir boş dizge içerip içermediğini kontrol et
eld # order sonuç listesi uzunluğa göre ve sonuncuyu al

Ruby, 88 82 69

Dizelerin bir listesini alma iznim yoksa ve çok satırlı bir dize almam gerekiyorsa, puana +12 ekleyin .split('\n')ve .grepçağrıdan hemen önce ekleyin .

Bana Ruby'de stab lambdaları ve manat işlerinden daha fazla optimizasyon öğrettiğin için teşekkürler CatsAreFluffy

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

C #, 141/112 / (120 bayt)

En kötü golf dili yarışmacısı, bariz sebeplerden dolayı. Qwerty yerine qwertz ile "my" yerel ayarını kullanır, ancak aksi halde iyi çalışır.

Nerede olmadan tam program:

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

Sadece Where olmadan çıktı:

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

Sadece çıktı (orijinal):

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

bash, 105 bayt

Ve elbette, çeşitli diğer kamu hizmetleri.

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

awk, 92 84 81 bayt

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

@Wolfgang önerisi sayesinde 3 bayt kurtarıldı

MATL , 54 bayt

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

Bu , dilin / derleyicinin geçerli sürümüyle (14.0.0) çalışır .

Giriş formatı (ilk örnek)

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

veya (ikinci örnek)

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

Çevrimiçi deneyin!

açıklama

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

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

Harf sembolü oldukça yüksek saymak.

Harika, 65 karakter

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

Örnek çalışma:

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

Tarafından kullanılan normal ifadenin .grep(), gruplamayı da boşa bırakmaya izin veren sabitleme gerektirmediğini unutmayın :

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