Liên quan: Cho tôi biết tôi phải làm bao nhiêu bài toán!

Thử thách

Đưa ra một danh sách số nguyên dương hoàn toàn tăng dần L và một số nguyên 3 ≤ N ≤ chiều dài L, thay thế các số nguyên giữa của các số nguyên liên tiếp của L có độ dài ≥ N bằng một dấu gạch ngang -.

Quy tắc

• Khoảng trắng ngang là không liên quan.
• Bạn có thể tùy ý giữ nguyên các ký tự giới thiệu, dấu phân cách và dấu kết thúc của định dạng danh sách mặc định của ngôn ngữ của bạn. Xem ví dụ về Định dạng , bên dưới.

Ví dụ dữ liệu

Tất cả những ví dụ này sử dụng L = 3 5 6 7 8 10 11 12 14 16 17 18 19 20 21 22 24.

N = 3 → 3 5 - 8 10 - 12 14 16 - 22 24

N = 4 → 3 5 - 8 10 11 12 14 16 - 22 24

N = 5 → 3 5 6 7 8 10 11 12 14 16 - 22 24

N = 8 → 3 5 6 7 8 10 11 12 14 16 17 18 19 20 21 22 24

Định dạng ví dụ

Đối với các đầu vào
 L = [3,5,6,7,8,10,11,12,14,16,17,18,19,20,21,22,24]và N = 3
tất cả các dòng dưới đây là ví dụ về các phản hồi hợp lệ, cả dưới dạng danh sách thực tế và dưới dạng chuỗi:

[3,5,"-",8,10,"-",12,14,16,"-",22,24]
[3,5,-,8,10,-,12,14,16,-,22,24]
[3,5-8,10-12,14,16-22,24]
3,5-8,10-12,14,16-22,24

Điều tương tự áp dụng với các định dạng danh sách khác, như {1 2 3}và (1; 2; 3)vv Có nghi ngờ gì không? Hỏi!

Python 2 , 132 115 byte

^{-17 byte nhờ Leaky Nun}

x,n=input()
o=[]
i=1
while x:
 t=x[0]
 while[t+i]==x[i:i+1]:i+=1
 o+=[[t,'-',t+i-1],x[:i]][i<n];x=x[i:];i=1
print o

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

Thạch ,  26 25  23 byte

-2 byte nhờ vào Erik Outgolfer (bằng cách đưa câu lệnh if vào liên kết chính)

Ḣ;Ṫj”-
IỊ¬1;œṗ⁸¹ÇL<¥?€F

Một liên kết dyadic trả về một danh sách trong [3,5,"-",8,10,"-",12,14,16,"-",22,24]định dạng.

Hãy thử trực tuyến! (chân trang tách biệt với khoảng trắng, để in định dạng ví dụ dữ liệu).

Làm sao?

Ḣ;Ṫj”- - Link 1, format a run: list R
Ḣ      -     head
  Ṫ    -     tail
 ;     -     concatenate
    ”- -     literal '-'
   j   -     join

IỊ¬1;œṗ⁸¹ÇL<¥?€F - Main link: list L, number N
I                - incremental differences
 Ị               - insignificant? (<=1)
  ¬              - not
   1;            - prepend a 1
       ⁸         - chain's left argument, L
     œṗ          - partition (L) at truthy indexes
              €  - for €ach row, R, in L:
             ?   -   if:
            ¥    -   condition: last two links as a dyad:
          L      -     length of R
           <     -     is less than N?
        ¹        -   then: identity - do nothing, yields R
         Ç       -   else: call the last link (1) as a monad with argument  R
               F - flatten into a single list

Bình thường, 23 byte

sm?<ldvzd[hd\-ed).ga=hZ

Dùng thử trực tuyến

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

sm?<ldvzd[hd\-ed).ga=hZkQ

                        Q    autoinitialized to eval(input())
                 .g          group by k ↦
                    =hZ          Z += 1, returning new value (Z is autoinitialized to 0)
                   a   k         absolute difference with k
 m                           map d ↦
  ?                              if
    ld                               length of d
   <  vz                             less than eval(z) (z is autoinitialized to input())
        d                        then d
         [hd\-ed)                else [d[0], '-', d[-1]]
s                            concatenate

Japt , 24 byte

óÈÄ¥Yîl ¨V?Zv +'-+Zo :Z

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

Giải trình

óÈ   Ä ¥ YÃ ®   l ¨ V?Zv +'-+Zo :Z
óXY{X+1==Y} mZ{Zl >=V?Zv +'-+Zo :Z}   Ungolfed
                                      Implicit: U = input array, V = input integer
óXY{      }                           Group U into runs such that for each pair X, Y:
    X+1==Y                              Y is exactly 1 more than X.
            mZ{                   }   Map each run Z to:
               Zl >=V?                  If Z has at least V items:
                      Zv     Zo           Z.unshift() and Z.pop() (the first and last items)
                         +'-+             joined with a hyphen.
                                :       Otherwise:
                                 Z        just Z.
                                      Implicit: output result of last expression

Toán học, 128 byte

(s=#2;t=r=1;While[t<Length@s,If[s[[t+1]]-s[[t]]==1,r++,r=1];If[r==#,s[[t-#+3;;t]]="-";r--];t++];s//.{b___,a_,a_,c___}:>{b,a,c})&

đầu vào

[3, {3,5,6,7,8,10,11,12,14,16,17,18,19,20,21,22,24}]

đầu ra

{3, 5, "-", 8, 10, "-", 12, 14, 16, "-", 22, 24}

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

APL, 38 byte

{∊⍺{⍺>≢⍵:⍵⋄2⌽'-',2↑¯1⌽⍵}¨⍵⊂⍨1,1≠2-⍨/⍵}

PHP 7, 137 136 134 117 110 108 byte

for($a=$argv,$i=2;$n=$a[$i++];$k<$a[1]||array_splice($a,$i,$k-2,"-"))for($k=print"$n ";$a[$i+$k]-++$k==$n;);

Lấy Ltừ đối số đầu tiên, liệt kê các yếu tố sau đó. Chạy với -nrhoặc thử trực tuyến .

Thay thế $L=($a=$argv)bằng $a=$argv,$L=(+1 byte) cho PHP <7.

phá vỡ

for($a=$argv,$i=2;              # import input
    $n=$a[$i++];                # loop $n through list elements
    $k<$a[1]||                      # 3. if streak length ($k) is >=L ($a[1])
        array_splice($a,$i,$k-2,"-")    # then replace with "-"
)
for($k=print"$n ";                  # 1. print element and space
    $a[$i+$k]-++$k==$n;);           # 2. find consecutive numbers

Võng mạc , 101 byte

\d+
$*
\b(1+) (?=1\1\b)
$1X
T`X` `\b((X)|1)+\b(?=.*¶(?<-2>1)+(?(2)(?!))11)
T`X`-
-1+(?=-)|¶1+

1+
$.&

Hãy thử trực tuyến! Lấy danh sách được phân tách bằng dấu cách Ltrên dòng đầu tiên và số nguyên Ntrên dòng thứ hai. Giải thích: Giai đoạn đầu tiên chuyển đổi đầu vào thành unary. Giai đoạn thứ hai thay đổi không gian giữa các số nguyên liên tiếp thành một X. Giai đoạn thứ ba tìm kiếm các chuỗi số nguyên liên tiếp có độ dài nhỏ hơn Nvà thay đổi Xtrở lại khoảng trắng. Giai đoạn thứ tư thay đổi Xs thành -(ngắn hơn 3 byte so với sử dụng -s ở vị trí đầu tiên.) Giai đoạn thứ năm xóa tất cả các số nguyên vẫn còn ở giữa một lần chạy, cũng như N, trong khi giai đoạn cuối chuyển đổi thành thập phân.

Ruby, 68 byte

->n,l{l.slice_when{|x,y|x<y-1}.map{|x|x[n-1]?x.minmax.uniq*?-:x}*?,}

Trả về một chuỗi như ví dụ 3,5-8,10-12,14,16-22,24 .

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

J , 40 byte

;@((](,_,{:)/)^:(<:#)&.>]<;.1~1,1<}.-}:)

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

Công dụng _ thay vì -.

Giải trình

;@((](,_,{:)/)^:(<:#)&.>]<;.1~1,1<}.-}:)  Input: integer N (LHS), array L (RHS)
                                  }.      Behead L
                                     }:   Curtail L
                                    -     Subtract elementwise to get the increments
                                1<        Test if greater than 1
                              1,          Prepend a 1
                        ]                 Get L
                         <;.1~            Partition L into boxes using the previous array
                     & >                  Operate on each box (partition) with N
              ^:                            If
                   #                          The length of the partition
                 <:                           Is greater than or equal to N
   (](     )/)                                Reduce (right-to-left) it using
         {:                                     Tail
       _,                                       Prepend _
      ,                                         Append to LHS
                     &.>                    Box the result
;@                                        Raze - join the contents in each box

Thạch, 39 37 36 byte

IỊṣ0;€1ṁ@
ÇL€<Ɠ¬TịÇḊ€Ṗ€F;€”-FyµŒgQ€F

Dùng thử trực tuyến

Lấy mảng thông qua các đối số và số nguyên qua STDIN. Liên kết TIO sử dụng chân trangÇG để đầu ra được phân tách bằng dấu cách.

Làm sao? (Mảng : a, Số nguyên n:)

(`f`)
IỊṣ0;€1ṁ@
I          Deltas of `a`
 Ị         Insignificant (x -> abs(x)<=1) applied to each element
  ṣ0       Split at occurrences of `0`.
    ;€1    Append `1` to each element
       ṁ@  `a` shaped like that
ÇL€<Ɠ¬TịÇḊ€Ṗ€F;€”-FyµŒgQ€F
Ç                            `f`
 L€                          Length of each element
   <Ɠ                        x -> x < n applied to each element
     ¬                       Logical not of each element (because Jelly doesn't have <= nor >= atoms)
      T                      Nonzero indexes
       ịÇ                    Index `f` at those indexes
         Ḋ€Ṗ€                x -> x[1:-1] applied to each element
             F               Flatten
              ;€”-           Append a hyphen to each element
                  F          Flatten
                   y         Translate (replaces all elements to be deleted with a hyphen)
                    µ        Start a new monadic link
                     Œg      Group runs of equal elements
                       Q€    Uniquify each element (make runs of hyphens one hypen)
                         F   Flatten, yet again.

Tôi đoán tôi đã ngã ... bằng phẳng trên cái này.

JavaScript (ES6), 126 119 byte

(e,c)=>{for(i=0,R='';i<e.length;R+=(R&&',')+(u-m>=c?m+'-'+--u:e.slice(z,i))){m=u=e[i],z=i;while(e[++i]==++u);}return R}

Một chức năng ẩn danh. Đưa đầu vào theo thứ tự Array L, Integer Nvà trả về kết quả dưới dạng chuỗi được phân tách bằng dấu phẩy.

M=(e,c)=>{for(i=0,R='';i<e.length;R+=(R&&',')+(u-m>=c?m+'-'+--u:e.slice(z,i))){m=u=e[i],z=i;while(e[++i]==++u);}return R}
console.log(M(eval(prompt()),+prompt()))

Dyalog APL v16.0, 82 80 78 76 75 65 62 byte

{S/⍨1,⍨2≠/S←'-'@(⍸⊃∨/(-0,⍳⍺-3)⌽¨⊂(⍴⍵)↑∧/¨(⍺-1),/¯1⌽1=-2-/⍵)⊢⍵}

Wow, điều này ... thật tệ. Có lẽ có một giải pháp ngắn hơn nhiều với stprint.

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

Gợi ý chơi golf chào mừng!