Lire un livre est facile, mais l’impression peut être un peu délicate. Lors de l'impression d'un livret, l'imprimante doit disposer les pages d'une certaine manière pour pouvoir être lues de gauche à droite. La façon dont cela est fait utilise un motif comme ci-dessous

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…

Cas de test

Livret de 4 pages: 4, 1, 2, 3

Livret de 8 pages: 8,1,2,7,6,3,4,5

Livret de 12 pages: 12,1,2,11,10,3,4,9,8,5,6,7

Livret de 16 pages: 16,1,2,15,14,3,4,13,12,5,6,11,10,7,8,9

Livret de 20 pages: 20,1,2,19,18,3,4,17,16,5,6,15,14,7,8,13,12,9,10,11

Tâche

Votre tâche consiste à, pour un nombre entier nmultiple de 4, afficher un tableau de nombres pouvant être utilisés pour imprimer un livre de npages.

Remarque: tant que la sortie génère les nombres corrects, délimités par des espaces, des virgules, des traits d'union ou des parenthèses, vous pouvez utiliser n'importe quelle méthode pour obtenir une solution.

Ceci est une question code-golf , les réponses seront donc notées en octets, avec le moins d'octets gagnants.

05AB1E , 9 8 7 octets

L`[Žˆrˆ

Essayez-le en ligne!

Explication

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 octets

Sauvegardé 4 octets avec l'aide de @RickHitchcock

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

Démo

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

Non récursif, 51 octets

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

Démo

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 octets

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

Essayez-le en ligne!

_{-6 octets en supprimant les indentations inutiles, merci Oliver Ni}

_{-5 octets en changeant le conditionnel, merci Luis Mendo}

_{-30 octets en optimisant les instructions d'impression, merci Arnold Palmer}

_{-2 octets en mettant la boucle sur une ligne, merci nedla2004}

_{-1 octet en faisant un peu de magie, merci M. Xcoder}

Python 2 , 46 octets

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

Essayez-le en ligne!

Génère la plage [1..n]et apparaît de l'avant et de l'arrière dans le motif répétéback, front, front, back, ...

Python 2 , 49 octets

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

Essayez-le en ligne!

Génère les 4 premiers éléments, puis continue récursivement avec la valeur supérieure ndiminuée de 2 et la valeur inférieure kaugmentée de 2.

Python 2 , 49 octets

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

Essayez-le en ligne!

Génère directement la iième valeur de la liste, en utilisant -i%4/2comme booléen la valeur inférieure ou supérieure.

Python 3 , 68 63 62 octets

−5 octets grâce à @notjagan (supprimer des espaces et utiliser à la [*...]place de list()).

−1 octet grâce à @ovs ( *1au lieu de [:]) .

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

Essayez-le en ligne!

MATL , 19 17 10 octets

:t"0&)@o?P

Essayez-le en ligne!

Explication

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

Gelée ,  12  11 octets

Amélioré à 11 octets, "Méthodes combinatoires":

9Bṁ×ḶṚÆ¡‘Œ?

Essayez-le en ligne!

Comment?

Ceci utilise des calculs de permutation et le système de nombres factoriels:

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 Améliorés, "Modèles de tricot":

RṚ‘żRs2Z€FḊṁ

Essayez-le en ligne!

Comment?

C'est l'approche simple, cela crée deux brins, les entrelace et coupe ensuite les extrémités:

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 octets

Un port de cette réponse en C (gcc) peut être trouvé ici .

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

Explication

1. k=1:2:n/2: Génère une séquence linéaire de 1 à n/2 par étapes de 2. Notez qu'elle est immédiatement utilisée à l'étape suivante.
2. [n-k+1;k;k+1;n-k]: Crée une matrice de 4 lignes telle que la première ligne crée la séquence n, n-2, n-4...jusqu'à n-(n/2)+2, la deuxième ligne 1, 3, 5...jusqu’à n/2 - 1, la troisième ligne est la deuxième ligne ajoutée par 1 et la quatrième ligne est la première ligne ajoutée par 1.
3. [n-k+1;k;k+1;n-k](:)': Ceci empile toutes les colonnes de cette matrice de gauche à droite pour créer un seul vecteur de colonne, et nous le transposons en un vecteur de ligne pour un affichage facile. L'empilement des colonnes de cette manière crée avec précision la séquence souhaitée.

Notez qu'il s'agit d'une fonction anonyme. Vous pouvez donc l'affecter à une variable avant de l'utiliser ou utiliser la ansvariable intégrée créée après la création de la fonction.

Essayez-le en ligne!

R , 48 octets (amélioré)

Merci à @ Giuseppe pour -7 octets!

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

Le truc est que cela x=1:n;x[order(x%%2)]équivaut à order(1:n%%2).

Essayez-le en ligne!

R , 55 octets (original)

Golfé

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

Ungolfed avec des commentaires

Lire nde stdin.

n=scan()

Définir xcomme séquence de pages de 1 à n.

x=1:n

Ordre des pages afin que même les pages soient avant les pages inégales.

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

Ordre des pages dans l'ordre décroissant par rapport au centre du livre calculé par n/2+.5.

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

Exemple avec 8 pages:

• le centre est 4,5;
• les pages 1 et 8 sont les plus éloignées du centre, mais 8 vient en premier parce que 8 est pair;
• les pages 2 et 7 sont les suivantes les plus éloignées du centre, mais 2 vient en premier, car 2 est pair;
• etc.

Essayez-le en ligne!

Mathematica, 54 53 45 octets

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

Explication

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 octets

^{-1 octet grâce aux ovs!}

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

Essayez-le en ligne!

Haskell, 42 octets

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

Essayez-le en ligne!

Un octet plus long:

Haskell, 43 octets

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

Java 8, 84 72 octets

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

ou

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

-12 octets grâce au commentaire de @TheLethalCoder sur la réponse C #.

Ancienne réponse (84 octets):

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

Explication:

Essayez ici.

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 octets

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

Essayez-le en ligne!

Swift 3 , 74 octets

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

Essayez-le en ligne!

Rapide 3 , 60 octets

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

Pour une raison quelconque, cela ne fonctionne dans aucun environnement en ligne que j'ai essayé jusqu'à présent. Si vous voulez tester, mettre var g=en face de lui, et l' appeler avec print(g(12))dans Xcode (Playgrounds) .

Voici une image après l'avoir vue dans une aire de jeu Xcode, version 8.3.1 (Running Swift 3.1):

QBIC , 25 octets

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

Bien que l'entrée soit% 4, le rythme réel est basé sur 2.

Explication

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

Un portage de mon octave répond au 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);}

Essayez-le en ligne!

cQuents , 21 octets

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

Essayez-le en ligne!

Explication

                            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 octets

Dégradé de manière dévastatrice par Djhurio ! Sa réponse est assez élégante, allez-y.

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

Une réponse octave de Rayryeng .

Essayez-le en ligne!

solution originale (64 octets):

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

Fonction récursive.

Essayez-le en ligne!

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

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

Affiche la sortie sur stderr . La sortie contient des déchets de fin.

Exemple d'utilisation:

$ 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 octets

sm[hK-QddhdK):1/Q2 2

Suite de tests.

Si la sortie sous forme de liste imbriquée est autorisée:

Pyth , 20 19 octets

m[hK-QddhdK):1/Q2 2

Suite de tests.

Explication

sm [hK-QddhdK): 1 / Q2 2 - Programme complet.

 m: 1 / Q2 2 - Carte sur la plage (1, entrée () / 2,2) avec une variable d.
  [) - Construisez une liste avec:
   hK-Qd - Entrée - d + 1,
        d - d,
         hd - d + 1 et
           K - Entrée - d.
s - Aplatit la liste et imprime implicitement.

Ruby , 40 octets

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

Essayez-le en ligne!

C #, 107 octets

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

Gardez deux jetons, l’un commençant à 1, l’autre à la p. Dans chaque itération de boucle, écrivez quatre éléments et incrémentez ou décrémentez simplement les compteurs après chaque entrée. Lorsque les pions se rencontrent au milieu, arrêtez-vous.

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 octets

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

Essayez-le en ligne!

Pyth , 27 24 23 octets

-3 octets en imprimant partout au lieu de à la fin.

-1 Merci à M. Xcoder

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

Essayez-le en ligne!

Ou sur le compilateur / exécuteur en ligne

Ceci est mon premier vrai programme en Pyth, donc il y a probablement de meilleures méthodes que je ne connais pas.

Explication

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 octets

En tant que lambda générique non nommé. nest #pages (% 4 == 0) et Cest un paramètre de référence pour le résultat, un conteneur vide du type vector<int>(uniquement push_backnécessaire).

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

solution précédente:

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

Essayez-le en ligne!

Légèrement non-golfé:

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

solution précédente _{légèrement non golfée} :

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

C'était assez simple à développer et il y a sûrement quelques optimisations mineures dans l'arithmétique.

• Edit1: unification de l'arithmétique sauvegardée 5 octets
• Edit2: après l'unification les 4 étapes ont été combinées

Usage:

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

Version imprimable, 77 octets ^obsolètes

Si vous insistez pour imprimer les valeurs, voici la solution:

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

Où oest votre désiré std::ostream, commestd::cout

Utilisation (si 2ème lambda a été assigné à g):

g(n, std::cout);

Common Lisp, 79 octets

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

Essayez-le en ligne!

Lua, 94 octets

Pour relever ce défi, j’ai en fait proposé deux méthodes différentes, soit 94 octets.

Méthode 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

Code commenté:

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éthode 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

Cette méthode est similaire à la première méthode, mais je retourne plutôt une chaîne concaténée au lieu de string.format ()

Dans les deux méthodes, j'ai utilisé le concept de n et i se rapprochant

PHP, 51 + 1 octets

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

imprime les numéros de page séparés par un trait de soulignement avec un délimiteur de fin.
Exécuter en pipe -nRou essayer en ligne .

J , 22 octets

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

Essayez-le en ligne!

Explication

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