Biorąc pod uwagę ciąg, wielkie litery. Przez wielkie litery mam na myśli conTeNT-lENgthzmiany w Content-Length. W przykładzie pokazałem ciąg z 2 wyrazami z -jako granicą słowa. Jednak oczekuję, że napiszesz kod dla ciągu zawierającego dowolną liczbę słów oddzielonych pojedynczym znakiem jako granicę. Granica ta może się zmieniać w całym ciągu.

Warunki

1. używanie nieregular expressions jest dozwolone .
2. w zdaniu (łańcuchu) może znajdować się dowolna liczba słów.
3. każde słowo będzie się składać z Englishliter [a-zA-Z]dowolnego przypadku.
4. różne słowa w zdaniu zostaną oddzielone pojedynczym znakiem. Postać ta będzie tylko być jednym z -, ., <space-character>, /, &, #. Możesz bezpiecznie założyć, że zdanie nie będzie zawierało żadnej innej postaci oprócz wymienionych.
5. na wyjściu należy zachować granice słów.
6. najkrótszy kod wygrywa.

Na przykład program powinien wypisać Begin/With.Type&Contentna 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 znaków

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

Całkiem podstawowe podejście do GolfScript, które działa dla wszystkich danych wejściowych zgodnie ze specyfikacją. Przykłady można przetestować online .

Python 3,22

print(input().title())

Ten kod pobierze ciąg jako dane wejściowe ze standardowego wejścia i przekaże standardowe wyjście na standardowe wyjście.

na przykład:

Wejście:

BEGIN/wITH.tyPe&cOnTENt

wyjście:

Begin/With.Type&Content

Poniższy kod dotyczy wejść wieloliniowych (w razie potrzeby)

Python 3, 46

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

Mathematica 62

Dane

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

Kod

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

Stosowanie

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

„Agent Accept / Length-Type User Range.Type”

f /@ tests

{„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 -A i typ Typ i długość.Typ Użytkownik.Użytkownik i z ”,
„ Zasięg i treść z typem treści ”,
„ Rozpocznij kod # Użytkownik # Agent.User ”,
„ Typ długości ”}

JavaScript (94)

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

PHP: 78 73 65 64 znaków

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

Dane wejściowe są przekazywane $s. Działa na łańcuch jako tablica znaków.

Jest to prosta maszyna 2-stanowa. Opiera się na leksykalnej kolejności ciągów, a parser automatycznie zakłada, że ​​w niektórych przypadkach zamierzałeś wpisać ciąg.

Stan jest zapisywany $bi jest reprezentowany jako nazwa funkcji, którą należy wywołać dla następnego znaku. ucfirsti lcfirstsą krótsze do pisania i mają identyczne zachowanie jak strtolower/ strtoupperna ciągach pojedynczych znaków. Ponadto, ponieważ różnią się tylko jedną literą, możemy je skutecznie wykorzystać do przechowywania stanu. Oryginalna wersja musiała jawnie przechowywać stan w logice.

Ponieważ echo nie wypisuje niczego dla fałszu logicznego, użyłem przecinka i !operatora, aby „ukryć” przypisanie (które w tym przypadku jest prawdziwe) w instrukcji echo. To pozwoliło mi uratować postać poprzez usunięcie {}.

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

Przyjmuje wiersze stdin, tłumaczy je na stdout. (Preferuje SIGINTsię EOF).

PowerShell: 37–43

W zależności od tego, jak chcesz wziąć wkład ...

Monituj użytkownika o wprowadzenie: 43

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

Pobieraj dane z rurociągu: 38

(Culture).TextInfo.ToTitleCase($input)

Podaj dane wejściowe jako argument podczas uruchamiania skryptu: 37

(Culture).TextInfo.ToTitleCase($args)

UWAGA: Powyższe skrypty zignorują słowa pisane wielkimi literami, pozostawiając je bez zmian. Jeśli trzeba to uwzględnić, dane wejściowe należy wymusić pisaniem małymi literami przed konwersją przypadku tytułowego. Dodaje to 10 znaków do pierwszej metody i 12 do pozostałych dwóch.

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

Java - 209 znaków

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

Dodałem znaki nowej linii tylko dla czytelności.

R, 143 116

Rozwiązanie może trochę długie, ale zaczynamy:

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

Nieco golfa i wyjaśniono:

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

Edycja : 116 znaków

Głównym wyzwaniem jest wektoryzacja substr. Oto inny mniej szczegółowy sposób.

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

Zębaty:

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
    }

Stosowanie:

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

Pisanie tego zraniło mój mózg.

To pobiera dane wejściowe ~i jeśli poprzedni znak był jednym z separatorów (lub jeśli nie było wcześniejszego znaku), wykonuje się

:'``!3*j' -;

Ten fragment kodu przyjmuje postać, a jeśli jego wartość ascii jest większa lub równa a, odejmuje od niej 32, zmieniając w ten sposób na wielkie litery. Jeśli jest mniej niża , 3*jpomija regulację. Następnie pomija następną część. Ta część obsługuje zmianę wielkich i małych liter (jestem pewien, że można ją połączyć z następną częścią; po prostu nie jestem pewien jak):

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

Znak jest drukowany (, ), a następnie sprawdza, czy znak jest jedną z granic:

'/`!

Zasadniczo porównuje znak do wartości ascii /. Jeśli znak nie jest granicą, kod przesuwa się, 12aby następnym razem pominąć dostosowanie wielkich liter. #przeskakuje program końcowy: @a jeśli osiągnięty zostanie koniec danych wejściowych, ~przesyła wykonanie kodu z powrotem do @, kończąc program.

Rubin: 60 51 50 47 znaków

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

Przykładowy przebieg:

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

Proste przetwarzanie oparte na maszynie skończonej:

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

(gdzie xjest stringkapitalizacja)

i oczywiście, jeśli chcesz się nudzić (po aktualizacji specyfikacji), możesz użyć

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

lub z całą nudną płytą grzewczą:

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)

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

Przetłumaczone dane wyjściowe są zapisywane stdoutpodczas odczytu stdin.

Befunge-98 (29), C (65)

Ponieważ metoda / algorytm jest prawie taka sama, umieszczam obie wersje w tym samym poście. Oba polegają na śledzeniu, czy ostatni znak był symbolem czy literą, aby wiedzieć, czy litera ma być mała, czy nie.

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

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

05AB1E , 1 bajt

Kod:

™

Wyjaśnienie:

™   # Implicit input which is converted to title case.

Wypróbuj online!

Znaki Excel VBA-11

W oknie Natychmiastowe

?[Proper()]

VBscript

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

AWK, 113 103 bajty

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

Działa to dobrze w przypadku zawartości jednowierszowej, ale w przypadku wprowadzania wielowierszowego należy dodać kilka 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}

Byłoby miło, gdybyśmy mogli skorzystać z automatycznego podziału rekordu na pola i zmodyfikować wspomniane pola, ale stracilibyśmy wtedy nasze separatory pól. :(

Wiem, że nie jest to najbardziej golfowa z odpowiedzi i jest to dość stare pytanie, ale czuję, że AWK jest niedostatecznie reprezentowany w przestrzeni odpowiedzi CG :)

(Dzięki @manatwork za testowanie kodu, powinno działać teraz :) Zmieniłem również przepływ, ale utrzymałem tę samą liczbę bajtów, zastępując niektóre ;znakami nowej linii.)

PHP (> v5.4.32) - 25 znaków

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

Wyjaśnienie:

• ucwords () to wbudowana funkcja PHP

• Pierwszy parametr $ato wejście

• Drugi parametr to delimetry (znaki nie alfabetyczne znalezione w przypadkach testowych)

• Zakłada się powrót / echo / wydruk z powodu użycia <?= ?>

Spinki do mankietów:

• Plac zabaw dla kodu

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

Wypróbuj wersję SELECT w SQL Server 2012 tutaj .

Zamień „foo” na ciąg wejściowy. Liczba znaków dotyczy łańcucha zerowej długości. Ten kod przechodzi przez ciąg znaków, używając indeksu, górnego lub dolnego znaku w tej pozycji w oparciu o poprzedni znak.

JavaScript (Node.js) , 70 bajtów

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

Wypróbuj online!

Jestem pewien, że można to jeszcze pograć w golfa.

Uwaga :

Pobiera dane wejściowe przez f(string)(), ostatnie są wymagane, ale nie wykonują niczego.

PowerShell, 77 75 bajtów

To rozwiązanie w pełni spełnia zasady zadania (nawet dwuznaczny przykład foo:bar).

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

Zobacz także rozwiązanie Powershell z wbudowaną funkcją ToTitleCase firmy @Iszi.

Wyjaśniony skrypt testowy:

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

Wynik:

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 bajty

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

Bajty są liczone w CP-437 ; jest pojedynczym bajtem (kod znaku 20).

Metoda wprowadzania jest tutaj nieco dziwna: znaki są wpisywane pojedynczo, a ich wielkie litery są konwertowane przed ich wyświetleniem. Kiedy więc wpiszesz aGeNT, pojawi się na ekranie jako Agent. Trafienie Enterkończy program.

Python 3 , 122 bajty

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

Wypróbuj online!

Nie jest to świetny wynik, ale chciałem go wypróbować bez wbudowanych operacji na łańcuchach do zmiany wielkości liter.

PHP - 23 znaki

mb_convert_case ($ w, 2);

Do działania potrzebuje php_mbstring