여기서 할 일은 간단합니다.

정수 세트 목록이 제공되면 세트 공용체를 찾으십시오. 즉, 원래 세트 목록의 모든 요소를 ​​포함하지만 다른 요소는 포함하지 않는 가장 짧은 정수 세트 목록을 찾으십시오. 예를 들면 다음과 같습니다.

[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

범위 표기법을 사용하여 집합에 표기 [1,4]합니다 1,2,3,4. 정수를 의미합니다 . 세트는 제한이 없습니다 : [3,]모든 정수 >= 3를 [,-1]의미하고 모든 정수 를 의미합니다 <= -1. 범위의 첫 번째 요소가 두 번째 요소보다 크지 않아야합니다.

문자열 표기법으로 집합을 선택하거나 정수가 아닌 상수를 "무한"값으로 사용하여 2 요소 튜플을 사용할 수 있습니다. 두 개의 다른 상수를 사용하여 무한한 상한과 무한한 하한을 나타낼 수 있습니다. 예를 들어, Javascript에서는 모든 테스트 사례에서 일관되게 사용 [3,{}]하는 한 모든 정수를 표기하는 데 사용할 수 있습니다 .>= 3{}

테스트 사례 :

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

이것은 code-golf 이므로 가능한 한 빨리 답변하십시오!

R + intervals, 90 87 81 바이트

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

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

입력은 간격 목록입니다. -Inf및 Inf마이너스 / 플러스 무한대 R 내장 된 기능입니다. 출력은 간격 열의 행렬입니다.

일반적으로 비표준 라이브러리를 사용하는 팬은 아니지만 재미있었습니다. TIO가 intervals설치 되지 않았습니다 . 자체 설치 또는 https://rdrr.io/snippets/ 에서 시도해 볼 수 있습니다

이 intervals패키지는 실수 및 정수 ( type = "Z") 간격을 지원하며이 reduce기능은 챌린지가 원하는 것을위한 내장 기능이지만 출력은 기본적으로 열린 간격으로 표시되므로 원하는 결과를 얻는 데 필요합니다.close_intervals +c(1,-1)

이전 버전에는 목록 목록에 예제 가있어 편리 할 수 ​​있으므로 여기 링크를 남겨 두었습니다.

자바 스크립트 (ES6), 103 바이트

@Shaggy 덕분에
1 바이트 절약 @KevinCruijssen 덕분에 1 바이트 절약

+/-Infinity무한한 값을 기대 합니다.

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)

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

방법?

먼저 가장 낮은 것에서 가장 높은 것까지의 하한을 기준으로 간격을 정렬합니다. 상한은 무시됩니다.

그런 다음 정렬 된 간격 $[p_n,q_n]$ 을 반복 하면서 현재 하한 및 상한을 추적합니다 $m$ 및 $M$ 각각 $p_1$ 및 $q_1$ 초기화합니다 .

각 간격 $[p_n,q_n]$ :

• 만약 $p_n\le M+1$ :이 간격은 이전 사람과 병합 할 수 있습니다. 그러나 우리는 새로운 상한을 가질 수 있으므로 $M$ 을 $\max(M,q_n)$ 합니다.
• 그렇지 않으면 : 이전 간격과이 간격 사이에 간격이 있습니다. 새로운 구간 $[m,M]$ 만들고 $m$ 업데이트 하고$M$$p_n$$q_n$

$[m,M]$

댓글

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

파이썬 (2) , 118 (113) 112 111 106 105 104 101 바이트

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

Xcoder 덕분에 1 바이트, Jonathan Frech 덕분에 1 바이트, Dead Possum 덕분에 3 바이트가 절약되었습니다.
온라인으로 사용해보십시오!

루비 , 89 76 바이트

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

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

배열을 정렬 한 다음 모든 범위를 첫 번째에 추가하여 병합합니다. 범위가 이전 범위와 겹치면 마지막 3 개에서 2 개의 요소를 버립니다 (최대 값 만 유지).

마지막에 모든 것을 푸십시오.

파스칼 (FPC) , 367 (362) 357 바이트

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;

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

2 개의 범위 경계로 구성된 동적 레코드 배열 을 가져 와서 배열 을 수정 한 다음 표준 출력 (한 줄에 하나씩)에 쓰는 절차입니다. (그 꼬인 문장이 유감입니다.)1/0 ubounded 및 -1/0unbounded down에 사용합니다.

읽을 수있는 버전

수정 된 수의 요소가있는 배열을 반환하는 것이 좋지만 함수 / 프로 시저에 전달 된 동적 배열은 더 이상 동적 배열이 아닙니다 ... 먼저 이것을 찾았습니다. 이 훌륭한 발견 이 있습니다 . .

이것은 코드를 단축하기 위해 찾은 최고의 데이터 구조입니다. 더 나은 옵션이 있으면 자유롭게 제안하십시오.

Wolfram Language (Mathematica) , 57 바이트

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

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

리스트의리스트로의 입력을 받아 {a,b}간격을 나타내는 [a,b]곳 a이 될 수 -Infinity와 b일 수Infinity .

내장을 사용 IntervalUnion하지만 물론 간격을 먼저 모양으로 마사지해야합니다. 간격은 정수이다 척하기 위해, 우리는 상한에 1을 추가 (의 결합 것을 확인 [1,3]하고 [4,9]있다[1,9] ). 마지막으로이 작업을 취소하고 결과를 목록 목록으로 되돌립니다.

완전히 다른 접근법도 있습니다. 73 바이트로 시계가 됩니다 .

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

여기서는 간격을 정렬 한 후 단일 간격 일 때마다 두 개의 연속 간격을 합집합으로 바꾸고 수행 할 작업이 없을 때까지 반복합니다.

05AB1E (레거시) , 88 79 78 바이트

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

무한대는 소문자 알파벳 ( 'abcdefghijklmnopqrstuvwxyz') 으로 입력됩니다 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

중요 사항 : 이 실제 인 경우 Infinity와 -Infinity, 그이었을 것입니다 (43) (42) 바이트 대신. 따라서 약 30 %의 약 50 % 가 Infinity..

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

온라인으로 시도 와 함께 ( Infinity대체 9999999999및 -Infinity교체-9999999999 ).

확실히 골프를 칠 수 있습니다. 결국 그것은 매우, 매우 추악한 해결 방법으로 가득했습니다. 그러나 지금은 그것이 작동하는 것이 기쁩니다.

설명:

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 (클랑) , 346 (342) 바이트

컴파일러 플래그 -DP=printf("(%d,%d)\n", -DB=a[i+1]및-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);}

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

Stax , 46 39 바이트

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

실행 및 디버깅

이 프로그램은 원래 지정된 문자열 표기법으로 입력을받습니다.