Dada una cadena, capitalícela. Por capitalización quiero decir conTeNT-lENgthcambios a Content-Length. En el ejemplo, mostré la cadena con 2 palabras con -el límite de la palabra. Sin embargo, espero que escriba el código de la cadena que contiene cualquier número de palabras separadas por un solo carácter como límite. Este límite puede cambiar a través de la cadena.

Condiciones

1. el uso noregular expressions está permitido .
2. puede haber cualquier cantidad de palabras en una oración (cadena).
3. cada palabra consistirá en Englishletras [a-zA-Z]de cualquier caso.
4. diferentes palabras en la oración estarán separadas por un solo carácter. Este personaje será solamente ser cualquiera de -, ., <space-character>, /, &, #. Puede asumir con seguridad que la oración no contendrá ningún otro carácter, excepto los mencionados.
5. los límites de palabras deben conservarse en la salida.
6. el código más corto gana.

Por ejemplo, su programa debería generar Begin/With.Type&Contentpara BeGin/wITH.tyPE&conTeNt.

Some test cases:
 "aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe" 
 "type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe" 
 "cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc" 
 "lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT" 
 "contENT/ACcEpT" 
 "BeGin/wITH.tyPE&conTeNt"
 "Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with" 
 "RaNgE&COnTeNT WITh CoNTENT-TypE tyPe"
 "BEgin COdE#uSeR#aGeNt.USeR"
 "TypE LENGth"

GolfScript, 36 27 19 caracteres

0\{95&+.47>32*\}%\;

Un enfoque bastante básico de GolfScript que funciona para todas las entradas de acuerdo con la especificación. Los ejemplos se pueden probar en línea .

Python 3,22

print(input().title())

Este código tomará una cadena como entrada de stdin y le dará una salida en mayúscula a stdout.

por ejemplo:

entrada:

BEGIN/wITH.tyPe&cOnTENt

salida:

Begin/With.Type&Content

El siguiente código es para entradas de varias líneas (si es necesario)

Pitón 3, 46

import sys
for i in sys.stdin:print(i.title())

Mathematica 62

Datos

tests={"aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe","type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe","cc/rEspoNCe.lEngtH#tYpEwitH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc","lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT","contENT/ACcEpT","BeGin/wITH.tyPE&conTeNt","Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with","RaNgE&COnTeNT WITh CoNTENT-TypE tyPe","BEgin COdE#uSeR#aGeNt.USeR","TypE LENGth"}

Código

StringReplace[ToLowerCase@#,WordBoundary~~x_:>ToUpperCase@x]&

Uso

f["aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe"]

"Agente aceptado / Tipo de longitud Rango de usuario. Tipo"

f /@ tests

{"Aceptar agente / Longitud-Tipo de usuario Rango. Tipo",
"Tipo y agente / Cc / Contenido Longitud # Aceptar / Agente.Rango-Cc / Contenido / Código", "Cc / Respuesta. Longitud # Tipo-con y usuario / Comenzar y usuario. Agente y comenzar / Aceptar / Cc "," Longitud # Usuario. Tipo / Principio y Tipo de longitud / Aceptar # Rango / Código y Y-Aceptar / Contenido "," Contenido / Aceptar ",
" Comenzar / Con.Tipo y Contenido ",
" Código.Cc # Usuario. Longitud-Usuario -Y Tipo de tipo y longitud. Tipo de usuario. Usuario y con ",
" Rango y contenido con tipo de contenido tipo ",
" Código de inicio # Usuario # Agente.Usuario ",
" Longitud de tipo "}

JavaScript (94)

prompt().split(l='').map(function(a){return l='A'>l?a.toUpperCase():a.toLowerCase()}).join('')

PHP: 78 73 65 64 caracteres

$b=ucfirst;foreach(str_split($s)as$c)echo$b($c),!$b[0]=$c<A?u:l;

La entrada se pasa $s. Funciona en la cadena como una matriz de caracteres.

Es una máquina simple de 2 estados. Se basa en el ordenamiento léxico de cadenas, y que el analizador asume automáticamente que en algunos casos tenía la intención de escribir una cadena.

El estado se almacena $by se representa como el nombre de la función que debe llamarse en el siguiente carácter. ucfirsty lcfirstson más cortos de escribir y tienen un comportamiento idéntico a strtolower/ strtoupperen cadenas de caracteres individuales. Además, dado que solo difieren en una letra, podemos usarlos de manera eficiente para almacenar el estado. La versión original necesitaba almacenar el estado explícitamente en un booleano.

Como echo no imprime nada para boolean false, utilicé una coma y el !operador para "ocultar" la asignación (que en este caso es verdadera) en la declaración de echo. Esto me permitió guardar un personaje eliminando el {}.

C, 83

n;main(c){c=getchar();putchar(c>96?n?c:(n=c-32):c&64?n?c+32:(n=c):(n=0,c));main();}

Toma líneas stdin, las traduce a stdout. (Prefiere SIGINTa EOF.)

Powershell: 37-43

Dependiendo de cómo desea tomar la entrada ...

Solicitar al usuario su aporte: 43

(Culture).TextInfo.ToTitleCase((read-host))

Tomar entrada de la tubería: 38

(Culture).TextInfo.ToTitleCase($input)

Proporcione información como argumento al ejecutar el script: 37

(Culture).TextInfo.ToTitleCase($args)

NOTA: Las secuencias de comandos anteriores ignorarán las palabras mayúsculas, dejándolas como están. Si esto debe tenerse en cuenta, la entrada debe forzarse a minúsculas antes de la conversión de mayúsculas y minúsculas. Esto agrega 10 caracteres al primer método y 12 a los otros dos.

(Culture).TextInfo.ToTitleCase((read-host).ToLower())
(Culture).TextInfo.ToTitleCase("$input".ToLower())
(Culture).TextInfo.ToTitleCase("$args".ToLower())

Java - 209 caracteres

class C{
public static void main(String[]a){
for(String b:a){
char[]k=b.toLowerCase().toCharArray();
for(int i=-1;i<k.length;i++){if(i<0||"-. /&#".indexOf(k[i])>=0)k[++i]=(char)(k[i]-32);}
System.out.println(k);}}}

Agregué nuevas líneas solo para facilitar la lectura.

R, 143 116

Tal vez una solución un poco larga, pero aquí vamos:

f=function(x){a=sapply(1:nchar(x),function(y)substr(tolower(x),y,y));d=c(1,which(!a%in%letters)+1);a[d]=toupper(a[d]);cat(a,sep="")}

Ligeramente desanimado y explicado:

f <- function(x){
    #Split the string in characters and "lower-case" everything
    a <- sapply(1:nchar(x),function(y)substr(tolower(x),y,y))
    #Select the first character and each character following a 
    #character that doesn't belong to lower case alphabet
    d <- c(1,which(!a%in%letters)+1)
    #Make those ones uppercase.
    a[d] <- toupper(a[d])
    #Output (stdout) while pasting them back together.
    cat(a,sep="")
    }

Editar : 116 caracteres

El principal desafío aquí es vectorizar substr. Aquí hay otra forma menos detallada.

f=function(x){n=1:nchar(x);a=mapply(substr,tolower(x),n,n);d=c(T,!a%in%letters);a[d]=toupper(a[d]);cat(a[n],sep="")}

Sangrado:

f <- function(x){
    n <- 1:nchar(x)
    a <- mapply(substr,tolower(x),n,n)
    d <- c(T,!a%in%letters) #This has been simplified as well
    a[d] <- toupper(a[d])
    cat(a[n],sep="") #Because a is now 1 char longer than x, need to subset a
    }

Uso:

> f("aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe")
Agent Accept/Length-Type User Range.Type

Befunge 98 - 24 45

~\j:'``!3*j' -;:'``b*j:'/`!3*j' +#;:,'/`!jc#@

Escribir esto hirió mi cerebro.

Esto lleva la entrada ~y si el carácter anterior era uno de los separadores (o si no había ningún carácter anterior), se ejecuta

:'``!3*j' -;

Este fragmento toma el carácter, y si su valor ascii es mayor o igual que a, resta 32 de él, cambiando así a mayúscula. Si es menor que a, 3*jomite el ajuste. Luego, se salta la siguiente parte. Esta parte maneja el cambio de mayúsculas a minúsculas (estoy seguro de que se puede combinar con la siguiente parte; simplemente no estoy seguro de cómo):

:'``b*j:'/`!3*j' +#;

El carácter se imprime ( ,), luego esto verifica si el carácter es uno de los límites:

'/`!

Básicamente compara el carácter con el valor ascii de /. Si el personaje no es un límite, el código lo empuja 12para que se salteará el ajuste de capitalización la próxima vez. #salta sobre el programa final: @y, si se alcanza el final de la entrada, ~envía la ejecución del código nuevamente al @final del programa.

Ruby: 60 51 50 47 caracteres

$_.downcase.chars{|c|$><<$/=$/<?0?c.upcase: c}

Ejecución de muestra:

bash-4.1$ for line in "${test[@]}"; do printf '%-75s | %s\n' "$line" "$( ruby -ne '$_.downcase.chars{|c|$><<$/=$/<?0?c.upcase: c}' <<< "$line" )"; done
aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe                                    | Agent Accept/Length-Type User Range.Type
type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe             | Type&Agent/Cc/Content Length#Accept/Agent.Range-Cc/Content/Code
cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc          | Cc/Responce.Length#Type-With&User/Begin&User.Agent&Begin/Accept/Cc
lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT     | Length#User.Type/Begin&Length Type/Accept#Range/Code&And-Accept/Content
contENT/ACcEpT                                                              | Content/Accept
BeGin/wITH.tyPE&conTeNt                                                     | Begin/With.Type&Content
Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with           | Code.Cc#User.Length-User-And&Type Type&Length.Type User.User&With
RaNgE&COnTeNT WITh CoNTENT-TypE tyPe                                        | Range&Content With Content-Type Type
BEgin COdE#uSeR#aGeNt.USeR                                                  | Begin Code#User#Agent.User
TypE LENGth                                                                 | Type Length

C # - 110

Un procesamiento simple basado en máquina de estado finito:

x.Aggregate(new{b=1>0,r=""},(s,c)=>new{b="-. /&#".Contains(c),r=s.r+(s.b?Char.ToUpper(c):Char.ToLower(c))}).r

(donde xestá el stringcapitalizar)

y, por supuesto, si quieres ser aburrido (después de actualizar la especificación), puedes usar

new CultureInfo(9).TextInfo.ToTitleCase(x)

o, con todo el aburrido repetitivo:

class C{static void Main(string[]a){System.Console.WriteLine(new System.Globalization.CultureInfo(9).TextInfo.ToTitleCase(a[0]));}}

Javascript 102

prompt().split(o=q='').map(function(c){o+=(q)?c.toLowerCase():c.toUpperCase(),q=('A'>c)?0:1})
alert(o)

Adelante, 135

: s swap ;
: c 1 begin key dup 96 > if s if 32 - then 0 s 
else dup 64 > if s 0= if 32 + then 0 s then else 1 s then then emit again ; c

La salida traducida se escribe a stdoutmedida que se lee stdin.

Befunge-98 (29), C (65)

Dado que el método / algoritmo es más o menos el mismo, incluyo ambas versiones en la misma publicación. Ambos confían en realizar un seguimiento de si el último carácter fue un símbolo o una letra, para saber si se debe minúscula o no.

#@~:'0` #v_,0>
',++@'% '<   ^

c,d;main(){for(;~(c=getchar());d=c>48)putchar(c<48?c:c&95|32*d);}

05AB1E , 1 byte

Código:

™

Explicación:

™   # Implicit input which is converted to title case.

Pruébalo en línea!

Excel VBA-11 caracteres

En la ventana Inmediato

?[Proper()]

VBscript

Set xlapp = CreateObject("excel.application")
wscript.echo xlapp.Evaluate("Proper(""BeGin/wITH.tyPE&conTeNt"")"

AWK 113 103 bytes

{for(;++i<=split($0,a,"");){s=a[i]
O=O (L?tolower(s):toupper(s))
L=1
if(index("-. /&#",s))L=0}print O}

Esto funciona bien para el contenido de una sola línea, pero para la entrada multilínea se necesita agregar un par de inits

{O=""
for(L=0;++i<=split($0,a,"");){s=a[i]
O=O (L?tolower(s):toupper(s))
L=1
if(index("-. /&#",s))L=0}print O}

Sería bueno si pudiéramos aprovechar la división automática de un registro en campos y modificar dichos campos, pero luego perderíamos nuestros separadores de campo. :(

Sé que esta no es la mejor respuesta y esta es una pregunta bastante antigua, pero creo que AWK está subrepresentada en el espacio de respuesta de CG :)

(Gracias @manatwork por probar el código, debería funcionar ahora :) También cambió el flujo pero mantuvo el recuento de bytes igual, al reemplazar algunos ;con nuevas líneas.

PHP (> v5.4.32) - 25 caracteres

<?=ucwords($a,'-. /&#')?>

Explicación:

• ucwords () es una función PHP integrada

• El primer parámetro $aes la entrada.

• El segundo parámetro son los delimitadores (caracteres no alfabéticos encontrados en casos de prueba)

• Se supone retorno / eco / impresión debido al uso de <?= ?>

Enlaces:

• Código de juegos

• Función PHP ucwords ()

T-SQL, 179

DECLARE @T VARCHAR(MAX)='foo',@X VARCHAR(2),@ INT=0WHILE @<LEN(@T)SELECT @X=SUBSTRING(@T,@,2),@+=1,@T=STUFF(@T,@,1,IIF(@X LIKE'[a-Z]_',LOWER(RIGHT(@X,1)),UPPER(RIGHT(@X,1))))PRINT @T

Pruebe la versión SELECT en SQL Server 2012 aquí .

Reemplace "foo" con la cadena de entrada. El recuento de caracteres es para una cadena de longitud cero. Este código atraviesa la cadena usando un índice, en mayúsculas o minúsculas en esa posición en función del carácter anterior.

JavaScript (Node.js) , 70 bytes

c=>a=>c.split``.map(b=>a="A">a?b.toUpperCase():b.toLowerCase()).join``

Pruébalo en línea!

Estoy seguro de que esto se puede jugar más golf.

Nota :

Toma entrada vía f(string)(), los últimos son obligatorios pero no realizan nada.

Powershell, 77 75 bytes

Esta solución cumple totalmente con las reglas de la tarea (incluso un ejemplo ambiguo foo:bar).

-join($args|% t*y|%{"$_"|%('ToU*r','ToL*r')[+$l];$l=!('# -./&'|% Co*s $_)})

Vea también la solución Powershell con función integrada ToTitleCase de @Iszi.

Script de prueba explicado:

$f = {

-join(
$args|% t*y|%{                   # for each char from input string
    "$_"|%('ToU*r','ToL*r')[+$l] # evaluate ToUpper or ToLower method depend on $l (lower) value
                                 # Note the variable $l is not defined for a first char
                                 # so it evaluates toUpper for the first char 
    $l=!('# -./&'|% Co*s $_)     # golfed form for $l=!'# -./&'.Contains($_) expression
                                 # =0 if the current char is specified separator (toUpper for next char)
}                                # =1 otherwise (toLower for next char)
)                                # finally, join all chars to a result string

}

@(
    ,('foo:bar'                                                                 ,'Foo:bar')
    ,('aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe'                                ,'Agent Accept/Length-Type User Range.Type')
    ,('type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe'         ,'Type&Agent/Cc/Content Length#Accept/Agent.Range-Cc/Content/Code')
    ,('cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc'      ,'Cc/Responce.Length#Type-With&User/Begin&User.Agent&Begin/Accept/Cc')
    ,('lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT' ,'Length#User.Type/Begin&Length Type/Accept#Range/Code&And-Accept/Content')
    ,('contENT/ACcEpT'                                                          ,'Content/Accept')
    ,('BeGin/wITH.tyPE&conTeNt'                                                 ,'Begin/With.Type&Content')
    ,('Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with'       ,'Code.Cc#User.Length-User-And&Type Type&Length.Type User.User&With')
    ,('RaNgE&COnTeNT WITh CoNTENT-TypE tyPe'                                    ,'Range&Content With Content-Type Type')
    ,('BEgin COdE#uSeR#aGeNt.USeR'                                              ,'Begin Code#User#Agent.User')
    ,('TypE LENGth'                                                             ,'Type Length')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-ceq$e): $r"
}

Salida:

True: Foo:bar
True: Agent Accept/Length-Type User Range.Type
True: Type&Agent/Cc/Content Length#Accept/Agent.Range-Cc/Content/Code
True: Cc/Responce.Length#Type-With&User/Begin&User.Agent&Begin/Accept/Cc
True: Length#User.Type/Begin&Length Type/Accept#Range/Code&And-Accept/Content
True: Content/Accept
True: Begin/With.Type&Content
True: Code.Cc#User.Length-User-And&Type Type&Length.Type User.User&With
True: Range&Content With Content-Type Type
True: Begin Code#User#Agent.User
True: Type Length

QBasic, 74 bytes

1c$=LCASE$(INPUT$(1))
IF f=0THEN c$=UCASE$(c$)
f=c$>"@
?c$;
IF""<c$GOTO 1

Los bytes se cuentan en CP-437 ; es un solo byte (código de carácter 20).

El método de entrada aquí es un poco extraño: los caracteres se escriben uno a la vez, y su uso de mayúsculas se convierte antes de mostrarse. Entonces, cuando escribe aGeNT, aparece en la pantalla como Agent. Golpear Entertermina el programa.

Python 3 , 122 bytes

lambda s:''.join(chr(ord(c)+[[0,0],[0,32],[-32,0]][('@'<c<'[')-('`'<c<'{')]['@'<p<'['or'`'<p<'{'])for c,p in zip(s,'-'+s))

Pruébalo en línea!

No es un gran puntaje, pero quería probarlo sin operaciones de cadena incorporadas para cambiar los casos.

PHP - 23 caracteres

mb_convert_case ($ w, 2);

Necesita php_mbstring para funcionar