Le défi

Je lisais le Java Style Guide de Google l'autre jour et je suis tombé sur son algorithme pour convertir toute chaîne arbitraire en notation camelCase. Dans ce défi, vous devez implémenter cet algorithme, car vous ne voulez pas faire tout cela dans votre tête lorsque vous écrivez vos soumissions Java extrêmement compétitives aux défis de code-golf.

Note: J'ai fait quelques petits ajustements à l'algorithme. Vous devez utiliser celui spécifié ci-dessous.

L'algorithme

Vous commencez avec une chaîne d'entrée arbitraire et appliquez-lui les opérations suivantes:

1. Supprimer toutes les apostrophes `'
2. Diviser le résultat en mots en divisant en
   • caractères non alphanumériques et non numériques [^a-zA-Z0-9]
   • Lettres majuscules entourées de lettres minuscules des deux côtés. abcDefGhI jkpar exemple les rendementsabc Def Ghi jk
3. Minuscule chaque mot.
4. Majuscule le premier caractère de chaque mot sauf le premier.
5. Rejoins tous les mots ensemble.

Notes complémentaires

• L'entrée ne contiendra que l'ASCII imprimable.
• Si un chiffre est la première lettre d'un mot, laissez-le tel quel et ne capitalisez pas autre chose dans ce mot.
• L'entrée aura toujours au moins un caractère.

Règles

• Fonction ou programme complet autorisé.
• Règles par défaut pour les entrées / sorties.
• Les failles standard s'appliquent.
• C'est le code-golf , donc le plus petit nombre d'octets gagne. Tiebreaker est une soumission antérieure.

Cas de test

"Programmation Puzzles & Code Golf" -> "programmationPuzzlesCodeGolf"
"Demande HTTP XML" -> "xmlHttpRequest"
"supporte IPv6 sur iOS?" -> "supportsIpv6OnIos"
"Quelque chose avec apo'strophe's et 'punc] tuation" -> "someThingW1thApostrophesAndPuncTuation"
"rien de spécial" -> "rien de spécial"
"5pecial ca5e" -> "5pecialCa5e"
"1337" -> "1337"
"1337-spEAk" -> "1337Speak"
"quel désordre" -> "whataMess"
"abcD" -> "abcd"
"a" -> "a"
"B" -> "b"

Bon codage!

Retina , 56 octets

Le nombre d'octets suppose un codage ISO 8859-1.

T`'\`
S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])
T`L`l
T`l`L`¶.
¶

Essayez-le en ligne!

Explication

Cela implémente littéralement la spécification:

T`'\`

Supprimer les apostrophes et les backticks.

S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])

Divisez la chaîne en caractères non-mots (dans regex, cela exclut également les chiffres et les tirets bas), ou les traits de soulignement ou les positions qui ont une lettre minuscule à gauche et une majuscule, la minuscule à droite. Cela créerait des segments vides quand il y a deux caractères non-lettres, non-numériques dans une ligne, ou plus important au début de la chaîne. Nous nous débarrassons de ceux qui ont l' _option. Dans ce cas, "fractionner" signifie mettre chaque partie restante sur sa propre ligne.

T`L`l

Convertissez tout en minuscule.

T`l`L`¶.

Convertissez chaque caractère qui apparaît après le saut de ligne en majuscule. Cela évite le premier mot car il n'y a pas de saut de ligne devant lui.

¶

Débarrassez-vous des sauts de ligne pour réunir le tout.

Java, 198 190 octets

+3 octets parce que j'ai oublié que \W+== [^a-zA-Z0-9_]+et que je dois correspondre[^a-zA-Z0-9]+

-11 octets grâce à user20093 - ?:au lieu de if/else

Parce que, Java.

s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;}

C'est un lambda. Appelle comme ça:

UnaryOperator<String> op = s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;};
System.out.println(op.apply("Programming Puzzles & Code Golf"));

Version lisible:

public static String toCamelCase(String s) {
    String[] tokens = s
            .replaceAll("`|'", "") // 1. Remove all apostrophes
            .split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])"); // 2. Split on [\W_]+ or between [a-z] and [A-Z][a-z]
    s = ""; // Reusing s for building output is cheap
    for (String token : tokens) {
        String lowercaseToken = token.toLowerCase(); // 3. Lowercase every word
        s += tokens[0].equals(token)?lowercaseToken:lowercaseToken.toUpperCase().charAt(0) + lowercaseToken.substring(1); // 4. Uppercase first char of all but first word
        // ^ 5. Join all words back together
    }
    return s;
}

JavaScript (ES6), 156 154 152 148 145 141 141 140 octets

Merci @Neil (6 octets), @ETHproductions (3 octets) et @ edc65 (7 octets)

a=>a[r='replace'](/`|'/g,a='')[r](/[a-z](?=[A-Z][a-z])/g,'$& ')[r](/[^\W_]+/g,b=>a+=(a?b[0].toUpperCase():'')+b.slice(!!a).toLowerCase())&&a

Supprime les apostrophes, puis effectue un remplacement pour séparer les caractères spéciaux / avant les majuscules entourées, puis se combine avec une casse appropriée. Malheureusement, toLowerCase()et toUpperCase()sont ennuyeusement long et difficile à éviter ici ...

vim, 69 68 66

:s/[`']//g<cr>:s/[a-z]\zs\ze[A-Z][a-z]\|\W\|_/\r/g<cr>o<esc>guggj<C-v>GgU:%s/\n<cr>

Vim plus court que Perl?! Quelle est cette folie?

:s/[`']//g<cr>           remove ` and '
:s/                      match...
 [a-z]\zs\ze[A-Z][a-z]   right before a lowercase-surrounded uppercase letter
 \|\W\|_                 or a non-word char or underscore
 /\r/g<cr>               insert newlines between parts
o<esc>                   add an extra line at the end, necessary later...
gugg                     lowercasify everything
j                        go to line 2 (this is why we added the extra line)
<C-v>G                   visual select the first char of all-but-first line
gU                       uppercase
:%s/\n<cr>               join all lines into one

Merci à Neil d' avoir remarqué une frappe inutile!

Mathematica 10.1, 101 octets

""<>(ToCamelCase@{##2}~Prepend~ToLowerCase@#&@@StringCases[StringDelete[#,"`"|"'"],WordCharacter..])&

Utilise le non documenté ToCamelCase, qui fonctionne de la même façon Capitalizemais définit les autres caractères en minuscule.

Julia, 98 89 octets

s->lcfirst(join(map(ucfirst,split(replace(s,r"['`]",""),r"[a-z]\K(?=[A-Z][a-z])|\W|_"))))

Il s'agit d'une fonction anonyme qui accepte une chaîne et retourne une chaîne. Pour l'appeler, assignez-le à une variable.

L’approche est la même que dans la réponse Perl de Doorknob : replaceapostrophes et backticks avec la chaîne vide, splitdans un tableau sur une expression régulière qui correspond aux cas nécessaires, mapla ucfirstfonction sur le tableau pour mettre en majuscule la première lettre de chaque élément, joinle tableau dans une chaîne, et lcfirstle résultat pour convertir le premier caractère en minuscule.

Perl 67 + 1 = 68 octets

y/'`//d;s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g;$_=lc;s/^ +| +(.)/\u$1/g

Nécessite le -pdrapeau, et -lpour plusieurs lignes:

$ perl -pl camelCase.pl input.txt
programmingPuzzlesCodeGolf
xmlHttpRequest
supportsIpv6OnIos:
someThingW1thApostrophesAndPuncTuation
nothingSpecial
5pecialCa5e
1337
1337Speak
abcd

Comment ça marche:

y/'`//d;                            # Remove ' and `
s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g; # Replace according to '2. Split...' this will create
                                    #   a space separated string.
$_=lc;                              # lower case string
s/^ +| +(.)/\u$1/g                  # CamelCase the space separated string and remove any
                                    #   potential leading spaces.

Perl, 87 80 78 octets

y/'`//d;$_=join'',map{ucfirst lc}split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;lcfirst

Octet ajouté pour le -pdrapeau.

Tout d'abord, nous utilisons l' y///opérateur de translittération pour dsupprimer tous les '`caractères de l'entrée:

y/'`//d;

Puis vient la viande du code:

                         split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;

(divisez la chaîne d'entrée $_aux emplacements appropriés, en utilisant la fantaisie \Kde la chaîne de correspondance pour exclure la partie la précédant de la correspondance réelle)

          map{ucfirst lc}

(mappez chaque partie de la chaîne et mettez la chaîne entière en minuscule, puis mettez le premier caractère de la chaîne modifiée en majuscule)

$_=join'',

(rejoindre sur une chaîne vide et réaffecter à un soulignement magique $_, qui est imprimé à la fin)

Enfin, nous mettons la première lettre en\l minuscule en la faisant correspondre par expression rationnelle et en utilisant dans la chaîne de remplacement avec une valeur intégrée, en économisant 2 octets par rapport à la méthode précédente:

lcfirst

Merci à @ MartinBüttner pour 7 octets ( [^a-zA-Z\d]-> \W|_)!

Lua, 127 octets

t=''l=t.lower z=io.read()for x in z:gmatch('%w+')do t=t..(t==''and l(x:sub(1,1))or x:sub(1,1):upper())..l(x:sub(2))end return t

Accepte une chaîne de stdin et renvoie des résultats camélisés.

Je vais probablement chercher une meilleure solution car tout stocker dans une variable semble inefficace.

Mais de toute façon, assez simple en général:

 z:gmatch('%w+')

C'est la beauté qui m'a sauvé un peu d'octets. gmatch divisera la chaîne en fonction du modèle: %w+qui ne saisit que les caractères alphanumériques.

Après cela, c’est de simples opérations sur les chaînes. string.upper, string.lower et done.

PHP, 145 122 133 octets

<?=join(split(" ",lcfirst(ucwords(strtolower(preg_replace(["#`|'#","#\W|_#","#([a-z])([A-Z][a-z])#"],[""," ","$1 $2"],$argv[1]))))));

Enregistrer dans un fichier, appelez à partir de la CLI.
Prend les entrées à partir d'un seul argument de ligne de commande; citations d'échappement et espaces blancs si nécessaire.

panne

<?=                 // 9. print result
join(split(" ",     // 8. remove spaces
    lcfirst(        // 7. lowercase first character
    ucwords(        // 6. uppercase first character in every word
    strtolower(     // 5. lowercase everything
    preg_replace(
        ["#`|'#",   "#\W|_#",   "#([a-z])([A-Z][a-z])#"],
        ["",        " ",        "$1 $2"],
        // 2. replace apostrophes with empty string (remove them)
                    // 3. replace non-word characters with space
                                // 4. insert space before solitude uppercase
        $argv[1]    // 1. take input from command line
    ))))
));

lcfirstautorisé à réduire cela à une seule commande, économisant 23 octets.
La fixation des apostrophes coûte 11 octets pour le cas de remplacement supplémentaire.

Kotlin , 160 octets

fun a(s: String)=s.replace(Regex("['`]"),"").split(Regex("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")).map{it.toLowerCase().capitalize()}.joinToString("").decapitalize()

Mon but était d'être Scala, l'autre "alternative Java", donc je suis assez content de mes résultats. J'ai volé la regex de la réponse Java .

Testez-le avec:

fun main(args: Array<String>) {
    val testCases = arrayOf(
            "Programming Puzzles & Code Golf",
            "XML HTTP request",
            "supports IPv6 on iOS?",
            "SomeThing w1th, apo'strophe's and' punc]tuation",
            "nothing special",
            "5pecial ca5e",
            "1337",
            "1337-spEAk",
            "abcD",
            "a",
            "B")
    testCases.forEach { println(a(it)) }

}

Scala, 181 170 144

def f(s:String)={val l=s.replaceAll("'|`","")split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")map(_.toLowerCase);l(0)+l.tail.map(_.capitalize).mkString}

Testeur:

val testCases = List(
  "Programming Puzzles & Code Golf" -> "programmingPuzzlesCodeGolf",
  "XML HTTP request" -> "xmlHttpRequest"
  // etc
)
println(testCases.map(t=>if(t._2!=f(t._1))s"FAIL:${f(t._1)}"else"PASS").mkString("\n"))

Accessoires à CAD97 et excuses à Nathan Merrill :)

C 272 caractères

La chaîne de transmission du programme C à camelCase est placée entre guillemets en tant qu'argument 1. Il y a beaucoup de pièges dans cette déclaration de problème ...

#define S strlen(t)
#define A isalnum(t[i])
j=0;main(i,v)char**v;{char*p=v[1],*t;char o[99]={0};while(t=strtok(p," [{(~!@#$%^*-+=)}]")){i=0;p+=S+1;while((!A)&&i<S)i++;if(i!=S){o[j]=((j++==0)?tolower(t[i++]):toupper(t[i++]));while(i<S){if(A)o[j++]=t[i];i++;}}}puts(o);}

JavaScript, 123 octets

v=>v[r="replace"](/[`']/g,"")[r](/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())[r](/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

Version lisible

v=>
  v.replace(/[`']/g,"")
  .replace(/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())
  .replace(/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

Supprimez les apostrophes, placez le premier caractère en minuscule, le dernier caractère en minuscule et tout regroupement de plusieurs caractères majuscules en faisant correspondre tout groupe d'un ou plusieurs caractères non alphanumériques + 1 autre caractère en remplaçant par le dernier caractère en majuscule.

[r = "remplace"] astuce de la solution de Mrw247.