Defina una secuencia de longitud de anteponer-agregarn para que sea una permutación de los números 1, 2, ..., nque se pueden generar mediante el siguiente procedimiento:

• Comience con el número 1.

• Para cada número de 2a n, colocar este número al principio o al final de la secuencia (ya sea prepend o append , de ahí el nombre de la secuencia).

Por ejemplo, esta es una forma válida de generar una secuencia de anteponer-agregar de longitud 4:

1
21     [beginning]
213    [end]
2134   [end]

Su tarea es crear un programa o función que tome un número nde 3a 30como entrada, e imprima o devuelva todas las secuencias de longitud de anteponer y agregar nen orden lexicográfico (si está generando cadenas y no listas, los números superiores a 9 se representarán como letras a-u, para preservar la longitud de la cadena). Por ejemplo, este es el orden para n = 4:

1234  [RRR]
2134  [LRR]
3124  [RLR]
3214  [LLR]
4123  [RRL]
4213  [LRL]
4312  [RLL]
4321  [LLL]

En general, hay 2 ^n-1 antemutaciones de longitud de anexión n.

No puede usar ninguna función de clasificación incorporada en su idioma en su código. El programa más corto para hacer esto en cualquier idioma gana.

CJam, 22 20 19 17 bytes

]]l~{)f+_1fm>|}/p

Expansión de código :

]]                   "Put [[]] onto stack. What we will do with this array of array is";
                     "that in each iteration below, we will first append the next";
                     "number to all present arrays, then copy all the arrays and";
                     "move the last element to first in the copy";
  l~                 "Read input number. Lets call it N";
    {         }/     "Run this code block N times ranging from 0 to N - 1";
     )f+             "Since the number on stack starts from 0, add 1 to it and append";
                     "it to all arrays in the array of array beginning with [[]]";
        _1fm>        "Copy the array of array and move last element from all arrays";
                     "to their beginning";
             |       "Take set union of the two arrays, thus joining them and eliminating";
                     "duplicates. Since we started with and empty array and started adding";
                     "numbers from 1 instead of 2, [1] would have appeared twice if we had";
                     "simply done a concat";
                p    "Print the array of arrays";

Cómo funciona :

Esta es una versión de depuración del código:

]]l~ed{)edf+ed_ed1fm>ed|ed}/edp

Veamos cómo funciona para la entrada 3:

[[[]] 3]                                 "]]l~"            "Empty array of array and input";
[[[]] 1]                                 "{)"              "First iteration, increment 0";
[[[1]]]                                  "{)f+"            "Append it to all sub arrays";
[[[1]] [[1]]]                            "{)f+_"           "Copy the final array of array";
[[[1]] [[1]]]                            "{)f+_1fm>"       "shift last element of each";
                                                           "sub array to the beginning";
[[[1]]]                                  "{)f+_1fm>|}"     "Take set based union";
[[[1]] 2]                                "{)"              "2nd iteration. Repeat";
[[[1 2]]]                                "{)f+"
[[[1 2]] [[1 2]]]                        "{)f+_";
[[[1 2]] [[2 1]]]                        "{)f+_1fm>";
[[[1 2] [2 1]]]                          "{)f+_1fm>|}";
[[[1 2] [2 1]] 3]                        "{)";
[[[1 2 3] [2 1 3]]]                      "{)f+"
[[[1 2 3] [2 1 3]] [[1 2 3] [2 1 3]]]    "{)f+_";
[[[1 2 3] [2 1 3]] [[3 1 2] [3 2 1]]]    "{)f+_1fm>";
[[[1 2 3] [2 1 3] [3 1 2] [3 2 1]]]      "{)f+_1fm>|}";
[[[1 2 3] [2 1 3] [3 1 2] [3 2 1]]]      "{)f+_1fm>|}/";

Pruébalo en línea aquí

Haskell, 47 bytes

f 1=[[1]]
f n=(\x->map(++[n])x++map(n:)x)$f$n-1

Pitón 2, 68

f=lambda n:[[1]]*(n<2)or[x*b+[n]+x*-b for b in[1,-1]for x in f(n-1)]

Emite una lista de listas de números.

Una solución recursiva. Para n==1, salida [[1]]. De lo contrario, agregue nal inicio o al final de todas las (n-1)permutaciones. La preparación previa hace que la permutación sea lexicográfica más tarde que la adición, por lo que las permutaciones permanecen ordenadas.

El "booleano" bcodifica si se debe poner [n]al principio o al final. En realidad, movemos el resto de la lista xen la expresión x*b+[n]+x*-b. Poner bcomo -1o 1permite usar flip negando, ya que una lista multiplicada por -1es la lista vacía.

Pyth, 19

usCm,+dH+HdGr2hQ]]1

Pruébalo en línea aquí

Este es un programa completo que toma información de stdin.

Esto funciona de manera similar a la solución de xnor, pero genera los valores un poco fuera de orden, por lo que deben reordenarse. Lo que sucede en cada nivel es que cada lista de valores anterior tiene el nuevo valor agregado al final y al principio y cada uno está envuelto en una tupla de 2 que está envuelta en una lista. Por ejemplo, el primer paso hace esto:

[[1]]
[([1,2], [2,1])]

Luego, esta lista de tuplas se comprime (y luego se suma para eliminar la lista más externa). En el primer caso, esto solo da el valor sin envolver de arriba, ya que solo hay un valor en la lista.

Pasos que muestran 2-> 3:

([1,2], [2,1])
[([1,2,3],[3,1,2]),([2,1,3],[3,2,1])]
([1,2,3],[2,1,3],[3,1,2],[3,2,1])

Mathematica, 57 54 49 bytes

f@1={{1}};f@n_:=#@n/@f[n-1]&/@Append~Join~Prepend

Ejemplo:

f[4]

{{1, 2, 3, 4}, {2, 1, 3, 4}, {3, 1, 2, 4}, {3, 2, 1, 4}, {4, 1, 2, 3} , {4, 2, 1, 3}, {4, 3, 1, 2}, {4, 3, 2, 1}}

J 26 bytes

   0|:<:((,,.,~)1+#)@[&0,.@1:

   (0|:<:((,,.,~)1+#)@[&0,.@1:) 3
1 2 3
2 1 3
3 1 2
3 2 1

Mejora de 1 byte gracias a FUZxxl .

Pyth 34 33 31 29

Básicamente una traducción de la respuesta Python de xnor . Todavía no soy bueno con Pyth, así que las sugerencias de mejora son bienvenidas.

Define una función ypara devolver una lista de listas de enteros.

L?]]1<b2smm++*kdb*k_dy-b1,1_1

Actualización: Guardado 2 bytes gracias a FryAmTheEggman .

Explicación:

L                                  define a function y with argument b that returns
 ?*]]1<b2                          [[1]] if b < 2 else
         s                         sum(
          m                        map(lambda d:
           m                       map(lambda k:
            ++*kdb*k_d             k*d + [b] + k*-d
                      y-b1         , y(b - 1))
                          ,1_1)    , (1, -1))

Pure Bash, 103

Más de lo que esperaba:

a=1..1
for i in {2..9} {a..u};{
((++c<$1))||break
a={${a// /,}}
a=`eval echo $a$i $i$a`
}
echo ${a%%.*}

JavaScript (ES6) 73 80

Implementación de JavaScript de la buena solución de @ Optimizer.

Recursivo (73):

R=(n,i=1,r=[[1]])=>++i>n?r:r.map(e=>r.push([i,...e])+e.push(i))&&R(n,i,r)

Iterativo (74):

F=n=>(i=>{for(r=[[1]];++i<=n;)r.map(e=>r.push([i,...e])+e.push(i))})(1)||r

Prueba en la consola Firefox / FireBug

R(4)

[[1, 2, 3, 4], [2, 1, 3, 4], [3, 1, 2, 4], [3, 2, 1, 4], [4, 1, 2, 3] , [4, 2, 1, 3], [4, 3, 1, 2], [4, 3, 2, 1]]

Mi solución Java:

public static void main(String[] args) {
    listPrependAppend(4);
}

private static void listPrependAppend(int n) {
    int total = (int) Math.pow(2, n - 1);
    int ps;
    boolean append;
    String sequence;
    String pattern;

    for (int num = 0; num < total; num++) {
        sequence = "";
        pattern = "";
        append = false;
        ps = num;
        for (int pos = 1; pos < n + 1; pos++) {
            sequence = append ? (pos + sequence) : (sequence + pos);
            append = (ps & 0x01) == 0x01;
            ps = ps >> 1;
            if (pos < n) {
                pattern += append ? "L" : "R";
            }
        }
        System.out.format("%s\t[%s]%n", sequence, pattern);
    }
}