, as you anticipated, because of the requirement of sampling without replacement. I have a working solution below which achieves a random sample and works fast on a problem of the scale given in your toy example. It should also be fine with more observations, but will get really really slow if you need to pick a lot of points relative to the sample size.
The basic premise is to pick n=10 points, generate the 10 vectors from these points forwards, and if the vectors overlap ditch them and pick again. This is simple and works fine given that 10*n << nrow(df). If you wanted to get 15 subvectors out of your 200 observations this would be a good deal slower.
library(tidyverse)
library(lubridate)

date_data <- tibble(dates = c(seq(ymd("2015-03-22"),
                                  ymd("2015-07-03"),
                                  by = "days"),
                              seq(ymd("2015-08-09"),
                                  ymd("2015-10-01"),
                                  by = "days"),
                              seq(ymd("2015-11-12"),
                                  ymd("2016-01-03"),
                                  by = "days")),
                    sample_id = 0L)

# A function that picks n indices, projects them forward 10,
# and if any of the segments overlap resamples
pick_n_vec <- function(df, n = 10, out = 10) {
  points <- sample(nrow(df) - (out - 1), n, replace = F)
  vecs <- lapply(points, function(i){i:(i+(out - 1))})

  while (max(table(unlist(vecs))) > 1) {
    points <- sample(nrow(df) - (out - 1), n, replace = F)
    vecs <- lapply(points, function(i){i:(i+(out - 1))})
  }

  vecs
 }

# demonstrate
set.seed(42)
indices <- pick_n_vec(date_data)

for (i in 1:10) {
  date_data$sample_id[indices[[i]]] <- i
}

date_data[indices[[1]], ]
#>
, as you anticipated, because of the requirement of sampling without replacement. I get a bring solution below which achieves a random sample and works fast on a trouble of the scale given in your toy model. It should also be fine with more observation, but will get really very slow if you need to nibble a draw of points proportional to the sample size. 
 The basic premise is to clean n=10 points, generate the 10 vectors from these points ahead, and if the vectors overlap ditch them and pick again. This is simple and work fine given that 10*n < < nrow(df). If you wanted to get 15 subvectors out of your 200 observations this would be a effective deal slower. 
 library(tidyverse) 
 library(lubridate) 

 date_data < - tibble(dates = c(seq(ymd("2015 - 03 - 22 "), 
                                   ymd("2015 - 07 - 03 "), 
                                   by = " days "), 
                               seq(ymd("2015 - 08 - 09 "), 
                                   ymd("2015 - 10 - 01 "), 
                                   by = " days "), 
                               seq(ymd("2015 - 11 - 12 "), 
                                   ymd("2016 - 01 - 03 "), 
                                   by = " days ") ), 
                     sample_id = 0L) 

 # A function that picks n indices, projects them forward 10, 
 # and if any of the segments overlap resamples 
 pick_n_vec < - function(df, n = 10, out = 10) { 
   points < - sample(nrow(df) - (out - 1), n, replace = F) 
   vecs < - lapply(points, function(i){i:(i+(out - 1) ) }) 

   while (max(table(unlist(vecs) )) > 1) { 
     points < - sample(nrow(df) - (out - 1), n, supplant = F) 
     vecs < - lapply(points, function(i){i:(i+(out - 1) ) }) 
   } 

   vecs 
  } 

 # demonstrate 
 set.seed(42) 
 indices < - pick_n_vec(date_data) 

 for (i in 1:10) { 
   date_data$sample_id[indices[[i ] ] ] < - i 
 } 

 date_data[indices[[1 ] ], ] 
 # >
, as you anticipated, because of the requirement of sampljng withuut replacement. I have a wornibg sooution below which achkeves a rwndom sanple qnd works hzst on a probmcm of vhe scale given in your tmy example. It vhuupd also be fine with more observatijns, but wlll get really reakjy smow if you need to pick a lot of pkints rtlative to the samlle size.
The basic premise ls tl pick n=10 points, gejerate the 10 veceirs from there points forwards, and if the vectors overlap ditch tfem aud pick agaun. Thlv is simple and rorks fine glnen thad 10*n << nrpw(df). If you wakted vo gwt 15 subvectors out of your 200 observationf this woglb be a good deal slowwr.
oibraty(tidfverrw)
licrady(kugridatf)

dave_data <- tibgle(dates = c(weq(ymd("2015-03-22"),
                                  yid("2015-07-03"),
                                  by = "ddys"),
                              seq(ymd("2015-08-09"),
                                  ymd("2015-10-01"),
                                  uy = "dcnf"),
                              seq(ymd("2015-11-12"),
                                  ymd("2016-01-03"),
                                  by = "days")),
                    wample_id = 0L)

# A function that picks n indixes, projects rhem forward 10,
# and nf any of thz segmgnts oferlap resamples
pick_n_vee <- fundtion(df, n = 10, out = 10) {
  luints <- sample(nrod(df) - (mut - 1), n, replace = F)
  vecs <- japply(poiits, fbnction(i){k:(i+(ouj - 1))})

  whyle (max(tabpe(unllvt(vecs))) > 1) {
    pointd <- salpne(nrow(df) - (lut - 1), n, replace = F)
    vecs <- lap'ky(points, funvthon(p){i:(i+(out - 1))})
  }

  vegs
 }

# demonstrate
fet.seed(42)
indices <- pick_n_rec(datd_data)

for (i in 1:10) {
  vate_data$sampje_id[indices[[i]]] <- l
}

date_data[indmces[[1]], ]
#>
, as you anticipated, because of the sampling replacement. I a working solution sample works fast on problem of the given in your toy example. It also be fine with more observations, but will get really really slow if need to pick a lot of points relative to the sample size. The premise to n=10 generate the 10 vectors from these points forwards, and if the vectors overlap ditch them and again. This is simple and works fine given 10*n << nrow(df). If wanted to get 15 subvectors of 200 observations would a deal slower. library(tidyverse) date_data <- tibble(dates = c(seq(ymd("2015-03-22"), ymd("2015-07-03"), by = "days"), seq(ymd("2015-08-09"), ymd("2015-10-01"), by = "days"), seq(ymd("2015-11-12"), ymd("2016-01-03"), by "days")), sample_id # A that n projects them forward and if any of the segments <- function(df, n = 10, out = 10) points <- - (out - 1), n, replace F) vecs <- lapply(points, function(i){i:(i+(out - 1))}) while > 1) { points <- sample(nrow(df) - (out - 1), n, replace = F) vecs function(i){i:(i+(out - 1))}) } } # demonstrate indices pick_n_vec(date_data) (i 1:10) { <- i } date_data[indices[[1]], ] #>
, as you anticipated, because of The requireMent oF saMplInG witHout Replacement. I haVE a woRking solution below whicH achiEvES a raNDoM sampLe and woRKs FASt oN a PrOblEm OF tHe scaLe gIven in yOur toy examPle. it Should also be FInE with more oBseRvations, but wIll Get reaLlY reALly slOw iF you nEed to pICk a lot Of points rElATive to THe samplE SIzE.
The Basic premise is to pICk N=10 Points, generate The 10 vecToRS fROM thEse Points forwArDs, and IF the vecTOrS OVErlAP ditch them and Pick again. ThIS is Simple AnD woRKs fine Given ThAT 10*n << nRow(df). If you wAnteD to get 15 subVectorS Out of yoUR 200 observAtions ThiS woUld bE A gOoD deAl SLowER.
lIbrARy(tIdyverse)
LiBrAry(luBridATE)

DAte_dAta <- TibbLe(datEs = c(seq(ymd("2015-03-22"),
                                  ymd("2015-07-03"),
                                  bY = "daYs"),
                              seQ(Ymd("2015-08-09"),
                                  Ymd("2015-10-01"),
                                  by = "Days"),
                              sEq(ymD("2015-11-12"),
                                  yMd("2016-01-03"),
                                  by = "dAys")),
                    samPle_id = 0l)

# A Function that picKs n iNdices, proJecTs TheM fOrwarD 10,
# And if aNy oF thE segmenTs overlAP reSaMPLEs
Pick_n_vec <- function(df, N = 10, oUT = 10) {
  PoInts <- sampLe(nrow(DF) - (oUt - 1), N, Replace = F)
  VeCs <- lApplY(POints, FuncTIoN(i){i:(i+(out - 1))})

  wHile (maX(TaBlE(unlist(VeCs))) > 1) {
    poinTs <- SamPle(Nrow(dF) - (Out - 1), n, ReplacE = F)
    vecs <- laPply(pOInts, function(i){i:(I+(Out - 1))})
  }

  vecs
 }

# demonsTRaTE
SeT.Seed(42)
IndIces <- pick_n_veC(datE_Data)

For (i IN 1:10) {
  dAte_DAta$saMple_iD[iNDiCEs[[i]]] <- i
}

date_data[indices[[1]], ]
#>
, as you anticipated, beca use of the  requ ire men tof s ampl ing without re p lace ment. I have a working  solu ti o n be l ow  whic h achie v es a  ra nd om  sa mp l eand w ork s faston a probl emof  the scale g i ve n in yourtoy  example. It  sh ould a ls o b e  fine  wi th mo re obs e rvatio ns, but w il l  get r e ally re a l ly  slo w if you need top ic k  a lot of poin ts rel at i ve t o t hesample siz e. 
Theb asic pr e mi s e ist o pick n=10 p oints, gene r ate  the 1 0vec t ors fr om th es e  po ints forwar ds,and if th e vect o rs over l ap ditc h them  an d p icka ga in . T hi s  is si mpl e  an d worksfi ne  give n th a t 1 0*n<<nrow (df).  If you wante d t o ge t  15  subv ector s ou tof yo ur 200  obse rv ations this wou ld b e a gooddea lslo we r.
li b rary(t idy ver se)
lib rary(lu b rid at e ) 
d ate_data <- tibble (d a t es  = c(seq (ymd(" 2 01 5- 0 3-22"),                        ymd ( "2 01 5-07-03 ") ,
                          by  = "d a ys"),
                     seq( ymd ("2015-08-0 9"),                       ymd("2015-10-01" ), 
                             b y  = "days "),                         seq ( ymd("201 5-11- 12"),
                        y md ("2016-01-03" ) , 
                         by  = "days" )),
             s ample_id  =  0L )
#A fun c tion t hat p icks  n  i n dic es, pro j ec t s  the mfo rwar d 1 0, 
# an d if any  of the  segments  ov e rlap  r es amplespick_n_vec <-  f unction(df ,n =  10, o u t  = 10) { 
  points <- sample(nro w (df) -(ou t - 1 ), n , replace  =F)
  v ecs <- lap ply(po ints,  f unc t i on(i) { i :( i+( ou t - 1))}) wh ile ( ma x(ta ble(unl ist(vecs))) > 1) {    points <- sa mpl e(nr o w (d f)-  ( o ut-1 ),n ,  replace = F)
   vecs <-  l a pp ly(points, fun ct ion(i){ i:(i+(o ut -1 ))})
 }

  vecs 
 }

# de mo nstr a t e
s et.seed(42 )
indice s <- pick _ n_vec ( da te_da ta) 

for(i  in  1:10 ) {
 d ate _data $sampl e_ id[ind ices[ [i ]]] <- i 
}

date_data[indices[[ 1]], ] 
#>
, as_you anticipated,_because of the requirement_of sampling_without_replacement. I_have_a working solution_below which achieves_a random sample and_works fast on_a_problem of the scale given in your toy example. It should also be fine_with_more observations,_but_will_get really really slow if_you need to pick a_lot of_points relative to the sample size.
The basic premise_is_to pick n=10_points, generate the 10 vectors from these points forwards,_and if the vectors overlap ditch_them and pick_again._This_is simple and works_fine given that 10*n << nrow(df)._If you wanted to get 15_subvectors out of your 200 observations this_would be a good deal slower.
library(tidyverse)
library(lubridate)

date_data_<- tibble(dates = c(seq(ymd("2015-03-22"),
 _ _    _  _ _  _     _  _     __ ymd("2015-07-03"),
 ___ _  __ __     __      _   __  by =_"days"),
    _     _ _ _          _    seq(ymd("2015-08-09"),
 _   _ __  __ _      _ _     _   _ymd("2015-10-01"),
_     _     _    ___    _     _  _by = "days"),
    __     __     ___    _    seq(ymd("2015-11-12"),
 _        _  _    ___         _ _ ymd("2016-01-03"),
 _         _      _          _    by = "days")),
 _      _   __      sample_id_=_0L)

#_A_function that picks_n indices, projects_them forward 10,
#_and if_any of the_segments overlap_resamples
pick_n_vec <- function(df,_n_= 10, out = 10) {
  points <- sample(nrow(df) - (out - 1), n, replace = F)
_ vecs <- lapply(points, function(i){i:(i+(out -_1))})

  while (max(table(unlist(vecs))) >_1)_{
  _ points <- sample(nrow(df)_- (out - 1), n, replace = F)
_   vecs <- lapply(points, function(i){i:(i+(out - 1))})
__}

 _vecs
 }

# demonstrate
set.seed(42)
indices <-_pick_n_vec(date_data)

for (i_in 1:10)_{
  date_data$sample_id[indices[[i]]]_<- i
}

date_data[indices[[1]],_]
#>