suche(zustand){
 if (rekursionsanker(zustand)){
  return loesung(zustand);
 }
 for (zug : legale_zuege(zustand)){
  make_move(zug,zustand);
  versuch = suche(zustand);
  if (versuch){
   return versuch;
  }
  undo_move(zug,zustand);  
 }
 return keineLoesung;
}

static int[] func;
static int zaehler = 0;
static int tmp = 0;
 
public static void main(String[] args) {
   int N = Integer.parseInt(args[0]);
   func = new int[2 * N];
   tmp = N;
   solve(N);
}
 
public static void solve(int N) {
   if (N == 0)
      return;
 
   for (int i = 0; i < func.length; i++) {
      if (i+N+1>= func.length) {
         i = 0;
         zaehler++;
      }
      if (func[i] == 0 && func[i + N + 1] == 0) {
         func[i] = N;
         func[i + N + 1] = N;
         break;
      }
      if (zaehler == 2) {
         Arrays.fill(func, 0);
         zaehler = 0;
         solve(tmp-1);
      }
   }
   solve(N-1);
}

    /*
     int i:     Current index
     int[] arr: Array to fill
     int[] set: Numbers to fill with
     */
    static boolean solve_rec(int i, int[] arr, int[] set){
        while (i < arr.length && arr[i] > 0) 
            ++i; // Skip already filled slots
        if (i >= arr.length) 
            return true; // End of array reached => Solution
        int k;
        for (int j = 0; j < set.length; ++j){ // For all k in set
            k = set[j];
            if (k == 0 || i+k+1 >= arr.length || arr[i+k+1]>0) 
                continue; // Skip if not present or if it does not fit
            set[j] = 0; // Remove k from set
            arr[i] = arr[i+k+1] = k; // Modify array
            if (solve_rec(i+1, arr, set)) 
                return true; // Solution found!
            arr[i] = arr[i+k+1] = 0; // Undo array modification
            set[j] = k; // Put k back in set
        }
        return false; // No solution found
    }
 

static int[] func;
static int zaehler = 0;
static int tmp = 0;
 
public static void main(String[] args) {
   int N = Integer.parseInt(args[0]);
   func = new int[2 * N];
   tmp = N;
   solve(N);
}
 
public static void solve(int N) {
   if (N == 0) // Basisfall der Rekursion
      return;
 
   for (int i = 0; i < func.length; i++) {
      if (i+N+1>= func.length) { // Hier schaue ich nach, ob mein i+N+1 schon über die Länge hinausragt,
                                 // um Array-Exception zu eliminieren
         i = 0;
         zaehler++; // Das ist, wenn ich den ersten Aufruf mit der Zahl N gemacht habe,
                    // dann das N soweit dezimiert wurde also N=1 ist, soll später überprüft werden,
                    // ob der Zaehler == 2 ist, um das Array mit Nullen zu füllen und den Aufruf diesmal mit tmp-1 zu starten
      }
      if (func[i] == 0 && func[i + N + 1] == 0) { // Hier wird überprüft, ob die i-te Stelle
                                                  // und derselbe Abstand der i-ten Stelle des Arrays eine Null ist
         func[i] = N;                             // Setze die Zahl N in das Feld
         func[i + N + 1] = N;                     // Setze vom gesetzten N mit demselben Abstand das andere N
         break;                                   // Hier verlassen wir nun die For-Schleife,
                                                  // um weiter mit der N-1 Ziffer das gleiche zu machen
      }
      if (zaehler == 2) {
         Arrays.fill(func, 0);                    // Array wieder mit Nullen befüllen
         zaehler = 0;
         solve(tmp-1);                            // Wir hatten ja vor immer, dass an erster Stelle immer das größte N steht,
                                                  // jetzt kann es ja auch sein, dass an erster Stelle ein N-1 steht.
      }
   }
   solve(N-1); // Nächster Funktionsaufruf mit N-1
}

    static boolean solve_rec(int N, int i, int[] arr){
        if (N == 0) 
            return true;
        if (i+N+1 >= arr.length)
            return false;
        if (arr[i] > 0 || arr[i+N+1] > 0)
            return solve_rec(N, i+1, arr);
        arr[i] = arr[i+N+1] = N;
        if (solve_rec(N-1, 0, arr))
            return true;
        arr[i] = arr[i+N+1] = 0;
        return solve_rec(N, i+1, arr);
    }
 

// globale Variablen
int n;                // jede Zahl 1,...,n soll zwei Mal an die
                      // Positionen 1,...,2n
int Feld[100] = {0};  // zu befuellendes Feld (mit genuegend Platz)
int count = 0;        // zaehlt die Loesungen
 
//------------------------------------------------------------------------
 
#include <stdio.h>
#include <stdlib.h>
 
//------------------------------------------------------------------------
 
void ausgabe(void){ // Ausgabe von Feld
  int i;
  count++;
  printf("Loesung Nr. %d: ", count);
  for(i=0; i<2*n; i++)
    printf("%d ", Feld[i]);
  printf("\n");
}
 
//------------------------------------------------------------------------
 
// versuche x zwei Mal mit korrektem Abstand ins Feld aufzunehmen
void solve(int x){
  int i;
 
  if(x > n){
    ausgabe(); // Loesung gefunden!
    return;
  }
 
  for(i=0; i+x+1<2*n; i++) // suche freien Platz für die Zahl x
    if(Feld[i] == 0 && Feld[i+x+1] == 0){
      Feld[i]     = x; // freier Platz gefunden -> x aufnehmen
      Feld[i+x+1] = x;
      solve(x+1);      // rekursiver Aufruf mit x+1
      Feld[i]     = 0; // Aufnahme rueckgaengig machen
      Feld[i+x+1] = 0;
    }
}
 
//------------------------------------------------------------------------
 
int main(int ac, char* av[])
{
  n = atoi(av[1]);       // einlesen von n aus der Kommandozeile
  if(n < 1 || 2*n > 100) // n muss im bereich 1,...,50 liegen
    return 0;
 
  solve(1); // fange an, Feld mit 1 zu befuellen
 
  printf("%d unterschiedliche Loesungen gefunden\n", count/2);
 
  return 0;
}

def solve(n,arr,HASH,DICT):
    if n == 0:
        return [[k for k in arr]]
    if HASH in DICT:
        return DICT[HASH]
    S = []
    for i in range(len(arr)):
        if arr[i]>0 \
           or i+n+1 >= len(arr)\
           or arr[i+n+1]>0:
            continue
        arr[i] = arr[i+n+1] = n
        HASH += 2**i + 2**(i+n+1)
        S += solve(n-1,arr,HASH,DICT)
        arr[i] = arr[i+n+1] = 0
        HASH -= 2**i + 2**(i+n+1)
    DICT[HASH] = S
    return DICT[HASH]
 
for n in range(1,13):
    DICT = {}
    S = solve(n,[0]*(2*n),0,DICT)
    with open("Array_Fill_Game.txt","a") as f:
        for s in S:
            f.write(str(s))
            f.write("\n")
    print(n,len(S))
 

void ausgabe(void){ // Ausgabe von Feld
  int i;
 
  for(i=0; i<2*n; i++)
    if(Feld[i] == n-1)
      break;
    else if(Feld[i] == n)
      return;
 
  count++;
  printf("Loesung Nr. %d: ", count);
  if(Feld[0] < Feld[2*n-1])
    for(i=0; i<2*n; i++)
      printf("%d ", Feld[i]);
  else
    for(i=2*n-1; i>=0; i--)
      printf("%d ", Feld[i]);
  printf("\n");
  return;
}

def do_stage(stage):
    if stage>N:
        if feld[0]<feld[2*N-1]: # wenn nicht nur gespiegelt
            print(feld)
    else:
        for where in range(2*N-stage-1):
            if feld[where]==0 and feld[where+stage+1]==0:
                feld[where]=stage
                feld[where+stage+1]=stage
                do_stage(stage+1)
                feld[where]=0
                feld[where+stage+1]=0
 
for N in range(2,8):
    feld = 2*N*[0]
    do_stage(1)