Recorrer el Alfabeto - C# a-caz
https://stackoverflow.com/questions/1011732
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Tengo una pregunta acerca de recorrer el Alfabeto.Me gustaría tener un bucle que empieza con "a" y termina con "z".Después de eso, el bucle comienza "aa" y contar con "az".después de que comienza con "ba" hasta "bz", y así sucesivamente...
Alguien sabe alguna solución?
Gracias
EDITAR:Me olvidé de que me den un carácter de "a" a la función, a continuación, la función debe devolver b.si te dan el "bnc", a continuación, la función debe devolver "bnd"
Solución
Editar: Hizo exactamente lo que quiere la última edición del OP
Esta es la solución más simple y probada:
static void Main(string[] args)
{
Console.WriteLine(GetNextBase26("a"));
Console.WriteLine(GetNextBase26("bnc"));
}
private static string GetNextBase26(string a)
{
return Base26Sequence().SkipWhile(x => x != a).Skip(1).First();
}
private static IEnumerable<string> Base26Sequence()
{
long i = 0L;
while (true)
yield return Base26Encode(i++);
}
private static char[] base26Chars = "abcdefghijklmnopqrstuvwxyz".ToCharArray();
private static string Base26Encode(Int64 value)
{
string returnValue = null;
do
{
returnValue = base26Chars[value % 26] + returnValue;
value /= 26;
} while (value-- != 0);
return returnValue;
}
Otros consejos
Primer esfuerzo, con solo a-z y luego aa-zz
public static IEnumerable<string> GetExcelColumns()
{
for (char c = 'a'; c <= 'z'; c++)
{
yield return c.ToString();
}
char[] chars = new char[2];
for (char high = 'a'; high <= 'z'; high++)
{
chars[0] = high;
for (char low = 'a'; low <= 'z'; low++)
{
chars[1] = low;
yield return new string(chars);
}
}
}
Tenga en cuenta que esto se detendrá en 'zz'. Por supuesto, hay una duplicación fea aquí en términos de los bucles. Afortunadamente, eso es fácil de solucionar, y también puede ser aún más flexible:
Segundo intento: alfabeto más flexible
private const string Alphabet = "abcdefghijklmnopqrstuvwxyz";
public static IEnumerable<string> GetExcelColumns()
{
return GetExcelColumns(Alphabet);
}
public static IEnumerable<string> GetExcelColumns(string alphabet)
{
foreach(char c in alphabet)
{
yield return c.ToString();
}
char[] chars = new char[2];
foreach(char high in alphabet)
{
chars[0] = high;
foreach(char low in alphabet)
{
chars[1] = low;
yield return new string(chars);
}
}
}
Ahora, si desea generar solo a, b, c, d, aa, ab, ac, ad, ba, ... llamaría a GetExcelColumns("abcd").
Tercer intento (revisado más adelante) - secuencia infinita
public static IEnumerable<string> GetExcelColumns(string alphabet)
{
int length = 0;
char[] chars = null;
int[] indexes = null;
while (true)
{
int position = length-1;
// Try to increment the least significant
// value.
while (position >= 0)
{
indexes[position]++;
if (indexes[position] == alphabet.Length)
{
for (int i=position; i < length; i++)
{
indexes[i] = 0;
chars[i] = alphabet[0];
}
position--;
}
else
{
chars[position] = alphabet[indexes[position]];
break;
}
}
// If we got all the way to the start of the array,
// we need an extra value
if (position == -1)
{
length++;
chars = new char[length];
indexes = new int[length];
for (int i=0; i < length; i++)
{
chars[i] = alphabet[0];
}
}
yield return new string(chars);
}
}
Es posible que sea un código más limpio usando la recursividad, pero no sería tan eficiente.
Tenga en cuenta que si desea detenerse en un punto determinado, puede usar LINQ:
var query = GetExcelColumns().TakeWhile(x => x != "zzz");
" Reiniciando " el iterador
Para reiniciar el iterador desde un punto dado, podría usar SkipWhile como lo sugiere thesoftwarejedi. Eso es bastante ineficiente, por supuesto. Si puede mantener cualquier estado entre llamadas, puede mantener el iterador (para cualquier solución):
using (IEnumerator<string> iterator = GetExcelColumns())
{
iterator.MoveNext();
string firstAttempt = iterator.Current;
if (someCondition)
{
iterator.MoveNext();
string secondAttempt = iterator.Current;
// etc
}
}
Alternativamente, es posible que pueda estructurar su código para usar un foreach de todos modos, simplemente rompiendo el primer valor que realmente puede usar.
Lo siguiente llena una lista con las cadenas requeridas:
List<string> result = new List<string>();
for (char ch = 'a'; ch <= 'z'; ch++){
result.Add (ch.ToString());
}
for (char i = 'a'; i <= 'z'; i++)
{
for (char j = 'a'; j <= 'z'; j++)
{
result.Add (i.ToString() + j.ToString());
}
}
Sé que hay un montón de respuestas, y uno ha aceptado, pero IMO todos ellos hacen que sea más difícil de lo que necesita ser.Creo que el siguiente es más limpia y sencilla:
static string NextColumn(string column){
char[] c = column.ToCharArray();
for(int i = c.Length - 1; i >= 0; i--){
if(char.ToUpper(c[i]++) < 'Z')
break;
c[i] -= (char)26;
if(i == 0)
return "A" + new string(c);
}
return new string(c);
}
Tenga en cuenta que esto no hace ninguna validación de la entrada.Si usted no confía en las personas que llaman, se debe añadir un IsNullOrEmpty compruebe en el principio, y una c[i] >= 'A' && c[i] <= 'Z' || c[i] >= 'a' && c[i] <= 'z' de verificación en la parte superior del bucle.O simplemente dejarlo ser y dejar ser GIGO.
Usted también puede encontrar un uso para estas funciones anejas:
static string GetColumnName(int index){
StringBuilder txt = new StringBuilder();
txt.Append((char)('A' + index % 26));
//txt.Append((char)('A' + --index % 26));
while((index /= 26) > 0)
txt.Insert(0, (char)('A' + --index % 26));
return txt.ToString();
}
static int GetColumnIndex(string name){
int rtn = 0;
foreach(char c in name)
rtn = rtn * 26 + (char.ToUpper(c) - '@');
return rtn - 1;
//return rtn;
}
Estas dos funciones están basadas en cero.Es decir, "A" = 0, "Z" = 25, "AA" = 26, etc.Para hacer de ellos uno basado (como Excel interfaz COM), quite la línea por encima de la línea de comentarios en cada función, y descomentar las líneas.
Como con la NextColumn la función, estas funciones no validar sus entradas.Ambos con darle la basura si eso es lo que consiguen.
Aquí & # 8217; s lo que se me ocurrió.
/// <summary>
/// Return an incremented alphabtical string
/// </summary>
/// <param name="letter">The string to be incremented</param>
/// <returns>the incremented string</returns>
public static string NextLetter(string letter)
{
const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (!string.IsNullOrEmpty(letter))
{
char lastLetterInString = letter[letter.Length - 1];
// if the last letter in the string is the last letter of the alphabet
if (alphabet.IndexOf(lastLetterInString) == alphabet.Length - 1)
{
//replace the last letter in the string with the first leter of the alphbat and get the next letter for the rest of the string
return NextLetter(letter.Substring(0, letter.Length - 1)) + alphabet[0];
}
else
{
// replace the last letter in the string with the proceeding letter of the alphabet
return letter.Remove(letter.Length-1).Insert(letter.Length-1, (alphabet[alphabet.IndexOf(letter[letter.Length-1])+1]).ToString() );
}
}
//return the first letter of the alphabet
return alphabet[0].ToString();
}
simplemente curioso, ¿por qué no solo
? private string alphRecursive(int c) {
var alphabet = "abcdefghijklmnopqrstuvwxyz".ToCharArray();
if (c >= alphabet.Length) {
return alphRecursive(c/alphabet.Length) + alphabet[c%alphabet.Length];
} else {
return "" + alphabet[c%alphabet.Length];
}
}
Esto es como mostrar un int, solo usando la base 26 en lugar de la base 10. Pruebe el siguiente algoritmo para encontrar la enésima entrada de la matriz
q = n div 26;
r = n mod 26;
s = '';
while (q > 0 || r > 0) {
s = alphabet[r] + s;
q = q div 26;
r = q mod 26;
}
Por supuesto, si desea las primeras n entradas, esta no es la solución más eficiente. En este caso, intente algo como la solución de Daniel.
Le di una oportunidad y se me ocurrió esto:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Alphabetty
{
class Program
{
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
static int cursor = 0;
static int prefixCursor;
static string prefix = string.Empty;
static bool done = false;
static void Main(string[] args)
{
string s = string.Empty;
while (s != "Done")
{
s = GetNextString();
Console.WriteLine(s);
}
Console.ReadKey();
}
static string GetNextString()
{
if (done) return "Done";
char? nextLetter = GetNextLetter(ref cursor);
if (nextLetter == null)
{
char? nextPrefixLetter = GetNextLetter(ref prefixCursor);
if(nextPrefixLetter == null)
{
done = true;
return "Done";
}
prefix = nextPrefixLetter.Value.ToString();
nextLetter = GetNextLetter(ref cursor);
}
return prefix + nextLetter;
}
static char? GetNextLetter(ref int letterCursor)
{
if (letterCursor == alphabet.Length)
{
letterCursor = 0;
return null;
}
char c = alphabet[letterCursor];
letterCursor++;
return c;
}
}
}
Aquí hay algo que había preparado que puede ser similar. Estaba experimentando con recuentos de iteraciones para diseñar un esquema de numeración que fuera lo más pequeño posible, pero que me diera suficiente singularidad.
Sabía que cada vez que agregaba un carácter Alfa, aumentaría las posibilidades 26 veces, pero no estaba seguro de cuántas letras, números o el patrón que quería usar.
Eso me lleva al siguiente código. Básicamente, le pasa una cadena AlphaNumber, y cada posición que tenga una letra, eventualmente se incrementará a & Quot; z \ Z & Quot; y cada posición que tenía un Número, eventualmente se incrementaría a " 9 " ;.
Entonces puedes llamarlo 1 de dos maneras ...
//This would give you the next Itteration... (H3reIsaStup4dExamplf)
string myNextValue = IncrementAlphaNumericValue("H3reIsaStup4dExample")
//Or Loop it resulting eventually as "Z9zzZzzZzzz9zZzzzzzz"
string myNextValue = "H3reIsaStup4dExample"
while (myNextValue != null)
{
myNextValue = IncrementAlphaNumericValue(myNextValue)
//And of course do something with this like write it out
}
(Para mí, estaba haciendo algo como " 1AA000 ")
public string IncrementAlphaNumericValue(string Value)
{
//We only allow Characters a-b, A-Z, 0-9
if (System.Text.RegularExpressions.Regex.IsMatch(Value, "^[a-zA-Z0-9]+$") == false)
{
throw new Exception("Invalid Character: Must be a-Z or 0-9");
}
//We work with each Character so it's best to convert the string to a char array for incrementing
char[] myCharacterArray = Value.ToCharArray();
//So what we do here is step backwards through the Characters and increment the first one we can.
for (Int32 myCharIndex = myCharacterArray.Length - 1; myCharIndex >= 0; myCharIndex--)
{
//Converts the Character to it's ASCII value
Int32 myCharValue = Convert.ToInt32(myCharacterArray[myCharIndex]);
//We only Increment this Character Position, if it is not already at it's Max value (Z = 90, z = 122, 57 = 9)
if (myCharValue != 57 && myCharValue != 90 && myCharValue != 122)
{
myCharacterArray[myCharIndex]++;
//Now that we have Incremented the Character, we "reset" all the values to the right of it
for (Int32 myResetIndex = myCharIndex + 1; myResetIndex < myCharacterArray.Length; myResetIndex++)
{
myCharValue = Convert.ToInt32(myCharacterArray[myResetIndex]);
if (myCharValue >= 65 && myCharValue <= 90)
{
myCharacterArray[myResetIndex] = 'A';
}
else if (myCharValue >= 97 && myCharValue <= 122)
{
myCharacterArray[myResetIndex] = 'a';
}
else if (myCharValue >= 48 && myCharValue <= 57)
{
myCharacterArray[myResetIndex] = '0';
}
}
//Now we just return an new Value
return new string(myCharacterArray);
}
}
//If we got through the Character Loop and were not able to increment anything, we retun a NULL.
return null;
}
Aquí está mi intento de usar la recursividad:
public static void PrintAlphabet(string alphabet, string prefix)
{
for (int i = 0; i < alphabet.Length; i++) {
Console.WriteLine(prefix + alphabet[i].ToString());
}
if (prefix.Length < alphabet.Length - 1) {
for (int i = 0; i < alphabet.Length; i++) {
PrintAlphabet(alphabet, prefix + alphabet[i]);
}
}
}
Luego simplemente llame a PrintAlphabet("abcd", "");
