Generate alphabet combination

[Joe San]

I was just trying to come up with a small Scala function that would do the alphabet combination for me. Something like we have in Excel as the column headers:

def getExcelColums(acc: List[String], alphabets: List[String], allAlphabets: List[String]): List[String] = alphabets match {
    case x :: Nil => acc ++ allAlphabets.map(_+x)
    case x :: xs  => {
      val all = allAlphabets
      getExcelColums(acc ++ allAlphabets.map(_+x), xs, all)
    }
  }

The call would be:

getExcelColums(List.empty[String], "abcdefghijklmnopqrstuvwxyz".toList.map(_.toString), "abcdefghijklmnopqrstuvwxyz".toList.map(_.toString))

Is there a much simpler way?

[Joe San]

My solution only gives me from a to zz. I would like to rather have it a to abcdefghijklmnopqrstuvwxyz. I guess I might have to do a small tweak!

[fred rosenberger]

Joe Harry wrote:I would like to rather have it a to abcdefghijklmnopqrstuvwxyz.

That seems like an odd stopping point...akin to saying "I want numbers from 0 to 123456789" why don't you want to go to zzzzzzzzzzzzzzzzzzzzzzzzzz?

[Joe San]

I want to have it like this:

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....zz,aaa,aab,aac,.....zzz,aaab....abcdefghijklmnopqrstuvwxyz

[Piet Souris]

hi Joe,

well, I tried to use as many functions as I could think of, but a decent classical while-loop
would be a lot easier...

But maybe someone can vastly improve on this code:

def base_26(n: Int) : List[Int] = {
     // o no, no while loops!
     def help(acc: List[Int], p: Int) : List[Int] = p match {
       case 0 => if (acc == Nil) List(0)
                 else acc
       case y => if (acc.length > 0) help( (y % 26 - 1) :: acc, y / 26)
                 else help((y % 26) :: acc, y / 26)
                 // if I don't do this trick, then after column Z comes column BA instead of AA
     }
     help(Nil, n)
}

def alphabetisize(list: List[Int]) : String = {
     val y = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     val z = for (p <- list) yield y(p)
     // val z = list map (y(_)) is even nicer!
     z.mkString
}

def excelColumns(n: Int) : List[String] = {
     for (p <- (0 to n).toList ) yield alphabetisize(base_26(p))
}

println(excelColumns(300))

Greetz,
Piet

[Maxim Karvonen]

There are many ways to generate sequences. I would use haskell'ish style to do that:

def lazyIterable[T](x : => Iterable[T]) : Iterable[T] = 
  new Iterable[T] {
    override def iterator = x.iterator
  }

def gen(codes : Seq[String]) : Iterable[String] =
  for(
      a <- Seq("").view ++ lazyIterable(gen(codes));
      b <- codes)
    yield a + b

val ff = gen(('a' to 'z').map(_.toString))
ff.drop(100).take(10).foreach(println(_))
ff.drop(100000000).take(10).foreach(println(_))

This code creates an unbounded sequence of strings. You can adapt this code to generate sequences of limited length. In this case you would not need any laziness tricks.