Una cuerda musical es cualquier cuerda que se puede tocar en un teclado de piano.

Para aquellos de nosotros que no nos vimos obligados a aprender el piano cuando éramos niños, así es como se ve el teclado.

Entonces, la cuerda feed a dead cabbagees una cuerda musical porque cada letra corresponde a una de estas notas.

Su desafío es escribir un programa que tome una cadena como entrada de STDIN y encuentre la subcadena musical más larga. Entonces su programa debe imprimir la subcadena, y su longitud. Aquí hay algunas entradas / salidas de muestra.

Entrada: "¡ALIMÉTEME! ¡Tengo hambre!"

Salida: alimentación 4

Entrada: No no no, no musistrin!

Salida: 0

Entrada: "A **bad** !!!fAd82342"

Salida: abadfad 7

Entrada: "¡Buen golf!"

Salida: dg 2

Reglas

• Su salida puede ser mayúscula o minúscula, pero no debe haber signos de puntuación ni espacios.

• Habrá mayúsculas y signos de puntuación en la cadena de entrada, pero esto no afecta si una subcadena se considera "musical" o no.

• Debe haber un espacio entre la subcadena musical y el número.

Pyth, 25 23 bytes

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

2 bytes guardados gracias a @Jakube.

Demostración. Prueba de arnés.

Explicación:

• rz0: La entrada, en minúsculas.
• @Grz0: Elimina los caracteres no alfabéticos.
• .:@Grz0): Genera todas las subcadenas.
• +k.:@Grz0): Agregue la cadena vacía.
• f ... +k.:@Grz0): Filtre sobre estas cadenas.
• -T<G7: Filtra cada cadena por caracteres no musicales.
• !-T<G7: Niega el resultado. Esto es Truesi y solo si la cuerda era musical.
• f!-T<G7+k.:@Grz0): Filtra las cuerdas musicales.
• ef!-T<G7+k.:@Grz0): Tome la última secuencia de este tipo. .:ordena las subcadenas por tamaño, por lo que esta también es la subcadena musical más larga.
• Jef!-T<G7+k.:@Grz0): Asignar el resultado a J.
• pdJ: Imprimir J, con d, espacio, como el carácter final.
• lJ: Luego, imprima la longitud de J.

Ruby, 83 75 caracteres

Bastante autoexplicativo.

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

Aprovecha el hecho de que Ruby puede dividir cadenas en regex ( .split(/[^a-g]/)).

Perl, 58

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

Utilizar:

$ 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;}}}

Expandido:

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 bytes

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

Ungolfed + explicación:

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

¡Sugerencias son bienvenidas!

Nota: La salida ahora es de mayúsculas y minúsculas, lo que está permitido según la edición del OP. Esto ahorró 4 bytes.

golflua , 84 85 84 bytes

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

Primero fuerzo minúsculas, luego separo espacios de caracteres que no son letras, luego elimino todas las letras no musicales en la entrada (stdin). Luego escaneo a través de cada palabra restante y comparo su longitud antes de generar la mayor y la longitud (stdout). Probablemente haya una forma más corta de hacer el ciclo, pero por el momento esto es lo que tengo.

Un código de Lua sin golf sería

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