Leer un libro es fácil, pero imprimir un libro puede ser un poco complicado. Al imprimir un folleto, la impresora necesita tener las páginas ordenadas de cierta manera para poder leerlas de izquierda a derecha. La forma en que se hace esto es usando un patrón como el siguiente

n, 1, 2, n-1, n-2, 3, 4, n-3, n-4, 5, 6, n-5, n-6, 7, 8, n-7, n-8, 9, 10, n-9, n-10, 11, 12, n-11…

Casos de prueba

Folleto de 4 páginas: 4, 1, 2, 3

Folleto de 8 páginas: 8,1,2,7,6,3,4,5

Folleto de 12 páginas: 12,1,2,11,10,3,4,9,8,5,6,7

Folleto de 16 páginas: 16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9

Folleto de 20 páginas: 20,1,2,19,18,3,4,17,16,5,6,15,14,7,8,13,12,9,10,11

Tarea

Su tarea es, dado un número entero nque es múltiplo de 4, mostrar una serie de números que podrían usarse para imprimir un libro den páginas.

Nota: siempre que la salida genere los números correctos, ya sea delimitados por espacios, comas, guiones o paréntesis, se puede utilizar cualquier método para llegar a una solución

Esta es una pregunta de código de golf , por lo que las respuestas se puntuarán en bytes, ganando la menor cantidad de bytes.

05AB1E , 9 8 7 bytes

L`[Žˆrˆ

Pruébalo en línea!

Explicación

L           # push range [1 ... input]
 `          # split as separate to stack
  [Ž        # loop until stack is empty
    ˆ       # add top of stack to global list
     r      # reverse stack
      ˆ     # add top of stack to global list
            # implicitly display global list

JavaScript (ES6), 49 45 bytes

Guardado 4 bytes con ayuda de @RickHitchcock

f=(n,k=1)=>n<k?[]:[n,k,k+1,n-1,...f(n-2,k+2)]

Manifestación

f=(n,k=1)=>n<k?[]:[n,k,k+1,n-1,...f(n-2,k+2)]

console.log(JSON.stringify(f(4)))
console.log(JSON.stringify(f(8)))
console.log(JSON.stringify(f(12)))
console.log(JSON.stringify(f(16)))
console.log(JSON.stringify(f(20)))

No recursivo, 51 bytes

n=>[...Array(n)].map((_,i)=>[2*n-i,,++i][i&2]+1>>1)

Manifestación

let f =

n=>[...Array(n)].map((_,i)=>[2*n-i,,++i][i&2]+1>>1)

console.log(JSON.stringify(f(4)))
console.log(JSON.stringify(f(8)))
console.log(JSON.stringify(f(12)))
console.log(JSON.stringify(f(16)))
console.log(JSON.stringify(f(20)))

Python 2, 99 93 88 58 56 55 bytes

f=input()
for i in range(1,f/2,2):print-~f-i,i,i+1,f-i,

Pruébalo en línea!

_{-6 bytes eliminando sangría innecesaria, gracias Oliver Ni}

_{-5 bytes cambiando el condicional, gracias Luis Mendo}

_{-30 bytes mediante la optimización de las declaraciones de impresión, gracias Arnold Palmer}

_{-2 bytes poniendo el bucle en una línea, gracias nedla2004}

_{-1 byte haciendo algo de magia, gracias Sr. Xcoder}

Python 2 , 46 bytes

lambda n:map(range(1,n+1).pop,n/4*[-1,0,0,-1])

Pruébalo en línea!

Genera el rango [1..n]y aparece desde el frente y hacia atrás en el patrón repetitivoback, front, front, back, ...

Python 2 , 49 bytes

f=lambda n,k=1:n/k*[0]and[n,k,k+1,n-1]+f(n-2,k+2)

Pruébalo en línea!

Genera los primeros 4 elementos, luego continúa recursivamente con el valor superior ndisminuido en 2 y el valor inferior kaumentado en 2.

Python 2 , 49 bytes

lambda n:[[n-i/2,i/2+1][-i%4/2]for i in range(n)]

Pruébalo en línea!

Genera directamente el ivalor 'th de la lista, utilizando -i%4/2como un valor booleano para tomar el valor más bajo o más alto.

Pitón 3 , 68 63 62 bytes

−5 bytes gracias a @notjagan (eliminando espacios y utilizando en [*...]lugar delist() ).

-1 byte gracias a @ovs (en *1lugar de [:]) .

def f(n):r=[*range(1,n+1)];return[r.pop(k%4//2-1)for k in r*1]

Pruébalo en línea!

MATL , 19 17 10 bytes

:t"0&)@o?P

Pruébalo en línea!

Explicación

:          % Implicitly input n. Push range [1 2 ... n]
t          % Duplicate
"          % For each (that is, do n times)
  0&)      %   Push last element, and then subarray with remaining elements
  @        %   Push 1-based iteration index
  o?       %   Is it odd? If so
    P      %     Reverse subarray of remaining elements
           %   Implicit end
           % Implicit end
           % Implicitly display stack

Gelatina ,  12  11 bytes

Mejorado a 11 bytes, "Métodos combinatorios":

9Bṁ×ḶṚÆ¡‘Œ?

Pruébalo en línea!

¿Cómo?

Utiliza los cálculos de permutación y el sistema de números factoriales:

9Bṁ×ḶṚÆ¡‘Œ? - Link n                        e.g. 16
9B          - nine in binary                     [1,0,0,1]
  ṁ         - mould like n                       [1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1]
    Ḷ       - lowered range(n)                   [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
   ×        - multiply                           [0,0,0,3,4,0,0,7,8,0,0,11,12,0,0,15]
     Ṛ      - reverse                            [15,0,0,12,11,0,0,8,7,0,0,4,3,0,0,0]
      Æ¡    - convert from factorial base        19621302981954 (=15*15!+12*12!+...+3*3!)
        ‘   - increment                          19621302981955 (we actually wanted 1*0! too)
         Œ? - shortest permutation of natural numbers [1,2,...] that would reside at that
            -   index in a sorted list of all permutations of those same numbers
            -                                    [16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9]

12 bytes sin mejorar, "Patrones de tejer":

RṚ‘żRs2Z€FḊṁ

Pruébalo en línea!

¿Cómo?

Este es el enfoque simple, crea dos hilos, los intercala y luego recorta los cabos sueltos:

RṚ‘żRs2Z€FḊṁ - Link: n                      e.g. 8
R            - range(n)                          [1,2,3,4,5,6,7,8]
 Ṛ           - reverse                           [8,7,6,5,4,3,2,1]
  ‘          - increment                         [9,8,7,6,5,4,3,2]
    R        - range(n)                          [1,2,3,4,5,6,7,8]
   ż         - zip (interleave)                  [[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8]]
     s2      - split into chunks of length 2     [[[9,1],[8,2]],[[7,3],[6,4]],[[5,5],[4,6]],[[3,7],[2,8]]]
       Z€    - transpose €ach (cross-stitch?!)   [[[9,8],[1,2]],[[7,6],[3,4]],[[5,4],[5,6]],[[3,2],[7,8]]]
         F   - flatten                           [9,8,1,2,7,6,3,4,5,4,5,6,3,2,7,8]
          Ḋ  - dequeue (removes excess start)    [8,1,2,7,6,3,4,5,4,5,6,3,2,7,8]
           ṁ - mould like n (removes excess end) [8,1,2,7,6,3,4,5]

Octava , 43 36 bytes

Un puerto de esta respuesta en C (gcc) se puede encontrar aquí .

@(n)[n-(k=1:2:n/2)+1;k;k+1;n-k](:)';

Explicación

1. k=1:2:n/2: Genera una secuencia lineal de 1 a n/2 en pasos de 2. Tenga en cuenta que esto se usa inmediatamente en el siguiente paso.
2. [n-k+1;k;k+1;n-k]: Crea una matriz de 4 filas de modo que la primera fila crea la secuencia n, n-2, n-4...hacia abajo n-(n/2)+2, la segunda fila es 1, 3, 5...hasta n/2 - 1, la tercera fila es la segunda fila agregada por 1 y la cuarta fila es la primera fila agregada por 1.
3. [n-k+1;k;k+1;n-k](:)': Esto apila todas las columnas de esta matriz juntas de izquierda a derecha para hacer un solo vector de columna, y lo transponemos a un vector de fila para una fácil visualización. Apilar las columnas juntas de esta manera crea con precisión la secuencia deseada.

Tenga en cuenta que esta es una función anónima, por lo que puede asignarla a una variable antes de usarla, o puede usar la ansvariable incorporada que se crea después de crear la función.

Pruébalo en línea!

R , 48 bytes (mejorado)

¡Gracias a @Giuseppe por -7 bytes!

n=scan();(x=order(1:n%%2))[order(-(n/2+.5-x)^2)]

El truco es que x=1:n;x[order(x%%2)]es equivalente a order(1:n%%2).

Pruébalo en línea!

R , 55 bytes (original)

Golfed

n=scan();x=1:n;x=x[order(x%%2)];x[order(-(n/2+.5-x)^2)]

Ungolfed con comentarios

Leer nde stdin.

n=scan()

Definir xcomo secuencia de páginas de 1 a n.

x=1:n

Ordene las páginas para que incluso las páginas estén antes de las páginas desiguales.

x=x[order(x%%2)]

Ordene las páginas en orden descendente con respecto al centro del libro calculado por n/2+.5.

x[order(-(n/2+.5-x)^2)]

Ejemplo con 8 páginas:

• el centro es 4.5;
• las páginas 1 y 8 son las más distantes del centro, pero 8 viene primero porque 8 es par;
• las páginas 2 y 7 son las siguientes más distantes del centro, pero 2 viene primero como 2 es par;
• y así.

Pruébalo en línea!

Mathematica, 54 53 45 bytes

Join@@Range[#][[(-1)^k{k,-k}]]~Table~{k,#/2}&

Explicación

Join@@Range[#][[(-1)^k{k,-k}]]~Table~{k,#/2}&  (* Input: # *)
                              ~Table~{k,#/2}   (* Iterate from k=1 to #/2 *)
      Range[#][[            ]]                 (* From {1..#}, take... *)
                      {k,-k}                   (* k-th and negative k-th element *)
                                               (* negative k-th = k-th from the end *)
                (-1)^k                         (* Reversed for odd k *)
Join@@                                         (* Join the result *)

Python 2 , 64 63 bytes

^{-1 byte gracias a los ovs!}

lambda n:sum([[i,i+1,n-i,n+~i]for i in range(1,n/2,2)],[n])[:n]

Pruébalo en línea!

Haskell, 42 bytes

n#a|n<a=[]|x<-n-2=n:a:a+1:n-1:x#(a+2)
(#1)

Pruébalo en línea!

Un byte más largo:

Haskell, 43 bytes

f n=[1,3..div n 2]>>= \x->[n-x+1,x,x+1,n-x]

Java 8, 84 72 bytes

n->{for(int j=0;++j<n;System.out.printf("%d,%d,%d,%d,",n--,j++,j,n--));}

o

n->{for(int j=0;++j<n;System.out.print(n--+","+j+++","+j+","+n--+","));}

-12 bytes gracias al comentario de @TheLethalCoder sobre la respuesta de C #.

Respuesta anterior (84 bytes):

n->{int r[]=new int[n],i=1,N=n,J=1;for(r[0]=n;i<n;r[i]=-~i++%4<2?J++:--N);return r;}

Explicación:

Pruébalo aquí

n->{                  // Method with integer parameter and no return-type
  for(int j=0;++j<n;  //  Loop from 1 to `n` (exclusive)
    System.out.printf("%d,%d,%d,%d,",n--,j++,j,n--)
                      //   Print four numbers simultaneously
  );                  //  End of loop
}                     // End of method

Perl 5 , 47 + 1 (-n) = 48 bytes

$,=$";print$_--,$i+++1,$i+++1,$_--,''while$_>$i

Pruébalo en línea!

Swift 3 , 74 bytes

func g(f:Int){for i in stride(from:1,to:f/2,by:2){print(f-i+1,i,i+1,f-i)}}

Pruébalo en línea!

Swift 3 , 60 bytes

{f in stride(from:1,to:f/2,by:2).map{(f-$0+1,$0,$0+1,f-$0)}}

Por alguna razón, esto no funciona en ningún entorno en línea que he probado hasta ahora. Si quieres probarlo, ponlo var g=delante y llámalo conprint(g(12)) en Xcode (Campos de juego) .

Aquí hay una imagen después de que la ejecuté en un patio de juegos Xcode, versión 8.3.1 (Running Swift 3.1):

QBIC , 25 bytes

[1,:/2,2|?b-a+1,a,1+a,b-a

Aunque la entrada es% 4, el ritmo real se basa en 2.

Explicación

[1,:/2,2|   FOR ( b=1; b <= <input>/2; b=b+2)               
?           PRINT
 b-a+1,     n
 a,         1
 1+a,       2
 b-a        n-1

C (gcc) , 66 bytes

Un puerto de mi Octave responde a C (gcc):

f(n,i){for(i=1;i<n/2;i+=2)printf("%d %d %d %d ",n-i+1,i,i+1,n-i);}

Pruébalo en línea!

cQuents , 21 bytes

=n::n-z+1,z+1,x-1,z-1

Pruébalo en línea!

Explicación

                            Implicit input n
=n                          First item in the sequence is n
  ::                        Mode :: (Sequence 2): print sequence from 1 to n
                            Comma delimited items are rotated through
    n-z+1,                    n - previous + 1
          z+1,                previous + 1
              x-1,            third-previous - 1
                  z-1         previous - 1

R , 64 60 bytes

Devastadoramente superado por djhurio ! Su respuesta es bastante elegante, vótala.

n=scan();matrix(c(n-(k=seq(1,n/2,2))+1,k,k+1,n-k),4,,T)[1:n]

Un puerto de respuesta de octava de rayryeng .

Pruébalo en línea!

solución original (64 bytes):

f=function(n,l=1:n)`if`(n,c(l[i<-c(n,1,2,n-1)],f(n-4,l[-i])),{})

Función recursiva.

Pruébalo en línea!

Bash + Perl + Groff + Psutils, 48 ​​bytes

perl -nE'say".bp
"x--$_'|groff|psbook>/dev/null

Muestra salida en stderr . La salida contiene algo de basura final.

Ejemplo de uso:

$ echo 20 | perl -nE'say".bp
> "x--$_'|groff|psbook>/dev/null
[20] [1] [2] [19] [18] [3] [4] [17] [16] [5] [6] [15] [14] [7] [8] [13] [12] 
[9] [10] [11] Wrote 20 pages, 4787 bytes

Pyth , 21 20 bytes

sm[hK-QddhdK):1/Q2 2

Banco de pruebas.

Si se permite la salida como una lista anidada:

Pyth , 20 19 bytes

m[hK-QddhdK):1/Q2 2

Banco de pruebas.

Explicación

sm [hK-QddhdK): 1 / Q2 2 - Programa completo.

 m: 1 / Q2 2 - Mapa sobre el rango (1, input () / 2,2) con una variable d.
  [) - Construye una lista con:
   hK-Qd - Entrada - d + 1,
        d - d,
         hd - d + 1 y
           K - Entrada - d.
s: aplana la lista e imprime implícitamente.

Rubí , 40 bytes.

->n{1.step(n/2,2){|x|p n-x+1,x,x+1,n-x}}

Pruébalo en línea!

C #, 107 bytes

int[]F(int p){var a=new int[p];for(int i=0,q=1;q<p;a[i++]=p--){a[i++]=p--;a[i++]=q++;a[i++]=q++;}return a;}

Mantenga dos contadores, uno comenzando en 1, uno en p. En cada iteración del ciclo, escriba cuatro elementos y solo incremente o disminuya los contadores después de cada entrada. Cuando los contadores se encuentren en el medio, deténgase.

int[] F(int p)
{
    var a = new int[p];
    for(int i = 0, q = 1; q < p; a[i++] = p--)
    {
        a[i++] = p--;
        a[i++] = q++;
        a[i++] = q++;
    }
    return a;
}

Haskell , 58 bytes

(x:y:r)#(a:b:s)=x:y:a:b:r#s
f n=take n$n:[1..]#[n-1,n-2..]

Pruébalo en línea!

Pyth , 27 24 23 bytes

-3 bytes imprimiendo en lugar de al final.

-1 Gracias al Sr. Xcoder

V:1/Q2 2pjd[-QtNNhN-QNk

Pruébalo en línea!

O en el compilador / ejecutor en línea

Este es mi primer programa real en Pyth, por lo que probablemente haya mejores métodos que no conozco.

Explicación

V:1/Q2 2pjd[-QtNNhN-QNk
V:1/Q2 2                   # For N in range(1, Q/2, 2):
        pjd                # print " ".join(...),
           [-QtNNhN-QNk    # The list [n - (N-1), N, N + 1, n - N, ""] (n is input)

C ++ (gcc) , 89 84 68 bytes

Como lambda genérico sin nombre. nes #pages (% 4 == 0) y Ces un parámetro de referencia para el resultado, un contenedor vacío como vector<int>(solo push_backes necesario).

[](int n,auto&C){for(int i=0,j=0;i<n;C.push_back(++j%4<2?n--:++i));}

solución previa:

#define P C.push_back(
[](int n,auto&C){for(int i=0;i<n;P n--),P++i),P++i),P n--));}

Pruébalo en línea!

Ligeramente incólume:

auto f=
[](int n,auto&C){
 for(int i=0,j=0;
     i<n;
     C.push_back(++j%4<2 ? n-- : ++i));
}

solución anterior _ungolfed :

auto f=
[](int n, auto&C){
 for(
  int i=0;
  i<n;
   P n--),
   P++i),
   P++i),
   P n--)
 );
}
;

Fue desarrollado de forma bastante directa y hay algunas optimizaciones menores en la aritmética.

• Edit1: unificación de la aritmética guardada 5 bytes
• Edit2: después de la unificación, los 4 pasos se combinaron

Uso:

std::vector<int> result;
f(n, result);

Variante de impresión, 77 bytes ^{desactualizados}

Si insiste en imprimir los valores, existe esta solución:

[](int n,auto&o){for(int i=0;i<n;o<<n--<<' '<<++i<<' '<<++i<<' '<<n--<<' ');}

¿Dónde oestá tu deseado std::ostream, comostd::cout

Uso (si se asignó la 2da lambda g):

g(n, std::cout);

Lisp común, 79 bytes

(defun f(n &optional(k 1))(and(> n k)`(,n,k,(1+ k),(1- n),@(f(- n 2)(+ k 2)))))

Pruébalo en línea!

Lua, 94 bytes

Para este desafío, en realidad se me ocurrieron 2 métodos diferentes que tienen 94 bytes.

Método 1:

function f(n,i)i=i or 1 return n>i and('%s,%s,%s,%s,%s'):format(n,i,i+1,n-1,f(n-2,i+2))or''end

Código comentado:

function f(n,i)
  i=i or 1
  -- On the first iteration i will be nil so I'm setting it's value to 1 if it is.

  return n>i and ('%s,%s,%s,%s,%s'):format(n,i,i+1,n-1,f(n-2,i+2)) or ''
  -- Here i return a ternary statement
  -- If n>i is true, it will return a string using string.format() and part of this is recursion
  -- If it's false, it will just return an empty string
end

Método 2:

function f(n,i)i=i or 1 return n>i and n..','..i..','..i+1 ..','..n-1 ..','..f(n-2,i+2)or''end

Este método es similar al primer método, sin embargo, en cambio estoy devolviendo una cadena concatenada en lugar de string.format ()

En ambos métodos, he usado el concepto de n y me estoy acercando

PHP, 51 + 1 bytes

while($i<$k=&$argn)echo$k--,_,++$i,_,++$i,_,$k--,_;

imprime números de página separados por guiones bajos con un delimitador final.
Ejecutar como tubería con -nRo probarlo en línea .

J , 22 bytes

($,)_2|.`]\1+],@,.&i.-

Pruébalo en línea!

Explicación

($,)_2|.`]\1+],@,.&i.-  Input: integer n
             ]          Identity
                     -  Negate
                  &i.   Form the ranges [0, 1, ..., n-1] and [n-1, ..., 1, 0]
                ,.      Interleave
              ,@        Flatten
           1+           Add 1
    _2    \             For each non-overlapping sublist of size 2
        `                 Cycle between these two operations
      |.                    Reverse for the first, third, ...
         ]                  Identity for the second, fourth, ...
  ,                     Flatten
 $                      Reshape to length n