Читать книгу легко, но печатать книгу может быть немного сложно. При печати буклета принтер должен располагать страницы определенным образом, чтобы их можно было читать слева направо. Способ, которым это сделано, использует образец как ниже

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

задача

Ваша задача состоит в том, чтобы, учитывая целое число n, кратное 4, отобразить массив чисел, который можно использовать для печати книги 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

JavaScript (ES6), 49 45 байт

Сохранено 4 байта с помощью @RickHitchcock

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

Python 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,

Попробуйте онлайн!

_{-6 байт, удалив ненужные отступы, спасибо Оливер Ни}

_{-5 байт при изменении условного, спасибо Луису Мендо}

_{-30 байтов за счет оптимизации операторов печати, спасибо Арнольду Палмеру}

_{-2 байта, поместив цикл в одну строку, спасибо nedla2004}

_{-1 байт, делая немного волшебства, спасибо мистер Xcoder}

Python 2 , 46 байт

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

Попробуйте онлайн!

Создает диапазон [1..n]и выскакивает спереди и сзади в повторяющейся схемеback, front, front, back, ...

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

Python 2 , 49 байт

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

Попробуйте онлайн!

Непосредственно генерирует iзначение в списке, используя -i%4/2в качестве логического значения, принимать ли меньшее или большее значение.

Python 3 , 68 63 62 байта

−5 байт благодаря @notjagan (удаление пробелов и использование [*...]вместо 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 байт

Улучшены до 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. Обратите внимание, что она сразу используется на следующем шаге.
2. [n-k+1;k;k+1;n-k]: Создает матрицу из 4 строк, так что первая строка создает последовательность n, n-2, n-4...до n-(n/2)+2, вторая строка - 1, 3, 5...до n/2 - 1, третья строка - вторая строка, добавленная на 1, и четвертая строка - первая строка, добавленная на 1.
3. [n-k+1;k;k+1;n-k](:)': Это объединяет все столбцы этой матрицы слева направо, чтобы сделать один столбец-вектор, и мы переносим его в вектор-строку для удобства отображения. Объединение столбцов таким образом точно создает желаемую последовательность.

Обратите внимание, что это анонимная функция, поэтому вы можете назначить ее переменной до ее использования или использовать встроенную ansпеременную, которая создается после создания функции.

Попробуйте онлайн!

R , 48 байт (улучшено)

Спасибо @Giuseppe за -7 байт!

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 байт (оригинал)

Golfed

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

Разгромленный с комментариями

Читайте nиз стандартного ввода.

n=scan()

Определить xкак последовательность страниц от 1 до 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 *)

Python 2 , 64 63 байта

^{-1 байт благодаря овсам!}

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

Попробуйте онлайн!

Haskell, 42 байта

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

Попробуйте онлайн!

Один байт длиннее:

Haskell, 43 байта

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

Java 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--+","));}

-12 байт благодаря @TheLethalCoder комментарию на C #.

Старый ответ (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

Perl 5 , 47 + 1 (-n) = 48 байт

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

Попробуйте онлайн!

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

Попробуйте онлайн!

Swift 3 , 60 байт

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

По какой-то причине это не работает ни в одной онлайн-среде, которую я пробовал до сих пор. Если вы хотите , чтобы проверить его, поставить var g=перед ним, и назвать его print(g(12))в Xcode (игровые площадки) .

Вот изображение после того, как я запустил его на игровой площадке Xcode, версия 8.3.1 (Running 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 байт

Ужасно отстает от Джурио ! Его ответ довольно элегантный, иди, проголосуй за него.

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

Порт Райриенга, октавский ответ .

Попробуйте онлайн!

оригинальное решение (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 - Карта в диапазоне (1, input () / 2,2) с переменной d.
  [) - Построить список с:
   hK-Qd - ввод - d + 1,
        д - д,
         HD - D + 1 и
           K - вход - д.
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. В каждой итерации цикла запишите четыре элемента и просто увеличивайте или уменьшайте счетчики после каждой записи. Когда счетчики встретятся посередине, остановитесь.

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 байт

(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 байта, печатая всюду, а не в конце.

-1 Спасибо мистеру Xcoder

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 байт

Как неназванная родовая лямбда. nis #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));
}

предыдущее решение _{слегка расклеилось} :

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

Это было довольно просто разработано, и в арифметике есть некоторые незначительные оптимизации.

• Edit1: объединение арифметики сохранено 5 байт
• Edit2: после объединения 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);

Common Lisp, 79 байт

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

Попробуйте онлайн!

Луа, 94 байта

Для этой задачи я на самом деле предложил 2 разных метода, каждый из которых по 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