Algoritmo para formatar texto em Pascal ou camel case

Question

Usando esta pergunta como base existe um alogritmo ou exemplo de codificação para alterar algum texto para Pascal ou Camel.

Por exemplo:

mynameisfred

torna-se

Camel: myNameIsFred
Pascal: MyNameIsFred

Answer 1

Eu encontrei um tópico com um monte de caras do Perl discutindo sobre essa questão em http://www.perlmonks.org/?node_id=336331.

Espero que isso não seja uma falta de resposta à pergunta, mas eu diria que você tem um pequeno problema, pois seria um algoritmo muito aberto que também poderia ter muitos 'erros' como sucessos.Por exemplo, digamos que você inseriu: -

camelCase("hithisisatest");

A saída poderia ser: -

"hiThisIsATest"

Ou:-

"hitHisIsATest"

Não há como o algoritmo saber qual preferir.Você poderia adicionar algum código extra para especificar que prefere palavras mais comuns, mas novamente ocorreriam erros (Peter Norvig escreveu um pequeno corretor ortográfico em http://norvig.com/spell-correct.html qual poder ajuda em termos de algoritmo, escrevi um Implementação de C# se C# for seu idioma).

Eu concordaria com Mark e diria que seria melhor ter um algoritmo que recebesse uma entrada delimitada, ou seja,this_is_a_test e converte isso.Isso seria simples de implementar, ou seja,em pseudocódigo: -

SetPhraseCase(phrase, CamelOrPascal):
    if no delimiters
     if camelCase
      return lowerFirstLetter(phrase)
     else
      return capitaliseFirstLetter(phrase)
    words = splitOnDelimiter(phrase)
    if camelCase 
      ret = lowerFirstLetter(first word) 
     else
      ret = capitaliseFirstLetter(first word)
    for i in 2 to len(words): ret += capitaliseFirstLetter(words[i])
    return ret

capitaliseFirstLetter(word):
    if len(word) <= 1 return upper(word)
    return upper(word[0]) + word[1..len(word)]

lowerFirstLetter(word):
    if len(word) <= 1 return lower(word)
    return lower(word[0]) + word[1..len(word)]

Você também pode substituir minha função capitaliseFirstLetter() por um algoritmo de caso adequado, se desejar.

Uma implementação em C# do algoritmo descrito acima é a seguinte (programa de console completo com equipamento de teste): -

using System;

class Program {
  static void Main(string[] args) {

    var caseAlgorithm = new CaseAlgorithm('_');

    while (true) {
      string input = Console.ReadLine();

      if (string.IsNullOrEmpty(input)) return;

      Console.WriteLine("Input '{0}' in camel case: '{1}', pascal case: '{2}'",
        input,
        caseAlgorithm.SetPhraseCase(input, CaseAlgorithm.CaseMode.CamelCase),
        caseAlgorithm.SetPhraseCase(input, CaseAlgorithm.CaseMode.PascalCase));
    }
  }
}

public class CaseAlgorithm {

  public enum CaseMode { PascalCase, CamelCase }

  private char delimiterChar;

  public CaseAlgorithm(char inDelimiterChar) {
    delimiterChar = inDelimiterChar;
  }

  public string SetPhraseCase(string phrase, CaseMode caseMode) {

    // You might want to do some sanity checks here like making sure
    // there's no invalid characters, etc.

    if (string.IsNullOrEmpty(phrase)) return phrase;

    // .Split() will simply return a string[] of size 1 if no delimiter present so
    // no need to explicitly check this.
    var words = phrase.Split(delimiterChar);

    // Set first word accordingly.
    string ret = setWordCase(words[0], caseMode);

    // If there are other words, set them all to pascal case.
    if (words.Length > 1) {
      for (int i = 1; i < words.Length; ++i)
        ret += setWordCase(words[i], CaseMode.PascalCase);
    }

    return ret;
  }

  private string setWordCase(string word, CaseMode caseMode) {
    switch (caseMode) {
      case CaseMode.CamelCase:
        return lowerFirstLetter(word);
      case CaseMode.PascalCase:
        return capitaliseFirstLetter(word);
      default:
        throw new NotImplementedException(
          string.Format("Case mode '{0}' is not recognised.", caseMode.ToString()));
    }
  }

  private string lowerFirstLetter(string word) {
    return char.ToLower(word[0]) + word.Substring(1);
  }

  private string capitaliseFirstLetter(string word) {
    return char.ToUpper(word[0]) + word.Substring(1);
  }
}

Answer 2

A única maneira de fazer isso seria examinar cada seção da palavra em um dicionário.

"mynameisfred" é apenas um conjunto de caracteres, dividi-lo em meu nome é Fred significa entender o que significa a união de cada um desses caracteres.

Você poderia fazer isso facilmente se sua entrada fosse separada de alguma forma, por exemplo."meu nome é Fred" ou "meu_nome_é_fred".