Une chaîne musicale est une chaîne qui peut être jouée sur un clavier de piano.

Pour ceux d'entre nous qui n'ont pas été obligés d'apprendre le piano quand ils étaient enfants, voici à quoi ressemble le clavier.

La chaîne feed a dead cabbageest donc une chaîne musicale car chaque lettre correspond à l'un de ces nots.

Votre défi est d'écrire un programme qui prend une chaîne en entrée de STDIN et trouve la plus longue sous-chaîne musicale. Ensuite, votre programme doit imprimer la sous-chaîne et sa longueur. Voici quelques exemples d'entrées / sorties.

Entrée: "ALIMENTEZ-MOI! J'ai faim!"

Sortie: alimentation 4

Entrée: Non non non, pas de musistrin!

Sortie: 0

Contribution: "A **bad** !!!fAd82342"

Sortie: abadfad 7

Entrée: "Bon golf!"

Sortie: dg 2

Règles

• Votre sortie peut être en majuscule ou en minuscule, mais il ne doit y avoir ni ponctuation ni espace.

• Il y aura des majuscules et des signes de ponctuation dans la chaîne d'entrée, mais cela n'affecte pas si une sous-chaîne est considérée ou non comme "musicale".

• Il doit y avoir un espace entre la sous-chaîne musicale et le nombre.

Pyth, 25 23 octets

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

2 octets enregistrés grâce à @Jakube.

Manifestation. Harnais de test.

Explication:

• rz0: L'entrée, en minuscules.
• @Grz0: Supprimez tous les caractères non alphabétiques.
• .:@Grz0): Générer toutes les sous-chaînes.
• +k.:@Grz0): Ajoutez la chaîne vide.
• f ... +k.:@Grz0): Filtrer sur ces chaînes.
• -T<G7: Filtrez chaque chaîne pour les caractères non musicaux.
• !-T<G7: Annuler le résultat. C'est Truesi et seulement si la chaîne était musicale.
• f!-T<G7+k.:@Grz0): Filtrer les cordes musicales.
• ef!-T<G7+k.:@Grz0): Prenez la dernière chaîne de ce type. .:commande les sous-chaînes par taille, c'est donc également la plus longue sous-chaîne musicale.
• Jef!-T<G7+k.:@Grz0): Attribuez le résultat à J.
• pdJ: Imprime J, avec d, espace, comme caractère final.
• lJ: Ensuite, imprimez la longueur de J.

Ruby, 83 75 caractères

Assez explicite.

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

Profite du fait que Ruby peut séparer les chaînes sur regex ( .split(/[^a-g]/)).

Perl, 58

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

Utilisation:

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

ou

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

Étendu:

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 octets

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

Non golfé + explication:

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

Les suggestions sont les bienvenues!

Remarque: La sortie est désormais à casse mixte, ce qui est autorisé par l'édition de l'OP. Cela a permis d'économiser 4 octets.

golflua , 84 85 84 octets

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

J'ai d' abord minuscule de force, puis dépouiller les espaces des caractères non-lettre, puis supprimer toutes les lettres non-musicales sur l'entrée (stdin). Je scanne ensuite chaque mot restant et compare sa longueur avant de sortir le plus grand et la longueur (stdout). Il y a probablement un moyen plus court de faire la boucle, mais pour le moment c'est ce que j'ai.

Un code Lua non golfé serait

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