Nó là phổ biến để làm cho một giao diện lựa chọn trang. Nó thường trông như thế này:

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

Điều đó có nghĩa là có tổng cộng 173 trang và hiện tại bạn đang ở trang thứ 5.

Thử thách này yêu cầu bạn lấy tổng số trang và số trang hiện tại làm đầu vào và xuất một chuỗi (hoặc một mảng) để "hiển thị" bộ chọn trang.

Đầu vào

2 số nguyên dương

• số trang hiện tại
• số trang

Nó được đảm bảo rằng 1 <= hiện tại <= tổng.

Đầu ra

Xuất ra một chuỗi hoặc một mảng đại diện cho ui cho các bộ chọn trang.

• Nếu đầu ra dưới dạng chuỗi, một khoảng trắng (U + 0020) nên được sử dụng giữa mỗi trang.
• Nếu đầu ra là một mảng, mảng sẽ tạo ra kết quả giống như chuỗi sau khi chuyển đổi từng mục thành chuỗi và nối chúng với một khoảng trắng.
  • Ba dấu chấm ( ...) không phải là tùy chọn cho đầu ra mảng.

Chi tiết

• Nếu hiện tại == 1, sẽ không có "tiền tố" nào được xuất ra, nếu không, "trước" sẽ xuất hiện trước.
• Nếu hiện tại == tổng, sẽ không có "tiếp theo" nào được xuất ra, nếu không, "tiếp theo" sẽ đến sau cùng.
• Trang đầu tiên (1) và trang cuối cùng (tổng cộng) phải luôn được xuất ra.
• Trang hiện tại, trang (hiện tại - 1), trang (hiện tại - 2), trang (hiện tại + 1), trang (hiện tại + 2) phải được xuất ra miễn là nằm trong phạm vi của [1..total].
• Không có số trang khác nên được xuất ra.
• Các trang xuất ra nên được sắp xếp theo thứ tự tăng dần.
• Đầu ra không được chứa số trang trùng lặp.
• Trang hiện tại nên được làm nổi bật bằng cách bọc nó trong một cặp [].
• Nếu có một khoảng cách giữa bất kỳ hàng xóm nào, ...nên chèn ba dấu chấm ( ).

Các trường hợp thử nghiệm

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

Quy tắc

• Đây là code-golf, mã ngắn nhất sẽ thắng!

Võng mạc , 125 113 109 107 byte

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

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Đã lưu 12 byte nhờ @MartinEnder. Giải trình:

.+
$*

Chuyển đổi sang unary.

r`1\G
 1$'

Tạo tất cả các số trang theo thứ tự ngược lại.

¶

Xóa dòng mới tách đầu vào. (Dù sao cũng có một khoảng trống ở thế hệ số trang.)

O`1+

Sắp xếp các trang trở lại theo thứ tự tăng dần. Điều này cũng sắp xếp trang hiện tại, hiện đang trùng lặp.

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

Không trùng lặp và bọc []s xung quanh trang hiện tại.

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

Thêm dấu chấm lửng nếu trang hiện tại ít nhất là 5 hoặc nếu có ít nhất 4 trang sau trang hiện tại. (Lưu ý dấu cách, để tránh bao gồm trang cuối cùng trong dấu chấm lửng.)

^1
prev 1

Thêm trước nếu trang hiện tại không phải là 1.

1$
1 next

Thêm trang tiếp theo nếu trang hiện tại không phải là trang cuối cùng.

1+
$.&

Chuyển đổi trở lại thập phân.

JavaScript (ES6), 130 122 121 byte

Gọi với cú pháp currying, ví dụ 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))

Hãy thử trực tuyến!

-1 byte (Arnauld): Đặt Xthành X-x.

Mã máy 6502 (C64), 160 byte

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

Bản demo trực tuyến - Cách sử dụng : sys49152,[current],[total] , ví dụsys49152,5,173.

Các số phải nằm trong phạm vi [1..255] với <= tổng. Vì điều này không được chỉ định khác, đây là phạm vi số nguyên không dấu "tự nhiên" trên bộ xử lý 8 bit.

Giải thích như bình luận tháo gỡ danh sách:

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

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

Hãy thử trực tuyến!

Cảm ơn @ user2390246 về một số mẹo chơi golf tuyệt vời

APL (Dyalog) , 83 82 byte

Hàm infix ẩn danh lấy hiện tại làm đối số bên trái và tổng cộng làm đối số bên phải.

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

Hãy thử trực tuyến!

{... } lambda rõ ràng nơi ⍺và ⍵đại diện cho lập luận trái và bên phải:

 ⍺<⍵ hiện tại nhỏ hơn tổng số?

 ' next'/⍨ nếu vậy (sử dụng nó để sao chép) văn bản

 (... ), thêm vào trước sau:

  ⍳⍵ ɩ ntegers từ 1 đến tổng

  'x'@(... ) thay thế với một x tại các vị trí nơi các mặt hàng là ...

   ~ không phải

   ∊ Thành viên của

   1 một

   , theo dõi bởi

   ⍵ Tổng số

   , theo dõi bởi

    ⍳5 năm ntegers đầu tiên ( [1,2,3,4,5])

    3- trừ ba ( [2,1,0,-1,-2])

    ⍺+ được thêm vào hiện tại ( [⍺+2,⍺+1,⍺,⍺-1,⍺-2])

   ⊢ mang lại (phục vụ để tách ⍺khỏi 'x')

   (... ) áp dụng các chức năng ngầm sau ở vị trí hiện tại:

    ⍕ định dạng (xâu chuỗi)

    '][', chuẩn bị văn bản 

    1⌽ xoay một bước sang trái (di chuyển ]đến cuối)

    ⊂ kèm theo (để nó là một vô hướng sẽ phù hợp với vị trí được chỉ định duy nhất)

   ∊ ε nlist (flatten - bởi vì chúng tôi đã làm cho nó lồng nhau khi chúng ta chèn dấu ngoặc)

   ⍕ định dạng (xâu chuỗi - 1 không gian ngăn cách các số với nhau và từ các xlần chạy)

  'x+'⎕R'...' PCRE R eplace xchạy với ba giai đoạn

 (... ), thêm vào trước sau:

  ⍺>1 hiện tại lớn hơn 1?

  'prev '/⍨ nếu vậy (sử dụng nó để sao chép) văn bản

Ngôn ngữ Wolfram (Mathicala) , 131 114 109 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Rất nhiều thay thế. Bắt đầu với một danh sách tất cả các trang, thay thế, theo thứ tự:

1. #->"["<>(t=ToString)@#<>"]": trang hiện tại có chuỗi ký tự,
2. 1->"prev 1": trang 1 với chuỗi prev 1,
3. #2->t@#2<>" next": trang cuối cùng với chuỗi (number) next, với
4. #-3|#+3:>"...": trang current-3và trang current+3có chuỗi "...",
5. x_/;Abs[x-#]>2:>Nothing: tất cả các trang (số nguyên) khác bên dưới current-2hoặc bên trên current+2không có gì. (Có, Nothinglà một tích hợp.)

Vui nhộn , 218 210 byte

Đã lưu một số byte, một số trong đó nhờ vào 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)}

Hãy thử trực tuyến!

Python 2 , 136 130 byte

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]

Hãy thử trực tuyến!

Nếu đầu ra là một mảng, mảng sẽ tạo ra kết quả giống như chuỗi sau khi chuyển đổi từng mục thành chuỗi và nối chúng với một khoảng trắng.

Hãy thử trực tuyến! ở dạng đẹp, trong đó bạn có thể thấy phần chân trang dịch hoàn toàn theo nghĩa đen để "chuyển đổi từng chuỗi thành chuỗi, nối vào khoảng trắng".

Đây là một cách thay thế cho phương pháp của Lynn.

Python 2 , 135 byte

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

Hãy thử trực tuyến!

Đầu tiên chúng ta tạo một chuỗi như thế prev 1 3 4 [5] 6 7 10 next, trong đó có các khoảng trống của Google gây ra bằng cách xóa một số số nhưng không phải là khoảng cách phân định của chúng. Sau đó, chúng tôi thay thế bất kỳ chạy hơn 2 dấu cách bằng ...cách sử dụng biểu thức chính quy.

Java 8, 201 200 197 byte

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

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Hãy thử trực tuyến!

Thạch , 59 byte

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

Một chương trình đầy đủ * in kết quả sang STDOUT. Đưa ra lập luận currentvà totaltheo thứ tự đó.

Hãy thử trực tuyến! hoặc xem bộ thử nghiệm .

Làm sao?

+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

* Là một liên kết dyadic currentở bên trái và totalbên phải, điều này trả về một danh sách với sự pha trộn của các ký tự và số nguyên; danh sách này bao gồm các không gian. KTuy nhiên, byte không thể được loại bỏ để tuân thủ thông số kỹ thuật, vì kết quả sau đó sẽ có dấu ngoặc currentlà các ký tự riêng biệt (như [...'[','5','2',']'...]), do đó, "chuyển đổi từng mục thành chuỗi và nối chúng với một khoảng trắng" sẽ không tạo ra kết quả mong muốn )

Con trăn 2 , 178 170 byte

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]

Hãy thử trực tuyến!

Lần thử thứ hai sau khi đọc các quy tắc cẩn thận hơn.

-8 bằng cách mất một số dấu ngoặc không cần thiết.

Octave , 169 196 190 181 175 169 166 byte

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

Hãy thử trực tuyến!

Tôi sẽ thêm một lời giải thích sau này.

Hmm, dường như có một số vấn đề với định dạng đầu ra. Những điều này đã được giải quyết - tất cả các kết quả đầu ra là chính xác. Nhưng than ôi nó có giá 27 byte. Quản lý để vuốt tất cả những người trở lại mặc dù với một chút cắt tỉa chất béo.

• Lưu 6 byte bằng cách sử dụng *thay vì.* - cảm ơn @StewieGriffin
• Lưu 9 byte bằng cách sử dụng sprintfthay vì num2strnhư tôi đã xử lý s.
• Lưu 6 byte bằng cách kéo []vào sprintcuộc gọi.
• Lưu 6 byte bằng cách tìm cách giảm số lượng so sánh.
• Lưu 3 byte bằng cách loại bỏ nhu cầu strtrim()mà không gây ra dấu cách.

C # (Lõi .NET) , 195 192 byte

Đã lưu 3 byte nhờ 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;}

Hãy thử trực tuyến!

C ++ - 247 byte

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

Hãy thử trực tuyến!

Python 2 ,  128  124 byte

-4 byte nhờ 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)

Hãy thử trực tuyến!

Đầu ra dưới dạng một danh sách, nhưng liên kết tio bao gồm in đẹp.

PHP, 157 150 byte

lấy các chi tiết theo nghĩa đen hóa ra là cách tiếp cận ngắn nhất:

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

Chạy với php -nr '<code>' <curpage> <numpages>hoặc thử trực tuyến .

CJam, 74

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

Đầu ra dưới dạng mảng. Dùng thử trực tuyến

Thay thế cuối cùng pvới S*đầu ra dưới dạng chuỗi.

Giải trình:

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 byte

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]

Hãy thử trực tuyến!

Chỉnh sửa: @ rjan Johansen đã lưu 16 byte. Cảm ơn!

Tập lệnh Golf - 104 ký tự

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

Ung dung

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

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

Dùng thử trực tuyến

Ruby , 127 byte

Tôi không đặc biệt hài lòng với điều này, đặc biệt là logic trước / sau.

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

Hãy thử trực tuyến!

Ung dung

->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 (Trình duyệt), 267 byte

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

Hãy thử trực tuyến!

Chắc chắn không nhỏ như nó có thể, và như đã được chứng minh ở trên, sử dụng PHP trong dòng lệnh có thể nhỏ hơn nhiều. Đầu vào là thông qua các yêu cầu GET, a là số được chọn, b là giới hạn. Trông giống nhưfoo.bar.com/index.php?a=2&b=12

Ung dung

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

Tôi khá chắc chắn rằng các nhà khai thác ternary của tôi có thể được cải thiện, hãy thử.

Công thức ghi chú của IBM / Lotus, 217 211 byte

-2 cảm ơn @KevinCruijssen

-4 bằng cách sử dụng các biến cho các giá trị @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

Về cơ bản, một cổng của câu trả lời Python 2 của tôi chỉ để giải trí cho việc cố gắng nhớ cách sử dụng Công thức.

Không có TIO cho Công thức nên đây là ảnh chụp màn hình của một số trường hợp thử nghiệm:

VBA Excel, ₂₀₂ 201 byte

Chức năng cửa sổ ngay lập tức VBE ẩn danh nhận đầu vào từ phạm vi A1:A2và đầu ra cho cửa sổ ngay lập tức 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","")]

Phiên bản chương trình con

Bao gồm để sẵn sàng

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 byte

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)

Hãy thử trực tuyến!

Một chuỗi nối khổng lồ với quá nhiều ký hiệu đô la. Làm việc trên sân golf hơn nữa. Không, tôi nghĩ rằng điều này là ngắn như cách tiếp cận này có thể đi.

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

-2 từ gỡ bỏ một công cụ gỡ lỗi

-5 từ nhận ra rằng tôi đang sử dụng ES6 và đôi khi có thể loại bỏ dấu ngoặc đơn

-18 từ việc xóa một cái gì đó từ một phiên bản trước đó đã lỗi thời

-1 từ làm một số công việc lén lút

-19 từ việc loại bỏ các biến không cần thiết

-26 byte từ việc loại bỏ tất cả các giá trị falsey quá phức tạp. Tôi mới dùng ES6

-1 từ việc sử dụng so sánh ngắn hơn

-11 từ việc sử dụng hàm đệ quy

* -4 từ thay thế ?...:0với &&..., và ... ${t}với...+t

Điều này đã chiếm quá nhiều trong cuộc sống của tôi và không cung cấp đủ số lượng. nhưng tôi rất vui vì mã cuối cùng có sức mạnh bằng 2 (2 ^ 8) Tôi biết có một câu trả lời JavaScript khác là khoảng 120 byte. nhưng tôi vẫn thích mã này

EDIT: tôi không biết tôi đang nghĩ gì 265 không phải là 2 ^ 8 ...

Trong khi thực hiện điều này, tôi đã xoay sở để phá vỡ phiên bản không có người nhận. Chúa ơi, tôi có ghét mã không.

EDIT 2: bây giờ nó trông giống như giải pháp 121 byte tốt hơn

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

Giải trình:

đến nhưng về cơ bản là y range(end, start)và nó làm một số thứ hay ho như:

1. hiển thị trước nếu pagelà 1
2. hiển thị dấu chấm trái nếu page > 4
3. hiển thị dấu chấm bên phải nếu total - page < 4
4. hiển thị tiếp theo nếu total - page == 0

và những thứ như thế và chỉ tham gia nó bằng ''. Tôi biết bạn không cần phải có nhưng tôi thích thực tế là bán thông thường. Tôi không biết. Thưởng thức.

Hãy thử trực tuyến!

Xác thực nó trực tuyến!

Dưới đây là một 186 185 174 giải pháp 170 byte mà tôi không thích: Thử trực tuyến!

PowerShell , 141 byte

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

Hãy thử trực tuyến!

Ít chơi gôn hơn:

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