Estoy buscando una forma de generar un orden alfabético:

A, B, C, ..., Z, AA, AB, AC, ..., ZZ.

Puede alguien sugerir una manera conveniente de hacer esto. ¿Qué estructuras de datos que puedo hacer uso de?

Me gustaría métodos que obtener el siguiente código en la secuencia y, a continuación, restaurar la secuencia.

InformationsquelleAutor mip | 2012-01-03

16 Comentarios

  1. 7

    Mi versión implementa Iterador y mantiene un int contador. El contador de valores se convierten a la cadena correspondiente:

    import com.google.common.collect.AbstractIterator;
    
    class Sequence extends AbstractIterator<String> {
        private int now;
        private static char[] vs;
        static {
            vs = new char['Z' - 'A' + 1];
            for(char i='A'; i<='Z';i++) vs[i - 'A'] = i;
        }
    
        private StringBuilder alpha(int i){
            assert i > 0;
            char r = vs[--i % vs.length];
            int n = i / vs.length;
            return n == 0 ? new StringBuilder().append(r) : alpha(n).append(r);
        }
    
        @Override protected String computeNext() {
            return alpha(++now).toString();
        }
    }

    Llamada a next() en el Iterador para usarlo.

    Sequence sequence = new Sequence();
    for(int i=0;i<100;i++){
      System.out.print(sequence.next() + " ");
    }

    A B C D E F G H I J K L M N Ñ O P Q R S T U V W X Y Z AA AB AC AD AE

    Una aplicación con un mejor rendimiento para grandes secuencias reutiliza el prefijo común:

    class SequencePrefix extends AbstractIterator<String> {
        private int now = -1;
        private String prefix = "";
        private static char[] vs;
        static {
            vs = new char['Z' - 'A' + 1];
            for(char i='A'; i<='Z';i++) vs[i - 'A'] = i;
        }
    
        private String fixPrefix(String prefix){
            if(prefix.length() == 0) return Character.toString(vs[0]);
            int last = prefix.length() - 1;
            char next = (char) (prefix.charAt(last) + 1);
            String sprefix = prefix.substring(0, last);
            return next - vs[0] == vs.length ? 
                fixPrefix(sprefix) + vs[0] : sprefix + next;
        }
    
        @Override protected String computeNext() {
            if(++now == vs.length) prefix = fixPrefix(prefix);
            now %= vs.length;
            return new StringBuilder().append(prefix).append(vs[now]).toString();
        }
    }

    Obtendrá un rendimiento aún mejor si reescribir este algoritmo básico con una aplicación que trabaja con matrices. (De la cadena.charAt, Cadena.subcadena y StringBuffer tienen cierta sobrecarga.)

    • Uno puede aprender de diferentes maneras: sugerencias o ejemplos. No veo cómo siguió su propio consejo.
    • El método que he utilizado en el final no era tan inteligente como este. Yo simplemente rellenar un ArrayList con todos los códigos posibles cuando el objeto es instanciado, a continuación, accede al siguiente código con un iterador. Esto es suficiente para mis necesidades.
    • Pero sus soluciones es perfecto entonces. Si no se necesita más y no puede encontrar un propósito general de la implementación, la implementación simple es la correcta. Su aplicación puede tener un rendimiento mucho mejor – todos los valores se almacenan en caché.
    • Interesante! Me he portado su solución para C#; Gracias 🙂
  2. 27

    He combinado de Wikipedia Hexavigesimal#Bijective base-26 y Bijective numeración#Propiedades de bijective base-k números para hacer esto:

    import static java.lang.Math.*;
    
    private static String getString(int n) {
        char[] buf = new char[(int) floor(log(25 * (n + 1)) / log(26))];
        for (int i = buf.length - 1; i >= 0; i--) {
            n--;
            buf[i] = (char) ('A' + n % 26);
            n /= 26;
        }
        return new String(buf);
    }

    Con la ayuda de Wolfram Alpha. Tal vez habría sido más sencillo el uso de la aplicación en el primer enlace, aunque.

    • No se encuentra en la Bijective numeración de página en la Wikipedia lo que es el valor de f está en el q_n=f(q_{n-1}/k) de la fórmula, lo que no informativo. +usted puede hacer 'A' + --n % 26 acortar el código con una línea, posiblemente a expensas de la claridad.
    • Pensándolo bien, creo que es una función de asignación del número de los dígitos, ¿verdad? Que haría necesario leer el Hexavigesimal página como bien de cualquier manera.
    • El artículo de la wikipedia hace referencia a (Bijective numeración#Propiedades de bijective base-k números) dice: si k > 1, el número de dígitos en el k-ádico cifra que representa un entero no negativo n es baja(log(n+1) + log(k-1)), donde log es el logaritmo base k. He pasado bastante tiempo en el análisis de este problema y no acabo de convencerme de que yo vea una prueba, ni siquiera una buena intuición que justifican esta afirmación. Es sin duda funciona para todos los casos que he probado, pero me pregunto si alguien tiene un buen argumento para esto? He implementado ambos métodos y se encontró que el método recursivo fue dos veces más lento.
    • He aquí una prueba: math.stackexchange.com/questions/607856/…
  3. 20

    Una línea de una función recursiva para generar la cadena de un número entero:

    static String str(int i) {
        return i < 0 ? "" : str((i / 26) - 1) + (char)(65 + i % 26);
    }

    Ejemplo de uso:

    public static void main(String[] args) {
        for (int i = 0; i < 27*27; ++i) {
            System.out.println(i + " -> " + str(i));
        }
    }

    De salida:

    0 -> A
    1 -> B
    2 -> C
    [...]
    24 -> Y
    25 -> Z
    26 -> AA
    27 -> AB
    [...]
    700 -> ZY
    701 -> ZZ
    702 -> AAA
    703 -> AAB
    [...]
    727 -> AAZ
    728 -> ABA
    • o return i-- <= 0 ? "" : (char) ('A' + i % 26) + str(i / 26); a partir del 1 de.
  4. 4
    public class SeqGen {
        public static void main(String[] args) {
            //This is the configurable param
            int seqWidth = 3;
    
            Double charSetSize = 26d;
    
            //The size of the array will be 26 ^ seqWidth. ie: if 2 chars wide, 26
            //* 26. 3 chars, 26 * 26 * 26
            Double total = Math.pow(charSetSize, (new Integer(seqWidth)).doubleValue());
    
            StringBuilder[] sbArr = new StringBuilder[total.intValue()];
            //Initializing the Array
            for(int j = 0; j <total; j++){
                sbArr[j] = new StringBuilder();
            }
    
            char ch = 'A';
            //Iterating over the entire length for the 'char width' number of times.
            //TODO: Can these iterations be reduced?
            for(int k = seqWidth; k >0; k--){
                //Iterating and adding each char to the entire array.        
                for(int l = 1; l <=total; l++){
                    sbArr[l-1].append(ch);
                    if((l % (Math.pow(charSetSize, k-1d))) == 0){
                        ch++;
                        if(ch > 'Z'){
                            ch = 'A';
                        }
                    }
                }
            }
    
            //Use the stringbuilder array.
            for (StringBuilder builder : sbArr) {
                System.out.println(builder.toString());
            }
        }
    }

    se refieren a la ejemplo y modificar según sus necesidades.

  5. 3

    He creado un proceso iterativo y recursivo de la solución a continuación. Puede encontrar un ejemplo siguiente estas soluciones que muestra cómo generar n-número de elementos en una secuencia usando un iterador. También, fui código de golf con mi recursiva solución para la diversión.

    Soluciones

    Iterativo

    public static String indexToColumnItr(int index, char[] alphabet) {
        if (index <= 0)
            throw new IndexOutOfBoundsException("index must be a positive number");
        if (index <= alphabet.length)
            return Character.toString(alphabet[index - 1]);
        StringBuffer sb = new StringBuffer();
        while (index > 0) {
            sb.insert(0, alphabet[--index % alphabet.length]);
            index /= alphabet.length;
        }
        return sb.toString();
    }

    Recursiva

    public static String indexToColumnRec(int index, char[] alphabet) {
        if (index <= 0)
            throw new IndexOutOfBoundsException("index must be a positive number");
        if (index <= alphabet.length)
            return Character.toString(alphabet[index - 1]);
        return indexToColumnRec(--index / alphabet.length, alphabet) + alphabet[index % alphabet.length];
    }

    Uso

    public static final char[] ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
    
    indexToColumnItr(703, ALPHABET); //AAA

    Ejemplo

    El siguiente código produce la siguiente secuencia de tamaño 52:

    [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ]

    Main.java

    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            System.out.println(Arrays.toString(AlphaUtils.generateSequence(52)));
        }
    }

    AlphaIterator.java

    import java.util.Iterator;
    
    public class AlphaIterator implements Iterator<String> {
        private int maxIndex;
        private int index;
        private char[] alphabet;
    
        public AlphaIterator() {
            this(Integer.MAX_VALUE);
        }
    
        public AlphaIterator(int maxIndex) {
            this(maxIndex, "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray());
        }
    
        public AlphaIterator(char[] alphabet) {
            this(Integer.MAX_VALUE, alphabet);
        }
    
        public AlphaIterator(int maxIndex, char[] alphabet) {
            this.maxIndex = maxIndex;
            this.alphabet = alphabet;
            this.index = 1;
        }
    
        @Override
        public boolean hasNext() {
            return this.index < this.maxIndex;
        }
    
        @Override
        public String next() {
            return AlphaUtils.indexToColumnItr(this.index++, this.alphabet);
        }
    }

    AlphaUtils.java

    public class AlphaUtils {
        //Iterative
        public static String indexToColumnItr(int index, char[] alphabet) {
            if (index <= 0) throw new IndexOutOfBoundsException("index must be a positive number");
            if (index <= alphabet.length) return Character.toString(alphabet[index - 1]);
            StringBuffer sb = new StringBuffer();
            while (index > 0) {
                sb.insert(0, alphabet[--index % alphabet.length]);
                index /= alphabet.length;
            }
            return sb.toString();
        }
    
        //Recursive
        public static String indexToColumnRec(int index, char[] alphabet) {
            if (index <= 0) throw new IndexOutOfBoundsException("index must be a positive number");
            if (index <= alphabet.length) return Character.toString(alphabet[index - 1]);
            return indexToColumnRec(--index / alphabet.length, alphabet) + alphabet[index % alphabet.length];
        }
    
        public static String[] generateSequence(int size) {
            String[] sequence = new String[size];
            int i = 0;
            for (AlphaIterator it = new AlphaIterator(size); it.hasNext();) {
                sequence[i++] = it.next();
            }
            return sequence;
        }
    }

    Código de Golf (89 bytes) 🙂

    String f(int i,char[]a){int l=a.length;return i<=0?"?":i<=l?""+a[i-1]:f(--i/l,a)+a[i%l];}
  6. 2

    Estuve probando pero, el código es malo…

    Hice mi código, que de trabajo de hasta 256, pero usted puede cambiar de acuerdo a las necesidades.

      public static String IntToLetter(int Int) {
        if (Int<27){
          return Character.toString((char)(Int+96));
        } else {
          if (Int%26==0) {
            return IntToLetter((Int/26)-1)+IntToLetter((Int%26)+1);
          } else {
            return IntToLetter(Int/26)+IntToLetter(Int%26);
          }
        }
      }

    EDITADO (método fijo):

      public static String IntToLetter(int Int) {
        if (Int<27){
          return Character.toString((char)(Int+96));
        } else {
          if (Int%26==0) {
            return IntToLetter((Int/26)-1)+IntToLetter(((Int-1)%26+1));
          } else {
            return IntToLetter(Int/26)+IntToLetter(Int%26);
          }
        }
      }

    Pruebas de mi código:

      for (int i = 1;i<256;i++) {
        System.out.println("i="+i+" -> "+IntToLetter(i));
      }

    El resultado

        i=1 -> a
    i=2 -> b
    i=3 -> c
    i=4 -> d
    i=5 -> e
    i=6 -> f
    i=7 -> g
    i=8 -> h
    i=9 -> i
    i=10 -> j
    i=11 -> k
    i=12 -> l
    i=13 -> m
    i=14 -> n
    i=15 -> o
    i=16 -> p
    i=17 -> q
    i=18 -> r
    i=19 -> s
    i=20 -> t
    i=21 -> u
    i=22 -> v
    i=23 -> w
    i=24 -> x
    i=25 -> y
    i=26 -> z
    i=27 -> aa
    i=28 -> ab
    i=29 -> ac
    i=30 -> ad
    i=31 -> ae
    i=32 -> af
    i=33 -> ag
    i=34 -> ah
    i=35 -> ai
    i=36 -> aj
    i=37 -> ak
    i=38 -> al
    i=39 -> am
    i=40 -> an
    i=41 -> ao
    i=42 -> ap
    i=43 -> aq
    i=44 -> ar
    i=45 -> as
    i=46 -> at
    i=47 -> au
    i=48 -> av
    i=49 -> aw
    i=50 -> ax
    i=51 -> ay
    i=52 -> az
    i=53 -> ba
    i=54 -> bb
    i=55 -> bc
    i=56 -> bd
    i=57 -> be
    i=58 -> bf
    i=59 -> bg
    i=60 -> bh
    i=61 -> bi
    i=62 -> bj
    i=63 -> bk
    i=64 -> bl
    i=65 -> bm
    i=66 -> bn
    i=67 -> bo
    i=68 -> bp
    i=69 -> bq
    i=70 -> br
    i=71 -> bs
    i=72 -> bt
    i=73 -> bu
    i=74 -> bv
    i=75 -> bw
    i=76 -> bx
    i=77 -> by
    i=78 -> bz
    i=79 -> ca
    i=80 -> cb
    i=81 -> cc
    i=82 -> cd
    i=83 -> ce
    i=84 -> cf
    i=85 -> cg
    i=86 -> ch
    i=87 -> ci
    i=88 -> cj
    i=89 -> ck
    i=90 -> cl
    i=91 -> cm
    i=92 -> cn
    i=93 -> co
    i=94 -> cp
    i=95 -> cq
    i=96 -> cr
    i=97 -> cs
    i=98 -> ct
    i=99 -> cu
    i=100 -> cv
    i=101 -> cw
    i=102 -> cx
    i=103 -> cy
    i=104 -> cz
    i=105 -> da
    i=106 -> db
    i=107 -> dc
    i=108 -> dd
    i=109 -> de
    i=110 -> df
    i=111 -> dg
    i=112 -> dh
    i=113 -> di
    i=114 -> dj
    i=115 -> dk
    i=116 -> dl
    i=117 -> dm
    i=118 -> dn
    i=119 -> do
    i=120 -> dp
    i=121 -> dq
    i=122 -> dr
    i=123 -> ds
    i=124 -> dt
    i=125 -> du
    i=126 -> dv
    i=127 -> dw
    i=128 -> dx
    i=129 -> dy
    i=130 -> dz
    i=131 -> ea
    i=132 -> eb
    i=133 -> ec
    i=134 -> ed
    i=135 -> ee
    i=136 -> ef
    i=137 -> eg
    i=138 -> eh
    i=139 -> ei
    i=140 -> ej
    i=141 -> ek
    i=142 -> el
    i=143 -> em
    i=144 -> en
    i=145 -> eo
    i=146 -> ep
    i=147 -> eq
    i=148 -> er
    i=149 -> es
    i=150 -> et
    i=151 -> eu
    i=152 -> ev
    i=153 -> ew
    i=154 -> ex
    i=155 -> ey
    i=156 -> ez
    i=157 -> fa
    i=158 -> fb
    i=159 -> fc
    i=160 -> fd
    i=161 -> fe
    i=162 -> ff
    i=163 -> fg
    i=164 -> fh
    i=165 -> fi
    i=166 -> fj
    i=167 -> fk
    i=168 -> fl
    i=169 -> fm
    i=170 -> fn
    i=171 -> fo
    i=172 -> fp
    i=173 -> fq
    i=174 -> fr
    i=175 -> fs
    i=176 -> ft
    i=177 -> fu
    i=178 -> fv
    i=179 -> fw
    i=180 -> fx
    i=181 -> fy
    i=182 -> fz
    i=183 -> ga
    i=184 -> gb
    i=185 -> gc
    i=186 -> gd
    i=187 -> ge
    i=188 -> gf
    i=189 -> gg
    i=190 -> gh
    i=191 -> gi
    i=192 -> gj
    i=193 -> gk
    i=194 -> gl
    i=195 -> gm
    i=196 -> gn
    i=197 -> go
    i=198 -> gp
    i=199 -> gq
    i=200 -> gr
    i=201 -> gs
    i=202 -> gt
    i=203 -> gu
    i=204 -> gv
    i=205 -> gw
    i=206 -> gx
    i=207 -> gy
    i=208 -> gz
    i=209 -> ha
    i=210 -> hb
    i=211 -> hc
    i=212 -> hd
    i=213 -> he
    i=214 -> hf
    i=215 -> hg
    i=216 -> hh
    i=217 -> hi
    i=218 -> hj
    i=219 -> hk
    i=220 -> hl
    i=221 -> hm
    i=222 -> hn
    i=223 -> ho
    i=224 -> hp
    i=225 -> hq
    i=226 -> hr
    i=227 -> hs
    i=228 -> ht
    i=229 -> hu
    i=230 -> hv
    i=231 -> hw
    i=232 -> hx
    i=233 -> hy
    i=234 -> hz
    i=235 -> ia
    i=236 -> ib
    i=237 -> ic
    i=238 -> id
    i=239 -> ie
    i=240 -> if
    i=241 -> ig
    i=242 -> ih
    i=243 -> ii
    i=244 -> ij
    i=245 -> ik
    i=246 -> il
    i=247 -> im
    i=248 -> in
    i=249 -> io
    i=250 -> ip
    i=251 -> iq
    i=252 -> ir
    i=253 -> is
    i=254 -> it
    i=255 -> iu

    Saludos

    • Hay un error con: i=52 -> aa. es un duplicado
    • Gracias, Cada 26 de incrementos, 52,78,104,130,156,182,208,234 el error fue detectado y Se ha fijado.
  7. 2

    Este método genera Alfa Secuencia de Caracteres

    Si llama con null, se devuelven A. Cuando se llama con Un devuelve B.

    La secuencia a, B, C …… Z, AA, AB, AC ….. AZ, BA, BB, BC…. BZ, CA, CB, CC….CZ, DA……ZA, ZB….ZZ, AAA, AAB, AAC….AAZ, ABA, ABB… AZZ, BAA, BAB….ZZZ

    /**
    * @param charSeqStr
    * @return
    */
    public static String getNextAlphaCharSequence(String charSeqStr) {
    String nextCharSeqStr       = null;
    char[] charSeqArr           = null;
    boolean isResetAllChar      = false;
    boolean isResetAfterIndex   = false;
    Integer resetAfterIndex     = 0;
    if (StringUtils.isBlank(charSeqStr)) {
    charSeqArr = new char[] { 'A' };
    } else {
    charSeqArr = charSeqStr.toCharArray();
    Integer charSeqLen = charSeqArr.length;
    for (int index = charSeqLen - 1; index >= 0; index--) {
    char charAtIndex = charSeqArr[index];
    if (Character.getNumericValue(charAtIndex) % 35 == 0) {
    if (index == 0) {
    charSeqArr = Arrays.copyOf(charSeqArr, charSeqLen + 1);
    isResetAllChar = true;
    } else {
    continue;
    }
    } else {
    char nextCharAtIndex = (char) (charAtIndex + 1);
    charSeqArr[index] = nextCharAtIndex;
    if (index + 1 < charSeqLen) {
    isResetAfterIndex = true;
    resetAfterIndex = index;
    }
    break;
    }
    }
    charSeqLen = charSeqArr.length;
    if (isResetAllChar) {
    for (int index = 0; index < charSeqLen; index++) {
    charSeqArr[index] = 'A';
    }
    } else if (isResetAfterIndex) {
    for (int index = resetAfterIndex + 1; index < charSeqLen; index++) {
    charSeqArr[index] = 'A';
    }
    }
    }
    nextCharSeqStr = String.valueOf(charSeqArr);
    return nextCharSeqStr;
    }
    public static void main(String args[]) {
    String nextAlphaSequence = null;
    for (int index = 0; index < 1000; index++) {
    nextAlphaSequence = getNextAlphaCharSequence(nextAlphaSequence);
    System.out.print(nextAlphaSequence + ",");
    }
    }
  8. 1

    Yo sugeriría un iterador de devolver el valor siguiente.

    El iterador debe ser capaz de crear la cadena para volver, basado en la interna de los contadores. Por su ejemplo sería suficiente con dos contadores. Uno para el primer carácter en la cadena, y uno para el segundo carácter.

    Cada contador podría corresponder a la de su índice de " ABCDEFGHIJKLMNOPQRSTUVWXYZ". Cuando haya devuelto una cadena de actualizar el contador de la última posición. Si se cae «por el borde» poner a punto «a» y el incremento de la siguiente contador. Cuando el contador llega a grande, o bien dejar que el iterador indican que no hay más elementos, o restablecer a punto para «» en función de lo que usted necesita.

    Tenga en cuenta que al tener la primera posición de un blanco, puede utilizar trim() en la cadena de deshacerse de los espacios de dar «A» para la primera respuesta.

  9. 1

    Curiosamente, nadie ha aportado un Java 8-funcional basado en la solución todavía. He aquí una solución utilizando jOOλ, que proporciona la funcionalidad como la range() para los personajes, foldLeft() y crossJoin() (descargo de responsabilidad, yo trabajo para la empresa que mantiene jOOλ):

    int max = 3;
    List<String> alphabet = Seq
    .rangeClosed('A', 'Z')
    .map(Object::toString)
    .toList();
    Seq.rangeClosed(1, max)
    .flatMap(length ->
    Seq.rangeClosed(1, length - 1)
    .foldLeft(Seq.seq(alphabet), (s, i) -> s.crossJoin(Seq.seq(alphabet))
    .map(t -> t.v1 + t.v2)))
    .forEach(System.out::println);

    Esta solución no es muy rápido (por ejemplo, como este). Sólo he añadido la integridad de’ bien.

  10. 1
        char ch;
    String str1 = "";
    String str2 = "";
    for (ch = 'A'; ch <= 'Z'; ch++) {
    str1 += ch;
    for (int i = 0; i < 26; i++) {
    char upper = (char) ('A' + i);
    str2 = str2 + ch + upper + " ";
    }
    }
    System.out.println(str1 + ", " + str2);
  11. 0

    Esto va a crear la secuencia de valor pasado.

    /**
    * Method that returns batch names based on passed value
    * @param batchCount
    * @return String[]
    */
    public static String[] getBatchNamesForExecutor(int batchCount) {
    //Batch names array
    String[] batchNames = new String[batchCount];
    //Loop from 0 to batchCount required
    for(int index=0; index < batchCount; index++) {
    //Alphabet for current batch name 
    int alphabet = index%26;
    //iteration count happened on all alphabets till now
    int iterations = index/26;
    //initializing array element to blank string
    batchNames[index] = "";
    //Looping over the iterationIndex and creating batch alphabet prefix /prefixes
    for(int iterationIndex = 0; iterationIndex < iterations; iterationIndex+=26){
    batchNames[index] += String.valueOf((char)('A' + (iterations-1) % 26 ));
    }
    //Adding last alphabet in batch name
    batchNames[index] += String.valueOf((char)('A' + alphabet % 26 ));
    }
    return batchNames;
    }
    public static void main(String[] args) {
    for(String s: getBatchNamesForExecutor(8))  {
    System.err.println(s);
    }
    System.exit(0); 
    }
  12. 0

    Sólo porque me gusta el código corto … inspirado por Thomas Jung respuesta:

    static String asLetters(long value) {
    int codePoint = (int) ('A' + --value % 26);
    long higher = value / 26;
    String letter = new String(Character.toChars(codePoint));
    return higher == 0 ? letter : asLetters(higher).concat(letter);
    }

    Comienza con 1 → a hasta Long.MAX_VALUECRPXNLSKVLJFHG. Uso 'a' en lugar de 'A' las letras minúsculas.

  13. 0

    tomar ‘A to Z’ como 26radix.
    Ejemplo(C++)

        vector<string> generateSequenceBySize(int N)
    {
    if(N<1)
    return vector<string>();
    int base = 26;
    vector<string> seqs;
    for(int i=0;i<pow(base,N);i++)
    {
    int value = i;
    string tmp(N,'A');
    for (int j=0;j<N;j++)
    {
    tmp[N-1-j] = 'A'+value%base;
    value = value/base;
    }
    seqs.push_back(tmp);
    }
    return seqs;
    }
    vector<string> generateSequence()
    {
    //http://stackoverflow.com/questions/8710719/generating-an-alphabetic-sequence-in-java
    //A, B, C, ..., Z, AA, AB, AC, ..., ZZ.
    vector<string> seqs;
    for (int i=1;i<=2;i++)
    {
    vector<string> subSeq = generateSequenceBySize(i);
    seqs.insert(seqs.end(),subSeq.begin(),subSeq.end());
    }
    return seqs;
    }
  14. 0

    No estoy familiarizado con la programación funcional en Java pero supongo que se podría hacer algo equivalente a este código en Haskell:

    — crear una lista [«A»..»Z»]

    uca = map (: []) [‘A’..’Z’]

    — producto cartesiano de dos listas de cadenas , ++ concatena dos cadenas

    cp lst1 lst2 =

        [x ++ y | x <- lst1, y <- lst2]

    — la siguiente proporciona la necesaria lista de cadenas

    uca ++ cp uca uca

  15. 0

    Todas estas respuestas largas… y los que el uso de la recursividad… wow. Esto se puede hacer en Java en un par de líneas sin recursividad:

    private static String intToValueKey(int value) {
    final StringBuilder sb = new StringBuilder(String.valueOf((char)('A'+(value % 26))));
    while((value = (value/26-1)) >= 0) {
    sb.append((char)('A'+(value % 26)));
    }
    return sb.reverse().toString();
    }

    Entonces usted acaba de llamar el método con el aumento de valor numérico en un bucle para generar la secuencia de 0 a n.

    for(int i=0; i<800; i++) {
    System.out.println(intToValueKey(i));
    }

    A la inversa() al final es sólo si usted se preocupa por el orden de las letras y no es realmente necesario si usted está buscando una única permutación.

  16. -1

    ¿Por qué no crear la secuencia de forma recursiva?

    Ejemplo (no probado):

    public String createSequenceElement(int index) {
    String sequenceElement = "";
    int first  = index / 26;
    int second = index % 26;
    if (first < 1) {
    sequenceElement +=  (char) ('A' + second);
    } else {
    sequenceElement +=  createSequenceElement(first) + (char) ('A' + second);
    }
    return sequenceElement ;
    }
    public static void main(String[] args) {
    String sequence = "";
    for (int i = 0; i < 100; i++) {
    if (i > 0) {
    sequence += ", ";
    }
    sequence += createSequenceElement(i);
    }
    System.out.println(sequence);
    }
    • No funcionó cuando lo probé.

Dejar respuesta

Please enter your comment!
Please enter your name here