페이지 선택 인터페이스를 만들어야하는 것이 일반적입니다. 일반적으로 다음과 같습니다.

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

즉, 총 173 페이지가 있으며 현재 5 페이지에 있습니다.

이 문제를 해결하려면 총 페이지 수와 현재 페이지 번호를 입력으로 사용하고 페이지 선택기를 "표시"하는 문자열 (또는 배열)을 출력해야합니다.

입력

양의 정수 2 개

• 현재 페이지 번호
• 페이지 수

1 <= 현재 <= 총계임을 보장합니다.

산출

페이지 선택기의 UI를 나타내는 문자열 또는 배열을 출력합니다.

• 문자열로 출력되는 경우 각 페이지 사이에 단일 공백 ​​(U + 0020)을 사용해야합니다.
• 배열로 출력하는 경우 배열은 각 항목을 문자열로 변환하고 단일 공백으로 결합한 후 문자열과 동일한 결과를 생성해야합니다.
  • 3 개의 도트 ( ...)는 배열 출력에 선택 사항이 아닙니다.

세부

• current == 1이면 "prev"가 출력되지 않으며, 그렇지 않으면 "prev"가 먼저옵니다.
• current == total이면 "next"가 출력되지 않으며, 그렇지 않으면 "next"가 마지막에옵니다.
• 첫 페이지 (1)와 마지막 페이지 (총)가 항상 출력되어야합니다.
• 현재 페이지, (현재 -1) 페이지, (현재-2) 페이지, (현재 + 1) 페이지, (현재 + 2) 페이지는 [1..total] 범위에있는 한 출력되어야합니다.
• 다른 페이지 번호는 출력하지 않아야합니다.
• 출력 된 페이지는 오름차순으로 정렬되어야합니다.
• 출력에 중복 페이지 번호가 포함되지 않아야합니다.
• 현재 페이지는로 묶어서 강조 표시해야합니다 [].
• 이웃 사이에 간격이 있으면 세 개의 점 ( ...)을 삽입해야합니다.

테스트 사례

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

규칙

• 이것은 가장 짧은 코드가이기는 코드 골프입니다!

망막 , 125 113 109 107 바이트

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

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. @MartinEnder 덕분에 12 바이트를 절약했습니다. 설명:

.+
$*

단항으로 변환합니다.

r`1\G
 1$'

모든 페이지 번호를 역순으로 생성하십시오.

¶

입력을 분리하는 개행을 삭제하십시오. (어쨌든 페이지 번호 생성부터 공간이 있습니다.)

O`1+

페이지를 오름차순으로 다시 정렬하십시오. 현재 페이지가 정렬되어 현재 복제되었습니다.

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

[]현재 페이지를 복제하고 줄 바꿈 합니다.

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

현재 페이지가 5 이상이거나 현재 페이지 다음에 4 페이지 이상이 있으면 줄임표를 추가하십시오. 생략 부호의 마지막 페이지를 포함하지 않으려면 후행 공백에 유의하십시오.

^1
prev 1

현재 페이지가 1이 아닌 경우 이전을 추가하십시오.

1$
1 next

현재 페이지가 마지막 페이지가 아닌 경우 다음을 추가하십시오.

1+
$.&

십진수로 다시 변환합니다.

자바 스크립트 (ES6) 130 122 121 바이트

카레 구문을 사용하여 호출하십시오 (예 :) 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))

온라인으로 사용해보십시오!

-1 바이트 (Arnauld) 세트 X로 X-x.

6502 머신 코드 (C64), 160 바이트

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

온라인 데모 - 사용법 : sys49152,[current],[total] 예sys49152,5,173.

숫자는 현재 <= 총계 인 [1..255] 범위에 있어야합니다. 이것은 달리 지정되지 않았기 때문에 이것은 8 비트 프로세서에서 "자연적인"부호없는 정수 범위입니다.

주석 처리 된 해체 목록에 설명 :

         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 바이트 168 바이트

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

온라인으로 사용해보십시오!

훌륭한 골프 팁을위한 @ user2390246에게 감사합니다

APL (Dyalog) , 83 82 바이트

익명 인수 함수는 현재를 왼쪽 인수로, 총계를 오른쪽 인수로 사용합니다.

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

온라인으로 사용해보십시오!

{... } 명시 적 람다 곳 ⍺과 ⍵왼쪽과 오른쪽 인수를 나타냅니다

 ⍺<⍵ 전류가 전체보다 작습니까?

 ' next'/⍨ 그렇다면 텍스트를 복제하여 사용하십시오.

 (… ), 다음을 추가하십시오.

  ⍳⍵ through ntegers 1-전체

  'x'@(... ) 로 교체 x 에서 항목이있는 위치 ...

   ~ 아니

   ∊ 의 회원

   1 하나

   , 뒤에

   ⍵ 전체

   , 뒤에

    ⍳5 처음 5 개의 ntnters ( [1,2,3,4,5])

    3- 3에서 빼기 ( [2,1,0,-1,-2])

    ⍺+ 현재에 추가됨 ( [⍺+2,⍺+1,⍺,⍺-1,⍺-2])

   ⊢ 수확량 ( ⍺로부터 분리 'x')

   (… 현재 위치 에서)  다음과 같은 암묵적 기능 을 적용하십시오 .

    ⍕ 형식 (stringify)

    '][', 텍스트 앞에 붙이다 

    1⌽ 한 단계 왼쪽으로 회전 ( ]끝 으로 이동 )

    ⊂ 묶음 (표시된 단일 위치에 맞는 스칼라가되도록)

   ∊ ε NLIST은 (평평 - 우리는 괄호를 삽입 할 때 중첩 만들었 기 때문에)

   ⍕ 형식 (stringify – 숫자를 서로 분리하고 x실행하는 공백 1 개)

  'x+'⎕R'...' PCRE R의 eplace은 x세 기간으로 실행

 (… ), 다음을 추가하십시오.

  ⍺>1 전류가 1보다 큽니까?

  'prev '/⍨ 그렇다면 텍스트를 복제하여 사용하십시오.

볼프람 언어 (티카) , 131 (114) 109 바이트

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

온라인으로 사용해보십시오!

작동 원리

많은 교체. 모든 페이지 목록으로 시작하여 순서대로 바꾸십시오.

1. #->"["<>(t=ToString)@#<>"]": 괄호 문자열이있는 현재 페이지
2. 1->"prev 1": 문자열이있는 1 페이지 prev 1,
3. #2->t@#2<>" next": 문자열로 마지막 페이지 (number) next와
4. #-3|#+3:>"...": 페이지 current-3와 페이지 current+3문자열로 "...",
5. x_/;Abs[x-#]>2:>Nothing: 아래 current-2또는 위의 다른 모든 (정수) 페이지 current+2는 아무 것도 없습니다. (예, Nothing내장되어 있습니다.)

펑키 , 218210 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 136130 바이트

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]

온라인으로 사용해보십시오!

배열로 출력하는 경우 배열은 각 항목을 문자열로 변환하고 단일 공백으로 결합한 후 문자열과 동일한 결과를 생성해야합니다.

온라인으로 사용해보십시오! 바닥 글이 문자 그대로 "각각을 문자열로 변환하고 공백으로 결합"하는 것을 볼 수 있습니다.

이것은 Lynn의 접근 방식에 대한 대안입니다.

파이썬 2 , 135 바이트

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

온라인으로 사용해보십시오!

먼저와 같은 문자열을 생성합니다.이 문자열은 prev 1 3 4 [5] 6 7 10 next일부 숫자를 지우면 공백이 아니라 "간격"이 생깁니다. 그런 다음 ...정규 표현식 을 사용하여 2 이상의 공백을 대체합니다 .

Java 8, 201 200 197 바이트

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

설명:

여기에서 시도하십시오.

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)

자바 (오픈 JDK 8) , 218 (179) 177 (167) 166 바이트

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

온라인으로 사용해보십시오!

젤리 , 59 바이트

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

결과를 STDOUT에 인쇄하는 전체 프로그램 *. 인수를 current하고 total순서입니다.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

+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

* current왼쪽과 total오른쪽 에 있는 2 차원 링크 로서 문자와 정수가 혼합 된 목록을 반환합니다. 이 목록에는 공백이 포함됩니다. 바이트 K는 스펙을 준수하기 위해 간단하게 제거 할 수 없습니다. 결과는 current(와 같은 [...'[','5','2',']'...]) 별도의 문자 로 괄호 로 묶 이므로 "각 항목을 문자열로 변환하고 단일 공백으로 결합"하면 원하는 결과를 얻지 못하므로 )

파이썬 2 , 178170 바이트

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]

온라인으로 사용해보십시오!

규칙을보다주의 깊게 읽은 후 두 번째 시도.

불필요한 괄호를 잃어 버려 -8.

옥타브 , 16996190181175169166 바이트

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

온라인으로 사용해보십시오!

나중에 설명을 추가하겠습니다.

흠, 출력 형식에 문제가있는 것 같습니다. 이것들은 이제 해결되었습니다-모든 출력이 정확합니다. 그러나 아쉽게도 27 바이트가 들었습니다. 약간의 뚱뚱한 트리밍으로 모든 사람들을 다시 발톱으로 관리했습니다.

• @StewieGriffin *대신 .*- 대신 6 바이트를 절약하십시오.
• 내가 이미 그 핸들을 가지고있는 sprintf대신 대신 9 바이트를 저장하십시오 .num2strs
• 당겨 6 바이트를 저장 []로 sprint전화를 겁니다.
• 비교 횟수를 줄이는 방법을 찾아서 6 바이트를 절약하십시오.
• strtrim()후행 공백없이 필요를 제거하여 3 바이트를 절약하십시오 .

C # (. NET 코어) , 195192 바이트

Kevin Cruijssen 덕분에 3 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

C ++-247 바이트

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

온라인으로 사용해보십시오!

파이썬 (2) ,  128  (124) 바이트

Jonathan Allan 덕분에 -4 바이트 !

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)

온라인으로 사용해보십시오!

목록으로 출력되지만 TIO 링크에는 예쁜 인쇄가 포함됩니다.

PHP, 157150 바이트

문자 그대로 세부 사항을 취하는 것이 가장 짧은 접근 방식으로 밝혀졌습니다.

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

온라인으로 실행 php -nr '<code>' <curpage> <numpages>하거나 사용해보십시오 .

CJam, 74

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

배열로 출력합니다. 온라인으로 사용해보십시오

문자열로 출력하기 위해 최종 p을 S*로 바꿉니다 .

설명:

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

하스켈 145 129 바이트

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]

온라인으로 사용해보십시오!

편집 : @ Ørjan Johansen은 16 바이트를 저장했습니다. 감사!

골프 스크립트 -104 자

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

언 골프

~\: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'

펄 5, 113 + 1 (-p) 109 +3 (-pal) 바이트

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

온라인으로 사용해보십시오

루비 , 127 바이트

나는 이것, 특히 이전 / 다음 논리에 특히 만족하지 않습니다.

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

온라인으로 사용해보십시오!

언 골프

->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 (브라우저), 267 바이트

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

온라인으로 사용해보십시오!

분명히 작을 수는 없었으며 위에서 설명한 것처럼 명령 행에서 PHP를 사용하는 것은 훨씬 작을 수 있습니다. 입력은 GET 요청을 통해 이루어지며 a는 선택된 숫자이며 b는 한계입니다. 이것은 다음과 같습니다foo.bar.com/index.php?a=2&b=12

언 골프

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

나는 삼항 연산자가 향상 될 수 있다고 확신하며 자유롭게 시도하십시오.

IBM / Lotus Notes 공식, 217211 바이트

@KevinCruijssen 덕분에 -2

@Text 값에 변수를 사용하여 -4

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

기본적으로 Python 2 포트는 Formula 사용 방법을 기억하는 재미를 위해 대답합니다.

공식에 대한 TIO가 없으므로 다음은 일부 테스트 사례의 스크린 샷입니다.

Excel VBA, ₂₀₂ 201 바이트

범위에서 입력 A1:A2을 받고 VBE 즉시 창으로 출력하는 익명 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","")]

서브 루틴 버전

준비성을 위해 포함

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 바이트

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)

온라인으로 사용해보십시오!

너무 많은 달러 기호가있는 하나의 거대한 문자열 연결. 더 골프 작업. 아니요,이 방법이 가능한 한 짧다고 생각합니다.

자바 (ES6) 265 263 258 240 239 220 194 193 182 178 바이트

디버그 도구 제거에서 -2

내가 ES6을 사용하고 때로는 괄호를 제거 할 수 있다는 것을 깨닫는 -5

더 이상 사용되지 않는 이전 버전에서 무언가를 제거하는 -18

비열한 일을하면서 -1

불필요한 변수 제거에서 -19

너무 복잡한 모든 제거에서 -26 바이트는 잘못된 값을 제거합니다. ES6을 처음 사용합니다

더 짧은 비교를 사용하여 -1

재귀 함수 사용에서 -11

* -4에 치환 ?...:0하여 &&...,과 ... ${t}함께...+t

이것은 내 인생을 너무 많이 가져 갔고 충분한 공짜를주지 않았다. 그러나 최종 코드가 2의 힘 (2 ^ 8)이라는 것이 너무 기쁩니다 . 약 120 바이트 인 또 다른 JavaScript 응답이 있다는 것을 알고 있습니다. 하지만 난 여전히이 코드를 좋아합니다

편집 : 나는 내가 무슨 생각을했는지 모르겠다. 265는 2 ^ 8이 아닙니다 ...

이것을 만드는 동안 나는 ungolfed 버전을 깨뜨 렸습니다. 하나님, 나는 ungolfing 코드를 싫어합니까?

편집 2 : 이제 더 나은 121 바이트 솔루션처럼 보입니다.

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

설명:

와야하지만 기본적으로 y는 다음 range(end, start)과 같은 멋진 것들을 수행합니다.

1. page1 인 경우 이전 표시
2. 다음과 같은 경우 왼쪽 점 표시 page > 4
3. 다음과 같은 경우 오른쪽 점 표시 total - page < 4
4. 다음에 표시 total - page == 0

그런 것들과 ''로 연결됩니다. 꼭 그럴 필요는 없지만 반 전통적인 사실을 좋아합니다. 모르겠어요 즐겨.

온라인으로 사용해보십시오!

온라인으로 확인하십시오!

여기에 있어요 (186) 185 (174) 내가하지 같이 할 것을 170 바이트 솔루션 : 온라인으로보십시오!

PowerShell , 141 바이트

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

온라인으로 사용해보십시오!

덜 골프 :

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