Incremento un valore da AAA a Zzz con rotazione ciclica

Question

ho bisogno di codificare un metodo che incrementa un valore stringa da AAA a Zzz con rotazione ciclica (prossimo valore dopo ZZZ è AAA)

Ecco il mio codice:

public static string IncrementValue(string value) { 
     if (string.IsNullOrEmpty(value) || value.Length != 3) { 
      string msg = string.Format("Incorrect value ('{0}' is not between AAA and ZZZ)", value); 
      throw new ApplicationException(msg); 
     } 
     if (value == "ZZZ") { 
      return "AAA"; 
     } 
     char pos1 = value[0]; 
     char pos2 = value[1]; 
     char pos3 = value[2]; 

     bool incrementPos2 = false; 
     bool incrementPos1 = false; 

     if (pos3 == 'Z') { 
      pos3 = 'A'; 
      incrementPos2 = true; 
     } else { 
      pos3++; 
     } 

     if (incrementPos2 && pos2 == 'Z') { 
      pos2 = 'A'; 
      incrementPos1 = true; 
     } else { 
      if (incrementPos2) { 
       if (pos2 == 'Z') { 
        pos2 = 'A'; 
        incrementPos1 = true; 
       } 
       pos2++; 
      } 
     } 

     if (incrementPos1) { 
      pos1++; 
     } 

     return pos1.ToString() + pos2.ToString() + pos3.ToString(); 
    } 

So che questo pezzo di codice è piuttosto sporco e non molto efficiente, ma non so come farlo correttamente.

Come è protetto questo snippet? (questo verrà eseguito solo su windows plaform)

Come ottimizzare e rendere più leggibile?

Grazie per i vostri commenti

Answer 1

Pensateci matematicamente: I suoi archi (AAA, AAB, ...) si comportano proprio come i numeri naturali (000, 001, ...), con l'eccezione di essere base 26 invece della base 10.

Quindi, è possibile utilizzare lo stesso principio. Ecco il codice:

// iterate cyclicly from 0 to 26^3 - 1 
int incrementValue(int i) { 
    // a verbose way of writing "return (i + 1) % 26^3" 
    i++; 
    if (i == 26*26*26) i = 0; 
    return i; 
} 

// convert 0 to AAA, 1 to AAB, ... 
string formatValue(int i) { 
    var result = new StringBuilder(); 

    result.Insert(0, (char)('A' + (i % 26))); 
    i /= 26; 
    result.Insert(0, (char)('A' + (i % 26))); 
    i /= 26; 
    result.Insert(0, (char)('A' + (i % 26))); 

    return result.ToString(); 
} 

Answer 2

Penso che sia più facile da analizzare in un numero intero, faccio l'incremento, quindi formattare il risultato sotto forma di stringa. Nota che se hai solo bisogno di scorrere i numeri per generare l'intervallo di combinazioni, allora non hai davvero bisogno dell'incremento/analisi. È sufficiente avere un ciclo for nell'intervallo intero e utilizzare il metodo format per convertire il numero intero in una stringa.

public static string IncrementValue(string value) { 
    if (string.IsNullOrEmpty(value) || value.Length != 3) { 
     string msg = string.Format("Incorrect value ('{0}' is not between AAA and ZZZ)", value); 
     throw new ApplicationException(msg); 
    } 
    if (value == "ZZZ") { 
     return "AAA"; 
    } 
    int thisValue = Parse(value); 
    thisValue = (thisValue + 1) % 17576; // 26 * 26 * 26 
    return Format(thisValue); 
} 

private static int Parse(string value) 
{ 
    int result = 0; 
    foreach (var c in value) 
    { 
     result += ('Z' - c); // might need to cast to int? 
    } 
    return result; 
} 

private static string[] Alphabet = new string[] { 'A', 'B', ... }; 
private static string Format(int value) 
{ 
    int digit0 = value % 26; 
    int digit1 = (value/26) % 26; 
    int digit2 = value/676; 
    return Alphabet[digit2] + Alphabet[digit1] + Alphabet[digit0]; 
} 

Answer 3

Forse mi manca qualcosa, ma penso che questa soluzione ragionevolmente banale funziona, e non solo per numeri a tre cifre; qualsiasi numero base 26 di lunghezza arbitary può essere incrementato. Si avvolgerà da ZZZZ a AAAA come da domanda, invece di incrementare "correttamente" da ZZZZ a AAAAA.

// Increment a base 26 number (composed of "digits" A..Z), wrapping around 
// from ZZZ... to AAA... 
string increment(string str) {   
    char[] digits = str.ToCharArray(); 

    for (int i = str.length - 1; i >= 0; --i) { 
    if (digits[i] == 'Z') { 
     digits[i] = 'A'; 
    } else { 
     digits[i] += 1; 
     break; 
    } 
    } 
    return new string(digits); 
} 

Answer 4

in 'C' ho scritto il seguente che farà esattamente come richiesto, vale a dire data AA aumenterà di AB. Dato ZZZ aumenterà a AAA (ciclo).

main(int argc, char **argv) 
{ 

    int i; 
    char *s = argv[1]; 

    for(i=strlen(s)-1; i >= 0; i--) { 
      if(++s[i] > 'Z') 
       s[i] = 'A'; 
      else 
       break; 
    } 

    printf("%s\n",s); 
} 

Answer 5

import java.util.*; 

import java.io.*; 

public class abc{ 

public static void main (String arg[])throws Exception{ 

int i; 

String s; 

BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 

System.out.println("...");\\just for get length of vector example 3 for aaa to zzz 
i= Integer.parseInt(br.readLine()); 
char[] guess = new char[i]; 

Arrays.fill(guess, 'a'); 


do { 
System.out.println("Current guess: " + new String(guess)); 


int n = guess.length - 1; 

while (n >= 0) { 

guess[n]++; 

if (guess[n] > 'z') { 

       if (n > 0) { 

        guess[n] = 'a'; 

       } 

       n--; 

      } 

    else { 

       break; 

      } 

     } 


    } 
while (guess[0] <= 'z'); 

}