Algoritmo para formatear texto en Pascal o mayúsculas de camello

Question

Usando esta pregunta Como base, hay un algoritmo o ejemplo de codificación para cambiar algún texto a mayúsculas Pascal o Camel.

Por ejemplo:

mynameisfred

se convierte

Camel: myNameIsFred
Pascal: MyNameIsFred

Answer 1

Encontré un hilo con un grupo de chicos de Perl discutiendo sobre esta cuestión en http://www.perlmonks.org/?node_id=336331.

Espero que esto no sea una falta de respuesta a la pregunta, pero diría que tienes un pequeño problema porque sería un algoritmo muy abierto que también podría tener muchos "errores". como hits.Por ejemplo, digamos que ingresó: -

camelCase("hithisisatest");

La salida podría ser: -

"hiThisIsATest"

O:-

"hitHisIsATest"

No hay forma de que el algoritmo sepa cuál preferir.Podría agregar código adicional para especificar que prefiere palabras más comunes, pero nuevamente se producirían errores (Peter Norvig escribió un corrector ortográfico muy pequeño en http://norvig.com/spell-correct.html cual podría ayuda algorítmica, escribí un implementación de c# si C# es su idioma).

Estoy de acuerdo con Mark y diría que sería mejor tener un algoritmo que acepte una entrada delimitada, es decir.this_is_a_test y lo convierte.Eso sería sencillo de implementar, es decir.en 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)]

También puede reemplazar mi función capitaliseFirstLetter() con un algoritmo de mayúsculas y minúsculas adecuado si así lo desea.

Una implementación en C# del algoritmo descrito anteriormente es la siguiente (programa de consola completo con arnés de prueba): –

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

La única forma de hacerlo sería ejecutar cada sección de la palabra en un diccionario.

"mynameisfred" es solo una serie de caracteres, dividirlo en my Name Is Fred significa comprender lo que significa la unión de cada uno de esos caracteres.

Podría hacerlo fácilmente si su entrada estuviera separada de alguna manera, p."mi nombre es fred" o "mi_nombre_es_fred".