책을 읽는 것은 쉽지만 책을 인쇄하는 것은 약간 까다로울 수 있습니다. 소책자를 인쇄 할 때 왼쪽에서 오른쪽으로 읽으려면 프린터가 특정 방식으로 페이지를 정렬해야합니다. 이 방법은 아래와 같은 패턴을 사용하는 것입니다.

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…

테스트 사례

4 페이지 소책자 : 4, 1, 2, 3

8 페이지 소책자 : 8,1,2,7,6,3,4,5

12 페이지 소책자 : 12,1,2,11,10,3,4,9,8,5,6,7

16 페이지 소책자 : 16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9

20 페이지 소책자 : 20,1,2,19,18,3,4,17,16,5,6,15,14,7,8,13,12,9,10,11

태스크

당신의 임무는 n4의 배수 인 정수 가 주어지면 , 책을 인쇄하는데 사용될 수있는 숫자의 배열을 표시하는 것 n입니다.

참고 : 공백, 쉼표, 하이픈 또는 괄호로 구분하여 출력이 올바른 숫자를 생성하는 한 솔루션에 도달하는 모든 방법을 사용할 수 있습니다.

이것은 코드 골프 질문이므로 답은 바이트 단위로 기록되며 가장 적은 바이트 수를 얻습니다.

05AB1E , 9 8 7 바이트

L`[Žˆrˆ

온라인으로 사용해보십시오!

설명

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

자바 스크립트 (ES6), 49 45 바이트

@RickHitchcock의 도움으로 4 바이트 저장

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

데모

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

비 재귀, 51 바이트

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

데모

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

파이썬 2, 99 93 88 58 56 55 바이트

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

온라인으로 사용해보십시오!

_{Oliver Ni 덕분에 불필요한 들여 쓰기를 제거하여 -6 바이트}

_{조건부를 변경하여 -5 바이트, Luis Mendo 덕분에}

_{Arnold Palmer 덕분에 인쇄 문을 최적화하여 -30 바이트}

_{nedla2004 덕분에 루프를 한 줄에 배치하여 -2 바이트}

_{Xcoder 씨에게 감사를 표합니다.}

파이썬 2 , 46 바이트

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

온라인으로 사용해보십시오!

범위를 생성하고 [1..n]반복되는 패턴으로 앞뒤로 팝back, front, front, back, ...

파이썬 2 , 49 바이트

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

온라인으로 사용해보십시오!

처음 4 개의 요소를 생성 한 다음 상위 값 n이 2 씩 감소하고 하위 값 k이 2 씩 증가 하면서 재귀 적으로 계속됩니다 .

파이썬 2 , 49 바이트

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

온라인으로 사용해보십시오!

더 낮거나 더 높은 값을 취할지 여부를 부울로 i사용하여 목록 의 '번째 값을 직접 생성합니다 -i%4/2.

파이썬 3 , 68 63 62 바이트

@notjagan 덕분에 −5 바이트 (공백을 제거하고 [*...]대신 사용 list())

-1 바이트 덕분 @ovs ( *1대신 [:]) .

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

온라인으로 사용해보십시오!

MATL , 19 17 10 바이트

:t"0&)@o?P

온라인으로 사용해보십시오!

설명

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

젤리 ,  12  11 바이트

"Combinatorial Methods"11 바이트로 개선 :

9Bṁ×ḶṚÆ¡‘Œ?

온라인으로 사용해보십시오!

어떻게?

순열 계산과 계승 시스템을 사용합니다.

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 인치 "편직 패턴"개선 :

RṚ‘żRs2Z€FḊṁ

온라인으로 사용해보십시오!

어떻게?

이것은 간단한 접근 방식으로 두 가닥을 만들어 인터리브 한 다음 느슨한 끝을 자릅니다.

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]

옥타브 , 43 36 바이트

C (gcc) 에서이 답변의 포트는 여기에서 찾을 수 있습니다 .

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

설명

1. k=1:2:n/2: 1에서 2까지의 선형 시퀀스를 생성합니다 n/2. 다음 단계에서 즉시 사용됩니다.
2. [n-k+1;k;k+1;n-k]: 첫 번째 행이 n, n-2, n-4...아래로 시퀀스를 만들고, n-(n/2)+2두 번째 행이 1, 3, 5...최대 n/2 - 1, 세 번째 행이 1이 추가 된 두 번째 행이고, 네 번째 행이 1이 추가 된 첫 번째 행이되도록 4 행 행렬을 만듭니다.
3. [n-k+1;k;k+1;n-k](:)':이 행렬의 모든 열을 왼쪽에서 오른쪽으로 쌓아 단일 열 벡터를 만들고 행 벡터로 바꾸어 쉽게 표시 할 수 있습니다. 이러한 방식으로 열을 쌓아 올리면 원하는 순서가 정확하게 만들어집니다.

이 함수는 익명 함수이므로 함수를 사용하기 전에 변수에 할당하거나 ans함수를 만든 후 만들어진 내장 변수를 사용할 수 있습니다 .

온라인으로 사용해보십시오!

R , 48 바이트 (개선)

-7 바이트의 @Giuseppe에게 감사드립니다!

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

트릭은와 x=1:n;x[order(x%%2)]같습니다 order(1:n%%2).

온라인으로 사용해보십시오!

R , 55 바이트 (원본)

골프

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

댓글이없는 언 골프

nstdin에서 읽습니다 .

n=scan()

x1에서 페이지 순서로 정의하십시오 n.

x=1:n

페이지가 짝수 페이지 이전에 오도록 페이지를 주문하십시오.

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

에서 계산 한 책의 중심을 기준으로 내림차순으로 페이지를 정렬하십시오 n/2+.5.

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

8 페이지의 예 :

• 중심은 4.5입니다.
• 1 페이지와 8 페이지는 중앙에서 가장 먼 곳이지만 8은 짝수이므로 8이 먼저 나옵니다.
• 2 페이지와 7 페이지는 중앙에서 가장 먼 곳이지만 2는 짝수이므로 2가 먼저옵니다.
• 등등.

온라인으로 사용해보십시오!

Mathematica, 54 53 45 바이트

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

설명

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

파이썬 2 , 64 63 바이트

^{ovs 덕분에 -1 바이트 !}

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

온라인으로 사용해보십시오!

하스켈, 42 바이트

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

온라인으로 사용해보십시오!

1 바이트 이상 :

하스켈, 43 바이트

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

자바 8, 84 72 바이트

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

또는

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

C # 답변에 대한 @TheLethalCoder 의 의견 덕분에 -12 바이트 .

이전 답변 (84 바이트) :

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

설명:

여기에서 시도하십시오.

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

펄 5 , 47 + 1 (-n) = 48 바이트

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

온라인으로 사용해보십시오!

스위프트 3 , 74 바이트

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

온라인으로 사용해보십시오!

스위프트 3 , 60 바이트

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

어떤 이유로 든, 이것은 지금까지 시도한 온라인 환경에서 작동하지 않습니다. 테스트하고 싶다면 var g=앞에 놓고 Xcode (Playgrounds)print(g(12)) 에서 호출하십시오 .

다음은 Xcode 놀이터 버전 8.3.1 (Swift 3.1 실행)에서 실행 한 그림입니다.

QBIC , 25 바이트

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

입력은 % 4이지만 실제 리듬은 2를 기준으로합니다.

설명

[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 바이트

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

온라인으로 사용해보십시오!

cQuents , 21 바이트

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

온라인으로 사용해보십시오!

설명

                            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 바이트

djhurio에 의해 엄청나게 outgolfed ! 그의 대답은 매우 우아합니다.

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

rayryeng의 Octave answer 포트 .

온라인으로 사용해보십시오!

원래 솔루션 (64 바이트) :

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

재귀 기능.

온라인으로 사용해보십시오!

Bash + Perl + Groff + Psutils, 48 ​​바이트

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

에 출력을 표시 stderr합니다. 출력에 일부 가비지가 포함되어 있습니다.

사용 예 :

$ 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 바이트

sm[hK-QddhdK):1/Q2 2

테스트 스위트.

중첩 목록으로 출력이 허용되는 경우 :

Pyth , 20 19 바이트

m[hK-QddhdK):1/Q2 2

테스트 스위트.

설명

sm [hK-QddhdK) : 1 / Q2 2-전체 프로그램.

 m : 1 / Q2 2-변수 d를 사용하여 범위 (1, 입력 () / 2,2)에 대한 맵.
  [)-다음을 사용하여 목록을 구성하십시오.
   hK-Qd-입력-d + 1,
        d-d,
         hd-d + 1 및
           K-입력-d.
s-목록을 평평하게하고 암시 적으로 인쇄합니다.

루비 , 40 바이트

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

온라인으로 사용해보십시오!

C #, 107 바이트

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

하나는 1에서 시작하고 하나는 p에서 2 개의 카운터를 유지하십시오. 각 루프 반복에서 4 개의 요소를 작성하고 각 항목 후에 카운터를 늘리거나 줄입니다. 카운터가 가운데에서 만나면 중지하십시오.

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

하스켈 , 58 바이트

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

온라인으로 사용해보십시오!

Pyth , 27 24 23 바이트

끝이 아닌 전체에 인쇄하여 -3 바이트.

Xcoder 씨에게 -1 감사합니다

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

온라인으로 사용해보십시오!

또는 온라인 컴파일러 / 실행기에서

이것은 Pyth의 첫 번째 실제 프로그램이므로 알지 못하는 더 좋은 방법이있을 것입니다.

설명

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 바이트

명명되지 않은 일반 람다. n#pages (% 4 == 0)이며 C결과에 대한 참조 매개 변수입니다 vector<int>( 빈 컨테이너 만 push_back필요합니다).

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

이전 솔루션 :

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

온라인으로 사용해보십시오!

약간 골퍼되지 않음 :

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

이전 솔루션이 _{약간 ungolfed} :

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

그것은 매우 간단하게 개발되었으며 산술에 약간의 최적화가 있습니다.

• Edit1 : 산술 통일 5 바이트 저장
• 편집 2 : 통일 후 4 단계가 결합되었습니다.

용법:

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

인쇄-변형은 77 바이트 ^{-일자 아웃}

값을 인쇄해야한다면 다음과 같은 해결책이 있습니다.

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

어디 o원하는되는 std::ostream것처럼,std::cout

사용법 (2 번째 람다가에 할당 된 경우 g) :

g(n, std::cout);

공통 리스프, 79 바이트

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

온라인으로 사용해보십시오!

루아, 94 바이트

이 도전을 위해 나는 실제로 94 바이트 인 두 가지 다른 방법을 생각해 냈습니다.

방법 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

주석 처리 된 코드 :

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

방법 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

이 방법은 첫 번째 방법과 비슷하지만 대신 string.format () 대신 연결된 문자열을 반환합니다.

두 방법 모두 n의 개념을 사용했으며 서로 더 가까워지고 있습니다.

PHP, 51 + 1 바이트

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

밑줄로 구분 된 페이지 번호를 후미 구분자로 인쇄합니다.
파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

J , 22 바이트

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

온라인으로 사용해보십시오!

설명

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