É relativamente rápido, mas tenho certeza que você vai gostar.

Codegolf um programa que terá entrada na forma de uma frase e fornecerá a saída com a primeira letra maiúscula em cada palavra.

Regras:

1. Os envios podem não estar na forma de uma função. Então não:

   function x(y){z=some_kind_of_magic(y);return z;} como sua resposta final ... Seu código deve mostrar que recebe entrada e fornece saída.

2. O código deve preservar quaisquer outras letras maiúsculas que a entrada possui. tão

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

   será renderizado como

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

3. Alguns de vocês podem estar pensando: "Calma, vou usar regex!" e, portanto, o uso da expressão regular nativa no idioma de golfe escolhido sofrerá uma penalidade de 30 caracteres, que será aplicada à sua contagem final de códigos. Risada maléfica

4. Uma "palavra" neste caso é qualquer coisa separada por um espaço. Portanto, palate cleanserhá duas palavras, enquanto que pigeon-toedé considerada uma palavra. if_you_love_her_then_you_should_put_a_ring_on_ité considerado uma palavra. Se uma palavra começa com um caracter não alfabético, a palavra é preservada; portanto, _thisapós a renderização, permanece como _this. (Parabéns a Martin Buttner por apontar este caso de teste).

   • 4b Não há garantia de que as palavras na frase de entrada sejam separadas por um único espaço.

5. Caso de teste (use para testar seu código):

   Entrada:

   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
   

   Saída:

   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. Este é o código de golfe, o código mais curto vence ...

Boa sorte...

CJam, 15 13 bytes

Lq{_eu?_S-}/;

Experimente online no intérprete CJam .

Pseudo-código

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)

Todos os caracteres modificados C são deixados na pilha e, portanto, impressos ao sair.

CSS 2.1, 49

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

Explicação :

• A attrfunção recebe a entrada de um tatributo HTML (texto).
• A entrada é maiúscula, configurando text-transformpara capitalize.
• A saída é fornecida como um conteúdo gerado, usando a contentpropriedade em um pseudoelemento .::after

Fragmento executável :

: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>

Nota : CSS 2.1 especificou o comportamento desejado: capitalizecoloque o primeiro caractere de cada palavra em maiúsculas. No entanto, o CSS3 maiúscula a primeira unidade de letra tipográfica de cada palavra. Portanto, o snippet acima não funcionará corretamente nem no IE antigo, que não seguia o CSS 2.1; nem em novos navegadores compatíveis que seguem CSS3.

Javascript ( ES6 ), 77 bytes

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

Comentado

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 bytes

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

9 bytes mais 4 bytes para 040p(assumindo que eu tenha interpretado as regras sobre invocações especiais corretamente).

-040define o separador de registro de entrada $/para um único espaço, para que os espaços sejam preservados; a \usequência de escape converte o próximo caractere em maiúscula.

CJam, 17 15 bytes

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

Teste aqui.

Implementação bastante direta das especificações. Utilize o novo {}&para evitar erros em espaços consecutivos.

Dois bytes salvos por Dennis.

C, 64 63 bytes

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

Correção: alguns compiladores (como Clang) não gostam de parâmetros int no lugar do argv, então mudei para uma variável global. A contagem de bytes permanece a mesma. Graças a ossifrage melindroso por perceber. Até 63 bytes, obrigado Dennis.

Ungolfed:

int a;

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

Bem direto: se a é falso, o caractere é convertido em maiúsculas. É definido após a leitura de um espaço: c - '' é falso apenas se c == ''. toupper () ignora tudo que não é uma letra minúscula; portanto, símbolos e vários espaços são adequados. -1 possui todos os bits configurados; portanto, quando getchar () retorna -1, o operador NOT o torna zero e o loop para. a é declarado como uma variável global e, portanto, é inicializado como zero (falso). Isso garante que a primeira palavra seja maiúscula.

Python 3, 59 56 bytes

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

Graças a @Reticality por 3 bytes.

Versão Perl <5.18, 30 27 26 25

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

24caracteres +1para -n.

\utorna o próximo caractere em uma seqüência de caracteres em maiúsculas . @ThisSuitIsBlackNot apontou isso para economizar 1 byte. Antes estávamos usando a função ucfirst.

Dos perldocs ,

Como outro caso especial, split emula o comportamento padrão da ferramenta de linha de comando awk quando o PATTERN é omitido ou uma string literal composta por um caractere de espaço único (como '' ou "\ x20", mas não por exemplo / / /). Nesse caso, qualquer espaço em branco à esquerda no EXPR é removido antes da divisão, e o PATTERN é tratado como se fosse / \ s + /; em particular, isso significa que qualquer espaço em branco contíguo (não apenas um caractere de espaço único) é usado como um separador. No entanto, esse tratamento especial pode ser evitado especificando o padrão / / em vez da sequência "", permitindo assim que apenas um caractere de espaço seja um separador. No Perls anterior, este caso especial estava restrito ao uso de um "" simples como argumento padrão a ser dividido, no Perl 5.18.

Como $"avalia um espaço, isso preservará os espaços. Como queremos definir $,um caractere de espaço e inserir um caractere de espaço na divisão, @nutki apontou que podemos fazer as duas coisas como entrada da divisão. Isso economiza 3 bytes do que tínhamos antes, que foi a primeira configuração $,e depois a entrada $"na divisão.

Usar um ,mapa for em vez de {}salvar um byte adicional, como @ alexander-brett apontou.

Correr com:

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$,=$"'

> <> (Peixe) , 39 bytes

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

Método:

• Pegue um caractere e coloque-o em maiúscula, se estiver dentro do alcance, a-ze imprima-o. (o código da esquerda para a direita desta parte é i::'backquote')$'{'(*' '*+)
• Se o último caractere obtido é um EOF, então saia ou imprima
• Se o último caractere obtido for um espaço , vá para o ponto 1 , pegue uma nova letra e vá para o ponto 2.

JAVA, 273 bytes

EDITAR

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 (solução regex) - 104 bytes

Alguém tem que morder a bala e postar a solução RegEx! 74 caracteres, mais a penalidade de +30 caracteres:

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

Ou se você quiser ler e entender o código de maneira não compactada:

//     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 bytes

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

Este programa coloca em maiúscula uma letra se precedido por um espaço (com um kludge para o primeiro caractere na string). Ele se baseia no .upper()método string para capitalizar corretamente.

PHP 64 76 77 83 84 89 bytes

Conta $_GETcomo entrada em PHP?
Se sim, aqui está minha primeira tentativa de computação gráfica

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

Graças manatwork :)

Pode-se usar a ucwordsfunção, o que resultaria em 21 bytes:

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

obrigado Harry Mustoe-Playfair :)

Haskell, 69

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

Explicação:

scanlpega uma função (a -> b -> a)e um valor inicial ae itera sobre uma lista de [b]s para criar uma lista de [a]s:

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

Ele pega repetidamente o resultado anterior como o argumento esquerdo da função passado para ele e um valor da lista de entrada como o argumento correto , para fazer o próximo.

Eu escrevi uma função (!) :: Char -> Char -> Charque retorna o caractere certo que você passa, mas coloca em maiúscula se o caractere esquerdo for ' '(espaço). Pois scanl, isso significa: retornar o valor da lista de entrada , mas colocar em maiúscula se o resultado anterior for um espaço. Assim scanl (!) ' ' "ab cd"se torna:

    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"

Precisamos do valor inicial ' 'para colocar em maiúscula a primeira letra, mas depois a cortamos tailpara obter nosso resultado final.

Pitão, 20 bytes

uXGHr@GH1fqd@+dzTUzz

Esses espaços múltiplos são realmente péssimos. Caso contrário, haveria uma solução realmente fácil de 12 bytes.

Experimente on-line: Compilador / Executor Pyth

Explicação

                      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 caracteres são possíveis com o algoritmo @Dennis.

CJam, 14 bytes

Não é o mais curto, mas ...

qS/Sf.{\eu}s1>

Outra resposta usando idéias semelhantes:

qS/Laf.{;eu}S*

.x somente altera o primeiro item se um dos parâmetros tiver apenas um item.

Lua, 64 62 61 bytes

Lua é uma linguagem horrenda para jogar golfe, então estou muito orgulhosa de mim mesma por esta.

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

[Experimente aqui] 1 Desatualizado, atualizará amanhã

JAVA, 204 211 226 bytes

Minha primeira entrada no CG, espero que esteja bem:

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

Guardado 7 bytes graças a @TNT

PHP: 76 74 caracteres

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

Exemplo de execução:

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

Não faz suposições sobre o conjunto de caracteres em tempo de execução (ASCII, EBCDIC, Baudot, ... qualquer que seja). Assume que o EOF é negativo (acho que C garante isso).

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

a é o caractere de entrada; b é verdadeiro se o último caractere for espaço. O único bit não óbvio é que usamos o fato de putcharretornar o caractere impresso se não houver erro.

C # Linq - 187

Isso não está nem perto de ganhar, mas eu amo Linq demais.

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

Explicação:

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

Recebo um distintivo de ouro por derrotar Dennis?

Bash, 61

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

Observe que os dois pontos são simplesmente para fazer o programa exibir OK aqui. Na realidade, esses caracteres podem ser imprimíveis, como BEL.

Saída

$ ./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

Infelizmente este não preserva espaços à esquerda / múltiplos / à direita, mas, caso contrário, funciona:

echo "${@^}"

Saída

$ ./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 para -s= 16

{IaUC:a@0a}Ma^s

Explicação:

                  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)

Uma característica interessante do Pip que este programa utiliza é o :meta-operador de atribuição. A maioria das linguagens tipo C possui algum conjunto de operadores de computação e atribuição: por exemplo, x*=5faz a mesma coisa que x=x*5. No Pip, no entanto, você pode prender :em qualquer operador e transformá-lo em um operador de computação e atribuição. Isso vale mesmo para operadores unários. Então -:xcalcula -xe atribui de volta x, da mesma forma que x:-xfaria. Nesse caso,UC: é usado (junto com as seqüências mutáveis ​​do Pip) para colocar em maiúscula o primeiro caractere de uma palavra.

O programa recebe entrada da linha de comando, exigindo uma chamada como esta:

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

C, 125

Não é a menor das soluções, mas eu realmente gosto de jogar golfe em 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();
  }
}

Eu não sei se o uso de sintaxe do tipo regex scanfestá estendendo as regras, mas funciona muito bem. (Bem, tecnicamente, não é um regex completo )

Outra coisa a considerar é que esse código funciona apenas para palavras menores que 99 bytes. Mas acho que essa solução funcionará na maioria dos casos.

Haskell: 127 caracteres

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])));

Uso:

$ 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]

Eu usaria ToCamelCase, mas não preserva o espaçamento.

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 + explicação:

# 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 com regex, 49 41 + 30 = 71 bytes

Estou realmente chateado; isso realmente tem uma pontuação melhor usando expressões regulares com a penalidade.

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

Isso corresponde a qualquer caractere único no início da sequência ou após qualquer número de espaços e o substitui por uma versão em maiúscula da captura. Observe que a inscrição \\Ué legítima e não tem efeito para não letras. pe=Té interpretado como perl = TRUEuma vez que tira proveito da correspondência parcial de parâmetros de função de R e do sinônimo de TRUE. Por qualquer motivo, R não usa a expressão regular no estilo Perl por padrão.

Agradecemos a MickyT por ajudar a economizar 8 bytes na abordagem regex!