Estoy tratando de crear secuencias de la serie de 6 casos, pero con 144 casos intervalos.

Como este por ejemplo

c(1:6, 144:149, 288:293)

1   2   3   4   5   6 144 145 146 147 148 149 288 289 290 291 292 293

¿Cómo podría generar automáticamente una secuencia con

seq 

o con otra función ?

OriginalEl autor giacomo | 2015-06-29

4 Comentarios

  1. 17

    Puedo encontrar el sequence función de ser útil en este caso. Si usted tuvo sus datos en una estructura como esta:

    (info <- data.frame(start=c(1, 144, 288), len=c(6, 6, 6)))
    #   start len
    # 1     1   6
    # 2   144   6
    # 3   288   6

    entonces usted podría hacer esto en una sola línea:

    sequence(info$len) + rep(info$start-1, info$len)
    #  [1]   1   2   3   4   5   6 144 145 146 147 148 149 288 289 290 291 292 293

    Tenga en cuenta que esta solución funciona incluso si las secuencias usted es la combinación de diferentes longitudes de onda.

    Sí, dado el anormal de intervalos en el OP ejemplo, el almacenamiento de la estructura de forma explícita como la que es probablemente una buena idea.
    Desde el ? página, «tenga en cuenta que la secuencia <- función(nvec) unlist(lapply(nvec, seq_len) y existe principalmente en la reverencia a la muy temprana de la historia de R.» es algo así como la respuesta de Frank.
    Todavía tengo que llenar manual el c(1, 144, 288) ? lo que si quiero 10 secuencias o 100 secuencias de 6 dígitos ? ¿Cuál sería la solución ? gracias
    si no hay ningún patrón de los puntos de partida y longitudes, entonces sí, por supuesto, usted tendrá que especificar manualmente. Si hay un patrón para los puntos de partida y longitudes, entonces será más fácil. Por ejemplo, si desea 100 secuencias de longitud 6 con los puntos de partida creciente por 144 cada vez que empieza en 0 utilizaría info <- data.frame(start=seq(0, by=144, length.out=100), len=6).

    OriginalEl autor josliber

  2. 6

    Este es un enfoque:

    unlist(lapply(c(0L,(1:2)*144L-1L),`+`,seq_len(6)))
    # or...
    unlist(lapply(c(1L,(1:2)*144L),function(x)seq(x,x+5)))

    Aquí está una manera que me gusta un poco mejor:

    rep(c(0L,(1:2)*144L-1L),each=6) + seq_len(6)

    Generalizar…

    rlen  <- 6L
    rgap  <- 144L
    rnum  <- 3L
    
    starters <- c(0L,seq_len(rnum-1L)*rgap-1L)
    
    rep(starters, each=rlen) + seq_len(rlen)
    # or...
    unlist(lapply(starters+1L,function(x)seq(x,x+rlen-1L)))
    Me siento como que debería haber una solución más elegante a este problema, sin embargo.
    woah mente soplado c(matriz) devuelve el vector de
    Sí, seq_len es sólo un poco más rápido, dicen, aunque dudo que importa en esta aplicación. Solo hábito. También, para la «generalización», yo tendría que escribir `:`(1,rlen) que es una especie de torpe.
    No hay prisa para aceptar. No estoy loco por mi respuesta, así que me gustaría igual de bien ver deja abierta la pregunta por un día o dos y ver si hay algo mejor se encuentra.
    ok y gracias de nuevo por tu ayuda !

    OriginalEl autor Frank

  3. 5

    Esto también se puede hacer uso de seq o seq.int

    x = c(1, 144, 288)
    c(sapply(x, function(y) seq.int(y, length.out = 6)))
    
    #[1]   1   2   3   4   5   6 144 145 146 147 148 149 288 289 290 291 292 293

    Como @Frank se menciona en los comentarios aquí hay otra manera de conseguir esto utilizando @josilber de la estructura de datos (Esto es útil, especialmente cuando hay una necesidad de diferentes longitud de la secuencia para los diferentes intervalos)

    c(with(info, mapply(seq.int, start, length.out=len)))
    
    #[1]   1   2   3   4   5   6 144 145 146 147 148 149 288 289 290 291 292 293
    Sí, esto es bueno. Me parece extraño que no puedo obtener el resultado en números enteros, incluso si me cambio a x = c(1L, 144L, 288L), aunque. Creo que este es un error en la manera en seq trata length.outseq.int parece hacer el «derecho» de la cosa, afortunadamente.
    Sí, lo sé. El resultado de seq(1L,length.out=6) debe ser un entero vector es mi punto. Estoy criticando cómo la función obras, no por su respuesta (que parece que es la mejor hasta el momento para mí). Su respuesta iba a funcionar «mejor» (en mi opinión), aunque, si x fueron un entero y seq.int fueron utilizados en lugar de seq para que el resultado final es un vector de enteros (como el OP ejemplo).
    Se podría ampliar la capacidad mediante la definición de una sublength <- c(6,6,6) y configuración de length.out=sublength , de modo que cada secuencia podría ser de una longitud diferente.
    Por desgracia, seq/seq.int no está vectorizada en el length.out argumento. Eso solo significa que mapply sería el camino a seguir, a pesar de que, en lugar de sapply. El uso de josilber de la estructura de datos, c(with(info, mapply(seq.int, start, length.out=len)))
    parece una cuestión de preferencia, a continuación,:)

    OriginalEl autor Veerendra Gadekar

  4. 0

    Estoy usando R 3.3.2. OSX 10.9.4

    He intentado:

    a<-c()  # stores expected sequence
    f<-288  # starting number of final sub-sequence
    it<-144 # interval
    for (d in seq(0,f,by=it))
    {
        if (d==0)
        {
            d=1
        }
        a<-c(a, seq(d,d+5))
        print(d)
    }
    print(a)

    Y se espera que la secuencia se almacena en un.

    [1] 1 2 3 4 5 6 144 145 146 147 148 149 288 289 290 291 292 293

    Y otro intento:

    a<-c()  # stores expected sequence
    it<-144 # interval
    lo<-4   # number of sub-sequences
    for (d in seq(0,by=it, length.out = lo))
    {
        if (d==0)
        {
            d=1
        }
        a<-c(a, seq(d,d+5))
        print(d)
    }
    print(a)

    El resultado:

    [1] 1 2 3 4 5 6 144 145 146 147 148 149 288 289 290 291 292 293 432 433 434 435 436 437

    OriginalEl autor Nick Dong

Dejar respuesta

Please enter your comment!
Please enter your name here