Capitalize String

Question

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.

Conditions

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 -, .,  , /, &, #. 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" 
 "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"

Answer 1

Python 3,22

print(input().title())

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

for example:

input:

BEGIN/wITH.tyPe&cOnTENt

ouput:

Begin/With.Type&Content

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

Python 3, 46

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

Answer 2

05AB1E, 1 byte

Code:

™

Explanation:

™   # Implicit input which is converted to title case.

Try it online!

Answer 3

GolfScript, 36 27 19 characters

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

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

Answer 4

JavaScript (94)

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

Answer 5

Mathematica 62

Data

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

---

Usage

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-And&Type Type&Length.Type User.User&With",
"Range&Content With Content-Type Type",
"Begin Code#User#Agent.User",
"Type Length"}

Answer 6

PHP : 78 73 65 64 characters

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

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

Answer 7

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

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

Answer 8

Powershell: 37 - 43

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

Prompt the user for input: 43

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

Take input from pipeline: 38

(Culture).TextInfo.ToTitleCase($input)

Provide input as an argument when running the script: 37

(Culture).TextInfo.ToTitleCase($args)

---

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.

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

Answer 9

Java - 209 characters

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

I added newlines only for readability.

Answer 10

R, 143 116

A solution a bit long maybe but here we go:

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

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.
    cat(a,sep="")
    }

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);a[d]=toupper(a[d]);cat(a[n],sep="")}

Indented:

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
    }

Usage:

> f("aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe")
Agent Accept/Length-Type User Range.Type

Answer 11

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.

Answer 12

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

Answer 13

JavaScript (string->string), 67 bytes

s=>[...s].map(a=>l=a[`to${'A'>l?'Upp':'Low'}erCase`](),l='').join``

Try it:

f=s=>[...s].map(a=>l=a[`to${'A'>l?'Upp':'Low'}erCase`](),l='').join``

console.log(f('aGeNT aCcEpT/LEngTh-tYPe USeR raNgE.TyPe'));
console.log(f('type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe'));
console.log(f('cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc'));
console.log(f('lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT'));
console.log(f('contENT/ACcEpT'));
console.log(f('BeGin/wITH.tyPE&conTeNt'));
console.log(f('Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with'));
console.log(f('RaNgE&COnTeNT WITh CoNTENT-TypE tyPe'));
console.log(f('BEgin COdE#uSeR#aGeNt.USeR'));
console.log(f('TypE LENGth'));

Jacob's variant - JavaScript (char[]->char[]), 55 bytes

s=>s.map(a=>l=a[`to${'A'>l?'Upp':'Low'}erCase`](),l='')

Try it:

f=s=>s.map(a=>l=a[`to${'A'>l?'Upp':'Low'}erCase`](),l='')

g = s => f([...s]).join``

console.log(g('aGeNT aCcEpT/LEngTh-tYPe USeR raNgE.TyPe'));
console.log(g('type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe'));
console.log(g('cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc'));
console.log(g('lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT'));
console.log(g('contENT/ACcEpT'));
console.log(g('BeGin/wITH.tyPE&conTeNt'));
console.log(g('Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with'));
console.log(g('RaNgE&COnTeNT WITh CoNTENT-TypE tyPe'));
console.log(g('BEgin COdE#uSeR#aGeNt.USeR'));
console.log(g('TypE LENGth'));

Answer 14

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

Answer 15

Javascript 102

prompt().split(o=q='').map(function(c){o+=(q)?c.toLowerCase():c.toUpperCase(),q=('A'>c)?0:1})
alert(o)

Answer 16

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.

Answer 17

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)

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

Answer 18

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.

Answer 19

AWK, 113 103 98 bytes

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

Try it online!

This works fine for single line content, but for multi-line input a few more inits need to be added

AWK, 104 bytes

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

Try it online!

It would have been nice to take advantage of AWK's automatic splitting of a record into fields and modifying said fields, but that throws away the field separators. :(

This update throws away the idea of tacking characters onto a string and then printing the string. Instead, each character becomes its own field. Without the OFS="" bit, each character/field would be separated by a space when printed, which isn't what was requested.

Realizing that "" is essentially the same thing as 0 in AWK shortens the byte-count for the multi-line version a little bit. (I know it's different... I said 'essentially' :p )

Answer 20

QBasic, 74 bytes

1c$=LCASE$(INPUT$(1))
IF f=0THEN c$=UCASE$(c$)
f=c$>"@
?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.

Answer 21

Python 3, 9 bytes

str.title

Try it online!

Answer 22

Perl 5 + -pF, 42 bytes

$\.=~$=?uc:lc,$==index'?/.- &#',$_ for@F}{

Try it online!

Answer 23

Vyxal, 20 15 bytes

f:ʀĠ•ƛḣv⇩$⇧p;f∑

Try it Online!

Or, if that's too long:

1 byte

ǐ

Try it Online!

Explained

f:ʀĠ•ƛḣv⇩$⇧p;f∑
f:               # Push two copies of the letters of the input
  ʀ              # is each letter in the first copy in the alphabet?
   Ġ             # group that on consecutive elements - this has the effect of grouping words.
    •            # reshape the other copy of the letters to have the same shape as that
     ƛ           # to each sublist L:
      ḣv⇩        #     push L[0] and [lower(x) for x in L[1:]] - on single length strings this just leaves L[0] on the stack.
         $⇧p     #     uppercase L[0] and prepend it to the other list
            ;    # close map
             f∑  # deep flatten and summate to get a single string - the `d` flag would save 3 bytes here by removing this pair and allowing structure autocompletion to save a byte.      

Answer 24

Excel VBA, 13 characters

In the Immediate window

?[Proper(A1)]

Function takes input from cell A1

VBScript

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

Answer 25

Go, 153 bytes

import."strings"
func f(s string)(o string){c:=0<1
for i:=range s{x:=s[i:i+1]
if c{o+=ToUpper(x);c=!c}else{o+=ToLower(x)}
c=Contains("-. /&#",x)}
return}

Attempt This Online!

Answer 26

Julia 1.0, 9 bytes

titlecase

Try it online!

Answer 27

Thunno, \$2\log_{256}(96)\approx\$ 1.65 bytes

zV

Attempt This Online!

Just a built-in solution.

Answer 28

JavaScript (Node.js), 54 53 bytes

Exact same score as the RegEx approach would have been!

s=>Buffer(s.toLowerCase()).map(x=c=>x=x>64?c:c^32)+``

Try it online! (includes all test cases)

Answer 29

K (ngn/k), 36 bytes

{,/{`c$x-32*~!#x}'_(&1,~~"a{"'_x)_x}

Try it online!

• _(&1,~~"a{"'_x)_x split input after each non-letter and lowecase it, e.g. "Begin/With.Type&Content" to ("begin/";"with.";"type&";"content")
• {`c$x-32*~!#x}' subtract 32 from the first character in each word and 0 from the rest (in effect capitalizing the first letter and leaving the others unchanged)
• ,/ flatten back into a single string and (implicitly) return

Answer 30

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

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.