Daily Challenge #95 - CamelCase Method

Write simple .camelCase method (camel_case function in PHP, CamelCase in C# or camelCase in Java) for strings. All words must have their first letter capitalized without spaces.

For instance:

camelcase("hello case") => HelloCase
camelcase("camel case word") => CamelCaseWord

---

This challenge comes from bestwebua on CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Want to propose a challenge idea for a future post? Email [e-mail] with your suggestions!

Comments

[kesprit]

My solution in Swift with an extension of String :

extension String {
    var camelCase: String {
        self.capitalized.filter {
            !$0.isWhitespace
        }
    }
}

[willsmart]

I agree with SavagePixie. replace is the way to go if you're in JS!

Here's an extended version that covers all the cases I can think of...

const toUpperCamelCase = str => str.replace(
  /[^a-zA-Z]*([a-zA-Z]?)([a-z]+|[A-Z]*)/g,
  (_, firstLetter, rest) => firstLetter.toUpperCase() + rest.toLowerCase()
);

> [
  'Fudge And Sprite', // Words
  'fudge and sprite', // words
  'fudge-and-sprite', // kebab-case
  'fudge_and_sprite', // underscore_case
  'fudgeAndSprite',   // lowerCamelCase
  'FudgeAndSprite',   // UpperCamelCase stays as it is
  'FUDGE_AND_SPRITE', // CONSTANT_CASE
  'fUDGEaNDsPRITE',   // um, uPSIDEDOWNcASE I guess
  '>>> Fudge,    (and SPRITE!)' // or whatevs
].map(toUpperCamelCase);
< ["FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite"]

Regex:

test in Debuggex

[Ed Reeseg]

C

Still very much learning - had to iterate an initial time to decide how large my result array should be once spaces are removed. Not sure if there's a better way. Still, this was fun - decided to iterate through the argument string in two different ways, to practice.

#include <stdio.h>
#include <ctype.h>

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Usage: ./camelCase \"argument\"\n");
        return 1;
    }
    char *c = argv[1];
    int len = 0;
    for (int i = 0; c[i] != '\0'; i++)
    {
        if (c[i] != ' ')
        {
            len++;
        }
    }
    char result[len + 1];
    int wordStart = 0, counter = 0;
    while(*c != '\0')
    {
        if (*c == ' ')
        {
            wordStart = 1;
        }
        else if (wordStart)
        {
            wordStart = 0;
            result[counter++] = toupper(*c);
        }
        else
        {
            wordStart = 0;
            result[counter++] = tolower(*c);
        }
        c++;
    }
    result[counter] = '\0';
    printf("%s\n", result);
    return 0;
}

[Jacob Evans]

Isn't this camelCase and this is PascalCase?

[Ricardo Delgado]

JS

var camelcase = (s) => {
    var o = new Object(s)
    return o.split` `
                 .map(p => p.split``
                       .map((q, i) => i === 0 ? q.toUpperCase(): q)
                                .join``)
                                        .join``
}

[Balaji K]

Javascript:

const camelCase = (string) => 
      string.split(" ").map(str => 
        `${str.charAt(0).toUpperCase()}${str.slice(1).toLowerCase()}`
      ).join('');

[Anders]

function CamelCase(s) {

    var uppercase = true;
    var rv = '';

    for (var i = 0; i < s.length; ++i) {

        var c = s[i];
        if (c == ' ') { uppercase = true; continue; }

        if (uppercase) {

            rv += c.toUpperCase();
            uppercase = false;

        } else {

            rv += c;
        }
    }

    return rv;
}

And benchmarked:

(Chrome 77, Win 10, 100K runs):

86 ms for LaBlatte
79 ms for SavagePixie
56 ms for Asfo
55 ms for BlessedTMahuni
54 ms for HVHarish
30 ms for Anders

(Firefox 69, Win 10, 100K runs):

116 ms for LaBlatte
55 ms for HVHarish
53 ms for Asfo
51 ms for BlessedTMahuni
29 ms for SavagePixie
23 ms for Anders

(Edge, Win 10, 100K runs):

208 ms for LaBlatte
127 ms for HVHarish
91 ms for Asfo
77 ms for BlessedTMahuni
46 ms for SavagePixie
27 ms for Anders

[Elliot DeNolf]

Crystal

def to_camel(input : String)
  input.split(" ").map(&.capitalize).join
end

Tests

describe "to_camel" do
  it "handles 1 word" do
    to_camel("hello").should eq "Hello"
  end

  it "handles 2 words" do
    to_camel("hello world").should eq "HelloWorld"
  end

  it "handles empty string" do
    to_camel("").should eq ""
  end

  it "handles extra whitespace" do
    to_camel("  hello  world  ").should eq "HelloWorld"
  end
end

[Rafael Acioly]

def to_camel_case(value: str) -> str:
    content = value.split(' ')
    return content[0] + ''.join(
        word.title()
        for word in content[1:] 
        if not word.isspace()
    )

This test was easy because i've written a python package that convert snake_case to camelCase and vice-versa :)

github.com/rafa-acioly/animal_case

[J. R. Swab]

How about in Go?

func camelcase(s string) string {
    var cameled string
    split := strings.Fields(s)

    for _, v := range split {
        cameled = fmt.Sprintf("%s%s", cameled, strings.Title(v))
    }
    return cameled
}

Playground