Dato una stringa, capitalizzala. Per capitalizzazione intendo le conTeNT-lENgthmodifiche a Content-Length. Nell'esempio ho mostrato la stringa con 2 parole con -come limite delle parole. Tuttavia mi aspetto che tu scriva il codice per la stringa contenente un numero qualsiasi di parole separate da un singolo carattere come limite. Questo limite può cambiare attraverso la stringa.

condizioni

1. l'uso nonregular expressions è permesso .
2. potrebbe esserci un numero qualsiasi di parole in una frase (stringa).
3. ogni parola sarà composta da Englishlettere [a-zA-Z]di ogni caso.
4. parole diverse nella frase saranno separate da un singolo carattere. Questo personaggio sarà solo essere uno qualsiasi di -, ., <space-character>, /, &, #. Puoi tranquillamente presumere che la frase non conterrà nessun altro personaggio tranne quelli menzionati.
5. i confini delle parole dovrebbero essere preservati nell'output.
6. vince il codice più breve.

Ad esempio, il tuo programma dovrebbe essere prodotto Begin/With.Type&Contentper 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 caratteri

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

Un approccio GolfScript piuttosto semplice che funziona per tutti gli input in base alle specifiche. Gli esempi possono essere testati online .

Python 3,22

print(input().title())

Questo codice prenderà una stringa come input da stdin e fornisce un output in maiuscolo a stdout.

per esempio:

ingresso:

BEGIN/wITH.tyPe&cOnTENt

ouput:

Begin/With.Type&Content

Il codice seguente è per gli ingressi multilinea (se necessario)

Python 3, 46

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

Mathematica 62

Dati

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

Codice

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

uso

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

"Tipo di intervallo utente di tipo accettazione / lunghezza agente"

f /@ tests

{"Tipo di intervallo utente di accettazione / tipo di lunghezza agente",
"Tipo e agente / Cc / Lunghezza contenuto # Accetta / Agente.Range-Cc / Contenuto / codice", "Tipo-lunghezza-codice-risposta -Cc / Responce.-User & Begin & User.Agent & Begin / Accetta / Cc "," Lunghezza # Tipo utente / Inizio e tipo di lunghezza / Accetta # Intervallo / Codice e E-Accetta / Contenuto "," Contenuto / Accetta ",
" Inizia / con Tipo e contenuto ",
" Codice.Cc # Utente.Lunghezza-Utente -End e Type Type & Length.Type User.User & With ",
" Range e Content With Content-Type Type ",
" Inizia Codice # User # Agent.User ",
" Type Length "}

JavaScript (94)

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

PHP: 78 73 65 64 caratteri

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

L'ingresso è passato $s. Funziona sulla stringa come una matrice di caratteri.

È una semplice macchina a 2 stati. Si basa sull'ordinamento lessicale delle stringhe e sul fatto che il parser presuppone automaticamente che si intendesse digitare una stringa in alcuni casi.

Lo stato viene archiviato $be viene rappresentato come il nome della funzione che deve essere chiamata sul carattere successivo. ucfirste lcfirstsono più brevi da digitare e hanno un comportamento identico a strtolower/ strtouppersu stringhe di caratteri singoli. Inoltre, poiché differiscono solo per una lettera, possiamo usarli in modo efficiente per memorizzare lo stato. La versione originale doveva memorizzare esplicitamente lo stato in un valore booleano.

Poiché echo non stampa nulla per falso booleano, ho usato una virgola e l' !operatore per "nascondere" l'assegnazione (che in questo caso è vera) nell'istruzione echo. Questo mi ha permesso di salvare un personaggio rimuovendo il {}.

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

Prende le linee stdin, le traduce in stdout. (Preferisce SIGINTa EOF.)

Powershell: 37-43

A seconda di come si desidera prendere l'input ...

Richiedi all'utente l'immissione: 43

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

Prendi input dalla pipeline: 38

(Culture).TextInfo.ToTitleCase($input)

Fornire input come argomento durante l'esecuzione dello script: 37

(Culture).TextInfo.ToTitleCase($args)

NOTA: gli script sopra citati ignoreranno le parole in maiuscolo, lasciandole così come sono. Se è necessario tenere conto di ciò, è necessario forzare l'input in minuscolo prima della conversione del Title Case. Ciò aggiunge 10 caratteri al primo metodo e 12 agli altri due.

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

Java - 209 caratteri

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

Ho aggiunto newline solo per leggibilità.

R, 143 116

Una soluzione un po 'lunga forse ma eccoci qui:

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

Leggermente ungolfed e spiegato:

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

Modifica : 116 caratteri

La sfida principale qui è vettorializzare substr. Ecco un altro modo meno prolisso.

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

rientrato:

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

Scrivere questo mi ha fatto male al cervello.

Questo prende input attraverso ~e se il carattere precedente era uno dei separatori (o se non c'era nessun carattere precedente), viene eseguito

:'``!3*j' -;

Questo frammento prende il carattere e se il suo valore ASCII è maggiore o uguale a a, sottrae 32 da esso, cambiandolo in maiuscolo. Se è inferiore a a, 3*jsalta la regolazione. Successivamente, salta la parte successiva. Questa parte gestisce il passaggio da maiuscole a minuscole (sono sicuro che può essere unita alla parte successiva; non sono sicuro di come):

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

Il carattere viene stampato ( ,), quindi verifica se il carattere è uno dei confini:

'/`!

In pratica confronta il carattere con il valore ASCII di /. Se il personaggio non è un limite, il codice spinge in 12modo che salterà la correzione delle maiuscole la volta successiva. #salta il programma finale:, @e se viene raggiunta la fine dell'input, ~rimanda l'esecuzione del codice a @, terminando il programma.

Rubino: 60 51 50 47 caratteri

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

Esecuzione di esempio:

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

Una semplice elaborazione basata su macchine a stati finiti:

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

(dov'è xil stringcapitalizzare)

e, naturalmente, se vuoi essere noioso (dopo che le specifiche sono state aggiornate), puoi usare

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

o, con tutto il noioso boilerplate:

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)

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

L'output tradotto viene scritto nel modo stdoutin cui legge stdin.

Befunge-98 (29), C (65)

Poiché il metodo / algoritmo è praticamente lo stesso, includo entrambe le versioni nello stesso post. Entrambi si basano sul tenere traccia del fatto che l'ultimo carattere fosse un simbolo o una lettera, al fine di sapere se minuscola o meno una lettera.

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

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

05AB1E , 1 byte

Codice:

™

Spiegazione:

™   # Implicit input which is converted to title case.

Provalo online!

Caratteri Excel VBA-11

Nella finestra immediata

?[Proper()]

VBscript

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

AWK, 113 103 byte

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

Questo funziona bene per il contenuto a riga singola, ma per l'input multilinea è necessario aggiungere un paio di elementi

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

Sarebbe bello se potessimo trarre vantaggio dalla suddivisione automatica di un record in campi e dalla modifica di tali campi, ma perderemmo i separatori dei campi. :(

So che questa non è la risposta più golfosa e questa è una domanda piuttosto vecchia, ma sento che AWK è sottorappresentato nello spazio di risposta di CG :)

(Grazie a @manatwork per aver testato il codice, dovrebbe funzionare ora :) Anche cambiato il flusso ma mantenendo lo stesso numero di byte, sostituendone alcuni ;con nuove righe.)

PHP (> v5.4.32) - 25 caratteri

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

Spiegazione:

• ucwords () è una funzione PHP integrata

• Il primo parametro $aè l'input

• Il secondo parametro sono i delimitatori (caratteri non alfabetici trovati nei casi di test)

• Il ritorno / eco / stampa è assunto a causa dell'uso di <?= ?>

link:

• Code Playground

• Funzione 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

Prova la versione SELEZIONA in SQL Server 2012 qui .

Sostituisci "pippo" con la stringa di input. Il conteggio dei caratteri è per una stringa di lunghezza zero. Questo codice attraversa la stringa utilizzando un indice, maiuscolo o minuscolo in quella posizione in base al carattere precedente.

JavaScript (Node.js) , 70 byte

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

Provalo online!

Sono sicuro che questo può essere ulteriormente migliorato.

Nota :

Accetta input tramite f(string)(), gli ultimi sono richiesti ma non eseguono nulla.

Powershell, 77 75 byte

Questa soluzione soddisfa pienamente le regole dell'attività (anche un esempio ambiguo foo:bar).

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

Vedi anche la soluzione Powershell con funzione integrata ToTitleCase di @Iszi.

Script di test spiegato:

$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"
}

Produzione:

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 byte

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

I byte vengono contati in CP-437 ; è un singolo byte (codice carattere 20).

Il metodo di input qui è un po 'strano: i caratteri vengono digitati uno alla volta e la loro maiuscola viene convertita prima di essere visualizzata. Quindi, quando si digita aGeNT, appare sullo schermo come Agent. Colpire Entertermina il programma.

Python 3 , 122 byte

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

Provalo online!

Non è un ottimo punteggio, ma volevo provarlo senza operazioni di stringa incorporate per la modifica dei casi.

PHP - 23 caratteri

mb_convert_case ($ w, 2);

Ha bisogno di php_mbstring per funzionare