행렬 생성, 호출

box <- sample(1:12)

> box
 [1]  5 10  1  8  7 12  4 11  3  6  2  9
 
dim(box) <- c(3,4)

> box
     [,1] [,2] [,3] [,4]
[1,]    5    8    4    6
[2,]   10    7   11    2
[3,]    1   12    3    9

 

• 이미 생성되어 있는 벡터를 행렬 단위로 변환 
  • dim(x) <- c(a, b) : a행 x b열의 크기를 가진 행렬로 변환

 

box2 <- sample(1:12)

> box2
 [1] 12  5 10  3  7 11  2  1  8  9  4  6
 
 box2 <- matrix(box2, nrow = 3)
 
 > box2
     [,1] [,2] [,3] [,4]
[1,]   12    3    2    9
[2,]    5    7    1    4
[3,]   10   11    8    6

 

• 동일한 형태의 매트릭스를 matrix( [vector], nrow = a) 로 생성 가능 

 

> x <- c(11,22,33,44)
> x
[1] 11 22 33 44
> x <- c(x[1:3],55,x[4])
> x
[1] 11 22 33 55 44

> length(x)
[1] 5

 

• length(x) → 행렬의 원소 갯수를 반환

fly <- c("a","bb","ccc")
length(fly)
nchar(fly)

 

• length는 갯수를 반환하지만, nchar는 각 원소의 길이를 반환한다 
  • 개별 원소별로 길이를 계산한 후, 개별 값을 반환

 

set.seed(1004)
c <- sample(1:50)
c

first1 <- function(x){
  for(i in 1:length(x)){
    if(x[i] == 1) break
  }
  return(i)
}

 

> c <- sample(1:50)
> c
 [1] 35 27 26 11 28 39 45 44 37 43 36 17  6  4  7 34 47 19  2  5 41 13 22 30 24 29 10
[28] 20 32  1  3 46 38 18 21 49 16 33  8 23 15 40 25 14 31 48  9 50 12 42

> first1(c)
[1] 30

 

• frist1(x) → 행렬에서 1의 인덱스를 반환하는 함수
  
  • length(x)를 사용하여 행렬의 길이를 정할 수 있다.

 

> c(1, 2, 3) + c(10, 11, 12, 13, 14, 15)
[1] 11 13 15 14 16 18

 

• 행렬 A의 길이가 행렬 B보다 짧을 경우, 두 행렬을 더 할경우
  • A의 원소를 B의 원소에 순차적으로 대응 시킨 후, A를 처음부터 다시 B의 나머지 원소에 대응

 

> x
[1] 5 4 3 1 2
> x[c(1,4)]
[1] 5 1
> x[1:4]
[1] 5 4 3 1

 

• Indexing : 행렬의 위치를 호출하는데 사용. 행렬의 이름에 [i]로 호출 (R은 i가 1부터 시작)
  • [a : b ] → a부터 b까지 위치를 순차적으로 호출
  • c(a, b) → a와 b를 개별적으로 호출

 

> seq(from = 12, to = 30, by=3)
[1] 12 15 18 21 24 27 30

> seq(1:12, by = 2)
Error in seq.default(1:12, by = 2) : 
  'from'은 반드시 길이가 1이어야 합니다
  
> seq(1:12)
 [1]  1  2  3  4  5  6  7  8  9 10 11 12
 
> seq(from = 1.1, to=2, length = 10)
 [1] 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0

 

• seq(x) : 자동으로 지정된 조건에 맞춘 행렬을 생성
  • seq(a : b) → 1 부터 (b-a+1)개의 행렬을 연속으로  정수 행렬을 생성
    • seq(1 : 4) → 1, 2, 3, 4
    • seq(2: 4) → 1, 2, 3
  • seq(from = a, to = b) 
    
    • 시점 a에서 부터 종점 b까지 연속된 정수 행렬을 생성 
    • seq(from = a, to = b, by = c) → 원소간의 차이가 3인 연속된 행렬 생성
    • seq(from = a, to = b, length = c) → 시점a와 종점b로 구성된 길이 c의 행렬을 생성 (유리수도 가능)

 

> x <- rep("a", 4)
> x
[1] "a" "a" "a" "a"

> y <- rep(c("yahoo", "naver", "google"), 3)
> y
[1] "yahoo"  "naver"  "google" "yahoo"  "naver"  "google" "yahoo"  "naver"  "google"

> rep(c("m16", "k2"), each =2)
[1] "m16" "m16" "k2"  "k2" 

> rep(c("m16", "k2"), 2)
[1] "m16" "k2"  "m16" "k2" 

 

• rep(x, n) : 행렬 x를 n번 반복하여 붙인 행렬을 생성 
  • rep((x, each = k) → 행렬 x의 각 원소를 k번씩 이어 붙임

> x <- 1:10
> x
 [1]  1  2  3  4  5  6  7  8  9 10
 
> any(x>8)
[1] TRUE

> any(x>88)
[1] FALSE

> all(x>88)
[1] FALSE

> all(x>8)
[1] FALSE

 

• all( [condition] ) : 행렬 x의 모든 원소가 특정 조건을 만족하는지 여부를 T/F로 return 
• any( [condition] ) : 행렬 x의 최소 한개의 원소가 특정 조건을 만족하는지 여부를 T/F로 return

series.check <- function(x,n){
  test <- NULL
  for(i in 1:(length(x)-n+1)){
    if(all(x[i:(i+n-1)]==1)){
      test <- c(test, i)
    }
  }
  return(test)
}

x <- c(1,0,0,1,1,1,0,1,1)


> x
[1] 1 0 0 1 1 1 0 1 1
> series.check(x,2)
[1] 4 5 8

 

• 한 행렬에서 1이 연속 n 번 배열되는 순서를 찾는 함수를 정의 

■■□□□□

□■■□□□

□□■■□□

□□□■■□

□□□□■■

 

• 행렬의 길이가 6이고, 1이 연속 2번 등장하는 순서를 찾는 경우 
  • 탐색과정은 1에서 5까지만 진행

■■■□□□

□■■■□□

□□■■■□

□□□■■■

□□□□■■ Error

 

• 1이 연속 3번 등장하는 순서를 찾는 경우
  • 탐색과정은 1에서 4까지만 진행 
  • 5로 가면 7번째 원소가 없기 때문에 error 발생 

• 행렬의 길이 n, 연속 횟수 k, 인덱스가 i인 경우 
  • 1: (n -k +1)
• 탐색 범위는  i : (i + k - 1) 
  • all( x[ i : (i + k -1 )] > ) → 모든 조건을 만족하지 여부를 True or False로 반환

 

series.check2 <- function(x,k){
  n <- length(x)
  test <- vector(length = n)
  count <- 0
  for(i in 1:(n-k+1)){
    if(all(x[i:(i+k-1)] == 1)){
      count <- count + 1
      test[count] <- i
    }
  }
  if(count > 0){
    test <- test[1:count]
  } else test <- NULL
  return(test)
}

> series.check2(x,2)
[1] 4 5 8

• test <- c(test, i) : 매번 test 행렬을 계속 할당하는 것은 메모리 낭비
• 미리 행렬의 메모리를 할당 → 각 원소에 값을 하나 씩 할당 → 사용하지 않는 메모리는 반환 
  • test <- vector(length = n) : 행렬의 길이  n만큼의 벡터를 생성
  • count <- count + 1
    test[count] <- i : 조건에 맞을 경우 카운터를 실행하고, 인덱싱으로 벡터에 배치 
  • test2 <- test[1:count] : 값이 입력된 부분만 메모리를 할당하고 나머지는 반환