Tugas Anda di sini sederhana:

Diberikan daftar set bilangan bulat, temukan serikat set. Dengan kata lain, temukan daftar terpendek dari himpunan integer yang berisi semua elemen dalam daftar himpunan asli (tetapi tidak ada elemen lain). Sebagai contoh:

[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

Set diberi notasi menggunakan notasi rentang: [1,4]berarti bilangan bulat 1,2,3,4. Set juga bisa tidak dibatasi: [3,]berarti semua bilangan bulat >= 3, dan [,-1]berarti semua bilangan bulat <= -1. Dijamin bahwa elemen pertama dari jangkauan tidak akan lebih besar dari yang kedua.

Anda dapat memilih untuk mengambil set dalam notasi string, atau Anda dapat menggunakan 2-elemen tupel, menggunakan konstanta non-integer sebagai nilai "tak terbatas". Anda dapat menggunakan dua konstanta berbeda untuk mewakili batas atas tak terbatas dan batas bawah tak terbatas. Misalnya, dalam Javascript, Anda bisa menggunakan [3,{}]untuk memberi tahu semua bilangan bulat >= 3, selama Anda secara konsisten digunakan {}di semua kasus uji.

Kasus uji:

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

Ini kode-golf , jadi buat jawaban Anda sesingkat mungkin!

R + intervals, 90 87 81 byte

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

Cobalah online!

Input adalah daftar interval. -InfdanInf merupakan R bawaan untuk minus / plus tak terhingga. Output adalah matriks kolom interval.

Tidak biasanya penggemar menggunakan perpustakaan non-standar tapi yang ini menyenangkan. TIO belum intervalsdiinstal. Anda dapat mencobanya di instalasi Anda sendiri atau di https://rdrr.io/snippets/

The intervalspaket dukungan nyata dan integer ( type = "Z"interval) dan reducefungsi built-in untuk apa yang diinginkan tantangan, tapi output tampaknya default ke interval terbuka, sehingga diperlukan untuk mendapatkan hasil yang diinginkan.close_intervals +c(1,-1)

Versi lama memiliki contoh dalam daftar daftar yang mungkin nyaman jadi saya meninggalkan tautan di sini.

JavaScript (ES6), 103 byte

Disimpan 1 byte berkat @Shaggy
1 byte disimpan berkat @KevinCruijssen

Berharap +/-Infinityuntuk nilai yang tak terbatas.

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)

Cobalah online!

Bagaimana?

Kami pertama-tama menyortir interval berdasarkan batas bawahnya, dari terendah ke tertinggi. Batas atas diabaikan.

$[p_n,q_n]$$m$$M$$p_1$$q_1$ masing-masing .

$[p_n,q_n]$

• $p_n\le M+1$$M$$\max(M,q_n)$
• $[m,M]$$m$$M$$p_n$$q_n$

$[m,M]$

Berkomentar

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

Disimpan satu byte terima kasih kepada Mr.Xcoder, satu terima kasih kepada Jonathan Frech, dan tiga terima kasih untuk Dead Possum.
Cobalah online!

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

Cobalah online!

Urutkan array, lalu ratakan dengan menambahkan semua rentang ke yang pertama: jika rentang tumpang tindih dengan yang sebelumnya, buang 2 elemen dari 3 yang terakhir (hanya maks.)

Batalkan semuanya di akhir.

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;

Cobalah online!

Sebuah prosedur yang mengambil array dinamis dari catatan yang terdiri dari 2 batas jangkauan, memodifikasi array di tempat dan kemudian menulisnya pada output standar, satu rentang per baris. (Maaf untuk kalimat bengkok itu.) Penggunaan 1/0untuk ubounded dan-1/0 down.

Versi yang mudah dibaca

Akan menyenangkan untuk hanya mengembalikan array dengan jumlah elemen yang dikoreksi, tetapi array dinamis yang diteruskan ke fungsi / prosedur bukan array dinamis lagi ... Pertama saya menemukan ini , maka ada penjelasan yang sangat baik dan membingungkan .

Ini adalah struktur data terbaik yang bisa saya temukan untuk memperpendek kode. Jika Anda memiliki pilihan yang lebih baik, jangan ragu untuk memberikan saran.

Bahasa Wolfram (Mathematica) , 57 byte

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

Cobalah online!

Mengambil input sebagai daftar daftar yang {a,b}mewakili interval [a,b], di mana abisa -Infinitydan bbisa Infinity.

Menggunakan built-in IntervalUnion, tapi tentu saja kita harus memijat interval ke dalam bentuk terlebih dahulu. Untuk berpura-pura bahwa intervalnya adalah bilangan bulat, kami menambahkan 1 ke batas atas (memastikan bahwa penyatuan dari [1,3]dan [4,9]adalah [1,9]). Pada akhirnya, kami membatalkan operasi ini, dan mengubah hasilnya menjadi daftar daftar.

Ada juga pendekatan yang sama sekali berbeda, yang menggunakan 73 byte :

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

Di sini, setelah menyortir interval, kami hanya mengganti dua interval berturut-turut dengan penyatuan mereka setiap kali itu akan menjadi interval tunggal, dan ulangi sampai tidak ada operasi yang tersisa untuk dilakukan.

05AB1E (legacy) , 88 79 78 byte

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

Infinity adalah input sebagai huruf kecil ( 'abcdefghijklmnopqrstuvwxyz').

Cobalah secara online atau verifikasi semua kasus uji .

Catatan penting: Jika ada aktual Infinitydan -Infinity, itu akan menjadi 43 42 byte sebagai gantinya. Jadi sedikit di atas 50% sekitar 30% adalah sebagai solusi untuk kurangnya Infinity..

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

Cobalah secara online (dengan Infinitydiganti dengan 9999999999dan -Infinitydiganti dengan -9999999999).

Pasti bisa bermain golf secara substansial. Pada akhirnya itu ternyata sangat, sangat buruk, penuh dengan penyelesaian masalah. Tapi untuk saat ini saya senang bekerja.

Penjelasan:

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 (dentang) , 346 342 byte

Compiler bendera -DP=printf("(%d,%d)\n", -DB=a[i+1]dan-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);}

Cobalah online!

Stax , 46 39 byte

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

Jalankan dan debug itu

Program ini mengambil input dalam notasi string yang ditentukan sebelumnya.