Creating new dataframe from list of lists

DBScan · April 21, 2020, 7:25pm

I want to create a new dataframe from a list with lists. My problem is that the code runs very slowly. I am a bit familiar with parApply etc., but I didn't manage to write this code with an apply function. The main problem I have is that I don't know how to access an other dataframe in apply and I also don't know how I create for instance new rows with apply. In this example I have a list "z" with two lists "x" and "y". Each of the sublists contains 3 to 10 elements. I want the final dataframe to have as many rows as elements in lists "z" times elements in all sublists.

x1 <- c("CCAAAAAT","GCAAAAAT","TCAAAAAT")
x2 <- c("CCAAAATT", "GCAAAATT", "TCAAAATT")
x3 <- c("CCAAAAGT", "GCAAAAGT", "TCAAAAGT")
x <- list(x1, x2, x3)
names(x) <- c("ACAAAAAT", "ACAAAATT", "ACAAAAGT")
x
#> $ACAAAAAT
#> [1] "CCAAAAAT" "GCAAAAAT" "TCAAAAAT"
#> 
#> $ACAAAATT
#> [1] "CCAAAATT" "GCAAAATT" "TCAAAATT"
#> 
#> $ACAAAAGT
#> [1] "CCAAAAGT" "GCAAAAGT" "TCAAAAGT"

y1 <- c("CAAATCAC","GAAATCAC","TAAATCAC")
y2 <- c("CAAATTAC", "GAAATTAC", "TAAATTAC")
y3 <- c("CAAATCAT", "GAAATCAT", "TAAATCAT")
y <- list(y1, y2, y3)
names(y) <- c("AAAATCAC", "AAAATTAC", "AAAATCAT")

z <- list(x,y)

d <-data.frame(matrix(, nrow = length(z), ncol = 0))
d$TF[1] <- "TF1"
d$TF[2] <- "TF1"

nr_rows <- sum(unname(unlist(lapply(z, length))))

df <- data.frame(matrix(, nrow = nr_rows, ncol = 3))
names(df) <- c("TF", "Pos", "Neighbour")

row <- 1
for (i in 1:length(z)){
  TF <- d$TF[[i]]
  names <- names(z[[i]])
  for (j in 1:length(z[[i]])){
    name <- names[[j]]
    neigh <- list(z[[i]][[j]])
    df$TF[[row]] <- TF
    df$Pos[[row]] <- name
    df$Neighbour[[row]] <- neigh
    row <- row + 1
  }
  print(i)
}
#> [1] 1
#> [1] 2
View(df)

^{Created on 2020-04-21 by the reprex package (v0.3.0)}

nirgrahamuk · April 22, 2020, 9:26am

I'm very hazy on what you are trying to achieve, its not clear to me what relationships x, y have to each other (or not) seems they are independent lists, each of which has 3 names for which each have declared neighbours.
Also I didn't see a principle by which TF would be numbered.
But I think you can approach it more simply perhaps something like this.
Run your code to make x and y , but at the point where you would make z <- list(x,y)
instead dont make z, but go straight to :


library(tidyverse)
enframe_and_name <- function(x){
  enframe(x,name = "Pos",value="Neighbour_list")
}
df2 <- union_all(enframe_and_name(x),
                 enframe_and_name(y)) %>% rowwise() %>% 
  mutate(Neighbour=paste0(Neighbour_list,collapse=","),
         "TF"="TF1")

result

 > df2
Source: local data frame [6 x 4]
Groups: <by row>

# A tibble: 6 x 4
  Pos      Neighbour_list Neighbour                  TF   
  <chr>    <list>         <chr>                      <chr>
1 ACAAAAAT <chr [3]>      CCAAAAAT,GCAAAAAT,TCAAAAAT TF1  
2 ACAAAATT <chr [3]>      CCAAAATT,GCAAAATT,TCAAAATT TF1  
3 ACAAAAGT <chr [3]>      CCAAAAGT,GCAAAAGT,TCAAAAGT TF1  
4 AAAATCAC <chr [3]>      CAAATCAC,GAAATCAC,TAAATCAC TF1  
5 AAAATTAC <chr [3]>      CAAATTAC,GAAATTAC,TAAATTAC TF1  
6 AAAATCAT <chr [3]>      CAAATCAT,GAAATCAT,TAAATCAT TF1

DBScan · April 22, 2020, 9:46am

Thank you for your answer. What I am trying to achieve is the following: I have a list (all_neighbours) with 81245 elements. Each entry of this list is also a list with 3-10 entries. Now I want a new dataframe with 4 columns: "TF", "Pos", "8mer", "Neighbours". The number of rows is given by 81245*(number of sublists). The entry in "TF" I get from another table, which has also 81245 rows. I tried to name the 81245 lists like this: names(all_neighbours) <- other_table$TF. "Pos" is just the list I am currently (from 1 to 81245) at. "8mer" is the name of each sublists. "Neighbour" is the value in each sublist.

Edit: How can I add another picture? I want to show the dataframe I get at the end.

nirgrahamuk · April 22, 2020, 10:02am

please do

dput(head(all_neighbours,n=5))
dput(head(TF,n=5))

and share the result with us.
This would provide us example data in the most straightforward way.

DBScan · April 22, 2020, 10:30am

Here are the ouputs:

dput(head(all_neighbours,n=5))
list(list(ACAAAAAT = c("CCAAAAAT", "GCAAAAAT", "TCAAAAAT", "AAAAAAAT", 
"AGAAAAAT", "ATAAAAAT", "ACCAAAAT", "ACGAAAAT", "ACTAAAAT", "ACACAAAT", 
"ACAGAAAT", "ACATAAAT", "ACAACAAT", "ACAAGAAT", "ACAATAAT", "ACAAACAT", 
"ACAAAGAT", "ACAAATAT", "ACAAAACT", "ACAAAAGT", "ACAAAATT", "ACAAAAAA", 
"ACAAAAAC", "ACAAAAAG"), ACAAAATT = c("CCAAAATT", "GCAAAATT", 
"TCAAAATT", "AAAAAATT", "AGAAAATT", "ATAAAATT", "ACCAAATT", "ACGAAATT", 
"ACTAAATT", "ACACAATT", "ACAGAATT", "ACATAATT", "ACAACATT", "ACAAGATT", 
"ACAATATT", "ACAAACTT", "ACAAAGTT", "ACAAATTT", "ACAAAAAT", "ACAAAACT", 
"ACAAAAGT", "ACAAAATA", "ACAAAATC", "ACAAAATG"), ACAAAAGT = c("CCAAAAGT", 
"GCAAAAGT", "TCAAAAGT", "AAAAAAGT", "AGAAAAGT", "ATAAAAGT", "ACCAAAGT", 
"ACGAAAGT", "ACTAAAGT", "ACACAAGT", "ACAGAAGT", "ACATAAGT", "ACAACAGT", 
"ACAAGAGT", "ACAATAGT", "ACAAACGT", "ACAAAGGT", "ACAAATGT", "ACAAAAAT", 
"ACAAAACT", "ACAAAATT", "ACAAAAGA", "ACAAAAGC", "ACAAAAGG")), 
    list(AAAATCAC = c("CAAATCAC", "GAAATCAC", "TAAATCAC", "ACAATCAC", 
    "AGAATCAC", "ATAATCAC", "AACATCAC", "AAGATCAC", "AATATCAC", 
    "AAACTCAC", "AAAGTCAC", "AAATTCAC", "AAAAACAC", "AAAACCAC", 
    "AAAAGCAC", "AAAATAAC", "AAAATGAC", "AAAATTAC", "AAAATCCC", 
    "AAAATCGC", "AAAATCTC", "AAAATCAA", "AAAATCAG", "AAAATCAT"
    ), AAAATTAC = c("CAAATTAC", "GAAATTAC", "TAAATTAC", "ACAATTAC", 
    "AGAATTAC", "ATAATTAC", "AACATTAC", "AAGATTAC", "AATATTAC", 
    "AAACTTAC", "AAAGTTAC", "AAATTTAC", "AAAAATAC", "AAAACTAC", 
    "AAAAGTAC", "AAAATAAC", "AAAATCAC", "AAAATGAC", "AAAATTCC", 
    "AAAATTGC", "AAAATTTC", "AAAATTAA", "AAAATTAG", "AAAATTAT"
    ), AAAATCAT = c("CAAATCAT", "GAAATCAT", "TAAATCAT", "ACAATCAT", 
    "AGAATCAT", "ATAATCAT", "AACATCAT", "AAGATCAT", "AATATCAT", 
    "AAACTCAT", "AAAGTCAT", "AAATTCAT", "AAAAACAT", "AAAACCAT", 
    "AAAAGCAT", "AAAATAAT", "AAAATGAT", "AAAATTAT", "AAAATCCT", 
    "AAAATCGT", "AAAATCTT", "AAAATCAA", "AAAATCAC", "AAAATCAG"
    )), list(ATTTTCTA = c("CTTTTCTA", "GTTTTCTA", "TTTTTCTA", 
    "AATTTCTA", "ACTTTCTA", "AGTTTCTA", "ATATTCTA", "ATCTTCTA", 
    "ATGTTCTA", "ATTATCTA", "ATTCTCTA", "ATTGTCTA", "ATTTACTA", 
    "ATTTCCTA", "ATTTGCTA", "ATTTTATA", "ATTTTGTA", "ATTTTTTA", 
    "ATTTTCAA", "ATTTTCCA", "ATTTTCGA", "ATTTTCTC", "ATTTTCTG", 
    "ATTTTCTT"), TTTTTCTA = c("ATTTTCTA", "CTTTTCTA", "GTTTTCTA", 
    "TATTTCTA", "TCTTTCTA", "TGTTTCTA", "TTATTCTA", "TTCTTCTA", 
    "TTGTTCTA", "TTTATCTA", "TTTCTCTA", "TTTGTCTA", "TTTTACTA", 
    "TTTTCCTA", "TTTTGCTA", "TTTTTATA", "TTTTTGTA", "TTTTTTTA", 
    "TTTTTCAA", "TTTTTCCA", "TTTTTCGA", "TTTTTCTC", "TTTTTCTG", 
    "TTTTTCTT"), ATTTTCAA = c("CTTTTCAA", "GTTTTCAA", "TTTTTCAA", 
    "AATTTCAA", "ACTTTCAA", "AGTTTCAA", "ATATTCAA", "ATCTTCAA", 
    "ATGTTCAA", "ATTATCAA", "ATTCTCAA", "ATTGTCAA", "ATTTACAA", 
    "ATTTCCAA", "ATTTGCAA", "ATTTTAAA", "ATTTTGAA", "ATTTTTAA", 
    "ATTTTCCA", "ATTTTCGA", "ATTTTCTA", "ATTTTCAC", "ATTTTCAG", 
    "ATTTTCAT"), ATCTTCTA = c("CTCTTCTA", "GTCTTCTA", "TTCTTCTA", 
    "AACTTCTA", "ACCTTCTA", "AGCTTCTA", "ATATTCTA", "ATGTTCTA", 
    "ATTTTCTA", "ATCATCTA", "ATCCTCTA", "ATCGTCTA", "ATCTACTA", 
    "ATCTCCTA", "ATCTGCTA", "ATCTTATA", "ATCTTGTA", "ATCTTTTA", 
    "ATCTTCAA", "ATCTTCCA", "ATCTTCGA", "ATCTTCTC", "ATCTTCTG", 
    "ATCTTCTT"), TTATTCTA = c("ATATTCTA", "CTATTCTA", "GTATTCTA", 
    "TAATTCTA", "TCATTCTA", "TGATTCTA", "TTCTTCTA", "TTGTTCTA", 
    "TTTTTCTA", "TTAATCTA", "TTACTCTA", "TTAGTCTA", "TTATACTA", 
    "TTATCCTA", "TTATGCTA", "TTATTATA", "TTATTGTA", "TTATTTTA", 
    "TTATTCAA", "TTATTCCA", "TTATTCGA", "TTATTCTC", "TTATTCTG", 
    "TTATTCTT")), list(AAGAAGAT = c("CAGAAGAT", "GAGAAGAT", "TAGAAGAT", 
    "ACGAAGAT", "AGGAAGAT", "ATGAAGAT", "AAAAAGAT", "AACAAGAT", 
    "AATAAGAT", "AAGCAGAT", "AAGGAGAT", "AAGTAGAT", "AAGACGAT", 
    "AAGAGGAT", "AAGATGAT", "AAGAAAAT", "AAGAACAT", "AAGAATAT", 
    "AAGAAGCT", "AAGAAGGT", "AAGAAGTT", "AAGAAGAA", "AAGAAGAC", 
    "AAGAAGAG"), AAGAAGGT = c("CAGAAGGT", "GAGAAGGT", "TAGAAGGT", 
    "ACGAAGGT", "AGGAAGGT", "ATGAAGGT", "AAAAAGGT", "AACAAGGT", 
    "AATAAGGT", "AAGCAGGT", "AAGGAGGT", "AAGTAGGT", "AAGACGGT", 
    "AAGAGGGT", "AAGATGGT", "AAGAAAGT", "AAGAACGT", "AAGAATGT", 
    "AAGAAGAT", "AAGAAGCT", "AAGAAGTT", "AAGAAGGA", "AAGAAGGC", 
    "AAGAAGGG"), AAGGAGAT = c("CAGGAGAT", "GAGGAGAT", "TAGGAGAT", 
    "ACGGAGAT", "AGGGAGAT", "ATGGAGAT", "AAAGAGAT", "AACGAGAT", 
    "AATGAGAT", "AAGAAGAT", "AAGCAGAT", "AAGTAGAT", "AAGGCGAT", 
    "AAGGGGAT", "AAGGTGAT", "AAGGAAAT", "AAGGACAT", "AAGGATAT", 
    "AAGGAGCT", "AAGGAGGT", "AAGGAGTT", "AAGGAGAA", "AAGGAGAC", 
    "AAGGAGAG")), list(ACAAAAAT = c("CCAAAAAT", "GCAAAAAT", "TCAAAAAT", 
    "AAAAAAAT", "AGAAAAAT", "ATAAAAAT", "ACCAAAAT", "ACGAAAAT", 
    "ACTAAAAT", "ACACAAAT", "ACAGAAAT", "ACATAAAT", "ACAACAAT", 
    "ACAAGAAT", "ACAATAAT", "ACAAACAT", "ACAAAGAT", "ACAAATAT", 
    "ACAAAACT", "ACAAAAGT", "ACAAAATT", "ACAAAAAA", "ACAAAAAC", 
    "ACAAAAAG"), ACAAAATT = c("CCAAAATT", "GCAAAATT", "TCAAAATT", 
    "AAAAAATT", "AGAAAATT", "ATAAAATT", "ACCAAATT", "ACGAAATT", 
    "ACTAAATT", "ACACAATT", "ACAGAATT", "ACATAATT", "ACAACATT", 
    "ACAAGATT", "ACAATATT", "ACAAACTT", "ACAAAGTT", "ACAAATTT", 
    "ACAAAAAT", "ACAAAACT", "ACAAAAGT", "ACAAAATA", "ACAAAATC", 
    "ACAAAATG"), AGAAAATT = c("CGAAAATT", "GGAAAATT", "TGAAAATT", 
    "AAAAAATT", "ACAAAATT", "ATAAAATT", "AGCAAATT", "AGGAAATT", 
    "AGTAAATT", "AGACAATT", "AGAGAATT", "AGATAATT", "AGAACATT", 
    "AGAAGATT", "AGAATATT", "AGAAACTT", "AGAAAGTT", "AGAAATTT", 
    "AGAAAAAT", "AGAAAACT", "AGAAAAGT", "AGAAAATA", "AGAAAATC", 
    "AGAAAATG")))

dput(head(TF,n=5))
c("AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330"
)

Note however that I have distinct values:

dput(head(unique(TF),n=5))
c("AT1G18330", "AT1G19000", "AT1G25550", "AT1G27730", "AT1G30650"
)

In the end I would like to have this (n is 17 because of the first 5 entries in the list containt 3+3+5+3+3 entries):

dput(head(df, n=17))
structure(list(TF = c("AT1G18330", "AT1G18330", "AT1G18330", 
"AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", 
"AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", 
"AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330"), Pos = c(1L, 
1L, 1L, 2L, 2L, 2L, 3L, 3L, 3L, 3L, 3L, 4L, 4L, 4L, 5L, 5L, 5L
), `_8mer` = c("TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", 
"TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", 
"TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", 
"TAGATAAA"), Neighbour = list(list(c("CCAAAAAT", "GCAAAAAT", 
"TCAAAAAT", "AAAAAAAT", "AGAAAAAT", "ATAAAAAT", "ACCAAAAT", "ACGAAAAT", 
"ACTAAAAT", "ACACAAAT", "ACAGAAAT", "ACATAAAT", "ACAACAAT", "ACAAGAAT", 
"ACAATAAT", "ACAAACAT", "ACAAAGAT", "ACAAATAT", "ACAAAACT", "ACAAAAGT", 
"ACAAAATT", "ACAAAAAA", "ACAAAAAC", "ACAAAAAG")), list(c("CCAAAATT", 
"GCAAAATT", "TCAAAATT", "AAAAAATT", "AGAAAATT", "ATAAAATT", "ACCAAATT", 
"ACGAAATT", "ACTAAATT", "ACACAATT", "ACAGAATT", "ACATAATT", "ACAACATT", 
"ACAAGATT", "ACAATATT", "ACAAACTT", "ACAAAGTT", "ACAAATTT", "ACAAAAAT", 
"ACAAAACT", "ACAAAAGT", "ACAAAATA", "ACAAAATC", "ACAAAATG")), 
    list(c("CCAAAAGT", "GCAAAAGT", "TCAAAAGT", "AAAAAAGT", "AGAAAAGT", 
    "ATAAAAGT", "ACCAAAGT", "ACGAAAGT", "ACTAAAGT", "ACACAAGT", 
    "ACAGAAGT", "ACATAAGT", "ACAACAGT", "ACAAGAGT", "ACAATAGT", 
    "ACAAACGT", "ACAAAGGT", "ACAAATGT", "ACAAAAAT", "ACAAAACT", 
    "ACAAAATT", "ACAAAAGA", "ACAAAAGC", "ACAAAAGG")), list(c("CAAATCAC", 
    "GAAATCAC", "TAAATCAC", "ACAATCAC", "AGAATCAC", "ATAATCAC", 
    "AACATCAC", "AAGATCAC", "AATATCAC", "AAACTCAC", "AAAGTCAC", 
    "AAATTCAC", "AAAAACAC", "AAAACCAC", "AAAAGCAC", "AAAATAAC", 
    "AAAATGAC", "AAAATTAC", "AAAATCCC", "AAAATCGC", "AAAATCTC", 
    "AAAATCAA", "AAAATCAG", "AAAATCAT")), list(c("CAAATTAC", 
    "GAAATTAC", "TAAATTAC", "ACAATTAC", "AGAATTAC", "ATAATTAC", 
    "AACATTAC", "AAGATTAC", "AATATTAC", "AAACTTAC", "AAAGTTAC", 
    "AAATTTAC", "AAAAATAC", "AAAACTAC", "AAAAGTAC", "AAAATAAC", 
    "AAAATCAC", "AAAATGAC", "AAAATTCC", "AAAATTGC", "AAAATTTC", 
    "AAAATTAA", "AAAATTAG", "AAAATTAT")), list(c("CAAATCAT", 
    "GAAATCAT", "TAAATCAT", "ACAATCAT", "AGAATCAT", "ATAATCAT", 
    "AACATCAT", "AAGATCAT", "AATATCAT", "AAACTCAT", "AAAGTCAT", 
    "AAATTCAT", "AAAAACAT", "AAAACCAT", "AAAAGCAT", "AAAATAAT", 
    "AAAATGAT", "AAAATTAT", "AAAATCCT", "AAAATCGT", "AAAATCTT", 
    "AAAATCAA", "AAAATCAC", "AAAATCAG")), list(c("CTTTTCTA", 
    "GTTTTCTA", "TTTTTCTA", "AATTTCTA", "ACTTTCTA", "AGTTTCTA", 
    "ATATTCTA", "ATCTTCTA", "ATGTTCTA", "ATTATCTA", "ATTCTCTA", 
    "ATTGTCTA", "ATTTACTA", "ATTTCCTA", "ATTTGCTA", "ATTTTATA", 
    "ATTTTGTA", "ATTTTTTA", "ATTTTCAA", "ATTTTCCA", "ATTTTCGA", 
    "ATTTTCTC", "ATTTTCTG", "ATTTTCTT")), list(c("ATTTTCTA", 
    "CTTTTCTA", "GTTTTCTA", "TATTTCTA", "TCTTTCTA", "TGTTTCTA", 
    "TTATTCTA", "TTCTTCTA", "TTGTTCTA", "TTTATCTA", "TTTCTCTA", 
    "TTTGTCTA", "TTTTACTA", "TTTTCCTA", "TTTTGCTA", "TTTTTATA", 
    "TTTTTGTA", "TTTTTTTA", "TTTTTCAA", "TTTTTCCA", "TTTTTCGA", 
    "TTTTTCTC", "TTTTTCTG", "TTTTTCTT")), list(c("CTTTTCAA", 
    "GTTTTCAA", "TTTTTCAA", "AATTTCAA", "ACTTTCAA", "AGTTTCAA", 
    "ATATTCAA", "ATCTTCAA", "ATGTTCAA", "ATTATCAA", "ATTCTCAA", 
    "ATTGTCAA", "ATTTACAA", "ATTTCCAA", "ATTTGCAA", "ATTTTAAA", 
    "ATTTTGAA", "ATTTTTAA", "ATTTTCCA", "ATTTTCGA", "ATTTTCTA", 
    "ATTTTCAC", "ATTTTCAG", "ATTTTCAT")), list(c("CTCTTCTA", 
    "GTCTTCTA", "TTCTTCTA", "AACTTCTA", "ACCTTCTA", "AGCTTCTA", 
    "ATATTCTA", "ATGTTCTA", "ATTTTCTA", "ATCATCTA", "ATCCTCTA", 
    "ATCGTCTA", "ATCTACTA", "ATCTCCTA", "ATCTGCTA", "ATCTTATA", 
    "ATCTTGTA", "ATCTTTTA", "ATCTTCAA", "ATCTTCCA", "ATCTTCGA", 
    "ATCTTCTC", "ATCTTCTG", "ATCTTCTT")), list(c("ATATTCTA", 
    "CTATTCTA", "GTATTCTA", "TAATTCTA", "TCATTCTA", "TGATTCTA", 
    "TTCTTCTA", "TTGTTCTA", "TTTTTCTA", "TTAATCTA", "TTACTCTA", 
    "TTAGTCTA", "TTATACTA", "TTATCCTA", "TTATGCTA", "TTATTATA", 
    "TTATTGTA", "TTATTTTA", "TTATTCAA", "TTATTCCA", "TTATTCGA", 
    "TTATTCTC", "TTATTCTG", "TTATTCTT")), list(c("CAGAAGAT", 
    "GAGAAGAT", "TAGAAGAT", "ACGAAGAT", "AGGAAGAT", "ATGAAGAT", 
    "AAAAAGAT", "AACAAGAT", "AATAAGAT", "AAGCAGAT", "AAGGAGAT", 
    "AAGTAGAT", "AAGACGAT", "AAGAGGAT", "AAGATGAT", "AAGAAAAT", 
    "AAGAACAT", "AAGAATAT", "AAGAAGCT", "AAGAAGGT", "AAGAAGTT", 
    "AAGAAGAA", "AAGAAGAC", "AAGAAGAG")), list(c("CAGAAGGT", 
    "GAGAAGGT", "TAGAAGGT", "ACGAAGGT", "AGGAAGGT", "ATGAAGGT", 
    "AAAAAGGT", "AACAAGGT", "AATAAGGT", "AAGCAGGT", "AAGGAGGT", 
    "AAGTAGGT", "AAGACGGT", "AAGAGGGT", "AAGATGGT", "AAGAAAGT", 
    "AAGAACGT", "AAGAATGT", "AAGAAGAT", "AAGAAGCT", "AAGAAGTT", 
    "AAGAAGGA", "AAGAAGGC", "AAGAAGGG")), list(c("CAGGAGAT", 
    "GAGGAGAT", "TAGGAGAT", "ACGGAGAT", "AGGGAGAT", "ATGGAGAT", 
    "AAAGAGAT", "AACGAGAT", "AATGAGAT", "AAGAAGAT", "AAGCAGAT", 
    "AAGTAGAT", "AAGGCGAT", "AAGGGGAT", "AAGGTGAT", "AAGGAAAT", 
    "AAGGACAT", "AAGGATAT", "AAGGAGCT", "AAGGAGGT", "AAGGAGTT", 
    "AAGGAGAA", "AAGGAGAC", "AAGGAGAG")), list(c("CCAAAAAT", 
    "GCAAAAAT", "TCAAAAAT", "AAAAAAAT", "AGAAAAAT", "ATAAAAAT", 
    "ACCAAAAT", "ACGAAAAT", "ACTAAAAT", "ACACAAAT", "ACAGAAAT", 
    "ACATAAAT", "ACAACAAT", "ACAAGAAT", "ACAATAAT", "ACAAACAT", 
    "ACAAAGAT", "ACAAATAT", "ACAAAACT", "ACAAAAGT", "ACAAAATT", 
    "ACAAAAAA", "ACAAAAAC", "ACAAAAAG")), list(c("CCAAAATT", 
    "GCAAAATT", "TCAAAATT", "AAAAAATT", "AGAAAATT", "ATAAAATT", 
    "ACCAAATT", "ACGAAATT", "ACTAAATT", "ACACAATT", "ACAGAATT", 
    "ACATAATT", "ACAACATT", "ACAAGATT", "ACAATATT", "ACAAACTT", 
    "ACAAAGTT", "ACAAATTT", "ACAAAAAT", "ACAAAACT", "ACAAAAGT", 
    "ACAAAATA", "ACAAAATC", "ACAAAATG")), list(c("CGAAAATT", 
    "GGAAAATT", "TGAAAATT", "AAAAAATT", "ACAAAATT", "ATAAAATT", 
    "AGCAAATT", "AGGAAATT", "AGTAAATT", "AGACAATT", "AGAGAATT", 
    "AGATAATT", "AGAACATT", "AGAAGATT", "AGAATATT", "AGAAACTT", 
    "AGAAAGTT", "AGAAATTT", "AGAAAAAT", "AGAAAACT", "AGAAAAGT", 
    "AGAAAATA", "AGAAAATC", "AGAAAATG")))), row.names = c(NA, 
17L), class = "data.frame")

nirgrahamuk · April 22, 2020, 10:59am

all_neighbours <- list(
  list(ACAAAAAT = c(
    "CCAAAAAT", "GCAAAAAT", "TCAAAAAT", "AAAAAAAT",
    "AGAAAAAT", "ATAAAAAT", "ACCAAAAT", "ACGAAAAT", "ACTAAAAT", "ACACAAAT",
    "ACAGAAAT", "ACATAAAT", "ACAACAAT", "ACAAGAAT", "ACAATAAT", "ACAAACAT",
    "ACAAAGAT", "ACAAATAT", "ACAAAACT", "ACAAAAGT", "ACAAAATT", "ACAAAAAA",
    "ACAAAAAC", "ACAAAAAG"
  ), ACAAAATT = c(
    "CCAAAATT", "GCAAAATT",
    "TCAAAATT", "AAAAAATT", "AGAAAATT", "ATAAAATT", "ACCAAATT", "ACGAAATT",
    "ACTAAATT", "ACACAATT", "ACAGAATT", "ACATAATT", "ACAACATT", "ACAAGATT",
    "ACAATATT", "ACAAACTT", "ACAAAGTT", "ACAAATTT", "ACAAAAAT", "ACAAAACT",
    "ACAAAAGT", "ACAAAATA", "ACAAAATC", "ACAAAATG"
  ), ACAAAAGT = c(
    "CCAAAAGT",
    "GCAAAAGT", "TCAAAAGT", "AAAAAAGT", "AGAAAAGT", "ATAAAAGT", "ACCAAAGT",
    "ACGAAAGT", "ACTAAAGT", "ACACAAGT", "ACAGAAGT", "ACATAAGT", "ACAACAGT",
    "ACAAGAGT", "ACAATAGT", "ACAAACGT", "ACAAAGGT", "ACAAATGT", "ACAAAAAT",
    "ACAAAACT", "ACAAAATT", "ACAAAAGA", "ACAAAAGC", "ACAAAAGG"
  )),
  list(AAAATCAC = c(
    "CAAATCAC", "GAAATCAC", "TAAATCAC", "ACAATCAC",
    "AGAATCAC", "ATAATCAC", "AACATCAC", "AAGATCAC", "AATATCAC",
    "AAACTCAC", "AAAGTCAC", "AAATTCAC", "AAAAACAC", "AAAACCAC",
    "AAAAGCAC", "AAAATAAC", "AAAATGAC", "AAAATTAC", "AAAATCCC",
    "AAAATCGC", "AAAATCTC", "AAAATCAA", "AAAATCAG", "AAAATCAT"
  ), AAAATTAC = c(
    "CAAATTAC", "GAAATTAC", "TAAATTAC", "ACAATTAC",
    "AGAATTAC", "ATAATTAC", "AACATTAC", "AAGATTAC", "AATATTAC",
    "AAACTTAC", "AAAGTTAC", "AAATTTAC", "AAAAATAC", "AAAACTAC",
    "AAAAGTAC", "AAAATAAC", "AAAATCAC", "AAAATGAC", "AAAATTCC",
    "AAAATTGC", "AAAATTTC", "AAAATTAA", "AAAATTAG", "AAAATTAT"
  ), AAAATCAT = c(
    "CAAATCAT", "GAAATCAT", "TAAATCAT", "ACAATCAT",
    "AGAATCAT", "ATAATCAT", "AACATCAT", "AAGATCAT", "AATATCAT",
    "AAACTCAT", "AAAGTCAT", "AAATTCAT", "AAAAACAT", "AAAACCAT",
    "AAAAGCAT", "AAAATAAT", "AAAATGAT", "AAAATTAT", "AAAATCCT",
    "AAAATCGT", "AAAATCTT", "AAAATCAA", "AAAATCAC", "AAAATCAG"
  )), list(ATTTTCTA = c(
    "CTTTTCTA", "GTTTTCTA", "TTTTTCTA",
    "AATTTCTA", "ACTTTCTA", "AGTTTCTA", "ATATTCTA", "ATCTTCTA",
    "ATGTTCTA", "ATTATCTA", "ATTCTCTA", "ATTGTCTA", "ATTTACTA",
    "ATTTCCTA", "ATTTGCTA", "ATTTTATA", "ATTTTGTA", "ATTTTTTA",
    "ATTTTCAA", "ATTTTCCA", "ATTTTCGA", "ATTTTCTC", "ATTTTCTG",
    "ATTTTCTT"
  ), TTTTTCTA = c(
    "ATTTTCTA", "CTTTTCTA", "GTTTTCTA",
    "TATTTCTA", "TCTTTCTA", "TGTTTCTA", "TTATTCTA", "TTCTTCTA",
    "TTGTTCTA", "TTTATCTA", "TTTCTCTA", "TTTGTCTA", "TTTTACTA",
    "TTTTCCTA", "TTTTGCTA", "TTTTTATA", "TTTTTGTA", "TTTTTTTA",
    "TTTTTCAA", "TTTTTCCA", "TTTTTCGA", "TTTTTCTC", "TTTTTCTG",
    "TTTTTCTT"
  ), ATTTTCAA = c(
    "CTTTTCAA", "GTTTTCAA", "TTTTTCAA",
    "AATTTCAA", "ACTTTCAA", "AGTTTCAA", "ATATTCAA", "ATCTTCAA",
    "ATGTTCAA", "ATTATCAA", "ATTCTCAA", "ATTGTCAA", "ATTTACAA",
    "ATTTCCAA", "ATTTGCAA", "ATTTTAAA", "ATTTTGAA", "ATTTTTAA",
    "ATTTTCCA", "ATTTTCGA", "ATTTTCTA", "ATTTTCAC", "ATTTTCAG",
    "ATTTTCAT"
  ), ATCTTCTA = c(
    "CTCTTCTA", "GTCTTCTA", "TTCTTCTA",
    "AACTTCTA", "ACCTTCTA", "AGCTTCTA", "ATATTCTA", "ATGTTCTA",
    "ATTTTCTA", "ATCATCTA", "ATCCTCTA", "ATCGTCTA", "ATCTACTA",
    "ATCTCCTA", "ATCTGCTA", "ATCTTATA", "ATCTTGTA", "ATCTTTTA",
    "ATCTTCAA", "ATCTTCCA", "ATCTTCGA", "ATCTTCTC", "ATCTTCTG",
    "ATCTTCTT"
  ), TTATTCTA = c(
    "ATATTCTA", "CTATTCTA", "GTATTCTA",
    "TAATTCTA", "TCATTCTA", "TGATTCTA", "TTCTTCTA", "TTGTTCTA",
    "TTTTTCTA", "TTAATCTA", "TTACTCTA", "TTAGTCTA", "TTATACTA",
    "TTATCCTA", "TTATGCTA", "TTATTATA", "TTATTGTA", "TTATTTTA",
    "TTATTCAA", "TTATTCCA", "TTATTCGA", "TTATTCTC", "TTATTCTG",
    "TTATTCTT"
  )), list(AAGAAGAT = c(
    "CAGAAGAT", "GAGAAGAT", "TAGAAGAT",
    "ACGAAGAT", "AGGAAGAT", "ATGAAGAT", "AAAAAGAT", "AACAAGAT",
    "AATAAGAT", "AAGCAGAT", "AAGGAGAT", "AAGTAGAT", "AAGACGAT",
    "AAGAGGAT", "AAGATGAT", "AAGAAAAT", "AAGAACAT", "AAGAATAT",
    "AAGAAGCT", "AAGAAGGT", "AAGAAGTT", "AAGAAGAA", "AAGAAGAC",
    "AAGAAGAG"
  ), AAGAAGGT = c(
    "CAGAAGGT", "GAGAAGGT", "TAGAAGGT",
    "ACGAAGGT", "AGGAAGGT", "ATGAAGGT", "AAAAAGGT", "AACAAGGT",
    "AATAAGGT", "AAGCAGGT", "AAGGAGGT", "AAGTAGGT", "AAGACGGT",
    "AAGAGGGT", "AAGATGGT", "AAGAAAGT", "AAGAACGT", "AAGAATGT",
    "AAGAAGAT", "AAGAAGCT", "AAGAAGTT", "AAGAAGGA", "AAGAAGGC",
    "AAGAAGGG"
  ), AAGGAGAT = c(
    "CAGGAGAT", "GAGGAGAT", "TAGGAGAT",
    "ACGGAGAT", "AGGGAGAT", "ATGGAGAT", "AAAGAGAT", "AACGAGAT",
    "AATGAGAT", "AAGAAGAT", "AAGCAGAT", "AAGTAGAT", "AAGGCGAT",
    "AAGGGGAT", "AAGGTGAT", "AAGGAAAT", "AAGGACAT", "AAGGATAT",
    "AAGGAGCT", "AAGGAGGT", "AAGGAGTT", "AAGGAGAA", "AAGGAGAC",
    "AAGGAGAG"
  )), list(ACAAAAAT = c(
    "CCAAAAAT", "GCAAAAAT", "TCAAAAAT",
    "AAAAAAAT", "AGAAAAAT", "ATAAAAAT", "ACCAAAAT", "ACGAAAAT",
    "ACTAAAAT", "ACACAAAT", "ACAGAAAT", "ACATAAAT", "ACAACAAT",
    "ACAAGAAT", "ACAATAAT", "ACAAACAT", "ACAAAGAT", "ACAAATAT",
    "ACAAAACT", "ACAAAAGT", "ACAAAATT", "ACAAAAAA", "ACAAAAAC",
    "ACAAAAAG"
  ), ACAAAATT = c(
    "CCAAAATT", "GCAAAATT", "TCAAAATT",
    "AAAAAATT", "AGAAAATT", "ATAAAATT", "ACCAAATT", "ACGAAATT",
    "ACTAAATT", "ACACAATT", "ACAGAATT", "ACATAATT", "ACAACATT",
    "ACAAGATT", "ACAATATT", "ACAAACTT", "ACAAAGTT", "ACAAATTT",
    "ACAAAAAT", "ACAAAACT", "ACAAAAGT", "ACAAAATA", "ACAAAATC",
    "ACAAAATG"
  ), AGAAAATT = c(
    "CGAAAATT", "GGAAAATT", "TGAAAATT",
    "AAAAAATT", "ACAAAATT", "ATAAAATT", "AGCAAATT", "AGGAAATT",
    "AGTAAATT", "AGACAATT", "AGAGAATT", "AGATAATT", "AGAACATT",
    "AGAAGATT", "AGAATATT", "AGAAACTT", "AGAAAGTT", "AGAAATTT",
    "AGAAAAAT", "AGAAAACT", "AGAAAAGT", "AGAAAATA", "AGAAAATC",
    "AGAAAATG"
  ))
)
TF <- c("AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330")
# Note however that I have distinct values:

#   dput(head(unique(TF),n=5))
# c("AT1G18330", "AT1G19000", "AT1G25550", "AT1G27730", "AT1G30650"
# )
# In the end I would like to have this (n is 17 because of the first 5 entries in the list containt 3+3+5+3+3 entries):

dftarget <- structure(list(TF = c(
  "AT1G18330", "AT1G18330", "AT1G18330",
  "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330",
  "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330",
  "AT1G18330", "AT1G18330", "AT1G18330", "AT1G18330"
), Pos = c(
  1L,
  1L, 1L, 2L, 2L, 2L, 3L, 3L, 3L, 3L, 3L, 4L, 4L, 4L, 5L, 5L, 5L
), `_8mer` = c(
  "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA",
  "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA",
  "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA", "TAGATAAA",
  "TAGATAAA"
), Neighbour = list(
  list(c(
    "CCAAAAAT", "GCAAAAAT",
    "TCAAAAAT", "AAAAAAAT", "AGAAAAAT", "ATAAAAAT", "ACCAAAAT", "ACGAAAAT",
    "ACTAAAAT", "ACACAAAT", "ACAGAAAT", "ACATAAAT", "ACAACAAT", "ACAAGAAT",
    "ACAATAAT", "ACAAACAT", "ACAAAGAT", "ACAAATAT", "ACAAAACT", "ACAAAAGT",
    "ACAAAATT", "ACAAAAAA", "ACAAAAAC", "ACAAAAAG"
  )), list(c(
    "CCAAAATT",
    "GCAAAATT", "TCAAAATT", "AAAAAATT", "AGAAAATT", "ATAAAATT", "ACCAAATT",
    "ACGAAATT", "ACTAAATT", "ACACAATT", "ACAGAATT", "ACATAATT", "ACAACATT",
    "ACAAGATT", "ACAATATT", "ACAAACTT", "ACAAAGTT", "ACAAATTT", "ACAAAAAT",
    "ACAAAACT", "ACAAAAGT", "ACAAAATA", "ACAAAATC", "ACAAAATG"
  )),
  list(c(
    "CCAAAAGT", "GCAAAAGT", "TCAAAAGT", "AAAAAAGT", "AGAAAAGT",
    "ATAAAAGT", "ACCAAAGT", "ACGAAAGT", "ACTAAAGT", "ACACAAGT",
    "ACAGAAGT", "ACATAAGT", "ACAACAGT", "ACAAGAGT", "ACAATAGT",
    "ACAAACGT", "ACAAAGGT", "ACAAATGT", "ACAAAAAT", "ACAAAACT",
    "ACAAAATT", "ACAAAAGA", "ACAAAAGC", "ACAAAAGG"
  )), list(c(
    "CAAATCAC",
    "GAAATCAC", "TAAATCAC", "ACAATCAC", "AGAATCAC", "ATAATCAC",
    "AACATCAC", "AAGATCAC", "AATATCAC", "AAACTCAC", "AAAGTCAC",
    "AAATTCAC", "AAAAACAC", "AAAACCAC", "AAAAGCAC", "AAAATAAC",
    "AAAATGAC", "AAAATTAC", "AAAATCCC", "AAAATCGC", "AAAATCTC",
    "AAAATCAA", "AAAATCAG", "AAAATCAT"
  )), list(c(
    "CAAATTAC",
    "GAAATTAC", "TAAATTAC", "ACAATTAC", "AGAATTAC", "ATAATTAC",
    "AACATTAC", "AAGATTAC", "AATATTAC", "AAACTTAC", "AAAGTTAC",
    "AAATTTAC", "AAAAATAC", "AAAACTAC", "AAAAGTAC", "AAAATAAC",
    "AAAATCAC", "AAAATGAC", "AAAATTCC", "AAAATTGC", "AAAATTTC",
    "AAAATTAA", "AAAATTAG", "AAAATTAT"
  )), list(c(
    "CAAATCAT",
    "GAAATCAT", "TAAATCAT", "ACAATCAT", "AGAATCAT", "ATAATCAT",
    "AACATCAT", "AAGATCAT", "AATATCAT", "AAACTCAT", "AAAGTCAT",
    "AAATTCAT", "AAAAACAT", "AAAACCAT", "AAAAGCAT", "AAAATAAT",
    "AAAATGAT", "AAAATTAT", "AAAATCCT", "AAAATCGT", "AAAATCTT",
    "AAAATCAA", "AAAATCAC", "AAAATCAG"
  )), list(c(
    "CTTTTCTA",
    "GTTTTCTA", "TTTTTCTA", "AATTTCTA", "ACTTTCTA", "AGTTTCTA",
    "ATATTCTA", "ATCTTCTA", "ATGTTCTA", "ATTATCTA", "ATTCTCTA",
    "ATTGTCTA", "ATTTACTA", "ATTTCCTA", "ATTTGCTA", "ATTTTATA",
    "ATTTTGTA", "ATTTTTTA", "ATTTTCAA", "ATTTTCCA", "ATTTTCGA",
    "ATTTTCTC", "ATTTTCTG", "ATTTTCTT"
  )), list(c(
    "ATTTTCTA",
    "CTTTTCTA", "GTTTTCTA", "TATTTCTA", "TCTTTCTA", "TGTTTCTA",
    "TTATTCTA", "TTCTTCTA", "TTGTTCTA", "TTTATCTA", "TTTCTCTA",
    "TTTGTCTA", "TTTTACTA", "TTTTCCTA", "TTTTGCTA", "TTTTTATA",
    "TTTTTGTA", "TTTTTTTA", "TTTTTCAA", "TTTTTCCA", "TTTTTCGA",
    "TTTTTCTC", "TTTTTCTG", "TTTTTCTT"
  )), list(c(
    "CTTTTCAA",
    "GTTTTCAA", "TTTTTCAA", "AATTTCAA", "ACTTTCAA", "AGTTTCAA",
    "ATATTCAA", "ATCTTCAA", "ATGTTCAA", "ATTATCAA", "ATTCTCAA",
    "ATTGTCAA", "ATTTACAA", "ATTTCCAA", "ATTTGCAA", "ATTTTAAA",
    "ATTTTGAA", "ATTTTTAA", "ATTTTCCA", "ATTTTCGA", "ATTTTCTA",
    "ATTTTCAC", "ATTTTCAG", "ATTTTCAT"
  )), list(c(
    "CTCTTCTA",
    "GTCTTCTA", "TTCTTCTA", "AACTTCTA", "ACCTTCTA", "AGCTTCTA",
    "ATATTCTA", "ATGTTCTA", "ATTTTCTA", "ATCATCTA", "ATCCTCTA",
    "ATCGTCTA", "ATCTACTA", "ATCTCCTA", "ATCTGCTA", "ATCTTATA",
    "ATCTTGTA", "ATCTTTTA", "ATCTTCAA", "ATCTTCCA", "ATCTTCGA",
    "ATCTTCTC", "ATCTTCTG", "ATCTTCTT"
  )), list(c(
    "ATATTCTA",
    "CTATTCTA", "GTATTCTA", "TAATTCTA", "TCATTCTA", "TGATTCTA",
    "TTCTTCTA", "TTGTTCTA", "TTTTTCTA", "TTAATCTA", "TTACTCTA",
    "TTAGTCTA", "TTATACTA", "TTATCCTA", "TTATGCTA", "TTATTATA",
    "TTATTGTA", "TTATTTTA", "TTATTCAA", "TTATTCCA", "TTATTCGA",
    "TTATTCTC", "TTATTCTG", "TTATTCTT"
  )), list(c(
    "CAGAAGAT",
    "GAGAAGAT", "TAGAAGAT", "ACGAAGAT", "AGGAAGAT", "ATGAAGAT",
    "AAAAAGAT", "AACAAGAT", "AATAAGAT", "AAGCAGAT", "AAGGAGAT",
    "AAGTAGAT", "AAGACGAT", "AAGAGGAT", "AAGATGAT", "AAGAAAAT",
    "AAGAACAT", "AAGAATAT", "AAGAAGCT", "AAGAAGGT", "AAGAAGTT",
    "AAGAAGAA", "AAGAAGAC", "AAGAAGAG"
  )), list(c(
    "CAGAAGGT",
    "GAGAAGGT", "TAGAAGGT", "ACGAAGGT", "AGGAAGGT", "ATGAAGGT",
    "AAAAAGGT", "AACAAGGT", "AATAAGGT", "AAGCAGGT", "AAGGAGGT",
    "AAGTAGGT", "AAGACGGT", "AAGAGGGT", "AAGATGGT", "AAGAAAGT",
    "AAGAACGT", "AAGAATGT", "AAGAAGAT", "AAGAAGCT", "AAGAAGTT",
    "AAGAAGGA", "AAGAAGGC", "AAGAAGGG"
  )), list(c(
    "CAGGAGAT",
    "GAGGAGAT", "TAGGAGAT", "ACGGAGAT", "AGGGAGAT", "ATGGAGAT",
    "AAAGAGAT", "AACGAGAT", "AATGAGAT", "AAGAAGAT", "AAGCAGAT",
    "AAGTAGAT", "AAGGCGAT", "AAGGGGAT", "AAGGTGAT", "AAGGAAAT",
    "AAGGACAT", "AAGGATAT", "AAGGAGCT", "AAGGAGGT", "AAGGAGTT",
    "AAGGAGAA", "AAGGAGAC", "AAGGAGAG"
  )), list(c(
    "CCAAAAAT",
    "GCAAAAAT", "TCAAAAAT", "AAAAAAAT", "AGAAAAAT", "ATAAAAAT",
    "ACCAAAAT", "ACGAAAAT", "ACTAAAAT", "ACACAAAT", "ACAGAAAT",
    "ACATAAAT", "ACAACAAT", "ACAAGAAT", "ACAATAAT", "ACAAACAT",
    "ACAAAGAT", "ACAAATAT", "ACAAAACT", "ACAAAAGT", "ACAAAATT",
    "ACAAAAAA", "ACAAAAAC", "ACAAAAAG"
  )), list(c(
    "CCAAAATT",
    "GCAAAATT", "TCAAAATT", "AAAAAATT", "AGAAAATT", "ATAAAATT",
    "ACCAAATT", "ACGAAATT", "ACTAAATT", "ACACAATT", "ACAGAATT",
    "ACATAATT", "ACAACATT", "ACAAGATT", "ACAATATT", "ACAAACTT",
    "ACAAAGTT", "ACAAATTT", "ACAAAAAT", "ACAAAACT", "ACAAAAGT",
    "ACAAAATA", "ACAAAATC", "ACAAAATG"
  )), list(c(
    "CGAAAATT",
    "GGAAAATT", "TGAAAATT", "AAAAAATT", "ACAAAATT", "ATAAAATT",
    "AGCAAATT", "AGGAAATT", "AGTAAATT", "AGACAATT", "AGAGAATT",
    "AGATAATT", "AGAACATT", "AGAAGATT", "AGAATATT", "AGAAACTT",
    "AGAAAGTT", "AGAAATTT", "AGAAAAAT", "AGAAAACT", "AGAAAAGT",
    "AGAAAATA", "AGAAAATC", "AGAAAATG"
  ))
)), row.names = c(
  NA,
  17L
), class = "data.frame")

library(tidyverse)

df1 <- enframe(all_neighbours,name="sublistnumber",value="content")
df2 <- rowwise(df1) %>% mutate(subframe=list(enframe(content)))
df3 <- unnest(df2,cols = c(sublistnumber,subframe))
df4 <- mutate( rowwise(df3),value_list = paste0(value,collapse=",")) 

#unlcear if the TF's map 1 to 1 to number of sublists we process of all-neighbours. assuming they do

tf_df <- enframe(TF,name="sublistnumber", value="TF")#

final_df <- inner_join(tf_df,
                       df4)

#could throw away stuff
final_df %>% select(  sublistnumber, TF,   name   ,  value_list )

#you could rename stuff with rename()

DBScan · April 22, 2020, 11:58am

Wow, thank you, worked!
I only had to change the sublistnumber type into an int, it was somehow a character, because else I got an error:

final_df <- inner_join(tf_df,df4)
Joining, by = "sublistnumber"
Error: Can't join on 'sublistnumber' x 'sublistnumber' because of incompatible types (integer / character)
df4$sublistnumber <- as.integer(df4$sublistnumber)

Thanks again!

system · May 13, 2020, 11:58am

This topic was automatically closed 21 days after the last reply. New replies are no longer allowed.