C’est relativement rapide, mais je suis sûr que vous l’aimerez.

Codegolf est un programme qui prend une entrée sous forme de phrase, puis fournit le résultat avec la première lettre en majuscule dans chaque mot.

Règles:

1. Les soumissions ne peuvent pas être sous la forme d'une fonction. Donc non:

   function x(y){z=some_kind_of_magic(y);return z;} en guise de réponse finale ... Votre code doit indiquer qu'il faut une entrée et une sortie.

2. Le code doit conserver les autres lettres majuscules de l’entrée. Alors

   eCommerce and eBusiness are cool, don't you agree, Richard III?
   

   sera rendu comme

   ECommerce And EBusiness Are Cool, Don't You Agree, Richard III?
   

3. Certains d'entre vous pensent peut-être: "Facile, je vais juste utiliser regex!" ainsi, l'utilisation de l'expression rationnelle native dans la langue de votre choix entraînera une pénalité de 30 caractères qui sera appliquée au nombre de codes final. Rire diabolique

4. Un "mot" dans ce cas est tout ce qui est séparé par un espace. Donc palate cleanserest deux mots, alors que pigeon-toedest considéré comme un mot. if_you_love_her_then_you_should_put_a_ring_on_itest considéré comme un mot. Si un mot commence par un caractère non alphabétique, le mot est conservé. Par conséquent, le _thisrendu reste identique à _this. (Félicitations à Martin Buttner pour avoir signalé ce cas de test).

   • 4b. Rien ne garantit que les mots de la phrase d'entrée seront séparés par un seul espace.

5. Cas de test, (veuillez utiliser pour tester votre code):

   Contribution:

   eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye
   

   Sortie:

   ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
   

6. C'est le code golf, le code le plus court gagne ...

Bonne chance...

CJam, 15 à 13 octets

Lq{_eu?_S-}/;

Essayez-le en ligne dans l' interprète CJam .

Pseudocode

L             e# B := ""
 q            e# Q := input()
  {       }/  e# for C in Q:
   _eu?       e#     C := B ? C : uppercase(C)
       _S-    e#     B := string(C).strip(" ")
            ; e# discard(B)

Tous les caractères modifiés C sont laissés sur la pile et sont donc imprimés lors de la sortie.

CSS 2.1, 49

:after{content:attr(t);text-transform:capitalize}

Explication :

• La attrfonction prend l'entrée d'un tattribut HTML (texte).
• L'entrée est mise en majuscule en mettant text-transformà capitalize.
• La sortie est fournie sous forme de contenu généré, en utilisant la contentpropriété sur un pseudo-élément .::after

Snippet exécutable :

:after {
    content: attr(t);
    text-transform: capitalize;
}

<div t="eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"></div>

Remarque : CSS 2.1 spécifiait le comportement souhaité: mettre en capitalizemajuscule le premier caractère de chaque mot. Cependant, CSS3 met en majuscule la première unité de lettre typographique de chaque mot. Ainsi, l'extrait de code ci-dessus ne fonctionnera pas correctement, ni sur l'ancien IE, qui ne suivait pas CSS 2.1; ni sur les nouveaux navigateurs conformes qui suivent CSS3.

Javascript ( ES6 ), 77 octets

alert(prompt().split(' ').map(x=>x&&x[0].toUpperCase()+x.slice(1)).join(' '))

Commenté

alert( // output
    prompt(). // take input
    split(' '). // split by spaces
    map(x=> // map function to array
        x && // if x, empty string "" is falsey and returns itself
        x[0].toUpperCase() + x.slice(1) // capaitalize 1st char and concatenate the rest
    ).
    join(' ') // join array with spaces
)

Perl, 13 octets

perl -040pe '$_="\u$_"'

9 octets plus 4 octets pour 040p(en supposant que j'ai correctement interprété les règles relatives aux invocations spéciales ).

-040définit le séparateur d'enregistrement d'entrée $/sur un seul espace, les espaces sont donc préservés; la \uséquence d'échappement convertit le caractère suivant en cas de titre.

CJam, 17 15 octets

lS/{S+(eu\+}/W<

Testez-le ici.

Mise en œuvre assez simple de la spécification. Utilisez le nouveau {}&pour éviter les erreurs pour les espaces consécutifs.

Deux octets enregistrés par Dennis.

C, 64 63 octets

a;main(c){while(~(c=getchar()))putchar(a?c:toupper(c)),a=c-32;}

Correction: certains compilateurs (tels que Clang) n'aiment pas les paramètres int à la place de argv, je l'ai donc déplacé vers une variable globale. Le nombre d'octets reste le même. Merci à ossifrage délirant pour l'avoir remarqué. Jusqu'à 63 octets, merci Dennis.

Ungolfed:

int a;

int main(int c) {
    while(~(c = getchar()))
        putchar(a ? c : toupper(c)),
        a = c - ' ';
}

Plutôt simple: si a est faux, le caractère est converti en majuscule. Il est défini après la lecture d'un espace: c - '' n'est faux que si c == ''. toupper () ignore tout ce qui n'est pas une lettre minuscule, les symboles et les espaces sont donc acceptables. -1 a tous les bits définis. Ainsi, lorsque getchar () renvoie -1, l'opérateur NOT le met à zéro et la boucle s'arrête. a est déclaré en tant que variable globale, il est donc initialisé à zéro (false). Cela garantit que le premier mot est en majuscule.

Python 3, 59 56 octets

f=1
for c in input():print(end=f*c.upper()or c);f=c==" "

Merci à @Reticality pour 3 octets.

Version Perl <5.18, 30 27 26 25

say map"\u$_",split$,=$"

24personnages +1pour -n.

\umet le caractère suivant dans une chaîne en majuscule . @ThisSuitIsBlackNot ne l'a pas signalé pour sauvegarder 1 octet. Avant, nous utilisions la fonction ucfirst.

Du perldocs ,

Comme autre cas particulier, split émule le comportement par défaut de l'outil de ligne de commande awk lorsque le PATTERN est omis ou une chaîne littérale composée d'un seul caractère d'espacement (tel que '' ou "\ x20", mais pas par exemple / /). Dans ce cas, tous les espaces blancs principaux dans EXPR sont supprimés avant la division, et le motif est alors traité comme s'il s'agissait de / \ s + /; en particulier, cela signifie que tout espace blanc contigu (pas seulement un caractère d'espacement) est utilisé comme séparateur. Toutefois, ce traitement spécial peut être évité en spécifiant le motif / / au lieu de la chaîne "", permettant ainsi à un seul caractère d’espace d’être un séparateur. Dans les précédents Perls, ce cas particulier était limité à l’utilisation d’un "" comme argument de motif à scinder, en Perl 5.18.

Puisque $"évalue à un espace, ceci préservera les espaces. Puisque nous voulons tous les deux définir $,un caractère d'espacement et saisir un caractère d'espacement dans la division, @nutki a souligné que nous pouvons effectuer les deux comme entrée de la division. Cela économise 3 octets par rapport à ce que nous avions auparavant, qui était d’abord paramétré $,puis entré $"dans la division.

Utiliser une ,carte au lieu d' {}enregistrer un octet supplémentaire, comme l'a souligné @ alexander-brett.

Courir avec:

echo 'eCommerce     rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye' | perl -nE'say map"\u$_",split$,=$"'

> <> (Poisson) , 39 octets

</?-' 'o:;?(0:<-*' '*('{'$)'`'::i
i/.0e

Méthode:

• Prenez un caractère et mettez-le en majuscule s'il est à portée a-zpuis imprimez-le. (le code de gauche à droite pour cette partie est i::'backquote')$'{'(*' '*+)
• Si le dernier caractère est pris un EOF ombles puis sortir d' autre imprimer
• Si le dernier caractère est pris un caractère d' espace , puis passez au point 1 autre prendre une nouvelle lettre et passez au point 2.

JAVA, 273 octets

MODIFIER

import static java.lang.System.*;class x{public static void main(String[] s){char[] a=new java.util.Scanner(in).nextLine().toCharArray();boolean f=1>0;for(int i=0;i<a.length;i++){if(a[i]==' '){f=1>0;continue;}if(f){a[i]=Character.toUpperCase(a[i]);f=1<0;}}out.println(a);}}

JavaScript (solution regex) - 104 octets

Quelqu'un doit mordre la balle et publier la solution RegEx! 74 caractères, plus la pénalité de +30 caractères:

alert(prompt().replace(/(^| )[a-z]/g,function(m){return m.toUpperCase()}))

Ou si vous voulez lire et comprendre le code de manière non compactée:

//     Matches the (beginning of the line or a space), followed by a lowercase English character.  
string.replace( /(^| )[a-z]/g ,
                function(match) { return match.toUpperCase(); }

Python 2, 73 octets

i=raw_input()
print''.join((c,c.upper())[p==' ']for p,c in zip(' '+i,i))

Ce programme capitalise une lettre si elle est précédée d’un espace (avec un kludge pour le premier caractère de la chaîne). Il s’appuie sur la .upper()méthode string pour capitaliser correctement.

PHP 64 76 77 83 84 89 bytes

Does $_GET count as input in PHP?
If so, here is my first CG attempt

foreach(explode(' ',$_GET[@s])as$k=>$v)echo$k?' ':'',ucfirst($v)

Thanks manatwork :)

One could just use the ucwords function, which would result in 21 bytes:

<?=ucwords($_GET[@s])

thanks Harry Mustoe-Playfair :)

Haskell, 69

import Data.Char
main=interact$tail.scanl(!)' '
' '!c=toUpper c;_!c=c

Explanation:

scanl takes a function (a -> b -> a) and an initial value a, then iterates over a list of [b]s to make a list of [a]s:

scanl (!) z [a,b,c] == [   z
                       ,   z ! a
                       ,  (z ! a) ! b
                       , ((z ! a) ! b) ! c]

It repeatedly takes the previous result as the left argument of the function passed to it, and a value from the input list as the right argument, to make the next one.

I wrote a function (!) :: Char -> Char -> Char that returns the right character you pass it, but capitalizes it if the left char is ' ' (space). For scanl, this means: return the value from the input list, but capitalize it if the previous result was a space. So scanl (!) ' ' "ab cd" becomes:

    scanl (!) ' ' "ab cd"
==> ' ' : scanl (!) (' ' ! 'a') "b cd"
==> ' ' : scanl (!)     'A'     "b cd"
==> ' ' : 'A' : scanl (!) ('A' ! 'b') " cd"
==> ' ' : 'A' : scanl (!)     'b'     " cd"
==> ' ' : 'A' : 'b' : scanl (!) ('b' ! ' ') "cd"
==> ' ' : 'A' : 'b' : scanl (!)     ' '     "cd"
==> ' ' : 'A' : 'b' : ' ' : scanl (!) (' ' ! 'c') "d"
==> ' ' : 'A' : 'b' : ' ' : scanl (!)     'C'     "d"
==> ' ' : 'A' : 'b' : ' ' : 'C' : scanl (!) ('C' ! 'd') ""
==> ' ' : 'A' : 'b' : ' ' : 'C' : scanl (!)     'd'     ""
==> ' ' : 'A' : 'b' : ' ' : 'C' : 'd' : ""
==> " Ab Cd"

We need the initial value ' ' to capitalize the first letter, but then we chop it off with tail to get our final result.

Pyth, 20 bytes

uXGHr@GH1fqd@+dzTUzz

These multiple spaces really sucks. Otherwise there would have been a really easy 12 bytes solution.

Try it online: Pyth Compiler/Executor

Explanation

                      implicit: z = input string
         f       Uz   filter [0, 1, 2, ..., len(z)-1] for elements T, which satisfy:
          qd@+dzT        " " == (" " + z)[T]
                      (this finds all indices, which should be capitalized)
u                  z  reduce, start with G = z, for H in idices ^ update G by
 XGH                     replace the Hth char of G by
    r   1                upper-case of
     @GH                 G[H]
                      implicitly print result

edit: 16 chars is possible with @Dennis algorithm.

CJam, 14 bytes

It's not the shortest, but...

qS/Sf.{\eu}s1>

Another answer using similar ideas:

qS/Laf.{;eu}S*

.x only changes the first item if one of the parameters has only one item.

Lua, 64 62 61 bytes

Lua is a horrendous language to golf in, so I'm pretty proud of myself for this one.

print(string.gsub(" "..io.read(),"%s%l",string.upper):sub(2))

[Try it here]1 Outdated, will update tommorow

JAVA, 204 211 226 bytes

My first entry on CG, I hope it's fine:

class U{public static void main(String[]s){int i=0;char[]r=s[0].toCharArray();r[0]=Character.toUpperCase(r[0]);for(char c:r){if(c==' '&&i>0)r[i+1]=Character.toUpperCase(r[i+1]);i++;System.out.print(c);}}}

Saved 7 bytes thanks to @TNT

PHP: 76 74 characters

foreach($l=str_split(fgets(STDIN))as$c){echo$l?ucfirst($c):$c;$l=$c==" ";}

Sample run:

bash-4.3$ php -r 'foreach($l=str_split(fgets(STDIN))as$c){echo$l?ucfirst($c):$c;$l=$c==" ";}' <<< 'eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye'
ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye

C, 74 bytes

a,b=1;main(){while((a=getchar())>0)b=isspace(putchar(b?toupper(a):a));}

Makes no assumptions about the run-time character set (ASCII, EBCDIC, Baudot, ...whatever). Does assume that EOF is negative (I think C guarantees that).

a,b=1;
main()
{
    while((a=getchar())>0)
        b=isspace(putchar(b?toupper(a):a));
}

a is the input character; b is true if the last character was space. The only non-obvious bit is that we use the fact that putchar returns the character printed if there's no error.

C# Linq - 187

This is nowhere close to winning but I just love Linq too much.

namespace System{using Linq;class P{static void Main(string[]a){Console.Write(a[0].Substring(1).Aggregate(a[0][0].ToString().ToUpper(),(b,c)=>b[b.Length-1]==32?b+char.ToUpper(c):b+c));}}}

Vim, 11, 10 bytes

qqvUW@qq@q

Explanation:

qq           #Start recording in register 'q'
  vU        #Make the character under the cursor uppercase
     W       #Move forward a WORD
      @q     #recursively call macro 'q'
        q    #stop recording
         @q  #Call the recursive macro

Do I get a gold-badge for outgolfing Dennis?

Bash, 61

a="${@//: / }"
a=(${a//: / })
a="${a[@]^}"
echo "${a//:/ }"

Note the colons are simply to make the program display OK here. In reality these can be some non-printable character, such as BEL.

Output

$ ./cap1st.sh "eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"
ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
$ 

Bash, 12

Sadly this one doesn't preserve leading/mutliple/trailing spaces, but otherwise it works:

echo "${@^}"

Output

$ ./cap1st.sh eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye
ECommerce Rocks. CrazyCamelCase Stuff. _those Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
$ 

Pip, 15 + 1 for -s = 16

{IaUC:a@0a}Ma^s

Explanation:

                  a is first cmdline arg (implicit)
            a^s   Split a on spaces
{         }M      Map this function to each element:
 Ia                 If the word is not empty,
   UC:a@0             uppercase its first character
         a          Return the word
                  Output the resulting list (implicit) joined on spaces (-s flag)

One interesting feature of Pip that this program draws on is the : assignment meta-operator. Most C-like languages have some set of compute-and-assign operators: e.g. x*=5 does the same thing as x=x*5. In Pip, however, you can tack : onto any operator and turn it into a compute-and-assign operator. This even goes for unary operators. So -:x computes -x and assigns it back to x, the same as x:-x would. In this case, UC: is used (together with Pip's mutable strings) to uppercase the first character of a word.

The program takes input from the command-line, requiring an invocation like this:

python3 pip.py -se "{IaUC:a@0a}Ma^s" "test teSt TEST  _test"

C, 125

Not the shortest of solutions, but I really like to golf in C.

char b[99];main(c){while(scanf("%[A-Za-z_-]",b)==1)islower(*b)&&(*b&=223),printf("%s",b);~(c=getchar())&&putchar(c)&&main();}

ungolfed:

char b[99];
main(c)
{
  while(scanf("%[A-Za-z_-]", b) == 1) {
    if(islower(b[0])) {
      b[0] &= 0xDF;
    }
    printf("%s", b);
  }
  if((c = getchar()) != -1) {
      putchar(c);
      main();
  }
}

I don't know wheter using regex-like syntax in scanf is streching the rules, but it works quite nicely. (Well, technically it's not a full regex)

An other thing to consider is that this code only works for words shorter than 99 bytes. But I think this solution will work for most cases.

Haskell: 127 characters

import Data.List
import Data.Char
i=isSpace
s a b=i a==i b
u (w:ws)=(toUpper w):ws
f w=concatMap u$groupBy s w
main=interact f

PHP, 82

echo join(' ',array_map(function($s){return ucfirst($s);},explode(' ',$argv[1])));

Usage :

$ php code.php "eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"

C#, 133 131

using C=System.Console;class P{static void Main(){var s=2>1;foreach(var c in C.ReadLine()){C.Write(s?char.ToUpper(c):c);s=c==32;}}}

Mathematica, 66 bytes

Print@StringReplace[InputString[],WordBoundary~~a_:>ToUpperCase@a]

I would use ToCamelCase, but it doesn't preserve spacing.

R, 139 105 bytes

for(i in 1:length(p<-strsplit(readline(),"")[[1]])){if(i<2||p[i-1]==" ")p[i]=toupper(p[i])};cat(p,sep="")

Ungolfed + explanation:

# Assign p to be a vector of the input read from stdin, split into characters

for(i in 1:length(p <- strsplit(readline(), "")[[1]])) {

    # If we're at the first iteration or the previous character was a space

    if (i < 2 || p[i-1] == " ") {

        # Convert the current character to its uppercase equivalent

        p[i] <- toupper(p[i])
    }
}

# Join the vector elements into a single string and print it to stdout
cat(p, sep = "")

R with regex, 49 41 + 30 = 71 bytes

I'm really bummed; this actually has a better score using regular expressions with the penalty.

gsub("(^.| +.)","\\U\\1",readline(),pe=T)

This matches any single character at the beginning of the string or following any number of spaces and replaces it with an uppercase version of the capture. Note that applying \\U is legit and has no effect for non-letters. pe=T is interpreted as perl = TRUE since it takes advantage of R's partial matching of function parameters and the synonym for TRUE. For whatever reason, R doesn't use Perl-style regular expression by default.

Thanks to MickyT for helping save 8 bytes on the regex approach!