preenchendo uma matriz por linhas

Aposto que uma linha pode resolver isso, R é uma linguagem vetorizada.

matrixinp <- matrix(data=NA, nrow=6, ncol=6)
matrixinp[lower.tri(matrixinp, diag = TRUE)] <- rep(1:6, 6:1)

matrixinp
#>      [,1] [,2] [,3] [,4] [,5] [,6]
#> [1,]    1   NA   NA   NA   NA   NA
#> [2,]    1    2   NA   NA   NA   NA
#> [3,]    1    2    3   NA   NA   NA
#> [4,]    1    2    3    4   NA   NA
#> [5,]    1    2    3    4    5   NA
#> [6,]    1    2    3    4    5    6

^{Criado em 2024-09-17 com reprex v2.1.0}

Espere, eu ganhei a aposta.
O truque é saber que as matrizes de R são colunas principais, portanto, com a matriz de índice, lower.trios valores irão para os lugares certos.

Como uma função:

f <- function(n) `dim<-`(rep(rbind(NA, 1:n), rbind(0:(n - 1), n:1)), c(n, n))
f(6)
#>      [,1] [,2] [,3] [,4] [,5] [,6]
#> [1,]    1   NA   NA   NA   NA   NA
#> [2,]    1    2   NA   NA   NA   NA
#> [3,]    1    2    3   NA   NA   NA
#> [4,]    1    2    3    4   NA   NA
#> [5,]    1    2    3    4    5   NA
#> [6,]    1    2    3    4    5    6
f(10)
#>       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
#>  [1,]    1   NA   NA   NA   NA   NA   NA   NA   NA    NA
#>  [2,]    1    2   NA   NA   NA   NA   NA   NA   NA    NA
#>  [3,]    1    2    3   NA   NA   NA   NA   NA   NA    NA
#>  [4,]    1    2    3    4   NA   NA   NA   NA   NA    NA
#>  [5,]    1    2    3    4    5   NA   NA   NA   NA    NA
#>  [6,]    1    2    3    4    5    6   NA   NA   NA    NA
#>  [7,]    1    2    3    4    5    6    7   NA   NA    NA
#>  [8,]    1    2    3    4    5    6    7    8   NA    NA
#>  [9,]    1    2    3    4    5    6    7    8    9    NA
#> [10,]    1    2    3    4    5    6    7    8    9    10

Você pode tentar

> replace(m <- diag(1:6) * NA, lower.tri(m, TRUE), rep(1:6, 6:1))
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1   NA   NA   NA   NA   NA
[2,]    1    2   NA   NA   NA   NA
[3,]    1    2    3   NA   NA   NA
[4,]    1    2    3    4   NA   NA
[5,]    1    2    3    4    5   NA
[6,]    1    2    3    4    5    6

onde

• diag(1:6)*NAproduz uma 6-by-6matriz de NAs
• lower.trirecupera a parte triangular inferior dem
• replacesubstitui os valores mde acordo com o indicador de máscara

Ou, se você quiser manipulações por linha

> do.call(rbind, lapply(1:6, \(k) `length<-`(seq.int(k), 6)))
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1   NA   NA   NA   NA   NA
[2,]    1    2   NA   NA   NA   NA
[3,]    1    2    3   NA   NA   NA
[4,]    1    2    3    4   NA   NA
[5,]    1    2    3    4    5   NA
[6,]    1    2    3    4    5    6

onde

• `length<-`define os comprimentos para o vetor fornecido
• do.call(rbind, ...)empilha vetores na lista por linhas

1) Crie uma matriz diagonal 6x6, preencha-a com os números das colunas e então extraia o triângulo superior.

library(magrittr)
diag(6) %>% col() %>% { ifelse(row(.) < ., NA, .) }

dando

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1   NA   NA   NA   NA   NA
[2,]    1    2   NA   NA   NA   NA
[3,]    1    2    3   NA   NA   NA
[4,]    1    2    3    4   NA   NA
[5,]    1    2    3    4    5   NA
[6,]    1    2    3    4    5    6

2) ou com o cachimbo nativo:

diag(6) |> col() |> list(x = _) |> with(ifelse(row(x) < x, NA, x))

3) Defina cc como uma matriz 6x6 com números de colunas como acima e então use a fórmula mostrada.

cc <- col(diag(6))
cc * NA ^ (cc > t(cc))

Você pode tentar o seguinte,

# Create an empty 6x6 matrix
matrixinp <- matrix(data=NA, nrow=6, ncol=6)

# Fill the matrix row by row
for (i in 1:6) {
  matrixinp[i, 1:i] <- seq(i)
}

# Display the matrix
print(matrixinp)

Mantenha a criação inicial da matriz vazia com valores NA. Use um único loop que itere sobre as linhas (1 a 6). Para cada linha i, preenchemos apenas as primeiras i colunas com a sequência seq(i). O restante dos elementos em cada linha permanece NA como definido inicialmente.

Este método garante que cada linha tenha a sequência até seu número de linha, e o restante das partes permaneçam como NA.

Você precisa fazer isso especificamente com um loop e seq()?

Você poderia criar essa matriz muito facilmente com as habilidades de álgebra matricial do R:

# Multiply a row vector of all 1s by a column vector of 1-6
matrixinp <- rep(1,6) %*% t(1:6)

# You have a matrix with an all-1s column, and all-2s column, etc. - now set the upper triangle to NA
matrixinp[upper.tri(matrixinp)] <- NA

Mas se você quiser entender por que seu loop não estava funcionando:

    for (i in 1:6){
      aaa<-seq(i)
      print(aaa)
      for(j in 1:6){ 
        matrixinp[j,] = aaa
      } 
    }

Quando você executa, seq(4)obtém um vetor de comprimento 4 c(1,2,3,4). Você então tenta atribuí-lo a cada linha de matrixinp, mas as linhas naquela matriz têm 6 elementos de comprimento. Essa atribuição falhará com o erro number of items to replace is not a multiple of replacement lengthquando você chegar à 4ª iteração do loop.

Antes de chegar à 4ª iteração, 6 é um múltiplo de 1, 2 e 3, então, para essas iterações, R preenche a matriz com repetições do seu vetor aaa:

• Quando i=1, aaa=1, ele preenche as linhas da matriz com c(1,1,1,1,1,1).
• Quando i=2, aaa=c(1,2)ele preenche as linhas da matriz com c(1,2,1,2,1,2).
• Quando i=3, aaa=c(1,2,3), ele preenche as linhas da matriz com c(1,2,3,1,2,3).
• Quando i=4, ele para com um erro em vez de preencher a matriz.

É por isso que você tem aquela matriz estranha onde cada linha era 1 2 3 1 2 3 - quando i=3, o loop interno com j atribuído c(1,2,3,1,2,3)a cada linha da matriz. Então seu loop parou quando encontrou um erro em i=4, deixando você com a versão i=3 da matriz.

Para ajudar o autor da pergunta original a entender, aqui está a frase que escrevi no meu comentário para RuiBarradas:

matrixinp <- ifelse(lower.tri(matrix(nrow=6,ncol=6),diag=T),rep(1,6) %*% t(1:6),NA)

Este é um código bagunçado e excessivamente complicado por ser bobo e tentar fazer tudo em uma linha. Você geralmente não deve fazer algo assim em código real, pois tornará o código difícil para outras pessoas lerem (ou para você ler quando olhar para ele novamente meses depois). Mas ele demonstra alguns recursos úteis do R, e brincar com coisas assim pode às vezes ajudar a aprender mais sobre R.

Este código é melhor lido de fora para dentro, por exemplo, começando com a função mais externa:

• ifelse()é uma função que verifica se seu primeiro argumento é verdadeiro - se for, ela retorna seu segundo argumento, caso contrário, ela retorna seu terceiro argumento.
  • Então ifelse(c(T,F,T,F),'A','B')retornaria c('A','B','A','B').
• O primeiro argumento que dei ifelse()foi lower.tri(matrix(nrow=6,ncol=6),diag=T), uma matriz de valores VERDADEIRO/FALSO indicando quais células em uma matriz 6x6 estão no triângulo inferior (incluindo a diagonal como "no triângulo inferior")
• O segundo argumento que dei foi rep(1,6) %*% t(1:6)a álgebra matricial da minha outra resposta à sua pergunta, que cria uma matriz com uma coluna só de 1, uma coluna só de 2, etc.
  • Esta parte na verdade é uma boa maneira de fazer uma matriz com 1 coluna, 2 colunas, etc. em R, eu não estava sendo bobo com isso. R é otimizado para fazer álgebra matricial muito, muito rápido, então uma solução de álgebra matricial é frequentemente a mais rápida.
• O terceiro argumento que dei foi NA

Então, esse código verifica para cada célula de uma matriz 6x6 se essa célula está no triângulo inferior. Se estiver, ele pega um valor para essa célula da matriz com uma coluna all-1s, all-2s, etc. Mas se estiver no triângulo superior, ele define essa célula como NA.

E minha segunda frase de efeito:(!upper.tri(diag(6)) | NA) * (rep(1,6) %*% t(1:6))

• Novamente, este é um código bobo, não faça isso de verdade
• Para entender isso, divida-o em partes - é a multiplicação elemento a elemento de duas matrizes, uma criada por (!upper.tri(diag(6)) | NA)e outra por(rep(1,6) %*% t(1:6))
• A matriz da esquerda usa a abordagem de R para manipulação e/ou lógica para criar uma matriz que é VERDADEIRA no triângulo inferior e NA no triângulo superior.
  • diag(6)cria uma matriz 6x6 que tem 1s nas diagonais e 0s em todos os outros lugares. Seu propósito é apenas criar uma matriz 6x6 de uma forma que seja mais curta de escrever do que matrix(nrow=6,ncol=6).
  • !upper.tri(diag(6))usa upper.tri()naquela matriz para criar uma matriz onde o triângulo superior (excluindo a diagonal) é TRUE e o triângulo inferior é FALSE. Então ele usa !(o operador "not") para transformar TRUEs em falses e vice-versa.
    • Eu também poderia ter escrito lower.tri(diag(6),diag=T)para fazer a mesma matriz V/F, mas como isso requer que a diag=Tmatriz inclua a diagonal, é mais curto (embora menos legível) para escrever !upper.tri(diag(6)).
  • Por fim, toda a matriz esquerda: (!upper.tri(diag(6)) | NA). Pego essa matriz V/F e faço um "ou" lógico com NA. "verdadeiro ou NA" é avaliado como "verdadeiro", enquanto "falso ou NA" é avaliado como NA.
• A matriz à esquerda é a mesma abordagem baseada em álgebra matricial que usei em minhas outras respostas, que cria a matriz com uma coluna só de 1, uma coluna só de 2, etc.
• Quando multiplico por elementos a matriz de trues e NAs pela matriz com todas as colunas X, o R converte o valor TRUE para 1 (ele também converteria o valor FALSE para 0 se houvesse algum FALSE presente). Então, para a metade inferior, multiplico 1*1, 1*2, 1*3, etc. Para a metade superior, estou multiplicando NAs, NA*1, NA*2, etc., o que produz NA como resultado.