Es común tener que hacer una interfaz de selección de página. Normalmente se ve así:

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

Lo que significa que hay 173 páginas en total, y actualmente estás en la quinta página.

Este desafío requiere que tome el número total de páginas y el número de página actual como entrada, y envíe una cadena (o una matriz) para "mostrar" el selector de página.

Entrada

2 enteros positivos

• número de página actual
• recuento de páginas

Se garantiza que 1 <= actual <= total.

Salida

Genere una cadena o una matriz que represente la interfaz de usuario para los selectores de página.

• Si se genera como una cadena, se debe usar un solo espacio (U + 0020) entre cada página.
• Si se genera como una matriz, la matriz debería producir el mismo resultado que la cadena después de convertir cada elemento en una cadena y unirlos con un solo espacio.
  • Los tres puntos ( ...) no son opcionales para la salida de la matriz.

Detalles

• Si actual == 1, no se generará "prev", de lo contrario, "prev" es lo primero.
• Si actual == total, no se generará "siguiente", de lo contrario, "siguiente" es el último.
• La primera página (1) y la última página (total) siempre deben imprimirse.
• La página actual, la página (actual - 1), la página (actual - 2), la página (actual + 1), la página (actual + 2) deben salir siempre que estén en el rango de [1..total].
• No se deben generar otros números de páginas.
• Las páginas enviadas deben clasificarse en orden ascendente.
• La salida no debe contener números de página duplicados.
• La página actual debe resaltarse envolviéndola en un par de [].
• Si hay un espacio entre los vecinos, se ...deben insertar tres puntos ( ).

Casos de prueba

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

Reglas

• Este es el código de golf, ¡el código más corto gana!

Retina , 125 113 109 107 bytes

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

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

Pruébalo en línea! El enlace incluye casos de prueba. Guardado 12 bytes gracias a @MartinEnder. Explicación:

.+
$*

Convierte a unario.

r`1\G
 1$'

Genere todos los números de página en orden inverso.

¶

Eliminar la nueva línea que separa la entrada. (De todos modos, también hay un espacio desde la generación del número de página).

O`1+

Ordenar las páginas de nuevo en orden ascendente. Esto también ordena la página actual, que ahora está duplicada.

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

Sin duplicar y ajustar []alrededor de la página actual.

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

Agregue puntos suspensivos si la página actual es de al menos 5 o si hay al menos 4 páginas después de la página actual. (Tenga en cuenta el espacio final, para evitar incluir la última página en los puntos suspensivos).

^1
prev 1

Agregue el anterior si la página actual no es 1.

1$
1 next

Agregue el siguiente si la página actual no es la última página.

1+
$.&

Convertir de nuevo a decimal.

JavaScript (ES6), 130 122 121 bytes

Invocar con sintaxis curry, por ejemplo 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))

Pruébalo en línea!

-1 byte (Arnauld): establecido Xen X-x.

Código de máquina 6502 (C64), 160 bytes

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

Demostración en línea - Uso: sys49152,[current],[total] psys49152,5,173.Ej.

Los números deben estar en el rango [1..255] con <= total actual. Como no se especificó lo contrario, este es el rango entero "natural" sin signo en un procesador de 8 bits.

Explicación como listado de desmontaje comentado:

         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 bytes 168 bytes

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

Pruébalo en línea!

Gracias a @ user2390246 por algunos buenos consejos de golf

APL (Dyalog) , 83 82 bytes

Función infija anónima tomando actual como argumento izquierdo y total como argumento derecho.

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

Pruébalo en línea!

{… } Explícito lambda donde ⍺y ⍵representa los argumentos izquierdo y derecho:

 ⍺<⍵ ¿La corriente es menor que el total?

 ' next'/⍨ si es así (iluminado, use eso para replicar) el texto

 (... ), anteponer lo siguiente:

  ⍳⍵ te ntegers del 1 al total

  'x'@(... ) reemplazar con un x en las posiciones donde están los artículos ...

   ~ no

   ∊ miembros de

   1 uno

   , seguido por

   ⍵ el total

   , seguido por

    ⍳5 los primeros cinco Ɩ ntegers ( [1,2,3,4,5])

    3- restado de tres ( [2,1,0,-1,-2])

    ⍺+ agregado a la actual ( [⍺+2,⍺+1,⍺,⍺-1,⍺-2])

   ⊢ rendimiento que (sirve para separar ⍺de 'x')

   (… ) Aplique la siguiente función tácita en la posición actual:

    ⍕ formato (stringify)

    '][', anteponer el texto` 

    1⌽ girar un paso hacia la izquierda (mueve el ]hasta el final)

    ⊂ encerrar (para que sea un escalar que se ajuste a la posición indicada)

   ∊ ε nlist (aplanar - porque lo hicimos anidado cuando insertamos entre paréntesis)

   ⍕ formato (stringify - 1 espacio separando números entre sí y de las xcorridas)

  'x+'⎕R'...' PCRE R eplace xfunciona con tres períodos

 (... ), anteponer lo siguiente:

  ⍺>1 ¿la corriente es mayor que 1?

  'prev '/⍨ si es así (iluminado, use eso para replicar) el texto

Wolfram Idioma (Mathematica) , 131 114 109 bytes

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

Pruébalo en línea!

Cómo funciona

Muchos reemplazos. Comenzando con una lista de todas las páginas, reemplace, en orden:

1. #->"["<>(t=ToString)@#<>"]": la página actual con una cadena entre corchetes,
2. 1->"prev 1": página 1 con la cadena prev 1,
3. #2->t@#2<>" next": la última página con la cadena (number) next, con
4. #-3|#+3:>"...": página current-3y página current+3con la cadena "...",
5. x_/;Abs[x-#]>2:>Nothing: todas las demás páginas (enteras) debajo current-2o arriba current+2sin nada. (Sí, Nothingestá integrado).

Funky , 218 210 bytes

Guardado algunos bytes, algunos de los cuales gracias a 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)}

Pruébalo en línea!

Python 2 , 136 130 bytes

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]

Pruébalo en línea!

Si se genera como una matriz, la matriz debería producir el mismo resultado que la cadena después de convertir cada elemento en una cadena y unirlos con un solo espacio.

Pruébalo en línea! en forma prettified, donde puede ver que el pie de página se traduce literalmente para "convertir cada uno en una cadena, unir en espacios".

Esta es una alternativa al enfoque de Lynn.

Python 2 , 135 bytes

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

Pruébalo en línea!

Primero creamos una cadena como prev 1 3 4 [5] 6 7 10 next, que tiene "huecos" causados ​​por borrar algunos números pero no sus espacios delimitadores. Luego reemplazamos cualquier corrida de más de 2 espacios ...usando una expresión regular.

Java 8, 201 200 197 bytes

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

Explicación:

Pruébalo aquí

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 bytes

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

Pruébalo en línea!

Jalea , 59 bytes

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

Un programa completo * que imprime el resultado en STDOUT. Toma argumentos currenty totalen ese orden.

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

+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

* Como enlace diádico currenta la izquierda y totala la derecha, esto devuelve una lista con una mezcla de caracteres y enteros; Esta lista incluye los espacios. KSin embargo, el byte no se puede eliminar simplemente para adherirse a la especificación, ya que el resultado se colocaría entre corchetes currentcomo caracteres separados (por ejemplo [...'[','5','2',']'...]), por lo que "convertir cada elemento en una cadena y unirlos con un solo espacio" no produciría el resultado deseado )

Python 2 , 178 170 bytes

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]

Pruébalo en línea!

Segundo intento después de leer las reglas con más cuidado.

-8 al perder algunos corchetes innecesarios.

Octave , 169 196 190 181 175 169 166 bytes

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

Pruébalo en línea!

Agregaré una explicación más adelante.

Hmm, parece que hubo algunos problemas con el formato de salida. Ahora se han resuelto: todas las salidas son correctas. Pero, por desgracia, costó 27 bytes. Se las arregló para arañar a todos de vuelta con un poco de recorte de grasa.

• Ahorre 6 bytes usando en *lugar de .*- gracias @StewieGriffin
• Ahorre 9 bytes usando en sprintflugar de num2strcomo ya tenía ese identificador s.
• Ahorre 6 bytes ingresando []a la sprintllamada.
• Ahorre 6 bytes encontrando una manera de reducir el número de comparaciones.
• Ahorre 3 bytes eliminando la necesidad strtrim()sin causar espacio final.

C # (.NET Core) , 195 192 bytes

Guardado 3 bytes gracias a 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;}

Pruébalo en línea!

C ++ - 247 bytes

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

Pruébalo en línea!

Python 2 ,  128  124 bytes

-4 bytes gracias a 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)

Pruébalo en línea!

Salida como una lista, pero el enlace tio incluye una bonita impresión.

PHP, 157 150 bytes

tomar los detalles literalmente resultó ser el enfoque más corto:

[,$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;

Ejecutar php -nr '<code>' <curpage> <numpages>o probarlo en línea .

CJam, 74

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

Salidas como matriz. Pruébalo en línea

Reemplace el final pcon la S*salida como cadena.

Explicación:

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 bytes

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]

Pruébalo en línea!

Editar: @ Ørjan Johansen guardó 16 bytes. ¡Gracias!

Golf Script - 104 caracteres

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

Sin golf

~\: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) bytes

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

Pruébalo en línea

Rubí , 127 bytes

No estoy particularmente contento con esto, especialmente la lógica anterior / siguiente.

->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]')}

Pruébalo en línea!

Sin golf

->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 (navegador), 267 bytes

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

Pruébalo en línea!

Definitivamente no es tan pequeño como podría haber sido, y como se demostró anteriormente, usar PHP en la línea de comandos puede ser mucho más pequeño. La entrada es a través de solicitudes GET, a es el número seleccionado, b es el límite. Esto parecefoo.bar.com/index.php?a=2&b=12

Sin golf

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

Estoy bastante seguro de que mis operadores ternarios se pueden mejorar, siéntase libre de probar.

Fórmula IBM / Lotus Notes, 217 211 bytes

-2 con agradecimiento a @KevinCruijssen

-4 mediante el uso de variables para los valores de @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

Básicamente, un puerto de mi Python 2 responde solo por la diversión de tratar de recordar cómo usar Formula.

No hay TIO para la fórmula, así que aquí hay una captura de pantalla de algunos de los casos de prueba:

Excel VBA, ₂₀₂ 201 Bytes

Función de ventana inmediata anónima de VBE que toma la entrada del rango A1:A2y las salidas a la ventana inmediata de 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","")]

Versión de subrutina

Incluido para legibilidad

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 bytes

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)

Pruébalo en línea!

Una concatenación de cadena gigantesca con demasiados signos de dólar. Trabajando más en el golf. No, creo que esto es tan corto como este enfoque puede llegar.

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

-2 de eliminar una herramienta de depuración

-5 al darme cuenta de que estoy usando ES6 y que a veces puedo eliminar los paréntesis

-18 de eliminar algo de una versión anterior que ahora está obsoleta

-1 de hacer algunas cosas furtivas

-19 de eliminar variables innecesarias

-26 bytes de eliminar los valores de Falsey demasiado complicados. Soy nuevo en ES6

-1 por usar comparaciones más cortas

-11 por usar una función recursiva

* -4 de reemplazar ?...:0con &&...y ... ${t}con...+t

Esto tomó demasiado de mi vida y no dio suficientes votos positivos. pero estoy muy contento de que el código final sea una potencia de 2 (2 ^ 8) . Sé que hay otra respuesta de JavaScript que tiene aproximadamente 120 bytes. pero todavía amo este código

EDITAR: no sé lo que estaba pensando. 265 no es 2 ^ 8 ...

Mientras hacía esto, logré romper la versión sin golf. Dios, odio el código no golfista.

EDIT 2: ahora parece la mejor solución de 121 bytes

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

Explicación:

por venir, pero básicamente es range(end, start)y hace algunas cosas interesantes como:

1. mostrar anterior si pagees 1
2. mostrar puntos a la izquierda si page > 4
3. mostrar puntos correctos si total - page < 4
4. mostrar a continuación si total - page == 0

y cosas por el estilo y simplemente se une por ''. Sé que no tienes que hacerlo, pero me gusta el hecho de que es semi-convencional. No lo sé. Disfrutar.

Pruébalo en línea!

Validarlo en línea!

Aquí hay una solución de 186 185 174 170 bytes que no me gusta: ¡ Pruébelo en línea!

PowerShell , 141 bytes

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]"

Pruébalo en línea!

Menos golfizado:

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]"