Đọc một cuốn sách là dễ dàng, nhưng in một cuốn sách có thể là một chút khó khăn. Khi in một cuốn sách nhỏ, máy in cần phải sắp xếp các trang theo một cách nhất định để được đọc từ trái sang phải. Cách thức này được thực hiện là sử dụng một mẫu như dưới đây

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…

Các trường hợp thử nghiệm

Tập sách 4 trang: 4, 1, 2, 3

Tập sách 8 trang: 8,1,2,7,6,3,4,5

Tập sách 12 trang: 12,1,2,11,10,3,4,9,8,5,6,7

Tập sách 16 trang: 16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9

Tập sách 20 trang: 20,1,2,19,18,3,4,17,16,5,6,15,14,7,8,13,12,9,10,11

Bài tập

Nhiệm vụ của bạn là, đưa ra một số nguyên nlà bội số của 4, hiển thị một dãy số có thể được sử dụng để in một cuốn sách các ntrang.

Lưu ý: Miễn là đầu ra tạo ra các số chính xác, cho dù được phân cách bằng dấu cách, dấu phẩy, dấu gạch nối hoặc dấu ngoặc đơn, bất kỳ phương pháp nào để có được một giải pháp đều có thể được sử dụng

Đây là một câu hỏi về môn đánh gôn, vì vậy các câu trả lời sẽ được tính theo byte, với số byte ít nhất sẽ giành chiến thắng.

05AB1E , 9 8 7 byte

L`[Žˆrˆ

Hãy thử trực tuyến!

Giải trình

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 byte

Đã lưu 4 byte với sự trợ giúp từ @RickHitchcock

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

Bản giới thiệu

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

Không đệ quy, 51 byte

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

Bản giới thiệu

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 byte

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

Hãy thử trực tuyến!

_{-6 byte bằng cách loại bỏ thụt không cần thiết, cảm ơn Oliver Ni}

_{-5 byte bằng cách thay đổi điều kiện, cảm ơn Luis Mendo}

_{-30 byte bằng cách tối ưu hóa các câu lệnh in, cảm ơn Arnold Palmer}

_{-2 byte bằng cách đặt vòng lặp trên một dòng, cảm ơn nedla2004}

_{-1 byte bằng cách thực hiện một số thuật sĩ, cảm ơn ông Xcoder}

Python 2 , 46 byte

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

Hãy thử trực tuyến!

Tạo phạm vi [1..n]và bật từ phía trước và phía sau trong mẫu lặp lạiback, front, front, back, ...

Python 2 , 49 byte

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

Hãy thử trực tuyến!

Tạo 4 phần tử đầu tiên, sau đó tiếp tục đệ quy với giá trị trên ngiảm 2 và giá trị thấp hơn ktăng 2.

Python 2 , 49 byte

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

Hãy thử trực tuyến!

Tạo trực tiếp igiá trị thứ của danh sách, sử dụng -i%4/2làm Boolean cho việc lấy giá trị thấp hơn hoặc cao hơn.

Python 3 , 68 63 62 byte

−5 byte nhờ @notjagan (xóa khoảng trắng và sử dụng [*...]thay vì list()).

Byte1 byte nhờ @ovs ( *1thay vì [:]) .

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

Hãy thử trực tuyến!

MATL , 19 17 10 byte

:t"0&)@o?P

Hãy thử trực tuyến!

Giải trình

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

Thạch ,  12  11 byte

Được cải thiện thành 11 byte, "Phương thức kết hợp":

9Bṁ×ḶṚÆ¡‘Œ?

Hãy thử trực tuyến!

Làm sao?

Điều này sử dụng tính toán hoán vị và hệ thống số giai thừa:

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]

Chưa được phê duyệt 12 byter, "Kiểu đan":

RṚ‘żRs2Z€FḊṁ

Hãy thử trực tuyến!

Làm sao?

Đây là cách tiếp cận đơn giản, nó tạo ra hai sợi, xen kẽ chúng và sau đó cắt các đầu lỏng lẻo:

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]

Octave , 43 36 byte

Một cổng của câu trả lời này trong C (gcc) có thể được tìm thấy ở đây .

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

Giải trình

1. k=1:2:n/2: Tạo một chuỗi tuyến tính từ 1 đến n/2các bước của 2. Lưu ý rằng điều này được sử dụng ngay lập tức trong bước tiếp theo.
2. [n-k+1;k;k+1;n-k]: Tạo ma trận 4 hàng sao cho hàng đầu tiên tạo chuỗi n, n-2, n-4...xuống n-(n/2)+2, hàng thứ hai 1, 3, 5...lên đến n/2 - 1, hàng thứ ba là hàng thứ hai được thêm bởi 1 và hàng thứ tư là hàng đầu tiên được thêm bởi 1.
3. [n-k+1;k;k+1;n-k](:)': Điều này sắp xếp tất cả các cột của ma trận này từ trái sang phải để tạo một vectơ cột đơn và chúng tôi chuyển nó thành một vectơ hàng để hiển thị dễ dàng. Xếp chồng các cột lại với nhau theo cách này chính xác tạo ra chuỗi mong muốn.

Lưu ý rằng đây là một hàm ẩn danh, vì vậy bạn có thể gán nó cho một biến trước khi sử dụng nó hoặc bạn có thể sử dụng ansbiến tích hợp được tạo sau khi tạo hàm.

Hãy thử trực tuyến!

R , 48 byte (được cải thiện)

Cảm ơn @Giuseppe cho -7 byte!

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

Bí quyết x=1:n;x[order(x%%2)]là tương đương với order(1:n%%2).

Hãy thử trực tuyến!

R , 55 byte (bản gốc)

Chơi gôn

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

Phản đối với ý kiến

Đọc ntừ stdin.

n=scan()

Xác định xlà chuỗi các trang từ 1 đến n.

x=1:n

Đặt hàng các trang để thậm chí các trang là trước các trang không đồng đều.

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

Sắp xếp các trang theo thứ tự giảm dần đối với trung tâm của cuốn sách được tính bởi n/2+.5.

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

Ví dụ với 8 trang:

• trung tâm là 4,5;
• trang 1 và 8 là xa trung tâm nhất, nhưng 8 đến trước vì 8 là chẵn;
• trang 2 và 7 là trang xa nhất tiếp theo từ trung tâm, nhưng 2 đến trước là 2 chẵn;
• vân vân

Hãy thử trực tuyến!

Toán học, 54 53 45 byte

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

Giải trình

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 byte

^{-1 byte nhờ vào lò nướng!}

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

Hãy thử trực tuyến!

Haskell, 42 byte

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

Hãy thử trực tuyến!

Một byte dài hơn:

Haskell, 43 byte

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

Java 8, 84 72 byte

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

hoặc là

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

-12 byte nhờ nhận xét của @TheLethalCoder về câu trả lời C #.

Câu trả lời cũ (84 byte):

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

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Hãy thử trực tuyến!

Swift 3 , 74 byte

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

Hãy thử trực tuyến!

Swift 3 , 60 byte

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

Vì một số lý do, điều này không hoạt động trong bất kỳ môi trường trực tuyến nào tôi đã thử cho đến nay. Nếu bạn muốn thử nghiệm nó, đặt var g=trước mặt nó, và gọi nó với print(g(12))trong Xcode (sân chơi) .

Đây là hình ảnh sau khi tôi chạy nó trong sân chơi Xcode, phiên bản 8.3.1 (Running Swift 3.1):

QBIC , 25 byte

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

Mặc dù đầu vào là% 4, nhịp điệu thực tế là dựa trên 2.

Giải trình

[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 byte

Một cổng của câu trả lời Octave của tôi cho 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);}

Hãy thử trực tuyến!

cQuents , 21 byte

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

Hãy thử trực tuyến!

Giải trình

                            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 byte

Sự tàn phá khủng khiếp của djhurio ! Câu trả lời của anh ấy khá tao nhã, hãy upvote nó.

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

Một câu trả lời Octave của rayryeng .

Hãy thử trực tuyến!

giải pháp gốc (64 byte):

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

Hàm đệ quy.

Hãy thử trực tuyến!

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

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

Hiển thị đầu ra trên stderr. Đầu ra chứa một số rác thải.

Ví dụ sử dụng:

$ 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

Bình thường , 21 20 byte

sm[hK-QddhdK):1/Q2 2

Phòng thử nghiệm.

Nếu xuất ra dưới dạng danh sách lồng nhau được cho phép:

Bình thường , 20 19 byte

m[hK-QddhdK):1/Q2 2

Phòng thử nghiệm.

Giải trình

sm [hK-QddhdK): 1 / Q2 2 - Chương trình đầy đủ.

 m: 1 / Q2 2 - Ánh xạ trên phạm vi (1, đầu vào () / 2,2) với một biến d.
  [) - Xây dựng danh sách với:
   hK-Qd - Đầu vào - d + 1,
        d - d,
         hd - d + 1 và
           K - Đầu vào - d.
s - Làm phẳng danh sách và in ngầm.

Ruby , 40 byte

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

Hãy thử trực tuyến!

C #, 107 byte

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

Giữ hai quầy, một bắt đầu từ 1, một tại p. Trong mỗi lần lặp lặp, hãy viết bốn phần tử và chỉ các bộ đếm tăng hoặc giảm sau mỗi lần nhập. Khi các quầy gặp nhau ở giữa, dừng lại.

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 byte

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

Hãy thử trực tuyến!

Bình thường , 27 24 23 byte

-3 byte bằng cách in trong suốt thay vì ở cuối.

-1 Cảm ơn ông Xcoder

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

Hãy thử trực tuyến!

Hoặc trên Trình biên dịch / Executor trực tuyến

Đây là chương trình thực sự đầu tiên của tôi ở Pyth, vì vậy có lẽ có những phương pháp tốt hơn mà tôi không biết.

Giải trình

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

Như lambda chung không tên. nlà #pages (% 4 == 0) và Clà tham số tham chiếu cho kết quả, một thùng chứa trống giống như vector<int>(chỉ push_backcần thiết).

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

giải pháp trước đây:

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

Hãy thử trực tuyến!

Hơi vô dụng:

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

giải pháp trước đây _{hơi vô căn cứ} :

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

Nó được phát triển khá đơn giản và chắc chắn có một số tối ưu hóa nhỏ trong mỹ phẩm.

• Edit1: thống nhất các arithologists lưu 5 byte
• Edit2: sau khi thống nhất, 4 bước được kết hợp

Sử dụng:

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

Biến thể in, 77 byte ^{lỗi thời}

Nếu bạn khăng khăng in các giá trị, có giải pháp này:

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

Trong trường hợp olà mong muốn của bạn std::ostream, giống nhưstd::cout

Cách sử dụng (nếu lambda thứ 2 được gán cho g):

g(n, std::cout);

Lisp thông thường, 79 byte

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

Hãy thử trực tuyến!

Lua, 94 byte

Đối với thử thách này, tôi thực sự đã đưa ra 2 phương thức khác nhau là cả 94 byte.

Cách 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

Mã nhận xét:

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

Cách 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

Phương thức này tương tự như phương thức đầu tiên, tuy nhiên, thay vào đó tôi trả về một chuỗi được nối thay vì chuỗi.format ()

Trong cả hai phương pháp tôi đã sử dụng khái niệm n và tôi gần nhau hơn

PHP, 51 + 1 byte

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

in số trang được phân tách bằng dấu gạch dưới với dấu phân cách.
Chạy như ống với -nRhoặc thử trực tuyến .

J , 22 byte

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

Hãy thử trực tuyến!

Giải trình

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