Una stringa musicale è qualsiasi stringa che può essere suonata su una tastiera di piano.

Per quelli di noi che non sono stati costretti ad imparare il piano da bambini, ecco come appare la tastiera.

Quindi la stringa feed a dead cabbageè una stringa musicale perché ogni singola lettera corrisponde a una di queste non.

La tua sfida è scrivere un programma che prende una stringa come input da STDIN e trova la sottostringa musicale più lunga. Quindi il tuo programma deve stampare la sottostringa e la sua lunghezza. Ecco alcuni input / output di esempio.

Input: "FEED ME! Ho fame!"

Uscita: feed 4

Input: No no no, no musistrin!

Uscita: 0

Ingresso: "A **bad** !!!fAd82342"

Uscita: abadfad 7

Input: "Buon golf!"

Uscita: dg 2

Regole

• L'output può essere maiuscolo o minuscolo, ma non devono esserci punteggiatura o spazi.

• Ci saranno maiuscole e punteggiatura nella stringa di input, ma ciò non influisce sul fatto che una sottostringa sia considerata o meno "musicale".

• Ci deve essere uno spazio tra la sottostringa musicale e il numero.

Pyth, 25 23 byte

pdJef!-T<G7+k.:@Grz0)lJ

2 byte salvati grazie a @Jakube.

Dimostrazione. Collaudare l'imbragatura.

Spiegazione:

• rz0: Input, in minuscolo.
• @Grz0: Togli tutti i caratteri non alfabetici.
• .:@Grz0): Genera tutte le sottostringhe.
• +k.:@Grz0): Aggiungi la stringa vuota.
• f ... +k.:@Grz0): Filtra su queste stringhe.
• -T<G7: Filtra ogni stringa per caratteri non musicali.
• !-T<G7: Annulla il risultato. Questo è Truese e solo se la corda fosse musicale.
• f!-T<G7+k.:@Grz0): Filtra le corde musicali.
• ef!-T<G7+k.:@Grz0): Prendi l'ultima stringa del genere. .:ordina sottostringhe per dimensione, quindi questa è anche la sottostringa musicale più lunga.
• Jef!-T<G7+k.:@Grz0): Assegna il risultato a J.
• pdJ: Stampa J, con d, spazio, come carattere finale.
• lJ: Quindi, stampare la lunghezza di J.

Rubino, 83 75 caratteri

Abbastanza autoesplicativo.

puts"#{s=gets.gsub(/[^a-z]/i,'').split(/[^a-g]/i).max_by &:size} #{s.size}"

Sfrutta il fatto che Ruby può dividere le stringhe su regex ( .split(/[^a-g]/)).

Perl, 58 anni

#!perl -p
$\=0;map{$i++;$\="$& $i"if/[a-g]{$i}/i}(s/\W//gr)x y!!!cd

Uso:

$ perl ~/mus.pl <<<"FEED ME! I'm hungry!"
FEED 4

o

$ perl -pe'$\=0;map{$i++;$\="$& $i"if/[a-g]{$i}/i}(s/\W//gr)x y!!!cd' <<<"FEED ME! I'm hungry!"
FEED 4

Java, 268

class Z{public static void main(String[]a){String s=new java.util.Scanner(System.in).nextLine().toLowerCase().replaceAll("[^a-z]",""),t;for(int i=s.length();i-->0;)if(!(t=s.replaceFirst("^(.*)([a-g]{"+i+"})(.*)$","$2")).equals(s)){System.out.println(t+" "+i);break;}}}

Allargato:

class Z {
    public static void main(String[] a) {
        String s = new java.util.Scanner(System.in).nextLine().toLowerCase().replaceAll("[^a-z]", ""), t;
        for (int i = s.length(); i-- > 0;) {
            if (!(t = s.replaceFirst("^(.*)([a-f]{" + i + "})(.*)$", "$2")).equals(s)) {
                System.out.println(t + " " + i);
                break;
            }
        }
    }
}

Perl 5 (106)

use List::Util reduce;$_=lc<>;s/[^a-z]//g;$_=reduce{length$a>length$b?$a:$b}m/[a-g]+/g;print"$_ ",0+length

R, 98 94 byte

p=strsplit(gsub("[^a-z]","",readline(),T),"[^a-gA-G]+")[[1]];m=max(n<-nchar(p));cat(p[n==m],m)

Ungolfed + spiegazione:

# Read from STDIN and remove all non-alphabetic characters
r <- gsub("[^a-z]", "", readline(), ignore.case = TRUE)

# Split r into a vector of substrings on characters other than a-g
p <- strsplit(r, "[^a-g]+")[[1]]

# Get the number of characters in each substring
n <- nchar(p)

# Get the length of the longest substring
m <- max(n)

# Print the string and length
cat(p[n == m], m)

I suggerimenti sono benvenuti!

Nota: l'output è ora in maiuscolo / minuscolo, il che è consentito per la modifica del PO. Ciò ha salvato 4 byte.

golflua , 84 85 84 byte

B=I.r():g("%A",""):g("[^a-gA-G]"," ")M=0Q=""~@W B:gm("(%w+)")?#W>M M=#W Q=W$$w(Q,M)

Ho minuscola forza, quindi striscia spazi caratteri non lettere, quindi rimuovere tutte le lettere non musicali sull'ingresso (stdin). Quindi eseguo la scansione di ogni parola rimanente e ne confronto la lunghezza prima di indicare la più grande e la lunghezza (stdout). C'è probabilmente un modo più breve per fare il loop, ma al momento questo è quello che ho.

Un codice Lua ungolfed sarebbe

Line = io.read()                                  -- read stdin
NoSpaced = Line:gsub("%A","")                     -- strip non-letter chars
MusicalLetters = NoSpaced:gsub("[^a-gA-g]", " ")  -- remove non-musical letters
WordLen = 0, LongWord = ""                        -- helpers
for words in MusicalLetters:gmatch("(%w+)") do    -- scan for longest word
   if words:length() > WordLen then 
      WordLen = words:length()
      LongWord = words 
   end
end
print(LongWord, WordLen)                          -- output solution