第一節：條件判斷式(1)

在R裡面，要判斷數字大小，可以使用下列幾個判斷語句：「>」、「>=」、「==」、「!=」、「<」、「<=」，而R會回傳邏輯(logical)向量

1 < 2
2 == 1 + 1
"Z" > "B"

當然，一整個向量可以一起使用判斷式，如下

x = c(1, 2, 3, 4, 5)
x <= 4
x > 2

第一節：條件判斷式(2)

我們可以利用「&」、「|」兩個符號將條件「交集」與「聯集」，以取得更複雜的組合

x = c(1, 2, 3, 4, 5)
x <= 4 & x > 2
x > 4 | x <= 2

第一節：條件判斷式(3)

我們可以利用函數「if」，讓滿足條件時，請R執行某些指令(要執行的指令要包含在大括號內)

if ("Z" > "B") {x = 2} else {x = 5}
if ("利" > "弊") {y = 3} else {y = 4}
x * y

我們已經知道一整個向量可以一起使用同個條件判斷式了，那可不可以一起包在if的括號內呢?

– 答案是不行的，因為函數「if」的括弧內僅能包含「一個」邏輯值(請同學試試)

那如果我們想要把物件「x」中大於2及小於等於4的部分改變成-1，我們可以利用索引函數做到這件事（索引值可以放入「邏輯向量」！）

x = c(1, 2, 3, 4, 5)
x[x <= 4 & x > 2] = -1
x

練習1：找尋滿足特定條件的位置

你已經學會了如何利用條件判斷式進行數值分析，我們再介紹一個特殊的函數「which()」

– 函數「which()」會將邏輯向量中為TRUE的位置回傳給我們

a = c(TRUE, FALSE, FALSE, TRUE, FALSE)
which(a)

現在請你試著找出向量「x」中不是整數的位置，並且請你告訴我這些數字是什麼

x = c(15,86,55,36,94,55,97,12,61,1,20,71,61,19,6,60,17,39,75,61,20,17,96,10,84,1,32,39,50,72,59,24,
      33,19,14,86,41,25,97,55,5,29,82,24,7,80,94,55,27,72,69,52,67,100,98,80,1,35,4,65,26,26,66,99,
      2,88,2,4,40,26,50,61,80,15,6,97,64,70,26,74,43,34,83.3,20,29,55,27,22,43,45,82,28,71,80,45,5,
      57,71,48,48,36,24,91,28,76,12,73,43,7,47,77,60,9,56,57,61,27,79,8,40,55,60,64,40,96,76,49,88,
      18,65,35,37,85,76,44,48,85,11,53,41,46,76,40,11,41,74,31,20,80,94,87,4,10,33,41,24,100,38,84,
      1,68,52,43,26,4,12,23,31,32,12,39,1.9,79,58,56,72,88,78,5,61,10,35,31,84,81,90,6,68,11,17,73,
      95,43,25,27,87,59,56,20,79,80,75,65,64,14,62,78,83,83,4,99.7,97,47,40,64,1,96,60,85,27,42,43,
      16,33,89,12,83,2,86,33,64,44,64,18,78,18,54,8,55,46,9,44,6,3,6,47,94,90,46,78,71,92,42,41,54,
      37,60,58,28,62,85,79,100,70,41,96,89,56,82,42,17,60,99,40,92,68,98,6,84,41,44,80,49,49,18,70,
      30,45,71,83,61,26,63,76.9,98,34,13,73,44,23,37,8,78,98,85,75,98,49,77,9,47,85,16,86,20,12,98)

練習1答案

有兩個方法能找出哪裡不是整數，第一種方法是使用上節課學到的「%%」符號：

x %% 1

– 這樣就不難找了

which((x %% 1) != 0)

## [1]  83 172 211 294

第二種方法則是強迫其變成整數，檢查其捨去小數點前與後的不一致性：

which(as.integer(x) != x)

## [1]  83 172 211 294

第二節：迴圈(1)

費波納奇數列：起始數列為1、1，之後每個數為前兩個數之和

x = c(1, 1)
x[3] = x[2] + x[1]
x[4] = x[3] + x[2]
x[5] = x[4] + x[3]
x[6] = x[5] + x[4]
x

## [1] 1 1 2 3 5 8

你是否覺得這樣的運算存在規律?而要怎樣抽解這些規律呢?

第二節：迴圈(2)

在剛剛的任務中我們注意到了一件事情，也就是每一行指令中索引函數都會一起增加1，所以我們現在使用另一個物件i來表示每一行指令中共同的部分

x = c(1, 1)

i = 3
x[i] = x[i-1] + x[i-2]

i = 4
x[i] = x[i-1] + x[i-2]

i = 5
x[i] = x[i-1] + x[i-2]

i = 6
x[i] = x[i-1] + x[i-2]

x

## [1] 1 1 2 3 5 8

透過物件i，我們將能整合所有的運算過程，只要讓i能夠依序提升即可，這是運用迴圈前的基本邏輯！

第二節：迴圈(3)

我們可以利用迴圈函數「for」，來創造費波納奇數列

– 在這裡我們需要兩個物件：物件「x」為儲存費波納奇數列的物件，而物件「indexes」代表著隨迴圈變化的物件

– 注意，在這裡我們第一次使用運算子「:」，而「3:20」表示從3到20的所有整數

x = c(1, 1)
indexes = 3:20
indexes

##  [1]  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

for (i in indexes) {
  x[i] = x[i-1] + x[i-2]
}

x

##  [1]    1    1    2    3    5    8   13   21   34   55   89  144  233  377  610
## [16]  987 1597 2584 4181 6765

第二節：迴圈(4)

剛剛那個迴圈函數的運作原理，是重複執行18次類似的動作，其中i變數在第一次的時候是物件「indexes」中的第一個內容「3」，因此在第一個迴圈中R其實是做了這樣的事情

i = 3 #物件「indexes」中的第一個數字
x[i] = x[i-1] + x[i-2]

而第二迴圈則是

i = 4 #物件「indexes」中的第二個數字
x[i] = x[i-1] + x[i-2]

依此類推，到最後一個迴圈時則是…

i = 20 #物件「indexes」中的最後一個數字
x[i] = x[i-1] + x[i-2]

根據上述流程，R重覆將物件「x」擴充了18次，加上最初的2個起始値，物件「x」現在為一個長度為20的數字(numeric)向量

第二節：迴圈(5)

值得一提的是，我們可以將直接在「in」後面直接使用序列數字進行表示，並且可以獲得完全相同的結果

x = c(1, 1)

for (i in 3:20) {
  x[i] = x[i-1] + x[i-2]
}

x

##  [1]    1    1    2    3    5    8   13   21   34   55   89  144  233  377  610
## [16]  987 1597 2584 4181 6765

第二節：迴圈(6)

迴圈中的變數不見得必須是數字，可以是任何屬性（如文字），下面是一個類似合併列印功能的函數

– 函數「cat」的功能是將文字前後連接起來並輸出在Console視窗中

students = c("小華", "小明", "小王")
scores = c(100, 80, 70)

for (i in 1:3) {
  cat(students[i], "的考試成績為", scores[i], "分\n")
}

## 小華 的考試成績為 100 分
## 小明 的考試成績為 80 分
## 小王 的考試成績為 70 分

練習2：NDMC數列

費波納奇數列是起始數列為1、1，之後每個數為前兩個數之和

– 而我們現在創造一個NDMC數列，其定義是起始數列為1、1，之後第三個數字（奇數）為前兩個相加，第四個數字（偶數）為前兩個數字相乘，第五個數字（奇數）為前兩個相加，依此類推。

下面是將所有程式碼都打下來的結果，請用迴圈功能完成它（小心奇偶數順序時，要做的動作不同，請同學思考如何利用if & else完成這個問題）

y = c(1, 1)
y[3] = y[1] + y[2]
y[4] = y[2] * y[3]
y[5] = y[3] + y[4]
y[6] = y[4] * y[5]
y[7] = y[5] + y[6]
y[8] = y[6] * y[7]
y[9] = y[7] + y[8]
y[10] = y[8] * y[9]
y

##  [1]     1     1     2     2     4     8    12    96   108 10368

練習2答案(1)

這個問題有數種解法，但首先我們要先會使用迴圈，我們先把索引改成這個形式：

y = c(1, 1)

i = 1
y[i+2] = y[i] + y[i+1]
i = 2
y[i+2] = y[i] * y[i+1]
i = 3
y[i+2] = y[i] + y[i+1]
i = 4
y[i+2] = y[i] * y[i+1]
i = 5
y[i+2] = y[i] + y[i+1]
i = 6
y[i+2] = y[i] * y[i+1]
i = 7
y[i+2] = y[i] + y[i+1]
i = 8
y[i+2] = y[i] * y[i+1]

y

我們這樣再改成迴圈的形式：

y = c(1, 1)

for (i in 1:8) {
  if (i == '奇數') {
    y[i+2] = y[i] + y[i+1]
  } else {
    y[i+2] = y[i] * y[i+1]
  }
}

y

這樣問題就只剩下，我們該如何判斷i是奇數還偶數呢?

練習2答案(2)

第一種解法是使用「%%」，這是最直覺的方法：

y = c(1, 1)

for (i in 1:8) {
  if (i %% 2 == 1) {
    y[i+2] = y[i] + y[i+1]
  } else {
    y[i+2] = y[i] * y[i+1]
  }
}

y

第二種解法是強迫其變成整數，這很類似我們練習1的方法：

y = c(1, 1)

for (i in 1:8) {
  if (as.integer(i/2) == i/2) {
    y[i+2] = y[i] + y[i+1]
  } else {
    y[i+2] = y[i] * y[i+1]
  }
}

y

第三種解法是最有趣的，還記得-1的n次方嗎？

y = c(1, 1)

for (i in 1:8) {
  if ((-1)^i == -1) {
    y[i+2] = y[i] + y[i+1]
  } else {
    y[i+2] = y[i] * y[i+1]
  }
}

y

練習2答案(3)

第四種解法也非常好玩，我們發現這其實是一個二循環的迴圈，那我們為什麼不把問題想成這樣。

– 這個解法的關鍵在於，我們需要改變我們的索引數：

y = c(1, 1)

i = 1
y[2*i+1] = y[2*i-1] + y[2*i]
y[2*i+2] = y[2*i] * y[2*i+1]
i = 2
y[2*i+1] = y[2*i-1] + y[2*i]
y[2*i+2] = y[2*i] * y[2*i+1]
i = 3
y[2*i+1] = y[2*i-1] + y[2*i]
y[2*i+2] = y[2*i] * y[2*i+1]
i = 4
y[2*i+1] = y[2*i-1] + y[2*i]
y[2*i+2] = y[2*i] * y[2*i+1]

y

寫成迴圈形式：

y = c(1, 1)

for (i in 1:4) {
  y[2*i+1] = y[2*i-1] + y[2*i]
  y[2*i+2] = y[2*i] * y[2*i+1]
}

y

第三節：多層次迴圈(1)

迴圈的美妙之處在於大量且快速的運算，而我們即將透過迴圈功能進行更複雜的組合任務

– 現在讓我們想辦法列出2:6內所有的「質數」

– 何謂質數?質數的定義為找不到比自己更小的可整除除數，如5以下的數字為2、3、4，而5無法被這些數字整除

– 現在讓我們思考該如何回答我們的問題…

第三節：多層次迴圈(2)

我們先產生一個物件x為2至6的所有數字

– 再使用函數「rep()」產生一個等長的物件answer.x表示物件x中相對應的元素是否為質數，而預設通通為TRUE

x = 2:6
answer.x = rep(TRUE, 5) #你也可以使用length(x)來替代5

一步一步來，先從3開始找起(3是x物件中的第2個數字)…

#對3進行檢測(x物件中的第2個數字)
if (x[2] %% x[1] == 0) {answer.x[2] = FALSE}

#對4進行檢測(x物件中的第3個數字)
if (x[3] %% x[1] == 0) {answer.x[3] = FALSE}
if (x[3] %% x[2] == 0) {answer.x[3] = FALSE}
  
#對5進行檢測(x物件中的第4個數字)
if (x[4] %% x[1] == 0) {answer.x[4] = FALSE}
if (x[4] %% x[2] == 0) {answer.x[4] = FALSE}
if (x[4] %% x[3] == 0) {answer.x[4] = FALSE}
  
#對6進行檢測(x物件中的第5個數字)
if (x[5] %% x[1] == 0) {answer.x[5] = FALSE}
if (x[5] %% x[2] == 0) {answer.x[5] = FALSE}
if (x[5] %% x[3] == 0) {answer.x[5] = FALSE}
if (x[5] %% x[4] == 0) {answer.x[5] = FALSE}

這樣我們使用answer.x做為x的索引函數，即可取得x內的質數：

x[answer.x]

## [1] 2 3 5

第三節：多層次迴圈(3)

聰明的你發現了一些規律，讓我們再次使用物件i來取代其中具有規律的部分…

#重新產生x與answer.x
x = 2:6
answer.x = rep(TRUE, 5)

#對3進行檢測(x物件中的第2個數字)
i = 2
if (x[i] %% x[1] == 0) {answer.x[i] = FALSE}

#對4進行檢測(x物件中的第3個數字)
i = 3
if (x[i] %% x[1] == 0) {answer.x[i] = FALSE}
if (x[i] %% x[2] == 0) {answer.x[i] = FALSE}
  
#對5進行檢測(x物件中的第4個數字)
i = 4
if (x[i] %% x[1] == 0) {answer.x[i] = FALSE}
if (x[i] %% x[2] == 0) {answer.x[i] = FALSE}
if (x[i] %% x[3] == 0) {answer.x[i] = FALSE}
  
#對6進行檢測(x物件中的第5個數字)
i = 5
if (x[i] %% x[1] == 0) {answer.x[i] = FALSE}
if (x[i] %% x[2] == 0) {answer.x[i] = FALSE}
if (x[i] %% x[3] == 0) {answer.x[i] = FALSE}
if (x[i] %% x[4] == 0) {answer.x[i] = FALSE}

#顯示所有質數
x[answer.x]

## [1] 2 3 5

這時候我們發現了一個討厭的問題，因為對於越後面的數字，要檢查的質數越多，因此對於每次檢查所需要的程式碼行數不同…

第三節：多層次迴圈(4)

這時一個有趣的想法就是，能不能產生另外一個物件j來取代i仍然無法解決的跳動的部分…

#重新產生x與answer.x
x = 2:6
answer.x = rep(TRUE, 5)

#對3進行檢測(x物件中的第2個數字)
i = 2
j = 1
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}

#對4進行檢測(x物件中的第3個數字)
i = 3
j = 1
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 2
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
  
#對5進行檢測(x物件中的第4個數字)
i = 4
j = 1
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 2
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 3
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
  
#對6進行檢測(x物件中的第5個數字)
i = 5
j = 1
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 2
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 3
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 4
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}

#顯示所有質數
x[answer.x]

## [1] 2 3 5

第三節：多層次迴圈(5)

讓我們先關注於6的部分

#對6進行檢測(x物件中的第5個數字)
i = 5
j = 1
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 2
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 3
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
j = 4
if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}

對於6的部分，似乎可以將這4行指令整合成一個以物件j為核心的迴圈…

#對6進行檢測(x物件中的第5個數字)
i = 5
for (j in 1:4) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}

第三節：多層次迴圈(6)

這個解法似乎可以擴展到所有的部分，差別只在於j的範圍不一致

#重新產生x與answer.x
x = 2:6
answer.x = rep(TRUE, 5)

#對3進行檢測(x物件中的第2個數字)
i = 2
for (j in 1:1) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}

#對4進行檢測(x物件中的第3個數字)
i = 3
for (j in 1:2) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}
  
#對5進行檢測(x物件中的第4個數字)
i = 4
for (j in 1:3) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}
  
#對6進行檢測(x物件中的第5個數字)
i = 5
for (j in 1:4) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}

#顯示所有質數
x[answer.x]

## [1] 2 3 5

第三節：多層次迴圈(7)

我們發現一件事情，那就是現在唯一會跳動的部分與物件i有關，他的最大值永遠是i-1，所以我們又能把程式整理成這樣…

#重新產生x與answer.x
x = 2:6
answer.x = rep(TRUE, 5)

#對3進行檢測(x物件中的第2個數字)
i = 2
for (j in 1:(i-1)) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}

#對4進行檢測(x物件中的第3個數字)
i = 3
for (j in 1:(i-1)) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}
  
#對5進行檢測(x物件中的第4個數字)
i = 4
for (j in 1:(i-1)) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}
  
#對6進行檢測(x物件中的第5個數字)
i = 5
for (j in 1:(i-1)) {
  if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
}

#顯示所有質數
x[answer.x]

## [1] 2 3 5

練習3：親手做出多層次迴圈

有趣的事情發生了，對於每個i的值來說，他所運行的程式碼是完全一樣的，所以可能可以再將i整合成一個迴圈

– 請你試著理解剛剛的每個過程，並找出100以下的質數有哪些。

– 但事實上質數可以再更精確的定義為找不到比自己更小的可整除的「質數」，如5以下的「質數」為2、3，因此在檢查5的時候我們其實不需要檢查4這個數字

如果你想要的話，還可以省略一些步驟…

練習3答案(1)

迴圈的基本概念就是重複執行N次同樣的程式碼，而這段程式碼也可以中間有個迴圈，因此合併剛剛的例子可以用下面的方法：

#重新產生x與answer.x
x = 2:6
answer.x = rep(TRUE, 5)

#i與j的組合迴圈
for (i in 2:5) {
  for (j in 1:(i-1)) {
    if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
  }
}

#顯示所有質數
x[answer.x]

## [1] 2 3 5

練習3答案(2)

透過雙層迴圈，這下我們如果要從2檢查到100，那就是輕而易舉的事情了…

#重新產生x與answer.x
x = 2:100
answer.x = rep(TRUE, 99)

#i與j的組合迴圈
for (i in 2:99) {
  for (j in 1:(i-1)) {
    if (x[i] %% x[j] == 0) {answer.x[i] = FALSE}
  }
}

#顯示所有質數
x[answer.x]

##  [1]  2  3  5  7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

你是否驚訝於迴圈組合的威力?

練習3引申

如果你想要找5000以下的質數，你會發現剛剛的語法非常慢，主要的原因是因為我們還有非常多步驟能省略，而這會快非常多！

– 我們其實只要檢查比\(\sqrt{n}\)更小的質數就好，並且如果遇到已經發現他不是質數了就可以跳過(使用「break」)！

x = 2:5000
answer.x = rep(TRUE, 4999)

for (i in 2:4999) {
  n = x[i]
  chech_n = as.integer(sqrt(n))
  for (j in 1:chech_n) {
    if (answer.x[j] == TRUE) {
      if (x[i] %% x[j] == 0) {
        answer.x[i] = FALSE
        break
      }
    }
  }
}

小結

本次課程介紹了條件判斷式與迴圈功能，這兩個功能是程式語言的基礎，我們可以大量利用電腦快速運算的特性幫助我們完成一些麻煩的事情

– 本節課學到功能如下，同學務必熟悉本次課程的內容：

if/else功能
索引函數與條件判斷的組合
迴圈運算

熟悉迴圈指令將能解放你的雙手，讓你免除於常規的重複工作！

R語言程式設計導論