Il est courant de devoir créer une interface de sélection de page. Cela ressemble typiquement à ceci:

prev 1 ... 3 4 [5] 6 7 ... 173 next

Ce qui signifie qu'il y a au total 173 pages et que vous êtes actuellement à la 5ème page.

Ce défi nécessite que vous preniez le nombre total de pages et le numéro de la page actuelle en entrée, puis que vous produisiez une chaîne (ou un tableau) pour "afficher" le sélecteur de page.

Contribution

2 entiers positifs

• numéro de page actuel
• nombre de pages

Il est garanti que 1 <= actuel <= total.

Sortie

Affiche une chaîne ou un tableau représentant l'interface utilisateur pour les sélecteurs de page.

• Si la sortie est sous forme de chaîne, un seul espace (U + 0020) doit être utilisé entre chaque page.
• En cas de sortie sous forme de tableau, le tableau doit produire le même résultat que la chaîne après avoir converti chaque élément en chaîne et les joindre avec un seul espace.
  • Les trois points ( ...) ne sont pas facultatifs pour la sortie de tableau.

Détails

• Si current == 1, aucun "prev" ne sera émis, sinon, "prev" vient en premier.
• Si courant == total, aucun "suivant" ne sera émis, sinon, "suivant" sera le dernier.
• La première page (1) et la dernière page (total) doivent toujours être imprimées.
• La page en cours, page (actuelle - 1), page (en cours - 2), page (en cours + 1), (page en cours + 2) doit être sortie tant qu'ils sont dans la plage de [1..total].
• Aucun autre numéro de page ne doit être sorti.
• Les pages imprimées doivent être triées par ordre croissant.
• La sortie ne doit pas contenir de numéros de page en double.
• La page en cours doit être mise en évidence en l’enveloppant dans une paire de [].
• S'il y a un espace entre les voisins, trois points ( ...) doivent être insérés.

Cas de test

Current Total    Output
1       1        [1]
1       2        [1] 2 next
1       10       [1] 2 3 ... 10 next
3       3        prev 1 2 [3]
3       6        prev 1 2 [3] 4 5 6 next
4       6        prev 1 2 3 [4] 5 6 next
4       7        prev 1 2 3 [4] 5 6 7 next
3       10       prev 1 2 [3] 4 5 ... 10 next
5       10       prev 1 ... 3 4 [5] 6 7 ... 10 next
10      10       prev 1 ... 8 9 [10]
52      173      prev 1 ... 50 51 [52] 53 54 ... 173 next

Règles

• C'est du code-golf, le code le plus court gagne!

Retina , 125 113 109 107 octets

.+
$*
r`1\G
 1$'
¶

O`1+
\b(1+) \1\b
[$1]
 .* (1+ 1+ \[)|(] 1+ 1+) .* 
$2 ... $1
^1
prev 1
1$
1 next
1+
$.&

Essayez-le en ligne! Le lien inclut des cas de test. Sauvegardé 12 octets grâce à @MartinEnder. Explication:

.+
$*

Convertir en unaire.

r`1\G
 1$'

Générez tous les numéros de page dans l'ordre inverse.

¶

Supprimer la nouvelle ligne séparant l'entrée. (De toute façon, il y a aussi un espace dans la génération du numéro de page.)

O`1+

Triez les pages par ordre croissant. Cela trie également la page actuelle, qui est maintenant dupliquée.

\b(1+) \1\b
[$1]

Sous-dupliquez et entourez []la page actuelle.

 .* (1+ 1+ \[)|(] 1+ 1+) .* 
$2 ... $1

Ajoutez des points de suspension si la page en cours est au moins 5 ou s'il y a au moins 4 pages après la page en cours. (Remarquez l'espace de fin, pour éviter d'inclure la dernière page dans les points de suspension.)

^1
prev 1

Ajoutez le prev si la page en cours n'est pas 1.

1$
1 next

Ajoutez le suivant si la page en cours n'est pas la dernière page.

1+
$.&

Reconvertir en décimal.

JavaScript (ES6), 130 122 121 octets

Invoquer avec la syntaxe de currying, par exemple f(3)(10).

x=>X=>[x>1&&'prev 1',x>4&&'...',x>3&&x-2,x>2&&x-1,`[${x}]`,(X-=x)>1&&x+1,X>2&&x+2,X>3&&'...',X&&X+x+' next'].filter(_=>_)

f=

x=>X=>[x>1&&'prev 1',x>4&&'...',x>3&&x-2,x>2&&x-1,`[${x}]`,(X-=x)>1&&x+1,X>2&&x+2,X>3&&'...',X&&X+x+' next'].filter(_=>_)

console.log(f(1)(1))
console.log(f(1)(2))
console.log(f(1)(10))
console.log(f(3)(3))
console.log(f(3)(6))
console.log(f(4)(6))
console.log(f(4)(7))
console.log(f(3)(10))
console.log(f(5)(10))
console.log(f(10)(10))
console.log(f(52)(173))

Essayez-le en ligne!

-1 octet (Arnauld): réglé Xsur X-x.

6502 code machine (C64), 160 octets

00 C0 20 9B B7 86 FB CA F0 01 CA 86 FD 20 9B B7 86 FC A6 FB E8 E4 FC B0 01 E8
86 FE A2 01 E4 FB F0 1A A9 91 A0 C0 20 1E AB A2 02 E4 FD B0 0D A9 2E 20 D2 FF
CA 10 FA 20 3F AB A6 FD 86 9E E4 FB D0 05 A9 5B 20 D2 FF A9 00 20 CD BD A6 9E
E4 FB D0 05 A9 5D 20 D2 FF 20 3F AB A6 9E E4 FC F0 25 E4 FE F0 05 E8 86 9E D0
D5 E8 E4 FC F0 0D A2 02 A9 2E 20 D2 FF CA 10 FA 20 3F AB A6 FC A9 00 20 CD BD
20 3F AB A6 FC E4 FB F0 07 A9 99 A0 C0 20 1E AB 60 50 52 45 56 20 31 20 00 4E
45 58 54 00

Démo en ligne - Utilisation:, sys49152,[current],[total] par exemplesys49152,5,173.

Les nombres doivent être compris dans la plage [1..255] avec le courant <= total. Comme cela n'a pas été spécifié autrement, il s'agit de la plage entière «naturelle» non signée sur un processeur 8 bits.

Explication sous forme de liste de désassemblage commentée:

         00 C0       .WORD $C000        ; load address
.C:c000  20 9B B7    JSR $B79B          ; read 8bit integer
.C:c003  86 FB       STX $FB            ; store current page
.C:c005  CA          DEX                ; calculate lower start for ...
.C:c006  F0 01       BEQ .stl
.C:c008  CA          DEX
.C:c009   .stl:
.C:c009  86 FD       STX $FD            ; ... range and store
.C:c00b  20 9B B7    JSR $B79B          ; read 8bit integer
.C:c00e  86 FC       STX $FC            ; store total pages
.C:c010  A6 FB       LDX $FB            ; load current page
.C:c012  E8          INX                ; calculate upper end for ...
.C:c013  E4 FC       CPX $FC
.C:c015  B0 01       BCS .stu
.C:c017  E8          INX
.C:c018   .stu:
.C:c018  86 FE       STX $FE            ; ... range and store
.C:c01a  A2 01       LDX #$01           ; check whether first page is current
.C:c01c  E4 FB       CPX $FB
.C:c01e  F0 1A       BEQ .sequence      ; then directly to sequence
.C:c020  A9 91       LDA #<.prev        ; output string for ...
.C:c022  A0 C0       LDY #>.prev
.C:c024  20 1E AB    JSR $AB1E          ; ... "prev 1 "
.C:c027  A2 02       LDX #$02           ; check whether page 2 is in range ...
.C:c029  E4 FD       CPX $FD
.C:c02b  B0 0D       BCS .sequence      ; ... then directly to sequence
.C:c02d  A9 2E       LDA #$2E           ; load character '.'
.C:c02f   .ellip1:
.C:c02f  20 D2 FF    JSR $FFD2          ; output ...
.C:c032  CA          DEX
.C:c033  10 FA       BPL .ellip1        ; ... 3 times
.C:c035  20 3F AB    JSR $AB3F          ; output space
.C:c038  A6 FD       LDX $FD            ; load lower start for range
.C:c03a   .sequence:
.C:c03a  86 9E       STX $9E            ; store to temporary
.C:c03c   .seqloop:
.C:c03c  E4 FB       CPX $FB            ; compare with current
.C:c03e  D0 05       BNE .notcurrent1   ; yes -> output '['
.C:c040  A9 5B       LDA #$5B
.C:c042  20 D2 FF    JSR $FFD2
.C:c045   .notcurrent1:
.C:c045  A9 00       LDA #$00
.C:c047  20 CD BD    JSR $BDCD          ; output number
.C:c04a  A6 9E       LDX $9E            ; compare with current
.C:c04c  E4 FB       CPX $FB
.C:c04e  D0 05       BNE .notcurrent2   ; yes -> output ']'
.C:c050  A9 5D       LDA #$5D
.C:c052  20 D2 FF    JSR $FFD2
.C:c055   .notcurrent2:
.C:c055  20 3F AB    JSR $AB3F          ; output space
.C:c058  A6 9E       LDX $9E
.C:c05a  E4 FC       CPX $FC            ; compare position with last page
.C:c05c  F0 25       BEQ .printnext     ; if eq jump to part printing "next"
.C:c05e  E4 FE       CPX $FE            ; compare position to upper end of range
.C:c060  F0 05       BEQ .printellip2   ; if eq jump to part printing "..."
.C:c062  E8          INX
.C:c063  86 9E       STX $9E            ; next number
.C:c065  D0 D5       BNE .seqloop       ; and repeat loop for sequence
.C:c067   .printellip2:
.C:c067  E8          INX
.C:c068  E4 FC       CPX $FC            ; compare next number with last page
.C:c06a  F0 0D       BEQ .printlast     ; if eq jump to part printing page num
.C:c06c  A2 02       LDX #$02
.C:c06e  A9 2E       LDA #$2E           ; load character '.'
.C:c070   .ellip2:
.C:c070  20 D2 FF    JSR $FFD2          ; output ...
.C:c073  CA          DEX
.C:c074  10 FA       BPL .ellip2        ; ... 3 times
.C:c076  20 3F AB    JSR $AB3F          ; output space
.C:c079   .printlast:
.C:c079  A6 FC       LDX $FC            ; output last page number
.C:c07b  A9 00       LDA #$00
.C:c07d  20 CD BD    JSR $BDCD
.C:c080  20 3F AB    JSR $AB3F          ; output space
.C:c083   .printnext:
.C:c083  A6 FC       LDX $FC            ; compare current page with last page
.C:c085  E4 FB       CPX $FB
.C:c087  F0 07       BEQ .done          ; if eq nothing else to do
.C:c089  A9 99       LDA #<.next        ; output string for ...
.C:c08b  A0 C0       LDY #>.next
.C:c08d  20 1E AB    JSR $AB1E          ; "next"
.C:c090   .done:
.C:c090  60          RTS
.C:c091   .prev:
.C:c091  50 52 45 56 .BYTE "prev"
.C:c095  20 31 20 00 .BYTE " 1 ", $00
.C:c099   .next:
.C:c099  4E 45 58 54 .BYTE "next"
.C:c09d  00          .BYTE $00

R , 214 octets, 168 octets

function(c,m,`~`=function(x,y)if(x)cat(y)){o=-2:2+c
o=o[o>0&o<=m]
o[o==c]=paste0('[',c,']')
c>1~'prev '
c>3~'1 '
c>4~' ... '
T~o
c+3<m~' ...'
c+2<m~c('',m)
c<m~' next'}

Essayez-le en ligne!

Merci à @ user2390246 pour ses bons conseils de golf

APL (Dyalog) , 83 82 octets

Fonction infixe anonyme prenant le courant comme argument de gauche et le total comme argument de droite.

{('prev '/⍨⍺>1),('x+'⎕R'...'⍕∊(⊂1⌽'][',⍕)@⍺⊢'x'@(~∊∘(1,⍵,⍺+3-⍳5))⍳⍵),' next'/⍨⍺<⍵}

Essayez-le en ligne!

{… } Lambda explicite où ⍺et ⍵représente les arguments gauche et droit:

 ⍺<⍵ le courant est-il inférieur au total?

 ' next'/⍨ si c'est le cas (lit. utilisez-le pour répliquer) le texte

 (… ), Préfixe ce qui suit:

  ⍳⍵ ɩ ntegers totale de 1 à

  'x'@(… ) Remplacer par un x aux positions où se trouvent les objets…

   ~ ne pas

   ∊ membres de

   1 un

   , suivi par

   ⍵ le total

   , suivi par

    ⍳5 les cinq premières ɩ ntegers ( [1,2,3,4,5])

    3- soustrait de trois ( [2,1,0,-1,-2])

    ⍺+ ajouté au courant ( [⍺+2,⍺+1,⍺,⍺-1,⍺-2])

   ⊢ céder que (sert à séparer ⍺de 'x')

   (… ) Applique la fonction tacite suivante à la position actuelle:

    ⍕ format (stringify)

    '][', ajouter le texte 

    1⌽ faire un tour vers la gauche (déplace le ]à la fin)

    ⊂ enfermer (de sorte que ce soit un scalaire qui tiendra dans la seule position indiquée)

   ∊ ε nlist (aplatissent - parce que nous l' avons fait lorsque nous avons inséré niché entre parenthèses)

   ⍕ format (stringify - 1 espace séparant les nombres les uns des autres et des passages x)

  'x+'⎕R'...' PCRE R eplace xfonctionne avec trois périodes

 (… ), Préfixe ce qui suit:

  ⍺>1 le courant est-il supérieur à 1?

  'prev '/⍨ si c'est le cas (lit. utilisez-le pour répliquer) le texte

Wolfram Language (Mathematica) , 131 114 109 octets

Range@#2/.{#->"["<>(t=ToString)@#<>"]",1->"prev 1",#2->t@#2<>" next",#-3|#+3:>"...",x_/;Abs[x-#]>2:>Nothing}&

Essayez-le en ligne!

Comment ça fonctionne

Beaucoup de remplacement. En commençant par une liste de toutes les pages, remplacez, dans l'ordre:

1. #->"["<>(t=ToString)@#<>"]": la page en cours avec une chaîne entre crochets,
2. 1->"prev 1": page 1 avec la ficelle prev 1,
3. #2->t@#2<>" next": la dernière page avec la chaîne (number) next, avec
4. #-3|#+3:>"...": page current-3et page current+3avec la chaîne "...",
5. x_/;Abs[x-#]>2:>Nothing: toutes les autres (entières) pages ci current-2- dessous ou ci -dessus current+2avec rien. (Oui, Nothingest intégré.)

Funky , 218 210 octets

Enregistré quelques octets, dont certains grâce à tsh

p=>m=>{t={}a=t::push b=t::pop fori=p-2i<p+3i++a(i)t[2]="[%i]"%p whilet[0]<1b(0)whilet[n=-1+#t]>m b(n)ifp>4a(0,"...")ifp>3a(0,1)ifp>1a(0,"prev")ifp<m-3a("...")ifp<m-2a(m)ifp<m a("next")t::reduce((a,b)=>a+" "+b)}

Essayez-le en ligne!

Python 2 , 136 130 octets

lambda p,n:[i for i,j in zip(['prev',1,'...',p-2,p-1,[p],p+1,p+2,'...',n,'next'],[1,3,4,2,1,.1,-n,1-n,3-n,2-n,-n])if p*cmp(j,0)>j]

Essayez-le en ligne!

En cas de sortie sous forme de tableau, le tableau doit produire le même résultat que la chaîne après avoir converti chaque élément en chaîne et les joindre avec un seul espace.

Essayez-le en ligne!sous forme prettifiée, où vous pouvez voir que le pied de page se traduit littéralement par "convertir chacun en chaîne, joindre sur des espaces".

C'est une alternative à l'approche de Lynn.

Python 2 , 135 octets

lambda c,t:re.sub('  +',' ... ','prev '*(c>1)+' '.join(`[x,[x]][x==c]`*(x%t<2or-3<x-c<3)for x in range(1,t+1))+' next'*(c<t))
import re

Essayez-le en ligne!

Tout d’abord, nous créons une chaîne semblable à une prev 1 3 4 [5] 6 7 10 next«lacune» résultant de l’effacement de certains nombres, mais pas de leurs espaces de délimitation. Ensuite, nous remplaçons toute série de 2 espaces ou plus en ...utilisant une expression régulière.

Java 8, 201 200 197 octets

t->n->(n<2?"[1] ":"prev 1 ")+(n>4?"... "+(n-2)+" "+~-n+" ["+n+"] ":n>3?"2 3 [4] ":n>2?"2 [3] ":n>1?"[2] ":"")+(n<t?(n>t-2?"":n>t-3?t-1+" ":n>t-4?(t-2)+" "+~-t+" ":++n+" "+-~n+" ... ")+t+" next":"")

Explication:

Essayez-le ici.

t->n->             // Method with two integer parameters and String return-type
  (n<2?            //  If the current page is 1:
    "[1] "         //   Start with literal "[1] "
   :               //  Else:
    "prev 1 ")     //   Start with literal "prev 1"
  +(n>4?           //  +If the current page is larger than 4:
     "... "        //    Append literal "... "
     +(n-2)+" "    //    + the current page minus 2, and a space
     ~-n           //    + the current page minus 1, and a space
     +" ["+n+"] "  //    + "[current_page]" and a space
    :n>3?          //   Else-if the current page is 4:
     "2 3 [4] "    //    Append literal "2 3 [4] "
    :n>2?          //   Else-if the current page is 3:
     "2 [3] "      //    Append literal "2 [3] "
    :n>1?          //   Else-if the current page is 2:
     "[2] "        //    Append literal "[2] "
    :              //   Else (the current page is 1):
     "")           //    Append nothing
  +(n<t?           //  +If the current page and total amount of pages are not the same:
     (n>t-2?       //    If the current page is larger than the total minus 2:
       ""          //     Append nothing
      :n>t-3?      //    Else-if the current page is larger than the total minus 3:
       t-1+" "     //     Append the total minus 1, and a space
      :n>t-4?      //    Else-if the current page is larger than the total minus 4:
       (t-2)+" "   //     Append the total minus 2, and a space
       +~-t+" "    //     + the total minus 1, and a space
      :            //    Else:
       ++n+" "     //     Append the current page plus 1, and a space
       +-~n+       //     + the current page plus 2, and a space
       " ... ")    //     + literal "... "
     +t            //    + the total itself
     +" next")     //    + literal " next"
    :              //   Else (current page and total amount of pages are the same):
     "")           //    Append nothing
                   // End of method (implicit / single-line return-statement)

Java (OpenJDK 8) , 218 179 177 167 166 octets

c->t->{String p,e="... ",x="["+c+"] ";int i=c-2;for(p=c>1?"prev 1 "+(c>4?e:""):x;i<c+3;i++)p+=i>1&i<t?i==c?x:i+" ":"";return p+(i<t-1?e:"")+(c<t?t+" next":t>1?x:"");}

Essayez-le en ligne!

Gelée , 59 octets

+2Rṫ-4>Ðḟ⁹1;;QµI’a3R”.ṁ⁸żẎ
Ị¬;n“¢©ỵY“¡&ç»ẋ"W€jçLÐfKṣ⁸j⁸WŒṘ¤

Un programme complet * imprimant le résultat sur STDOUT. Prend les arguments currentet totaldans cet ordre.

Essayez-le en ligne!ou voir la suite de tests .

Comment?

+2Rṫ-4>Ðḟ⁹1;;QµI’a3R”.ṁ⁸żẎ - Link 1, numbers and ellipses: current, total
                           -                                   e.g. 52, 173
 2                         - literal two                            2
+                          - add to current                         54
  R                        - range                                  [1,2,3,...,53,54]
    -4                     - literal minus four                     -4
   ṫ                       - tail from index (i.e. right five)      [50,51,52,53,54]
         ⁹                 - chain's right argument, total          173
       Ðḟ                  - filter discard if:
      >                    -  greater than?                         [50,51,52,53,54]
          1                - literal one                            1
           ;               - concatenate                            [1,50,51,52,53,54]
            ;              - concatenate (implicit right = total)   [1,50,51,52,53,54,173]
             Q             - unique (remove excess 1 and/or total)  [1,50,51,52,53,54,173]
              µ            - new monadic chain, call that X
               I           - incremental differences                [49,1,1,1,1,119]
                ’          - decrement (vectorises)                 [48,0,0,0,0,118]
                  3        - literal three                          3
                 a         - logical and (vectorises)               [3,0,0,0,0,3]
                   R       - range (vectorises)                     [[1,2,3],[],[],[],[],[1,2,3]]
                    ”.     - literal '.' character                  '.'
                      ṁ    - mould like that                        [['.','.','.'],[],[],[],[],['.','.','.']]
                       ⁸   - chain's left argument, X               [1,50,51,52,53,54,173]
                        ż  - zip with that                          [[1,['.', '.', '.']],[50,[]],[51,[]],[52,[]],[53,[]],[54,['.','.','.']],[173]]
                         Ẏ - tighten                                [1,['.', '.', '.'],50,[],51,[],52,[],53,[],54,['.','.','.'],173]

Ị¬;n“¢©ỵY“¡&ç»ẋ"W€jçLÐfKṣ⁸j⁸WŒṘ¤ - Main link: current, total   e.g. 52, 173
Ị                                - insignificant? (abs(current)<=1)  0
 ¬                               - logical not                       1
   n                             - not equal (current != total)      1
  ;                              - concatenate                       [1,1]
    “¢©ỵY“¡&ç»                   - list of compressed strings        [['p','r','e','v'], ['n','e','x','t']]
               "                 - zip with:
              ẋ                  -   repeat (zeros -> empty lists)   [['p','r','e','v'], ['n','e','x','t']]
                W€               - wrap €ach (prep for the join)     [[['p','r','e','v']], [['n','e','x','t']]]
                   ç             - call last link (1) as a dyad      [1,['.', '.', '.'],50,[],51,[],52,[],53,[],54,['.','.','.'],173]
                  j              - join                              [['p','r','e','v'],1,['.','.','.'],50,[],51,[],52,[],53,[],54,['.','.','.'],173,['n','e','x','t']]
                     Ðf          - filter keep if:
                    L            -   length (removes empty lists)    [['p','r','e','v'],1,['.','.','.'],50,51,52,53,54,['.','.','.'],173,['n','e','x','t']]
                       K         - join with spaces                  ['p','r','e','v',' ',1,' ','.','.','.',' ',50,' ',51,' ',52,' ',53,' ',54,' ','.','.','.',' ',173,' ','n','e','x','t']
                         ⁸       - chain's left argument, current    52
                        ṣ        - split at that                     [['p','r','e','v',' ',1,' ','.','.','.',' ',50,' ',51,' ',],[,' ',53,' ',54,' ','.','.','.',' ',173,' ','n','e','x','t']]
                               ¤ - nilad followed by link(s) as a nilad:
                           ⁸     -   chain's left argument, current  52
                            W    -   wrap                            [52]
                             ŒṘ  -   Python string representation    ['[','5','2',']']
                          j      - join                              ['p','r','e','v',' ',1,' ','.','.','.',' ',50,' ',51,' ','[','5','2',']',' ',53,' ',54,' ','.','.','.',' ',173,' ','n','e','x','t']
                                 - implicit print                    prev 1 ... 50 51 [52] 53 54 ... 173 next

* En tant que lien dyadique prenant currentà gauche et totalà droite, une liste contenant un mélange de caractères et d’entiers est renvoyée. cette liste comprend les espaces. L'octet Kne peut pas simplement être supprimé pour adhérer à la spécification cependant, car le résultat aurait alors les currentcaractères séparés entre crochets (comme [...'[','5','2',']'...]), de sorte que "convertir chaque élément en chaîne et les joindre avec un seul espace" ne produirait pas le résultat souhaité. )

Python 2 , 178 170 octets

x,y=input()
e="... ",""
o=("Prev 1 ","[1] ")[y<2]+e[y<5]
for z in range(2,x):o+=("",(`z`,`[z]`)[z==y]+" ")[y-3<z<y+3]
print o+("",e[x-y<4]+(`x`+" Next",`[x]`)[y==x])[x>1]

Essayez-le en ligne!

Deuxième tentative après avoir lu les règles plus attentivement.

-8 en perdant des crochets inutiles.

Octave , 169 196 190 181 175 175 166 166 octets

@(n,m)(r=[(n>1)*'prev ' (g=n>4)*'1 ... ' (s=@sprintf)(f='%d ',max(n-3+g,1):n-1) s('[%d]',n) 32*(q=n<m) s(f,n+1:min(n+3-(l=n<m-3),m)) l*['... ' s(f,m)] q*'next'])(r>0)

Essayez-le en ligne!

Je vais ajouter une explication plus tard.

Hmm, il semble y avoir quelques problèmes avec le format de sortie. Celles-ci sont maintenant résolues - toutes les sorties sont correctes. Mais hélas, ça coûte 27 octets. Parvenu à griffer tous ces dos avec un peu de gros gras.

• Économisez 6 octets en utilisant *au lieu de .*- merci @StewieGriffin
• Enregistrer 9 octets en utilisant sprintfau lieu de num2strcomme j'avais déjà cette poignée danss .
• Économisez 6 octets en participant []à l' sprintappel.
• Économisez 6 octets en trouvant un moyen de réduire le nombre de comparaisons.
• Économisez 3 octets en supprimant le besoin de strtrim()sans créer d'espace.

C # (.NET Core) , 195 192 octets

3 octets sauvés grâce à Kevin Cruijssen.

c=>t=>{var n=c>1?"prev ":"";n+=c>4?"1 ... ":c<2?"[1] ":"1 ";if(t>1){for(int i=c-3;i++<c+2;)if(i>1&i<t)n+=i==c?$"[{i}] ":i+" ";n+=c<t-4?"... "+t:c==t?$"[{t}]":t+"";n+=c<t?" next":"";}return n;}

Essayez-le en ligne!

C ++ - 247 octets

#include <iostream>
#define c std::cout<<
#define N (a-i<3?i-a<2?1:b-i:a-i-2)
void s(int a,int b){if(a>1)c"prev ";for(int i=1;i<=b&&N!=0;i+=N)c(i==1?"":" ")<<(a==i?"[":"")<<i<<(a==i?"]":"")<<(N>1?" ...":"");if(a<b-2)c" "<<b;if(a<b)c" next";c"\n";}

Essayez-le en ligne!

Python 2 ,  128  124 octets

-4 octets merci à Jonathan Allan !

lambda c,l:["prev"]*(c>1)+[range(1,c),[1,"...",c-2,c-1]][c>4]+[[c]]+[range(c+1,l+1),[c+1,c+2,"...",l]][l-c>4]+["next"]*(c<l)

Essayez-le en ligne!

Sortir sous forme de liste, mais ce lien inclut de jolies impressions.

PHP, 157 150 octets

prendre les détails s'est avéré être l'approche la plus courte:

[,$k,$n]=$argv;for($k>1&&print"prev ";$i++<$n;)$g=in_array($i,range($k-2,$k+2)+[5=>1,$n])?!print$i-$k?"$i ":"[$i] ":$g||print"... ";$k<$n&&print next;

Courez avec php -nr '<code>' <curpage> <numpages>ou essayez-le en ligne .

CJam, 74

q~\:A\:B]3e*[1T4A3+1A].>["prev"1'.3*_B"next"]:a.*3/5,A2-f+B,2>&*:+_A#Aa`tp

Les sorties sous forme de tableau. Essayez-le en ligne

Remplacez la finale ppar la S*sortie sous forme de chaîne.

Explication:

q~          read and evaluate the input (pushing 2 numbers on the stack)
\:A\:B      store the numbers in A and B, keeping them in the same order
]3e*        wrap in array, then repeat each number 3 times - [A A A B B B]
[1T4        make an array containing 1, 0 (T=0 by default), 4,
A3+1A]      then A+3, 1, and A
.>          compare the 2 arrays element by element - [A>1 A>0 A>4 B>A+3 B>1 B>A]
             (each result is 1 or 0)
["prev"1    make an array containing "prev", 1,
'.3*_       "..." twice ("..." = '.' repeated 3 times),
B"next"]    then B and "next"
:a          wrap each of its elements in an array - [["prev"][1]["..."]…]
.*          repeat each of these arrays according to the previous array
             e.g. ["prev"] is repeated A>1 times - ["prev"] if A>1, else []
             [1] is repeated A>0 times (always 1), etc.
             obtaining an array of 6 arrays, some of which may be empty
3/          split into 2 arrays of 3 arrays each (between the "..." parts)
5,A2-f+     make an array [0 1 2 3 4] then add A-2 to each element
B,2>&       intersect with the array [2 3 … B-1] (these are the middle numbers)
*           join the 2 previous arrays by adding these numbers between them
:+          concatenate all these arrays and numbers together
             obtaining an array containing only numbers and strings
_A#         duplicate the array then find the position of A in it
Aa`         generate the "[A]" string (with the actual number for A)
             by wrapping A in an array and getting its string representation
t           put it in the array at A's position
p           print the array's string representation

Haskell, 145 129 octets

s x=show x
a#t=["prev 1"|a>1]++["..."|a>4]++map s[max 4a-2..a-1]++s[a]:map s[a+1..min(a+3)t-1]++["..."|t-a>3]++[s t++" next"|a<t]

Essayez-le en ligne!

Edit: @ Ørjan Johansen a enregistré 16 octets. Merci!

Script de golf - 104 personnages

~\:a;:b;1a<'prev '*3a<'1 ... '*[5,{a 2-+}/]{.0>\b)<&},{.a={'['\']'}*' '}/;b a-:c 2>' ... 'b+*0c<' next'*

Ungolfed

~\:a;:b;       # a = 1st arg, b = 2nd arg
1a<'prev '*    # if a > 1: print 'prev '
3a<'1 ... '*   # if a > 3: print '1 ... '
[5,{a 2-+}/]   # creates an array [a-2 a-1 a a+1 a+2]
{.0>\b)<&},    # keeps only elements >0 and <=b
{
  .a={'['\']'}*      # puts '[' ']' around the element equal to a
  ' '}/;             # prints each element with a leading space
b a-:c 2>' ... 'b+*  # if b-a > 2: print ' ... ' + b
0c<' next'*          # if b-a > 0: print ' next'

Perl 5, 113 + 1 (-p) 109 +3 (-pal) octets

$_=join$",1..<>;s/\b@F\b/[$&]/;s/^1/prev 1/;s/\d$/$& next/;s/(^|\] )\w+ \w+ \K[\w ]*(?= \w+ \w+( \[|$))/.../g

Essayez-le en ligne

Ruby , 127 octets

Je ne suis pas particulièrement satisfait de cela, en particulier de la logique précédente / suivante.

->c,t{"prev #{(1..t).chunk{|n|n<2||n==t||n>c-3&&n<c+3}.map{|t,a|t ?a:?.*3}*" "} next".sub(/(prev )?\b(#{c})\b( next)?/,'[\2]')}

Essayez-le en ligne!

Ungolfed

->c,t{
  "prev #{
    (1..t)
    .chunk {|n| n < 2 || n == t || n > c - 3 && n < c + 3 }
    .map {|t,a| t ? a : ?. * 3 } * " "
  } next"
  .sub(/(prev )?\b(#{ c })\b( next)?/, '[\2]')
}

PHP (navigateur), 267 octets

<?php parse_str($_SERVER['QUERY_STRING']);$c=$a!=1?$a>3?$a>4?'prev 1 . . . ':'prev 1 ':'prev ':'[1] ';$d=$a<$b-2?$a+3:$b;for($i=$a<=2?$a==1?$i=2:$i=$a-1:$i=$a-2;$i<$d;$i++)$c.=$a==$i?"[$i] ":"$i ";if($a<$b-2)$c.=" . . . $b next";else $c.=$a==$b?"[$b]":"$b next";echo $c?>

Essayez-le en ligne!

Certainement pas aussi petit qu'il aurait pu l'être, et comme cela a été démontré ci-dessus, utiliser PHP en ligne de commande peut être beaucoup plus petit. La saisie s'effectue via des requêtes GET, a est le nombre sélectionné, b est la limite. Cela ressemble àfoo.bar.com/index.php?a=2&b=12

Ungolfed

<?
    parse_str($_SERVER['QUERY_STRING']);
    $c=$a!=1?$a>3?$a>4?'prev 1 . . . ':'prev 1 ':'prev ':'[1] ';
    $d=$a<$b-2?$a+3:$b;
    for($i=$a<=2?$a==1?$i=2:$i=$a-1:$i=$a-2;$i<$d;$i++)
        $c.=$a==$i?"[$i] ":"$i ";

    if($a<$b-2)$c.=" . . . $b next";else
    $c.=$a==$b?"[$b]":"$b next";
    echo $c
?>

Je suis assez sûr que mes opérateurs ternaires peuvent être améliorés, n'hésitez pas à essayer.

Formule IBM / Lotus Notes, 217 211 octets

-2 grâce à @KevinCruijssen

-4 en utilisant des variables pour les valeurs @Text

o:=@If(a=1;"[1]";"Prev 1 ")+@If(a>4;"... ";"");@For(x:=2;x<b;x:=x+1;T:=@Text(x);o:=o+@If(x>a-3&x<a+3;@If(a=x;"["+T+"]";T)+" ";""));Z:=@Text(b);o:=o+@If(b>1;@If(b-a>3;"... ";"")+@If(a=b;"["+Z+"]";Z+" Next");"");o

En gros, un portage de Python 2 répond juste pour le plaisir d'essayer de se rappeler comment utiliser Formula.

Il n'y a pas de TIO pour Formula, voici donc une capture d'écran de certains des cas de test:

Excel VBA, ₂₀₂ 201 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage A1:A2et les envoie à la fenêtre immédiate VBE.

For i=[Max(A1-2,1)]To[Min(A1+2,A2)]:s=s &IIf([A1]=i,"[" &i &"]",i)&" ":Next:?[If(A1=1,"","prev "&If(A1>3,1&If(A1>4," ... "," "),""))]s[If(A1<A2,If(A1-A2<-3,"... ","")&If(A1-A2<-2,A2&" ","")&"next","")]

Version du sous-programme

Inclus pour la lisibilité

Public Sub PageSelect(Optional ByVal Current As Long = -1, _
                      Optional ByVal Total   As Long = -1)

    Call Sheet1.Activate

    Let [A1] = IIf(Current = -1, [A1], Current)
    Let [A2] = IIf(Total   = -1, [A1], Total)

    Dim s As String
    Let s = ""

    For i = [Max(A1-2,1)] To [Min(A1+2,A2)] Step 1
        Let s = s & IIf([A1] = i, "[" & i & "]", i) & " "
    Next
    Debug.Print [If(A1=1,"","prev "&If(A1>3,1&If(A1>4," ... "," "),""))]; _
                s; _
                [If(A1<A2,If(A1-A2<-3,"... ","")&If(A1-A2<-2,A2&" ","")&"next","")]
End Sub

PowerShell , 237 octets

param($a,$n)('prev 1','[1]')[$n-lt2]+" ... $($n-2) $($n-1) [$n]"*($n-gt4)+" 2 3 [4]"*($n-eq4)+" 2 [3]"*($n-eq3)+" [2]"*($n-eq2)+" $($n+1) $($n+2) ..."*($n-lt$a-3)+" $($n+1) $($n+2)"*($n-eq$a-3)+" $($n+1)"*($n-eq$a-2)+" $a next"*($n-ne$a)

Essayez-le en ligne!

Une concaténation de cordes gigantesque avec beaucoup trop de signes dollar. Travailler sur le golf plus loin. Non, je pense que c'est aussi court que cette approche peut aller.

Javascript (ES6), 265 263 258 240 239 220 194 193 182 178 octets

-2 de la suppression d'un outil de débogage

-5 de réaliser que j'utilise ES6 et que je peux parfois me passer de parenthèses

-18 de supprimer quelque chose d'une version antérieure qui est maintenant obsolète

-1 de faire des trucs sournois

-19 de supprimer les variables inutiles

-26 octets pour supprimer les valeurs de falsey trop compliquées. Je suis nouveau sur ES6

-1 d'utiliser des comparaisons plus courtes

-11 d'utiliser une fonction récursive

* -4 de remplacer ?...:0par &&...et ... ${t}avec...+t

Cela a pris beaucoup trop de temps dans ma vie et n’a pas donné assez de votes positifs. mais je suis si heureux que le code final soit une puissance de 2 (2 ^ 8). Je sais qu'il existe une autre réponse JavaScript d'environ 120 octets. mais j'aime toujours ce code

EDIT: Je ne sais pas ce que je pensais. 265 n'est pas 2 ^ 8 ...

En faisant cela, j'ai réussi à casser la version non-golfée. Mon Dieu, est-ce que je déteste le code non-golfeur?

EDIT 2: cela ressemble maintenant à la meilleure solution de 121 octets

y=(e,i,t="")=>i++<e?y(e,i,t+i+' '):t.slice(0,-1);m=(t,p)=>[p-1&&"prev",p<5?y(p-1,0):"1 ... "+y(p-1,p-3),`[${t}]`,t-p<4?y(t,p):y(p+2,p)+` ... `+t,t-p&&"next"].filter(e=>e).join` `

Explication:

à venir mais fondamentalement y est range(end, start)et il fait des trucs sympas comme:

1. montre prev if pageis 1
2. montrer les points de gauche si page > 4
3. montrer les bons points si total - page < 4
4. montrer ensuite si total - page == 0

et des trucs comme ça et juste rejoint par ''. Je sais que vous n'êtes pas obligé de le faire mais j'aime le fait que ce soit semi conventionnel. Je ne sais pas. Prendre plaisir.

Essayez-le en ligne!

Validez-le en ligne!

Voici un 186 185 174 170 solution d'octets que je ne aime pas: Essayez en ligne!

PowerShell , 141 octets

param($c,$t)($('prev'*($c-ne1)
1
'...'*($c-gt4)
($c-2)..($c+2)-gt1-lt$t
'...'*($t-$c-gt4)
$t
'next'*($t-ne$c))|?{$_}|gu)-replace"^$c$","[$c]"

Essayez-le en ligne!

Moins joué au golf:

param($current,$total)
$uiElements=$(
    'prev'*($current-ne1)
    1
    '...'*($current-gt4)
    ($current-2)..($current+2)-gt1-lt$total
    '...'*($total-$current-gt4)
    $total
    'next'*($total-ne$current)
)
($uiElements|where{$_}|Get-Unique)-replace"^$current$","[$current]"