Ein Buch zu lesen ist einfach, aber ein Buch zu drucken kann etwas schwierig sein. Beim Drucken einer Broschüre müssen die Seiten auf dem Drucker in einer bestimmten Reihenfolge angeordnet sein, damit sie von links nach rechts gelesen werden können. Hierfür wird ein Muster wie das folgende verwendet

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…

Testfälle

4-seitiges Booklet: 4, 1, 2, 3

8-seitiges Booklet: 8,1,2,7,6,3,4,5

12-seitiges Booklet: 12,1,2,11,10,3,4,9,8,5,6,7

16-seitiges Booklet: 16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9

20-seitiges Booklet: 20,1,2,19,18,3,4,17,16,5,6,15,14,7,8,13,12,9,10,11

Aufgabe

Ihre Aufgabe ist es, bei einer Ganzzahl n, die ein Vielfaches von 4 ist, ein Array von Zahlen anzuzeigen, mit denen Sie ein Buch mit nSeiten drucken können .

Hinweis: Solange die Ausgabe die richtigen Zahlen generiert, unabhängig davon, ob sie durch Leerzeichen, Kommas, Bindestriche oder Klammern getrennt sind, kann jede Methode zum Erreichen einer Lösung verwendet werden

Dies ist eine Code-Golf- Frage, daher werden die Antworten in Bytes gewertet, wobei die wenigsten Bytes gewinnen.

05AB1E , 9 8 7 Bytes

L`[Žˆrˆ

Probieren Sie es online!

Erläuterung

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

4 Bytes mit Hilfe von @RickHitchcock gespeichert

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

Demo

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)))

Nicht rekursiv, 51 Bytes

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

Demo

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,

Probieren Sie es online!

_{-6 Bytes durch Entfernen nicht benötigter Einrückungen, danke Oliver Ni}

_{-5 Bytes durch Ändern der Bedingung, danke Luis Mendo}

_{-30 Bytes durch Optimierung der Druckanweisungen, danke Arnold Palmer}

_{-2 Bytes durch Setzen der Schleife in eine Zeile, danke nedla2004}

_{-1 Byte durch Zauberkunst, danke Mr. Xcoder}

Python 2 , 46 Bytes

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

Probieren Sie es online!

Erzeugt den Bereich [1..n]und springt von vorne und hinten in das sich wiederholende Musterback, 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)

Probieren Sie es online!

Erzeugt die ersten 4 Elemente und fährt dann rekursiv fort, wobei der obere Wert num 2 verringert und der untere Wert kum 2 erhöht wird.

Python 2 , 49 Bytes

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

Probieren Sie es online!

Erzeugt direkt den i'ten Wert der Liste, wobei -i%4/2als Boolescher Wert verwendet wird, ob der niedrigere oder der höhere Wert verwendet werden soll.

Python 3 , 68 63 62 Bytes

−5 Bytes dank @notjagan (Leerzeichen entfernen und [*...]statt verwenden list()).

−1 Byte dank @ovs ( *1anstelle von [:]) .

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

Probieren Sie es online!

MATL , 19 17 10 Bytes

:t"0&)@o?P

Probieren Sie es online!

Erläuterung

:          % 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

Jelly ,  12  11 Bytes

Verbessert auf 11 Bytes, "Kombinatorische Methoden":

9Bṁ×ḶṚÆ¡‘Œ?

Probieren Sie es online!

Wie?

Dies verwendet Permutationsberechnungen und das Fakultätszahlensystem:

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]

Unverbesserte 12 Bytes, "Knitting Patterns":

RṚ‘żRs2Z€FḊṁ

Probieren Sie es online!

Wie?

Dies ist der einfache Ansatz, der zwei Stränge erzeugt, diese verschachtelt und dann die losen Enden schneidet:

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]

Oktave , 43 36 Bytes

Ein Port dieser Antwort in C (gcc) ist hier zu finden .

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

Erläuterung

1. k=1:2:n/2: Erzeugt eine lineare Sequenz von 1 bis n/2in Schritten von 2. Beachten Sie, dass dies sofort im nächsten Schritt verwendet wird.
2. [n-k+1;k;k+1;n-k]: Erstellt eine Matrix mit 4 Zeilen, sodass die erste Zeile die Sequenz n, n-2, n-4...bis erstellt n-(n/2)+2, die zweite Zeile 1, 3, 5...bis n/2 - 1, die dritte Zeile die zweite Zeile, die um 1 erhöht wird, und die vierte Zeile die erste Zeile, die um 1 erhöht wird.
3. [n-k+1;k;k+1;n-k](:)': Hiermit werden alle Spalten dieser Matrix von links nach rechts gestapelt, um einen einzelnen Spaltenvektor zu erstellen, und wir transponieren ihn zur einfachen Anzeige in einen Zeilenvektor. Wenn Sie die Spalten auf diese Weise genau stapeln, wird die gewünschte Reihenfolge erstellt.

Beachten Sie, dass dies eine anonyme Funktion ist, sodass Sie sie vor der Verwendung einer Variablen zuweisen oder die integrierte ansVariable verwenden können, die nach dem Erstellen der Funktion erstellt wird.

Probieren Sie es online!

R , 48 Bytes (verbessert)

Vielen Dank an @ Giuseppe für -7 Bytes!

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

Der Trick ist, dass x=1:n;x[order(x%%2)]entspricht order(1:n%%2).

Probieren Sie es online!

R , 55 Bytes (original)

Golf gespielt

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

Ungolfed mit Kommentaren

Lesen Sie naus Standard.

n=scan()

Definieren Sie xals Folge von Seiten von 1 bis n.

x=1:n

Bestellen Sie Seiten so, dass gerade Seiten vor ungeraden Seiten stehen.

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

Ordnen Sie die Seiten in absteigender Reihenfolge in Bezug auf die Mitte des von berechneten Buches an n/2+.5.

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

Beispiel mit 8 Seiten:

• Zentrum ist 4,5;
• Die Seiten 1 und 8 sind am weitesten vom Zentrum entfernt, aber 8 steht an erster Stelle, weil 8 gerade ist.
• Die Seiten 2 und 7 sind am nächsten vom Zentrum entfernt, aber 2 steht an erster Stelle, da 2 gerade ist.
• und so weiter.

Probieren Sie es online!

Mathematica, 54 53 45 Bytes

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

Erläuterung

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 dank ovs!}

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

Probieren Sie es online!

Haskell, 42 Bytes

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

Probieren Sie es online!

Ein Byte länger:

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--));}

oder

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

-12 Bytes dank @TheLethalCoders Kommentar zur C # Antwort.

Alte Antwort (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;}

Erläuterung:

Probieren Sie es hier aus.

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

Probieren Sie es online!

Schnelle 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)}}

Probieren Sie es online!

Schnelle 3 , 60 Bytes

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

Aus irgendeinem Grund funktioniert dies in keiner Online-Umgebung, die ich bisher ausprobiert habe. Wenn Sie es testen möchten, stellen Sie es var g=davor und rufen Sie es mit print(g(12))in Xcode (Playgrounds) auf .

Hier ist ein Bild, nachdem ich es auf einem Xcode-Spielplatz, Version 8.3.1 (Running Swift 3.1), ausgeführt habe:

QBIC , 25 Bytes

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

Obwohl die Eingabe% 4 ist, basiert der tatsächliche Rhythmus auf 2.

Erläuterung

[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

Ein Port meiner Octave-Antwort auf 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);}

Probieren Sie es online!

cQuents , 21 Bytes

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

Probieren Sie es online!

Erläuterung

                            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

Verheerend überfordert von Djhurio ! Seine Antwort ist ziemlich elegant.

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

Ein Port von Rayryengs Octave-Antwort .

Probieren Sie es online!

ursprüngliche Lösung (64 Bytes):

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

Rekursive Funktion.

Probieren Sie es online!

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

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

Zeigt die Ausgabe an stderr. Die Ausgabe enthält nachgestellten Müll.

Anwendungsbeispiel:

$ 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 bis 20 Bytes

sm[hK-QddhdK):1/Q2 2

Test Suite.

Wenn die Ausgabe als verschachtelte Liste zulässig ist:

Pyth , 20 bis 19 Bytes

m[hK-QddhdK):1/Q2 2

Test Suite.

Erläuterung

sm [hK-QddhdK): 1 / Q2 2 - Volles Programm.

 m: 1 / Q2 2 - Karte über Bereich (1, Eingang () / 2,2) mit einer Variablen d.
  [) - Erstelle eine Liste mit:
   hK-Qd - Eingang - d + 1,
        d - d,
         hd - d + 1 und
           K - Eingabe - d.
s - Reduziert die Liste und druckt implizit.

Ruby , 40 Bytes

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

Probieren Sie es online!

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;}

Behalten Sie zwei Zähler bei, einer beginnend bei 1, einer bei p. Schreiben Sie in jeder Schleifeniteration vier Elemente und erhöhen oder verringern Sie die Zähler nach jedem Eintrag. Wenn sich die Zähler in der Mitte treffen, hören Sie auf.

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..]

Probieren Sie es online!

Pyth , 27 24 23 Bytes

-3 Bytes durch Drucken durch anstatt am Ende.

-1 Danke an Herrn Xcoder

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

Probieren Sie es online!

Oder im Online Compiler / Executor

Dies ist mein erstes echtes Programm in Pyth, daher gibt es wahrscheinlich bessere Methoden, die ich nicht kenne.

Erläuterung

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 Byte

Wie unbenanntes generisches Lambda. nist #pages (% 4 == 0) und Cist ein Referenzparameter für das Ergebnis, wie ein leerer Container vector<int>(wird nur push_backbenötigt).

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

vorherige Lösung:

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

Probieren Sie es online!

Leicht ungolfed:

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

vorherige Lösung _{leicht ungolfed} :

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

Es wurde recht einfach entwickelt und es gibt sicher einige kleinere Optimierungen in der Arithmetik.

• Edit1: Vereinheitlichung der Arithmetik 5 Byte gespeichert
• Edit2: Nach der Vereinigung wurden die 4 Schritte kombiniert

Verwendungszweck:

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

Druckvariante, 77 Bytes ^veraltet

Wenn Sie darauf bestehen, die Werte auszudrucken, gibt es diese Lösung:

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

Wo oist dein Wunsch std::ostream, wiestd::cout

Verwendung (wenn 2. Lambda zugeordnet wurde g):

g(n, std::cout);

Common Lisp, 79 Bytes

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

Probieren Sie es online!

Lua, 94 Bytes

Für diese Herausforderung habe ich mir 2 verschiedene Methoden ausgedacht, die beide 94 Bytes lang sind.

Methode 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

Kommentierter Code:

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

Methode 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

Diese Methode ähnelt der ersten Methode, jedoch wird statt string.format () eine verkettete Zeichenfolge zurückgegeben.

In beiden Methoden habe ich das Konzept von n verwendet und ich komme näher zusammen

PHP, 51 + 1 Bytes

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

druckt Seitenzahlen, die durch einen Unterstrich mit einem nachgestellten Trennzeichen getrennt sind.
Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

J , 22 Bytes

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

Probieren Sie es online!

Erläuterung

($,)_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