Esta es relativamente rápida, pero estoy seguro de que te gustará.

Codegolf es un programa que tomará la entrada en forma de una oración y luego proporcionará la salida con la primera letra en mayúscula en cada palabra.

Reglas:

1. Las presentaciones pueden no tener la forma de una función. Entonces no:

   function x(y){z=some_kind_of_magic(y);return z;} como su respuesta final ... Su código debe mostrar que toma entrada y proporciona salida.

2. El código debe conservar cualquier otra letra mayúscula que tenga la entrada. Asi que

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

   se representará como

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

3. Algunos de ustedes pueden estar pensando, "¡Fácil, solo usaré regex!" y, por lo tanto, utilizar la expresión regular nativa en el idioma de golf elegido incurrirá en una penalización de 30 caracteres que se aplicará a su recuento de código final. Risa malvada

4. Una "palabra" en este caso es cualquier cosa separada por un espacio. Por palate cleanserlo tanto, son dos palabras, mientras que pigeon-toedse considera una palabra. if_you_love_her_then_you_should_put_a_ring_on_itse considera una palabra Si una palabra comienza con un carácter no alfabético, la palabra se conserva, por lo que _thisdespués de la representación permanece como _this. (Felicitaciones a Martin Buttner por señalar este caso de prueba).

   • 4b. No hay garantía de que las palabras en la frase de entrada estén separadas por un solo espacio.

5. Caso de prueba, (use para probar su 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
   

   Salida:

   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 es el código de golf, el código más corto gana ...

Buena suerte...

CJam, 15 13 bytes

Lq{_eu?_S-}/;

Pruébelo en línea en el intérprete de CJam .

Pseudocó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 los caracteres modificados C se dejan en la pila y, por lo tanto, se imprimen al salir.

CSS 2.1, 49

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

Explicacion :

• La attrfunción toma la entrada de un tatributo HTML (texto).
• La entrada se capitaliza estableciéndose text-transformen capitalize.
• La salida se proporciona como contenido generado, utilizando la contentpropiedad en un pseudo-elemento .::after

Fragmento ejecutable :

: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 especificó el comportamiento deseado: en capitalizemayúscula el primer carácter de cada palabra. Sin embargo, CSS3 pone en mayúscula la primera unidad de letra tipográfica de cada palabra. Por lo tanto, el fragmento anterior no funcionará correctamente ni en IE antiguo, que no seguía CSS 2.1; ni en los nuevos navegadores compatibles que siguen 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 más 4 bytes para 040p(suponiendo que haya interpretado las reglas sobre invocaciones especiales correctamente).

-040establece el separador de registro de entrada $/en un solo espacio, de modo que los espacios se conservan; la \usecuencia de escape convierte el siguiente personaje en mayúscula.

CJam, 17 15 bytes

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

Pruébalo aquí.

Implementación bastante sencilla de la especificación. Utilice el nuevo {}&para evitar errores en espacios consecutivos.

Dos bytes guardados por Dennis.

C, 64 63 bytes

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

Solución: a algunos compiladores (como Clang) no les gustan los parámetros int en lugar de argv, así que lo moví a una variable global. El recuento de bytes permanece igual. Gracias a aprensivo ossifrage por notarlo. Hasta 63 bytes, gracias Dennis.

Sin golf:

int a;

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

Bastante sencillo: si a es falso, el personaje se convierte a mayúsculas. Se establece después de leer un espacio: c - '' es falso solo si c == ''. toupper () ignora todo lo que no sea una letra minúscula, por lo que los símbolos y los espacios múltiples están bien. -1 tiene todos los bits establecidos, así que cuando getchar () devuelve -1, el operador NOT lo pone a cero y el ciclo se detiene. a se declara como una variable global, por lo que se inicializa a cero (falso). Esto asegura que la primera palabra esté en mayúscula.

Python 3, 59 56 bytes

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

Gracias a @Reticality por 3 bytes.

Versión Perl <5.18, 30 27 26 25

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

24personajes +1para -n.

\uhace que el siguiente carácter en una cadena sea mayúscula . @ThisSuitIsBlackNot señaló esto para ahorrar 1 byte. Antes estábamos usando la función ucfirst.

De los perldocs ,

Como otro caso especial, dividir emula el comportamiento predeterminado de la herramienta de línea de comandos awk cuando se omite el PATRÓN o una cadena literal compuesta de un solo carácter de espacio (como '' o "\ x20", pero no por ejemplo / /). En este caso, cualquier espacio en blanco inicial en EXPR se elimina antes de que ocurra la división, y el PATRÓN se trata como si fuera / \ s + /; en particular, esto significa que cualquier espacio en blanco contiguo (no solo un carácter de espacio simple) se usa como separador. Sin embargo, este tratamiento especial puede evitarse especificando el patrón / / en lugar de la cadena "", permitiendo así que solo un carácter de espacio sea un separador. En Perls anteriores, este caso especial se restringía al uso de un "" simple como argumento de patrón para dividir, en Perl 5.18.

Como se $"evalúa como un espacio, esto preservará los espacios. Como queremos establecer ambos $,un carácter de espacio e ingresar un carácter de espacio en la división, @nutki señaló que podemos hacer ambas cosas como la entrada a la división. Eso ahorra 3 bytes de lo que teníamos antes, que primero estaba configurando $,y luego ingresando $"a la división.

Usar un ,mapa for en lugar de {}guardar un byte adicional, como señaló @ alexander-brett.

Corre con:

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

> <> (Pescado) , 39 bytes

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

Método:

• Tome un carácter y capitalícelo si está dentro del rango y a-zluego imprímalo. (el código de izquierda a derecha para esta parte es i::'backquote')$'{'(*' '*+)
• Si el último carácter tomado es un carácter EOF , salga de lo contrario imprímalo
• Si el último carácter tomado es un carácter espacial , vaya al punto 1 , tome una nueva letra y vaya al punto 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 (solución regex) - 104 bytes

¡Alguien tiene que morder la bala y publicar la solución RegEx! 74 caracteres, más la penalización de +30 caracteres:

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

O si desea leer y comprender el código de manera no 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 escribe en mayúscula una letra si está precedida por un espacio (con un kludge para el primer carácter de la cadena). Se basa en el .upper()método de cadena para capitalizar correctamente.

PHP 64 76 77 83 84 89 bytes

Hace $_GET Cuenta como entrada en PHP?
Si es así, aquí está mi primer intento de CG

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

Gracias manatwork :)

Uno podría usar el ucwords función, lo que daría como resultado 21 bytes:

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

gracias Harry Mustoe-Playfair :)

Haskell, 69

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

Explicación:

scanltoma una función (a -> b -> a)y un valor inicial a, luego itera sobre una lista de [b]s para hacer una lista de [a]s:

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

Repetidamente toma el resultado anterior como el argumento izquierdo de la función que se le pasó, y un valor de la lista de entrada como argumento correcto , para hacer el siguiente.

Escribí una función (!) :: Char -> Char -> Charque devuelve el carácter correcto al pasarlo, pero lo capitaliza si el carácter izquierdo es ' '(espacio). Para scanl, esto significa: devolver el valor de la lista de entrada , pero ponerlo en mayúscula si el resultado anterior fue un espacio. Entonces se scanl (!) ' ' "ab cd"convierte en:

    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"

Necesitamos el valor inicial ' 'para poner en mayúscula la primera letra, pero luego la cortamos tailpara obtener nuestro resultado final.

Pyth, 20 bytes

uXGHr@GH1fqd@+dzTUzz

Estos múltiples espacios realmente apestan. De lo contrario, habría habido una solución realmente fácil de 12 bytes.

Pruébelo en línea: Pyth Compiler / Executor

Explicación

                      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

editar: 16 caracteres son posibles con el algoritmo @Dennis.

CJam, 14 bytes

No es el más corto, pero ...

qS/Sf.{\eu}s1>

Otra respuesta usando ideas similares:

qS/Laf.{;eu}S*

.x solo cambia el primer elemento si uno de los parámetros tiene solo un elemento.

Lua, 64 62 61 bytes

Lua es un lenguaje horrible para el golf, así que estoy muy orgulloso de mí mismo por este.

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

[Pruébalo aquí] 1 Desactualizado, actualizará mañana

JAVA, 204 211 226 bytes

Mi primera entrada en CG, espero que esté bien:

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 gracias a @TNT

PHP: 76 74 caracteres

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

Ejecución de muestra:

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

No hace suposiciones sobre el conjunto de caracteres en tiempo de ejecución (ASCII, EBCDIC, Baudot, ... lo que sea). Asume que EOF es negativo (creo que C lo garantiza).

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

a es el carácter de entrada; b es verdadero si el último carácter fue el espacio. El único bit no obvio es que usamos el hecho de que putchardevuelve el carácter impreso si no hay ningún error.

C # Linq - 187

Esto no está cerca de ganar, pero me encanta demasiado Linq.

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

Explicación:

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

¿Recibo una insignia de oro por superar a Dennis?

Bash, 61

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

Tenga en cuenta que los dos puntos son simplemente para hacer que el programa muestre OK aquí. En realidad, estos pueden ser algunos caracteres no imprimibles, como BEL.

Salida

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

Lamentablemente, este no conserva espacios iniciales / múltiples / finales, pero de lo contrario funciona:

echo "${@^}"

Salida

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

Explicación:

                  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)

Una característica interesante de Pip en la que se basa este programa es el :metaoperador de asignación. La mayoría de los lenguajes tipo C tienen algún conjunto de operadores de cálculo y asignación: por ejemplo, x*=5hace lo mismo que x=x*5. En la pipa, sin embargo, puede virar :a cualquier operador y convertirlo en un operador de cómputo-and-asignación. Esto incluso se aplica a operadores unarios. Entonces lo -:xcalcula -xy lo asigna de nuevo x, igual que lo x:-xharía. En este caso, UC:se usa (junto con las cadenas mutables de Pip) para poner en mayúscula el primer carácter de una palabra.

El programa toma información de la línea de comandos, lo que requiere una invocación como esta:

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

C, 125

No es la solución más corta, pero realmente me gusta jugar golf en 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();}

sin golf:

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

No sé si usar una sintaxis de tipo regex scanfes estirar las reglas, pero funciona bastante bien. (Bueno, técnicamente no es una expresión regular completa )

Otra cosa a tener en cuenta es que este código solo funciona para palabras de menos de 99 bytes. Pero creo que esta solución funcionará en la mayoría de los 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]

Lo usaría ToCamelCase, pero no conserva el espacio.

R, 139105 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 + explicación:

# 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 con expresión regular, 49 41 + 30 = 71 bytes

Estoy realmente desanimado; esto en realidad tiene una mejor puntuación usando expresiones regulares con la penalización.

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

Esto coincide con cualquier carácter individual al comienzo de la cadena o después de cualquier número de espacios y lo reemplaza con una versión en mayúscula de la captura. Tenga en cuenta que la aplicación \\Ues legítima y no tiene ningún efecto para las no letras. pe=Tse interpreta perl = TRUEya que aprovecha la coincidencia parcial de R de los parámetros de función y el sinónimo de TRUE. Por alguna razón, R no usa la expresión regular estilo Perl por defecto.

¡Gracias a MickyT por ayudar a ahorrar 8 bytes en el enfoque regex!