Você poderia fazer:

$ eval echo '{a..c}'{1..3}
a1 b1 c1 a2 b2 c2 a3 b3 c3

Que então diz ao shell para avaliar:

echo {a..c}1 {a..c}2 {a..c}3

Para este caso em particular, acho que a opção dada por Stéphane Chazelas é a melhor.

Por outro lado, quando você expande coisas mais complexas, essa opção não escala bem. Então, você pode conseguir o mesmo com isso:

$ printf '%s\0' {a..c}{1..3} | sort -zk 1.2,1.2 | tr '\0' ' '

que retorna:

a1 b1 c1 a2 b2 c2 a3 b3 c3

Parece um pouco confuso, mas agora, tenho um controle enorme na ordem, apenas alterando dois chars no comando acima; por exemplo:

$ echo {a..b}{1..2}{a..b}{1..2}

isso se expandirá para:

a1a1 a1a2 a1b1 a1b2 a2a1 a2a2 a2b1 a2b2 b1a1 b1a2 b1b1 b1b2 b2a1 b2a2 b2b1 b2b2

Suponha que eu queira todos os 1na segunda expansão, então o 2:

$ printf '%s\0' {a..b}{1..2}{a..b}{1..2} | sort -zk 1.2,1.2 | tr '\0' ' '
a1a1 a1a2 a1b1 a1b2 b1a1 b1a2 b1b1 b1b2 a2a1 a2a2 a2b1 a2b2 b2a1 b2a2 b2b1 b2b2

Suponha que eu queira todos os ana terceira expansão, então o b:

$ printf '%s\0' {a..b}{1..2}{a..b}{1..2} | sort -zk 1.3,1.3 | tr '\0' ' '
a1a1 a1a2 a2a1 a2a2 b1a1 b1a2 b2a1 b2a2 a1b1 a1b2 a2b1 a2b2 b1b1 b1b2 b2b1 b2b2

Suponha que eu queira todos os 1na quarta expansão, então o 2:

$ printf '%s\0' {a..b}{1..2}{a..b}{1..2} | sort -zk 1.4,1.4 | tr '\0' ' '
a1a1 a1b1 a2a1 a2b1 b1a1 b1b1 b2a1 b2b1 a1a2 a1b2 a2a2 a2b2 b1a2 b1b2 b2a2 b2b2

Suponha que eu queira tudo 1ano meio, então 1b, então 2a, então 2b:

$ printf '%s\0' {a..b}{1..2}{a..b}{1..2} | sort -zk 1.2,1.3 | tr '\0' ' '
a1a1 a1a2 b1a1 b1a2 a1b1 a1b2 b1b1 b1b2 a2a1 a2a2 b2a1 b2a2 a2b1 a2b2 b2b1 b2b2

Você pode até mesmo, com a mesma facilidade, reverter qualquer ordem nas expansões acima, apenas adicionando um rao comando anterior; por exemplo, o último:

$ printf '%s\0' {a..b}{1..2}{a..b}{1..2} | sort -rzk 1.2,1.3 | tr '\0' ' '
b2b2 b2b1 a2b2 a2b1 b2a2 b2a1 a2a2 a2a1 b1b2 b1b1 a1b2 a1b1 b1a2 b1a1 a1a2 a1a1

Nota_1 : normalmente, se esta expansão final for usada como uma lista de argumentos, o espaço à direita não é um problema; mas se você quiser se livrar dele, você pode adicionar, a qualquer um dos comandos acima, por exemplo| sed 's/ $//' ; ou mesmo| sed 's/ $/\n/', para alterar esse espaço à direita por umnewline

Nota_2 : Nos exemplos acima, usei subconjuntos de dois elementos (ou seja: {a,b} e {1,2} ) apenas para simplificar na prova de conceito: você pode usar subconjuntos de qualquer comprimento finito e o comando correspondente, seria comparável.

bash, ksh, zsh

Um forro que funciona em (bash, ksh, zsh) (nem todos os shells podem fazer "expansão de chaves" na ordem inversa):

$ echo {3..1}{c..a} | rev
a1 b1 c1 a2 b2 c2 a3 b3 c3

Uma alternativa que usa eval(que ainda é para bash, ksh, zsh e pode ser mais enigmática) é:

$ eval echo '{a..c}'{1..3}
a1 b1 c1 a2 b2 c2 a3 b3 c3

Para entender o que acontece, substitua evalpor echo:

$ echo echo '{a..c}'{1..3}
echo {a..c}1 {a..c}2 {a..c}3

O comando executado (após a expansão eval) é na verdade echo {a..c}1 {a..c}2 {a..c}3. Que se expande conforme você quer/precisa.

todas as conchas

Existem vários shells sem "expansões de chaves", portanto, não é possível usar isso para "todos os shells". Precisamos de um loop (com um espaço em branco à direita):

$ for i in 1 2 3; do for j in a b c; do printf "%s%s " "$j" "$i"; done; done; echo
a1 b1 c1 a2 b2 c2 a3 b3 c3 

Se você não deve ter nenhum espaço à direita adicionado:

s=""
for i in 1 2 3; do
    for j in a b c; do
        printf "%s%s%s" "$s" "$j" "$i"
        s=" "
    done
done
echo

Impressões

a1 b1 c1 a2 b2 c2 a3 b3 c3

SE você precisar fazer isso para muitos valores, precisamos usar algo semelhante à expansão de chaves para gerar uma lista de números $(seq 10). E, como seq não consegue gerar uma lista de letras, precisamos converter para ascii os números gerados:

s=""
for i in $(seq 4); do
    for j in $(seq 5); do
        printf "%s\\$(printf %03o $((96+j)))%s" "$s" "$i"
        s=" "
    done
done
echo

imprime:

a1 b1 c1 d1 e1 a2 b2 c2 d2 e2 a3 b3 c3 d3 e3 a4 b4 c4 d4 e4

{a..c}1 {a..c}2 {a..c}3

As expansões de chaves {a..c}{1..3}são expandidas da esquerda para a direita, então você primeiro obtém a{1..3} b{1..3} c{1..3}e, em seguida, as letras são combinadas com os números em a1 a2 a3 b1 b2 b3 c1 c2 c3. Para obter a ordem desejada, você terá que usar a expressão um pouco mais longa acima.

Usando um laço:

for n in {1..3}; do printf '%s\n' {a..c}"$n"; done

Isso fará um loop pela sua primeira expansão e, em seguida, expandirá cada caractere com a segunda.

Se você precisar da saída toda em uma linha, poderá remover o \n:

for n in {1..3}; do printf '%s ' {a..c}"$n"; done

Isso não lhe dará uma nova linha à direita, mas se você estiver passando para um comando ou variável, isso não deve ser um problema.

Isso funciona para o seu caso simples e pode ser estendido, mas rapidamente sairia do controle. Casos mais complexos para os quais isso não funcionaria são fáceis de construir.

Inverta a ordem das expansões de chaves e troque os caracteres:

echo {1..3}{a..c} | sed -E 's/(.)(.)( ?)/\2\1\3/g'

Um método simples seria usar sort (o 1.2,1.2 significa que você pega um caractere na segunda posição e termina no mesmo lugar).

$ for i in {a..c}{1..3}; do echo $i; done|sort -n -k1.2,1.2
a1
b1
c1
a2
b2
c2
a3
b3
c3

Se você quiser eles em uma linha, você pode usar tr assim:

$ for i in {a..c}{1..3}; do echo $i; done|sort -n -k1.2,1.2|tr '\n' ' '
a1 b1 c1 a2 b2 c2 a3 b3 c3

Feito pelo método abaixo

for i in {1..10}; do for j in {a..c}; do echo $j$i; done; done| perl -pne "s/\n/ /g"

resultado

a1 b1 c1 a2 b2 c2 a3 b3 c3 a4 b4 c4 a5 b5 c5 a6 b6 c6 a7 b7 c7 a8 b8 c8 a9 b9 c9 a10 b10 c10