Wenn Sie eine Zeichenfolge angegeben haben, aktivieren Sie diese. Mit Großschreibung meine ich conTeNT-lENgthÄnderungen an Content-Length. Im Beispiel habe ich die Zeichenkette mit 2 Wörtern -als Wortgrenze gezeigt. Ich erwarte jedoch, dass Sie den Code für die Zeichenfolge schreiben, die eine beliebige Anzahl von Wörtern enthält, die durch ein einzelnes Zeichen als Begrenzung getrennt sind. Diese Grenze kann sich in der Zeichenfolge ändern.

Bedingungen

1. Verwenden regular expressionsist nicht erlaubt .
2. Ein Satz kann beliebig viele Wörter enthalten.
3. Jedes Wort wird in jedem Fall aus EnglishBuchstaben bestehen [a-zA-Z].
4. Verschiedene Wörter im Satz werden durch ein einzelnes Zeichen getrennt. Dieser Charakter wird nur sein , einer der -, ., <space-character>, /, &, #. Sie können sicher , dass Satz davon ausgehen , nicht andere Zeichen außer den genannten diejenigen enthalten.
5. Wortgrenzen sollten in der Ausgabe erhalten bleiben.
6. kürzester Code gewinnt.

Zum Beispiel sollte Ihr Programm Ausgang Begin/With.Type&Contentfür 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 Zeichen

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

Ein recht einfacher GolfScript-Ansatz, der für alle Eingaben gemäß der Spezifikation funktioniert. Die Beispiele können online getestet werden .

Python 3,22

print(input().title())

Dieser Code nimmt eine Zeichenfolge als Eingabe von stdin und gibt stdout eine Ausgabe in Großbuchstaben.

beispielsweise:

Eingang:

BEGIN/wITH.tyPe&cOnTENt

Ausgabe:

Begin/With.Type&Content

Der folgende Code gilt für mehrzeilige Eingänge (falls erforderlich)

Python 3, 46

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

Mathematica 62

Daten

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

Code

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

Verwendung

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

"Agent Accept / Length-Type User Range.Type"

f /@ tests

{"Agent akzeptieren / Länge-Typ Benutzer Range.Type",
"Typ & Agent / Cc / Inhalt Länge # Accept / Agent.Range-Cc / Inhalt / Code", "Cc / Responce.Length # Typ-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 -Und & Type Type & Length.Type User.User & With ",
" Range & Content With Content-Type Type ",
" Begin Code # 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 Zeichen

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

Die Eingabe wird übergeben $s. Die Zeichenfolge wird als Array von Zeichen verarbeitet.

Es ist eine einfache 2-Zustandsmaschine. Es basiert auf der lexikalischen Reihenfolge von Zeichenfolgen, und der Parser geht automatisch davon aus, dass Sie in einigen Fällen eine Zeichenfolge eingeben möchten.

Der Status wird in gespeichert $bund als Name der Funktion dargestellt, die beim nächsten Zeichen aufgerufen werden muss. ucfirstund lcfirstsind kürzer zu geben und ein identisches Verhalten haben strtolower/ strtoupperauf einzelne Zeichenkette. Da sie sich nur durch einen Buchstaben unterscheiden, können wir sie auch effizient zum Speichern des Status verwenden. Die Originalversion, die benötigt wird, um den Status explizit in einem Booleschen Wert zu speichern.

Da echo für boolean false nichts ausgibt, habe ich ein Komma und den !Operator verwendet, um die Zuordnung (die in diesem Fall wahr ist) in der echo-Anweisung "auszublenden". Dadurch konnte ich ein Zeichen speichern, indem ich das entfernte {}.

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

Übernimmt Zeilen stdin, übersetzt sie in stdout. (Prefers SIGINTan EOF.)

Powershell: 37 - 43

Je nachdem, wie Sie die Eingabe übernehmen möchten ...

Benutzer zur Eingabe auffordern: 43

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

Eingaben aus der Pipeline übernehmen: 38

(Culture).TextInfo.ToTitleCase($input)

Geben Sie beim Ausführen des Skripts Folgendes als Argument ein: 37

(Culture).TextInfo.ToTitleCase($args)

HINWEIS: Die obigen Skripte ignorieren Wörter mit Großbuchstaben und lassen sie unverändert . Wenn dies berücksichtigt werden muss, sollte die Eingabe vor der Konvertierung in Groß- und Kleinschreibung erzwungen werden. Dies fügt der ersten Methode 10 Zeichen und den beiden anderen 12 hinzu.

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

Java - 209 Zeichen

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

Ich habe Zeilenumbrüche nur zur besseren Lesbarkeit hinzugefügt.

R 143 116

Eine Lösung vielleicht ein bisschen lang, aber jetzt geht es los:

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

Leicht ungolfed und erklärt:

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

Bearbeiten : 116 Zeichen

Die größte Herausforderung hierbei ist die Vektorisierung substr. Hier ist ein weiterer, weniger ausführlicher Weg.

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

Eingerückt:

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
    }

Verwendung:

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

Das zu schreiben hat mein Gehirn verletzt.

Dies nimmt Eingaben durch ~und wenn das vorherige Zeichen eines der Trennzeichen war (oder wenn es kein vorheriges Zeichen gab), wird es ausgeführt

:'``!3*j' -;

Dieses Snippet nimmt das Zeichen und asubtrahiert , wenn sein ASCII-Wert größer oder gleich ist , 32 davon, wodurch es in Großbuchstaben geändert wird. Wenn es kleiner als ist a, wird 3*jdie Anpassung übersprungen. Danach wird der nächste Teil übersprungen. Dieser Teil behandelt den Wechsel von Groß- zu Kleinschreibung (ich bin mir sicher, dass er mit dem nächsten Teil zusammengeführt werden kann; ich bin mir nur nicht sicher, wie):

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

Das Zeichen wird gedruckt ( ,), dann wird geprüft, ob das Zeichen eine der Grenzen ist:

'/`!

Es vergleicht im Grunde das Zeichen mit dem ASCII-Wert von /. Wenn das Zeichen keine Grenze ist, wird der Code gedrückt, 12sodass die Anpassung der Großschreibung beim nächsten Mal übersprungen wird. #überspringt das Programmende: @und ~sendet , wenn das Ende der Eingabe erreicht ist, die Codeausführung zurück an @das Programmende.

Ruby: 60 51 50 47 Zeichen

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

Probelauf:

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

Eine einfache maschinenbasierte Verarbeitung:

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

(wo xist das stringzu kapitalisieren)

und natürlich, wenn Sie langweilig sein möchten (nachdem die Spezifikation aktualisiert wurde), können Sie verwenden

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

oder mit dem ganzen langweiligen 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)

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

Die übersetzte Ausgabe wird beim stdoutLesen geschrieben stdin.

Befunge-98 (29), C (65)

Da die Methode / der Algorithmus ziemlich gleich ist, füge ich beide Versionen in den gleichen Beitrag ein. Beide verlassen sich darauf, zu verfolgen, ob das letzte Zeichen ein Symbol oder ein Buchstabe war, um zu wissen, ob ein Buchstabe in Kleinbuchstaben geschrieben werden muss oder nicht.

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

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

05AB1E , 1 Byte

Code:

™

Erläuterung:

™   # Implicit input which is converted to title case.

Probieren Sie es online!

Excel VBA-11-Zeichen

Im Sofortfenster

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

Dies funktioniert gut für einzeiligen Inhalt, aber für mehrzeilige Eingaben müssen ein paar Inits hinzugefügt werden

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

Es wäre schön, wenn wir die automatische Aufteilung eines Datensatzes in Felder und die Änderung dieser Felder nutzen könnten, aber wir würden dann unsere Feldtrennzeichen verlieren. :(

Ich weiß, dass dies nicht die golfenste Antwort ist, und dies ist eine ziemlich alte Frage, aber ich habe das Gefühl, dass AWK im Antwortbereich von CG unterrepräsentiert ist :)

(Vielen Dank an @manatwork für das Testen des Codes, er sollte jetzt funktionieren :) Auch der Ablauf wurde geändert, aber die Anzahl der Bytes wurde beibehalten, indem einige ;durch neue Zeilen ersetzt wurden.)

PHP (> v5.4.32) - 25 Zeichen

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

Erläuterung:

• ucwords () ist eine integrierte PHP-Funktion

• Erster Parameter $aist die Eingabe

• Zweiter Parameter sind Delimeter (Nicht-Alphabet-Chat-Zeichen, die in Testfällen gefunden wurden)

• Return / Echo / Print wird aufgrund der Verwendung von angenommen <?= ?>

Links:

• Code-Spielplatz

• PHP ucwords () Funktion

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

Probieren Sie hier die SELECT-Version in SQL Server 2012 aus .

Ersetzen Sie "foo" durch die Eingabezeichenfolge. Die Zeichenanzahl gilt für eine Zeichenfolge mit der Länge Null. Dieser Code durchläuft die Zeichenfolge unter Verwendung eines Index, wobei das Zeichen an dieser Position anhand des vorherigen Zeichens groß oder klein geschrieben wird.

JavaScript (Node.js) , 70 Byte

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

Probieren Sie es online!

Ich bin mir sicher, dass dies weiter golfen werden kann.

Hinweis :

Nimmt Eingaben über f(string)(), die letzten sind erforderlich, führen aber nichts aus.

Powershell, 77 75 Bytes

Diese Lösung erfüllt die Aufgabenregeln vollständig (auch bei mehrdeutigen Beispielen foo:bar).

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

Siehe auch die Powershell-Lösung mit integrierter Funktion ToTitleCase von @Iszi.

Erklärtes Testskript:

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

Ausgabe:

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

Bytes werden in CP-437 gezählt ; ist ein einzelnes Byte (Zeichencode 20).

Die Eingabemethode ist hier etwas seltsam: Zeichen werden einzeln eingegeben und ihre Groß- und Kleinschreibung wird konvertiert, bevor sie angezeigt werden. Wenn Sie also etwas eingeben aGeNT, wird es auf dem Bildschirm als angezeigt Agent. Schlagen Enterbeendet das Programm.

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

Probieren Sie es online!

Keine gute Punktzahl, aber ich wollte es versuchen, ohne eingebaute Zeichenfolgenoperationen zum Ändern der Groß- / Kleinschreibung.

PHP - 23 Zeichen

mb_convert_case ($ w, 2);

Es braucht php_mbstring um zu funktionieren