Nhiệm vụ của bạn ở đây rất đơn giản:

Đưa ra một danh sách các bộ số nguyên, tìm tập hợp. Nói cách khác, tìm danh sách ngắn nhất của các bộ số nguyên có chứa tất cả các phần tử trong danh sách gốc của bộ (nhưng không có phần tử nào khác). Ví dụ:

[1,5] and [3,9] becomes [1,9] as it contains all of the elements in both [1,5] and [3,9]
[1,3] and [5,9] stays as [1,3] and [5,9], because you don't want to include 4

Các bộ được ký hiệu bằng cách sử dụng ký hiệu phạm vi: [1,4]có nghĩa là các số nguyên 1,2,3,4. Các bộ cũng có thể không bị ràng buộc: [3,]có nghĩa là tất cả các số nguyên >= 3và [,-1]có nghĩa là tất cả các số nguyên <= -1. Nó được đảm bảo rằng phần tử đầu tiên của phạm vi sẽ không lớn hơn phần tử thứ hai.

Bạn có thể chọn lấy các tập hợp trong ký hiệu chuỗi hoặc bạn có thể sử dụng bộ dữ liệu 2 phần tử, sử dụng giá trị không nguyên không đổi làm giá trị "vô hạn". Bạn có thể sử dụng hai hằng số riêng biệt để biểu thị giới hạn trên vô hạn và giới hạn dưới vô hạn. Ví dụ: trong Javascript, bạn có thể sử dụng [3,{}]để ghi chú tất cả các số nguyên >= 3, miễn là bạn luôn sử dụng {}trong tất cả các trường hợp kiểm tra.

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

[1,3]                     => [1,3]
[1,]                      => [1,]
[,9]                      => [,9]
[,]                       => [,]
[1,3],[4,9]               => [1,9]
[1,5],[8,9]               => [1,5],[8,9]
[1,5],[1,5]               => [1,5]
[1,5],[3,7]               => [1,7]
[-10,7],[1,5]             => [-10,7]
[1,1],[2,2],[3,3]         => [1,3]
[3,7],[1,5]               => [1,7]
[1,4],[8,]                => [1,4],[8,]
[1,4],[-1,]               => [-1,]
[1,4],[,5]                => [,5]
[1,4],[,-10]              => [1,4],[,-10]
[1,4],[,]                 => [,]
[1,4],[3,7],[8,9],[11,20] => [1,9],[11,20]

Đây là môn đánh gôn , vì vậy hãy trả lời ngắn gọn nhất có thể!

R + intervals, 90 87 81 byte

function(...)t(reduce(Intervals(rbind(...),type="Z")))+c(1,-1)
library(intervals)

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

Đầu vào là một danh sách các khoảng. -InfvàInf được tích hợp R cho âm / cộng vô cực. Đầu ra là một ma trận các cột của các khoảng.

Không thường là một người hâm mộ sử dụng các thư viện không chuẩn nhưng cái này rất thú vị. TIO chưa intervalscài đặt. Bạn có thể dùng thử trên bản cài đặt của riêng bạn hoặc tại https://rdrr.io/snippets/

Các intervalshỗ trợ gói thực và số nguyên ( type = "Z") khoảng và reducechức năng là một built-in cho những gì thách thức muốn, nhưng sản lượng dường như mặc định khoảng thời gian mở, vì vậy là cần thiết để có được kết quả mong muốn.close_intervals +c(1,-1)

Phiên bản cũ có các ví dụ trong danh sách các danh sách có thể thuận tiện nên tôi đã để lại liên kết ở đây.

JavaScript (ES6), 103 byte

Đã lưu 1 byte nhờ @Shaggy
Lưu 1 byte nhờ @KevinCruijssen

Mong đợi +/-Infinity đợi cho các giá trị vô hạn.

a=>(a.sort(([p],[P])=>p-P).map(m=M=([p,q])=>p<M+2?M=q>M?q:M:(b.push([m,M]),m=p,M=q),b=[]),b[0]=[m,M],b)

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

Làm sao?

Trước tiên chúng tôi sắp xếp các khoảng theo giới hạn dưới của chúng, từ thấp nhất đến cao nhất. Giới hạn trên được bỏ qua.

Sau đó, chúng tôi lặp lại các khoảng được sắp xếp $[p_n,q_n]$ , trong khi theo dõi các giới hạn dưới và trên hiện tại $m$ và $M$ , được khởi tạo cho $p_1$ và $q_1$ lần lượt là .

Đối với mỗi khoảng $[p_n,q_n]$ :

• Nếu $p_n\le M+1$ : khoảng này có thể được hợp nhất với các khoảng trước đó. Nhưng chúng tôi có thể có giới hạn trên mới, vì vậy chúng tôi cập nhật $M$ lên $\max(M,q_n)$ .
• Mặt khác: có một khoảng cách giữa các khoảng trước và khoảng này. Chúng tôi tạo một khoảng mới $[m,M]$ và cập nhật $m$ và $M$ thành $p_n$ và $q_n$ tương ứng.

Khi kết thúc quá trình, chúng ta tạo một khoảng cuối cùng với giới hạn hiện tại $[m,M]$ .

Đã bình luận

a => (                  // a[] = input array
  a.sort(([p], [P]) =>  // sort the intervals by their lower bound; we do not care about
    p - P)              // the upper bounds for now
  .map(m = M =          // initialize m and M to non-numeric values
    ([p, q]) =>         // for each interval [p, q] in a[]:
    p < M + 2 ?         //   if M is a number and p is less than or equal to M + 1:
      M = q > M ? q : M //     update the maximum M to max(M, q)
    : (                 //   else (we've found a gap, or this is the 1st iteration):
      b.push([m, M]),   //     push the interval [m, M] in b[]
      m = p,            //     update the minimum m to p
      M = q             //     update the maximum M to q
    ),                  //
    b = []              //   start with b[] = empty array
  ),                    // end of map()
  b[0] = [m, M], b      // overwrite the 1st entry of b[] with the last interval [m, M]
)                       // and return the final result

Python 2 , 118 113 112 111 106 105 104 101 byte

x=input()
x.sort();a=[];b,c=x[0]
for l,r in x:
 if l>c+1:a+=(b,c),;b,c=l,r
 c=max(c,r)
print[(b,c)]+a

Tiết kiệm được một byte nhờ Mr.Xcoder, một cảm ơn Jonathan Frech và ba cảm ơn Dead Possum.
Hãy thử trực tuyến!

Ruby , 89 76 byte

->a{[*a.sort.reduce{|s,y|s+=y;y[0]-s[-3]<2&&s[-3,3]=s.max;s}.each_slice(2)]}

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

Sắp xếp mảng, sau đó làm phẳng bằng cách nối tất cả các phạm vi vào đầu tiên: nếu một phạm vi chồng lấp lên trước đó, loại bỏ 2 phần tử từ 3 cuối cùng (chỉ giữ tối đa).

Hủy kết thúc mọi thứ ở cuối.

Pascal (FPC) , 367 362 357 byte

uses math;type r=record a,b:real end;procedure d(a:array of r);var i,j:word;t:r;begin for i:=0to length(a)-1do for j:=0to i do if a[i].a<a[j].a then begin t:=a[i];a[i]:=a[j];a[j]:=t;end;j:=0;for i:=1to length(a)-1do if a[j].b>=a[i].a-1then begin a[j].a:=min(a[i].a,a[j].a);a[j].b:=max(a[i].b,a[j].b)end else j:=j+1;for i:=0to j do writeln(a[i].a,a[i].b)end;

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

Một thủ tục lấy một mảng các bản ghi động gồm 2 giới hạn phạm vi, sửa đổi mảng tại chỗ và sau đó ghi nó vào đầu ra tiêu chuẩn, một phạm vi trên mỗi dòng. (Xin lỗi vì câu vặn vẹo đó.) Sử dụng 1/0cho ubounded lên và -1/0không bị ràng buộc xuống.

Phiên bản dễ đọc

Sẽ thật tuyệt khi chỉ trả về mảng với số phần tử đã được sửa, nhưng mảng động được truyền cho hàm / thủ tục không phải là mảng động nữa ... Đầu tiên tôi tìm thấy điều này , sau đó là lời giải thích tuyệt vời, không thể tin được .

Đây là cấu trúc dữ liệu tốt nhất tôi có thể tìm thấy để rút ngắn mã. Nếu bạn có lựa chọn tốt hơn, hãy thoải mái đưa ra gợi ý.

Ngôn ngữ Wolfram (Mathicala) , 57 byte

List@@(#-{0,1}&/@IntervalUnion@@(Interval[#+{0,1}]&/@#))&

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

Lấy đầu vào là một danh sách các danh sách {a,b}đại diện cho khoảng [a,b], nơi acó thể -Infinityvà bcó thể Infinity.

Sử dụng tích hợp sẵn IntervalUnion, nhưng tất nhiên chúng ta phải xoa bóp các khoảng thành hình trước tiên. Để giả vờ rằng các khoảng là số nguyên, chúng ta thêm 1 vào giới hạn trên (đảm bảo rằng liên kết của [1,3]và [4,9]là [1,9]). Cuối cùng, chúng tôi hoàn tác thao tác này và biến kết quả trở lại thành một danh sách các danh sách.

Ngoài ra còn có một cách tiếp cận hoàn toàn khác, với xung nhịp 73 byte :

NumericalSort@#//.{x___,{a_,b_},{c_,d_},y___}/;b+1>=c:>{x,{a,b~Max~d},y}&

Ở đây, sau khi sắp xếp các khoảng, chúng ta chỉ cần thay thế hai khoảng liên tiếp bằng liên kết của chúng bất cứ khi nào đó là một khoảng duy nhất và lặp lại cho đến khi không còn thao tác nào như vậy nữa.

05AB1E (di sản) , 88 79 78 byte

g≠i˜AKïDW<UZ>VIøεAXY‚Nè:}ïø{©˜¦2ôíÆ1›.œʒíεćsO_*}P}н€g®£εø©θàDYQiA}V®нßDXQiA}Y‚

Infinity là đầu vào dưới dạng bảng chữ cái chữ thường ( 'abcdefghijklmnopqrstuvwxyz').

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Lưu ý quan trọng: Nếu có một thực tế Infinityvà -Infinity, nó sẽ có 43 42 byte thay thế. Vì vậy, ít hơn 50% khoảng 30% là giải quyết vấn đề thiếu Infinity..

{©Dg≠i˜¦2ôíÆ1›.œʒíεćsO_*}P}н€g®£εø©θàV®нßY‚

Hãy thử trực tuyến (với Infinitythay thế bằng 9999999999và -Infinitythay thế bằng -9999999999).

Chắc chắn có thể được đánh golf đáng kể. Cuối cùng, nó bật ra rất, rất xấu xí đầy cách giải quyết. Nhưng bây giờ tôi chỉ vui mừng vì nó hoạt động.

Giải trình:

Dg≠i          # If the length of the implicit input is NOT 1:
              #   i.e. [[1,3]] → length 1 → 0 (falsey)
              #   i.e. [[1,4],["a..z",-5],[3,7],[38,40],[8,9],[11,20],[25,"a..z"],[15,23]]
              #    → length 8 → 1 (truthy)
    ˜         #  Take the input implicit again, and flatten it
              #   i.e. [[1,4],["a..z",-5],[3,7],[38,40],[8,9],[11,20],[25,"a..z"],[15,23]]
              #    → [1,4,"a..z",-5,3,7,38,40,8,9,11,20,25,"a..z",15,23]
     AK       #  Remove the alphabet
              #   i.e. [1,4,"a..z",-5,3,7,38,40,8,9,11,20,25,"a..z",15,23]
              #    → ['1','4','-5','3','7','38','40','8','9','11','20','25','15','23']
       ï      #  Cast everything to an integer, because `K` turns them into strings..
              #   i.e. ['1','4','-5','3','7','38','40','8','9','11','20','25','15','23']
              #    → [1,4,-5,3,7,38,40,8,9,11,20,25,15,23]
        D     #  Duplicate it
         W<   #  Determine the min - 1
              #   i.e. [1,4,-5,3,7,38,40,8,9,11,20,25,15,23] → -5
           U  #  Pop and store it in variable `X`
         Z>   #  Determine the max + 1
              #   i.e. [1,4,-5,3,7,38,40,8,9,11,20,25,15,23] → 40
           V  #  Pop and store it in variable `Y`
Iø            #  Take the input again, and transpose/zip it (swapping rows and columns)
              #   i.e. [[1,4],["a..z",-5],[3,7],[38,40],[8,9],[11,20],[25,"a..z"],[15,23]]
              #    → [[1,'a..z',3,38,8,11,25,15],[4,-5,7,40,9,20,'a..z',23]]
  ε       }   #  Map both to:
   A          #   Push the lowercase alphabet
    XY‚       #   Push variables `X` and `Y`, and pair them into a list
       Nè     #   Index into this list, based on the index of the mapping
         :    #   Replace every alphabet with this min-1 or max+1
              #   i.e. [[1,'a..z',3,38,8,11,25,15],[4,-5,7,40,9,20,'a..z',23]]
              #    → [['1','-6','3','38','8','11','25','15'],['4','-5','7','40','9','20','41','23']]
ï             #  Cast everything to integers again, because `:` turns them into strings..
              #   i.e. [['1','-6','3','38','8','11','25','15'],['4','-5','7','40','9','20','41','23']]
              #    → [[1,-6,3,38,8,11,25,15],[4,-5,7,40,9,20,41,23]]
 ø            #  Now zip/transpose back again
              #   i.e. [[1,-6,3,38,8,11,25,15],[4,-5,7,40,9,20,41,23]]
              #    → [[1,4],[-6,-5],[3,7],[38,40],[8,9],[11,20],[25,41],[15,23]]
  {           #  Sort the pairs based on their lower range (the first number)
              #   i.e. [[1,4],[-6,-5],[3,7],[38,40],[8,9],[11,20],[25,41],[15,23]]
              #    → [[-6,-5],[1,4],[3,7],[8,9],[11,20],[15,23],[25,41],[38,40]]
   ©          #  Store it in the register (without popping)
˜             #  Flatten the list
              #   i.e. [[-6,-5],[1,4],[3,7],[8,9],[11,20],[15,23],[25,41],[38,40]]
              #    → [-6,-5,1,4,3,7,8,9,11,20,15,23,25,41,38,40]
 ¦            #  And remove the first item
              #   i.e. [-6,-5,1,4,3,7,8,9,11,20,15,23,25,41,38,40]
              #    → [-5,1,4,3,7,8,9,11,20,15,23,25,41,38,40]
  2ô          #  Then pair every two elements together
              #   i.e. [-5,1,4,3,7,8,9,11,20,15,23,25,41,38,40]
              #    → [[-5,1],[4,3],[7,8],[9,11],[20,15],[23,25],[41,38],[40]]
    í         #  Reverse each pair
              #   i.e. [[-5,1],[4,3],[7,8],[9,11],[20,15],[23,25],[41,38],[40]]
              #    → [[1,-5],[3,4],[8,7],[11,9],[15,20],[25,23],[38,41],[40]]
     Æ        #  Take the difference of each pair (by subtracting)
              #   i.e. [[1,-5],[3,4],[8,7],[11,9],[15,20],[25,23],[38,41],[40]]
              #    → [6,-1,1,2,-5,2,-3,40]
      1›      #  Determine for each if they're larger than 1
              #   i.e. [6,-1,1,2,-5,2,-3,40] → [1,0,0,1,0,1,0,1]
.œ            #  Create every possible partition of these values
              #   i.e. [1,0,0,1,0,1,0,1] → [[[1],[0],[0],[1],[0],[1],[0],[1]],
              #                             [[1],[0],[0],[1],[0],[1],[0,1]],
              #                             ...,
              #                             [[1,0,0,1,0,1,0],[1]],
              #                             [[1,0,0,1,0,1,0,1]]]
  ʒ         } #  Filter the partitions by:
   í          #   Reverse each inner partition
              #    i.e. [[1],[0,0,1],[0,1],[0,1]] → [[1],[1,0,0],[1,0],[1,0]]
    ε     }   #   Map each partition to:
     ć        #    Head extracted
              #     i.e. [1,0,0] → [0,0] and 1
              #     i.e. [1] → [] and 1
              #     i.e. [1,0,1] → [1,0] and 1
      s       #    Swap so the rest of the list is at the top of the stack again
       O      #    Take its sum
              #     i.e. [0,0] → 0
              #     i.e. [] → 0
              #     i.e. [1,0] → 1
        _     #    And check if it's exactly 0
              #     i.e. 0 → 1 (truthy)
              #     i.e. 1 → 0 (falsey)
         *    #    And multiply it with the extracted head
              #    (is only 1 when the partition has a single trailing 1 and everything else a 0)
              #     i.e. 1 and 1 → 1 (truthy)
              #     i.e. 1 and 0 → 0 (falsey)
           P  #   And check if all mapped partitions are 1
н             #  Take the head (there should only be one valid partition left)
              #   i.e. [[[1],[0,0,1],[0,1],[0,1]]] → [[1],[0,0,1],[0,1],[0,1]]
 €g           #  Take the length of each inner list
              #   i.e. [[1],[0,0,1],[0,1],[0,1]] → [1,3,2,2]
   ®          #  Push the sorted pairs we've saved in the register earlier
    £         #  Split the pairs into sizes equal to the partition-lengths
              #   i.e. [1,3,2,2] and [[-6,-5],[1,4],[3,7],[8,9],[11,20],[15,23],[25,41],[38,40]]
              #    → [[[-6,-5]],[[1,4],[3,7],[8,9]],[[11,20],[15,23]],[[25,41],[38,40]]]
ε             #  Map each list of pairs to:
 ø            #   Zip/transpose (swapping rows and columns)
              #    i.e. [[1,4],[3,7],[8,9]] → [[1,3,8],[4,7,9]]
              #    i.e. [[25,41],[38,40]] → [[25,38],[41,40]]
  ©           #   Store it in the register
   θ          #   Take the last list (the ending ranges)
              #    i.e. [[25,38],[41,40]] → [41,40]
    à         #   And determine the max
              #    i.e. [41,40] → 41
     DYQi }   #   If this max is equal to variable `Y`
              #     i.e. 41 (`Y` = 41) → 1 (truthy)
         A    #    Replace it back to the lowercase alphabet
           V  #   Store this max in variable `Y`
  ®           #   Take the zipped list from the register again
   н          #   This time take the first list (the starting ranges)
              #    i.e. [[25,38],[41,40]] → [25,38]
    ß         #   And determine the min
              #    i.e. [25,38] → 25
     DXQi }   #   If this min is equal to variable `X`
              #     i.e. 25 (`X` = -6) → 0 (falsey)
         A    #    Replace it back to the lowercase alphabet
           Y‚ #   And pair it up with variable `Y` (the max) to complete the mapping
              #    i.e. 25 and 'a..z' → [25,'a..z']
              #  Implicitly close the mapping (and output the result)
              #   i.e. [[[-6,-5]],[[1,4],[3,7],[8,9]],[[11,20],[15,23]],[[25,41],[38,40]]]
              #    → [['a..z',-5],[1,9],[11,23],[25,'a..z']]
              # Implicit else (only one pair in the input):
              #  Output the (implicit) input as is
              #   i.e. [[1,3]]

C (tiếng kêu) , 346 342 byte

Biên dịch những lá cờ -DP=printf("(%d,%d)\n", -DB=a[i+1]và-DA=a[i]

typedef struct{int a,b;}t;s(t**x,t**y){if((*x)->a>(*y)->a)return 1;else if((*x)->a<(*y)->a)return -1;}i;f(t**a){for(i=0;A;)i++;qsort(a,i,sizeof(t*),s);for(i=0;B;i++){if(B->a<=A->b+1){A->b=B->b;if(B->a<A->a)A->a=B->a;else B->a=A->a;}}for(i=0;A;i++){if(!B)break;if(A->a!=B->a)P,A->a,A->b);}P,A->a,A->b);}

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

Stax , 46 39 byte

ÿδ7│ⁿ╚╪║»ÿ1Wç♥├óπ◙+╣╝[á╬p£ß₧ΓÑ°♥ºië«4T╗

Chạy và gỡ lỗi nó

Chương trình này nhận đầu vào trong ký hiệu chuỗi được chỉ định ban đầu.