Given a string, capitalize it. By capitalization I mean conTeNT-lENgth changes to Content-Length. In the example I showed the string with 2 words with - as the word boundary. However I expect you to write the code for the string containing any number of words separated by a single character as the boundary. This boundary may change across the string.


  1. using regular expressions is not allowed.
  2. there could be any number of words in a sentence(string).
  3. each word will consist of English letters[a-zA-Z] of any case.
  4. different words in the sentence will be separated by a single character. This character will only be any one of -, ., <space-character>, /, &, #. You can safely assume that sentence will not contain any other character except the mentioned ones.
  5. word boundaries should be preserved in the output.
  6. shortest code wins.

For example your program should output Begin/With.Type&Content for 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" 
 "lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT" 
 "Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with" 
 "BEgin COdE#uSeR#aGeNt.USeR"
 "TypE LENGth"
  • 2
    \$\begingroup\$ What you call capitalization is actually a transformation to camel-case. \$\endgroup\$ Dec 17 '13 at 14:03
  • 6
    \$\begingroup\$ @ArlaudPierre No, what he's given as "test cases" are more like camel case. What's being called capitalization is closer to Title Case. \$\endgroup\$
    – Iszi
    Dec 17 '13 at 14:42
  • \$\begingroup\$ Can you please provide the expected output for the test cases? It seems some built-in functions may assume that all-caps words (like /CC/ in line 2, or -AND& in line 7) should be left alone. Is this ok, for this challenge? \$\endgroup\$
    – Iszi
    Dec 17 '13 at 14:44
  • \$\begingroup\$ Does the input always begin with a word or it may start with a separator? \$\endgroup\$
    – lebatsnok
    Jan 2 '14 at 15:04

25 Answers 25


Python 3,22


This code will take a string as input from stdin and gives a capitalized output to stdout.

for example:





The following code is for multi-line inputs (if necessary)

Python 3, 46

import sys
for i in sys.stdin:print(i.title())
  • \$\begingroup\$ while 1:print(input.title()) is a shorter equivalent for the last piece of code. \$\endgroup\$ Dec 17 '13 at 14:44
  • 1
    \$\begingroup\$ @RamchandraApte I'm not sure is it allowed or not. Your code will die with an EOFError as soon as its hits the EOF \$\endgroup\$
    – Wasi
    Dec 17 '13 at 15:08
  • 1
    \$\begingroup\$ I think the general consensus for golfs is that as long as the output is correct, errors don't matter \$\endgroup\$
    – Volatility
    Dec 17 '13 at 23:26
  • \$\begingroup\$ Dang; as soon as I saw this question, I thought of this, but you beat me to it. +1 \$\endgroup\$
    – Justin
    Dec 18 '13 at 6:38
  • \$\begingroup\$ +1 I like this better than the golfscript one because it doesn't look like an obscenity. \$\endgroup\$ Jan 1 '14 at 22:58

GolfScript, 36 27 19 characters


A quite basic GolfScript approach which works for all input according to the specification. The examples can be tested online.

  • \$\begingroup\$ Cool. Was curious whether my solution is at least twice as a professional one. :) But I am sure you will shorten this several times before the day ends. \$\endgroup\$
    – manatwork
    Dec 17 '13 at 12:15
  • \$\begingroup\$ @manatwork Now we have a factor of two ;-) Still unhappy with all the swaps. \$\endgroup\$
    – Howard
    Dec 17 '13 at 13:50
  • \$\begingroup\$ I knew you will not disappoint me. \$\endgroup\$
    – manatwork
    Dec 17 '13 at 13:52

Mathematica 62


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




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

  • \$\begingroup\$ -1 That's basically regex \$\endgroup\$ Mar 29 '16 at 19:47
  • \$\begingroup\$ Mathematica can run regex directly but I used something else. It's similar to regex, but it is not regex. \$\endgroup\$
    – DavidC
    Mar 29 '16 at 21:17
  • \$\begingroup\$ %% %%% % %% \$\endgroup\$ Mar 29 '16 at 21:22

JavaScript (94)

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

PHP : 78 73 65 64 characters


Input is passed in $s. It operates on the string as an array of characters.

It is a simple 2 state machine. It relies on lexical ordering of strings, and that the parser automatically assumes you meant to type a string in some cases.

The state is being stored in $b and is being represented as the name of the function that needs to be called on the next character. ucfirst and lcfirst are shorter to type and have identical behaviour to strtolower/strtoupper on single character strings. Also, since they only differ by one letter, we can use them efficiently to store the state. The original version needed to store the state explicitly in a boolean.

Since echo doesn't print anything for boolean false, I used a comma and the ! operator to "hide" the assignment(which in this case is truthy) in the echo statement. This allowed me to save a character by removing the {}.

  • \$\begingroup\$ Please use code block markup instead of inline code, so scripts like Code Golf UserScript Enhancement Pack can insert the size below the code. By the way, in your code all 3 space characters can be removed. \$\endgroup\$
    – manatwork
    Dec 29 '13 at 14:32
  • \$\begingroup\$ Instead of $b=ord($c)>64; try $b=$c>"@";. Or even $b=$c>=A; – AFAIR that throws a warning, but good coding practices are not a virtue here. \$\endgroup\$
    – manatwork
    Dec 29 '13 at 17:02
  • \$\begingroup\$ @manatwork thanks, didn't think of that. I am already throwing a warning for using an unset variable anyway. \$\endgroup\$ Dec 29 '13 at 17:04
  • \$\begingroup\$ Hmm… What about not using $b just as a flag, but storing the actual function name in it? $b=ucfirst;foreach(str_split($s)as$c){echo$b($c);$b[0]=$c>=A?l:u;}. \$\endgroup\$
    – manatwork
    Dec 29 '13 at 17:08
  • \$\begingroup\$ @manatwork great! I was trying to think of a way to do that with the function. My tries were all bigger. \$\endgroup\$ Dec 29 '13 at 17:14

C, 83


Takes lines on stdin, translates them to stdout. (Prefers SIGINT to EOF.)


Powershell: 37 - 43

Depending on how you want to take the input...

Prompt the user for input: 43


Take input from pipeline: 38


Provide input as an argument when running the script: 37


NOTE: The above scripts will ignore all-caps words, leaving them as-is. If this needs to be accounted for, the input should be forced to lower-case before the Title Case conversion. This adds 10 characters to the first method, and 12 to the other two.

  • \$\begingroup\$ Does not work according to the specification. Try foo:bar. \$\endgroup\$
    – Mormegil
    Dec 17 '13 at 15:33
  • \$\begingroup\$ @Mormegil Which one? The read-host version, at least, works fine for me. I tested it against all the test cases in the question and they all returned as expected except for the special cases I posted in comment to the question. \$\endgroup\$
    – Iszi
    Dec 17 '13 at 15:35
  • \$\begingroup\$ : (colon) is not listed as a word separator in rule #4, therefore, AFAICS, foo:bar should result in Foo:bar, not Foo:Bar. But that is just my (quite strict) reading of the specification. \$\endgroup\$
    – Mormegil
    Dec 17 '13 at 15:38
  • 2
    \$\begingroup\$ @Mormegil Well, this is neat. Looks like the spec was tweaked to resolve that ambiguity, while at the same time not invalidating this answer. \$\endgroup\$
    – Iszi
    Dec 17 '13 at 16:19
  • 1
    \$\begingroup\$ You can replace get-culture with culture; see codegolf.stackexchange.com/a/778/1308 \$\endgroup\$ Dec 18 '13 at 11:50

Java - 209 characters

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

I added newlines only for readability.


R, 143 116

A solution a bit long maybe but here we go:


Slightly ungolfed and explained:

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.

Edit: 116 characters

The main challenge here is to vectorize substr. Here's another less verbose way.



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


> f("aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe")
Agent Accept/Length-Type User Range.Type
  • \$\begingroup\$ You can save some characters. Since a consits of lowercase characters only, there's no need to check for matches with uppercase LETTERS. \$\endgroup\$ Dec 18 '13 at 14:50
  • \$\begingroup\$ @SvenHohenstein indeed, thanks! \$\endgroup\$
    – plannapus
    Dec 18 '13 at 14:51
  • \$\begingroup\$ Another one: You can replace TRUE with T. \$\endgroup\$ Dec 18 '13 at 14:53
  • \$\begingroup\$ Originally i had the tolower later. \$\endgroup\$
    – plannapus
    Dec 18 '13 at 15:02
  • \$\begingroup\$ OK, here's another one ;-) You can replace mapply(substr,tolower(x),n,n) with strsplit(tolower(x),"")[[1]] to save one character. \$\endgroup\$ Dec 18 '13 at 15:30

Befunge 98 - 24 45

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

Writing this hurt my brain.

This takes input through ~ and if the previous character was one of the separators (or if there was no previous character), it executes

:'``!3*j' -;

This snippet takes the character, and if its ascii value is greater than or equal to a, it subtracts 32 from it, thus changing it to upper case. If it is less than a, 3*j skips the adjustment. Afterwards, it skips the next part. This part handles changing from upper case to lower case (I'm sure it can be merged with the next part; I'm just not sure how):

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

The character is printed (,), then this checks if the character is one of the boundaries:


It basically compares the character to the ascii value of /. If the character is not a boundary, the code pushes 12 so that it will skip the capitalization adjustment the next time around. # skips over the end program: @, and if the end of the input is reached, ~ sends the code execution back to the @, ending the program.


Ruby: 60 51 50 47 characters

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

Sample run:

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
  • 1
    \$\begingroup\$ Isn't l==l.swapcase the same as l<?0 (not tested)? At least for the input allowed for this task. \$\endgroup\$
    – Howard
    Dec 17 '13 at 15:59
  • \$\begingroup\$ Yes. Now that batman emphasized that no other separators have to be expected, indeed that is shorter. Thank you, @Howard. \$\endgroup\$
    – manatwork
    Dec 17 '13 at 16:19

05AB1E, 1 byte



™   # Implicit input which is converted to title case.

Try it online!

  • \$\begingroup\$ That's pretty cool :-) \$\endgroup\$
    – batman
    Mar 30 '16 at 9:12

C# – 110

A simple finite-state-machine-based processing:

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

(where x is the string to capitalize)

and of course, if you want to be boring (after the specification was updated), you can use

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

or, with all the boring boilerplate:

class C{static void Main(string[]a){System.Console.WriteLine(new System.Globalization.CultureInfo(9).TextInfo.ToTitleCase(a[0]));}}
  • \$\begingroup\$ Nah, won't compile as C# is no scripting language and you need to encapsulate this in a class. \$\endgroup\$ Dec 17 '13 at 14:04
  • 2
    \$\begingroup\$ Says who? Microsoft (R) Roslyn C# Compiler version 1.2.20906.1 Loading context from 'CSharpInteractive.rsp'. Type "#help" for more information. > "foobar".Aggregate(new{b=1>0,r=""},(s,c)=>new{b="-. /&#".Contains(c),r=s.r+(s.b?Char.ToUpper(c):Char.ToLower(c))}).r "Foobar" But if you really care about the boring boilerplate, add 112 characters of it. \$\endgroup\$
    – Mormegil
    Dec 17 '13 at 15:31
  • 1
    \$\begingroup\$ You can cut the public and string[]a from the boilerplate \$\endgroup\$
    – Johnbot
    Dec 17 '13 at 17:34
  • \$\begingroup\$ Oh yeah, you’re right with public, but I need the arguments, as that is what I process… \$\endgroup\$
    – Mormegil
    Dec 18 '13 at 9:25

Javascript 102

  • \$\begingroup\$ You need no () around the ternary condition. Even more, you not need the second ternary: function(c){o+=q?c.toLowerCase():c.toUpperCase(),q='@'<c}. \$\endgroup\$
    – manatwork
    Dec 30 '13 at 9:34

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

Translated output is written to stdout as it reads from stdin.

  • 1
    \$\begingroup\$ "then then emit again" rhyming with forth! \$\endgroup\$
    – cat
    Mar 30 '16 at 22:25

Befunge-98 (29), C (65)

Since the method/algorithm is pretty much the same, I include both versions in the same post. Both rely on keeping track of whether the last character was a symbol or letter, in order to know whether to lowercase a letter or not.

Befunge-98 (29)
#@~:'0` #v_,0>
',++@'% '<   ^
C (65)

Excel VBA-11 characters

In the Immediate window



Set xlapp = CreateObject("excel.application")
wscript.echo xlapp.Evaluate("Proper(""BeGin/wITH.tyPE&conTeNt"")"
  • \$\begingroup\$ Could you provide some help on usage? I get “Compile error: External name not defined”. (In Word 2013 on the Developer tab I clicked Visual Basic, then in Visual Basic for Application I copy-pasted your code in the Immediate window and pressed Enter.) \$\endgroup\$
    – manatwork
    Dec 29 '13 at 13:29
  • \$\begingroup\$ @manatwork I should have clarified it was in Excel. You can do this from Word but the path is longer as you need to automate Excel. \$\endgroup\$
    – brettdj
    Dec 29 '13 at 13:34
  • 1
    \$\begingroup\$ Cool. Works perfectly when VBA is started from Excel 2013. \$\endgroup\$
    – manatwork
    Dec 29 '13 at 13:47
  • \$\begingroup\$ Works in directly in Excel as well: =PROPER(A1), also 11 bytes \$\endgroup\$
    – Wernisch
    Mar 28 '18 at 13:27

AWK, 113 103 bytes

O=O (L?tolower(s):toupper(s))
if(index("-. /&#",s))L=0}print O}

This works fine for single line content, but for multiline input a couple inits need to be added

O=O (L?tolower(s):toupper(s))
if(index("-. /&#",s))L=0}print O}

It would be nice if we could take advantage of the automatic splitting of a record into fields and modifying said fields, but we would then lose our field separators. :(

I know this isn't the golfiest of answers and this is a rather old question, but I feel that AWK is underrepresented in the answer-space of CG :)

(Thanks @manatwork for testing the code, it should work now :) Also changed the flow but kept the byte-count the same, by replacing some ; with newlines.)

  • 1
    \$\begingroup\$ Are you sure? None of the codes seems to produce the required output neither with gawk, mawk or original-awk. (Tested on Ubuntu.) \$\endgroup\$
    – manatwork
    Mar 30 '16 at 7:31
  • \$\begingroup\$ It was written using gawk on an RHEL6 box, but then transcribed to a windows box. There could very well be a transcription issue. I'll try testing after work when I can do testing and posting on the same machine.... I think I see the issue, anyway. l=0 should be L=0 \$\endgroup\$ Mar 30 '16 at 12:53
  • \$\begingroup\$ Hopefully it works now, @manatwork . Thanks for the testing. :) \$\endgroup\$ Mar 30 '16 at 12:58
  • 1
    \$\begingroup\$ Now seems to work correctly. Not checked all test cases, but seems to be possible to reduce it a bit: {for(l=split($0,a,$0="");i<=l;s=a[++i]){$0=$0(L?toupper(s):tolower(s));L=index("-. /&#",s)}}1. \$\endgroup\$
    – manatwork
    Mar 30 '16 at 13:23
  • \$\begingroup\$ I like your use of changing $0 and the 1 label to avoid the print command are things I haven't thought of doing. I'll have to keep it in mind for future golfing :) \$\endgroup\$ Mar 30 '16 at 14:07

PHP (> v5.4.32) - 25 chars

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


  • ucwords() is a built-in PHP function

  • First parameter $a is the input

  • Second parameter is delimeters (non-alphabet chatacters found in test cases)

  • Return/echo/print is assumed due to use of <?= ?>


  • 1
    \$\begingroup\$ Hi and welcome to the site! I think at the moment this is a snippet which isn't allowed by default, but you can get 41 bytes as a full program using -R: Try it online! or 42 using arguments: Try it online! \$\endgroup\$ May 30 '18 at 20:49

T-SQL, 179


Try the SELECT version in SQL Server 2012 here.

Replace "foo" with the input string. The char count is for a zero-length string. This code traverses the string using an index, uppercasing or lowercasing the character at that position based on the previous character.


JavaScript (Node.js), 70 bytes


Try it online!

I am sure this can be golfed further.

Note :

Takes input via f(string)() , the last are required but perform nothing.


Powershell, 77 75 bytes

This solution fully meets the task rules (even ambiguous example foo:bar).

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

See also the Powershell solution with builtin function ToTitleCase from @Iszi.

Explained test script:

$f = {

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


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

IF f=0THEN c$=UCASE$(c$)
IF""<c$GOTO 1

Bytes are counted in CP-437; is a single byte (character code 20).

The input method here is a bit strange: characters are typed one at a time, and their capitalization is converted before they are displayed. So when you type in aGeNT, it appears on screen as Agent. Hitting Enter ends the program.


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

Try it online!

Not a great score, but I wanted to try it without builtin string operations for case changing.


PHP - 23 characters

mb_convert_case($w, 2);

It needs php_mbstring to work

  • 1
    \$\begingroup\$ On my 5.3.26 mb_convert_case("BeGin/wITH.tyPE&conTeNt", 2); returns “Begin/with.type&content”, not “Begin/With.Type&Content”. \$\endgroup\$
    – manatwork
    Dec 19 '13 at 14:28

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.