Dada uma string, coloque-a em maiúscula. Por maiúscula, quero dizer conTeNT-lENgthalterações em Content-Length. No exemplo, mostrei a string com 2 palavras com -o limite da palavra. No entanto, espero que você escreva o código da string que contém qualquer número de palavras separadas por um único caractere como limite. Esse limite pode mudar na cadeia.

Condições

1. nãoregular expressions é permitido usar .
2. pode haver qualquer número de palavras em uma frase (string).
3. cada palavra consistirá em Englishletras [a-zA-Z]de qualquer caso.
4. palavras diferentes na frase serão separadas por um único caractere. Este personagem vai unicamente ser qualquer um de -, ., <space-character>, /, &, #. Você pode assumir com segurança que a sentença não conterá nenhum outro caractere, exceto os mencionados.
5. limites de palavras devem ser preservados na saída.
6. o código mais curto vence.

Por exemplo, seu programa deve gerar 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*\}%\;

Uma abordagem bastante básica do GolfScript que funciona para todas as entradas de acordo com a especificação. Os exemplos podem ser testados online .

Python 3,22

print(input().title())

Esse código pegará uma string como entrada de stdin e fornecerá uma saída em maiúscula para stdout.

por exemplo:

entrada:

BEGIN/wITH.tyPe&cOnTENt

saída:

Begin/With.Type&Content

O código a seguir é para entradas com várias linhas (se necessário)

Python 3, 46

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

Mathematica 62

Dados

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

"Usuário aceita / tipo de comprimento Range.Type"

f /@ tests

{"User Accept / Type-Length User Range.Type",
"Type & Agent / Cc / Length do Conteúdo # 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 -E & Tipo Tipo e Comprimento.Tipo Usuário.Usuário e Com ",
" Intervalo e Conteúdo com Tipo de Conteúdo ",
" Código de Início # Usuário # Agent.User ",
" Tipo Comprimento "}

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;

A entrada é passada em $s . Opera na cadeia como uma matriz de caracteres.

É uma máquina simples de 2 estados. Ele se baseia na ordem lexical de seqüências de caracteres e que o analisador assume automaticamente que você deseja digitar uma sequência em alguns casos.

O estado está sendo armazenado $be está sendo representado como o nome da função que precisa ser chamada no próximo caractere. ucfirste lcfirstsão mais curtos para digitar e têm comportamento idêntico às strtolower/ strtouppernas cadeias de caracteres simples. Além disso, como eles diferem apenas em uma letra, podemos usá-los com eficiência para armazenar o estado. A versão original precisava armazenar o estado explicitamente em um booleano.

Como echo não imprime nada para booleano false, usei uma vírgula e o !operador para "ocultar" a atribuição (que neste caso é verdadeira) na instrução echo. Isso me permitiu salvar um personagem removendo o {}.

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

Pega linhas stdin, traduz para stdout. (Prefere SIGINTa EOF.)

Powershell: 37 - 43

Dependendo de como você deseja receber a entrada ...

Solicitar entrada do usuário: 43

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

Receber entrada do pipeline: 38

(Culture).TextInfo.ToTitleCase($input)

Forneça entrada como argumento ao executar o script: 37

(Culture).TextInfo.ToTitleCase($args)

NOTA: Os scripts acima ignorarão as letras maiúsculas, deixando-as como estão. Se isso precisar ser contabilizado, a entrada deve ser forçada a minúscula antes da conversão de maiúsculas e minúsculas. Isso adiciona 10 caracteres ao primeiro método e 12 aos outros dois.

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

Eu adicionei novas linhas apenas para facilitar a leitura.

R, 143 116

Uma solução um pouco longa, talvez, mas aqui vamos nós:

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="")}

Ligeiramente não-destruído e explicou:

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

O principal desafio aqui é vetorizar substr. Aqui está outra maneira menos detalhada.

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="")}

Recuado:

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#@

Escrever isso machucou meu cérebro.

Isso leva a entrada ~e, se o caractere anterior era um dos separadores (ou se não havia caractere anterior), ele executa

:'``!3*j' -;

Esse trecho pega o caractere e, se seu valor ascii for maior ou igual a a, subtrai 32 dele, alterando-o para maiúsculas. Se for menor que a, 3*jpula o ajuste. Depois, pula a próxima parte. Esta parte trata da alteração de maiúsculas para minúsculas (tenho certeza de que pode ser mesclada com a próxima parte; não sei como):

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

O caractere é impresso ( ,), então verifica se o caractere é um dos limites:

'/`!

Basicamente, compara o caractere ao valor ascii de /. Se o caractere não for um limite, o código será pressionado 12para ignorar o ajuste de capitalização da próxima vez. #pula o programa final: @e, se o final da entrada for atingido, ~envia a execução do código de volta para o @final do programa.

Ruby: 60 51 50 47 caracteres

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

Exemplo de execução:

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

Um processamento simples baseado em 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

(onde xé a stringcapitalizar)

e, claro, se você quiser ser chato (depois que a especificação for atualizada), você pode usar

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

ou, com todo o clichê chato:

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)

Quarto, 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

A saída traduzida é gravada na stdoutleitura de stdin.

Befunge-98 (29), C (65)

Como o método / algoritmo é praticamente o mesmo, incluo as duas versões no mesmo post. Ambos dependem de saber se o último caractere era um símbolo ou letra, para saber se uma letra é minúscula ou não.

#@~:'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:

™

Explicação:

™   # Implicit input which is converted to title case.

Experimente online!

Caracteres Excel VBA-11

Na janela Imediata

?[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}

Isso funciona bem para o conteúdo de uma única linha, mas para a entrada de várias linhas, é necessário adicionar algumas unidades

{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}

Seria bom se pudéssemos tirar proveito da divisão automática de um registro em campos e modificar esses campos, mas perderíamos nossos separadores de campos. :(

Sei que essa não é a resposta mais divertida e essa é uma pergunta bastante antiga, mas acho que o AWK está sub-representado no espaço de resposta do CG :)

(Obrigado @manatwork por testar o código, ele deve funcionar agora :) Também alterou o fluxo, mas manteve a contagem de bytes igual, substituindo alguns ;por novas linhas.)

PHP (> v5.4.32) - 25 caracteres

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

Explicação:

• ucwords () é uma função PHP embutida

• O primeiro parâmetro $aé a entrada

• O segundo parâmetro é delimeter (caracteres não alfabéticos encontrados nos casos de teste)

• O retorno / eco / impressão é assumido devido ao uso de <?= ?>

Ligações:

• Code Playground

• Função 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

Experimente a versão SELECT no SQL Server 2012 aqui .

Substitua "foo" pela sequência de entrada. A contagem de caracteres é para uma cadeia de comprimento zero. Esse código percorre a seqüência de caracteres usando um índice, maiúsculas ou minúsculas o caractere naquela posição com base no caractere anterior.

JavaScript (Node.js) , 70 bytes

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

Experimente online!

Estou certo de que isso pode ser jogado ainda mais.

Nota :

Recebe entradas via f(string)(), as últimas são necessárias, mas não executam nada.

Powershell, 77 75 bytes

Esta solução atende totalmente às regras da tarefa (mesmo exemplo ambíguo foo:bar).

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

Veja também a solução Powershell com a função incorporada ToTitleCase do @Iszi.

Script de teste 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"
}

Resultado:

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

Os bytes são contados no CP-437 ; é um byte único (código de caractere 20).

O método de entrada aqui é um pouco estranho: os caracteres são digitados um de cada vez e sua capitalização é convertida antes de serem exibidos. Então, quando você digita aGeNT, ele aparece na tela como Agent. Bater Entertermina o 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))

Experimente online!

Não é uma pontuação excelente, mas eu queria experimentá-lo sem operações de string internas para mudar de caso.

PHP - 23 caracteres

mb_convert_case ($ w, 2);

Precisa do php_mbstring para funcionar