Latihan Materi 1,2,dan 3

Latihan Materi 1 1. Menghitung simpangan baku nilai UTS

# Data nilai UTS
L <- c(40, 96, 57, 52, 84, 72, 60,
       85, 86, 73, 81, 78, 89, 54, 62)

n <- length(L)

# Menghitung rata-rata
total <- 0
for (i in 1:n) {
  total <- total + L[i]
}
rata <- total / n

# Menghitung jumlah kuadrat selisih
jumlah <- 0
for (i in 1:n) {
  jumlah <- jumlah + (L[i] - rata)^2
}

# Menghitung simpangan baku
simpangan <- sqrt(jumlah / n)

cat("Rata-rata =", rata, "\n")

## Rata-rata = 71.26667

cat("Simpangan baku =", simpangan)

## Simpangan baku = 15.70761

Modifikasi CariIdxMaks agar mengembalikan indeks kemunculan terakhir

CariIdxMaks <- function(L) {
  imaks <- 1

  for (i in 2:length(L)) {
    if (L[i] >= L[imaks]) {
      imaks <- i
    }
  }

  return(imaks)
}

# Data
L <- c(4, 9, 2, 9, 1)

hasil <- CariIdxMaks(L)

cat("Indeks maksimum terakhir =", hasil)

## Indeks maksimum terakhir = 4

cat("\nNilai maksimum =", L[hasil])

## 
## Nilai maksimum = 9

Prosedur MaksMinSekaligus dalam satu kali traversal

MaksMinSekaligus <- function(L) {
  imaks <- 1
  imin <- 1
  perbandingan <- 0

  for (i in 2:length(L)) {

    perbandingan <- perbandingan + 1
    if (L[i] > L[imaks]) {
      imaks <- i
    }

    perbandingan <- perbandingan + 1
    if (L[i] < L[imin]) {
      imin <- i
    }
  }

  list(
    maksimum = L[imaks],
    indeks_maks = imaks,
    minimum = L[imin],
    indeks_min = imin,
    perbandingan = perbandingan
  )
}

L <- c(25, 22, 18, 20, 15)

hasil <- MaksMinSekaligus(L)
print(hasil)

## $maksimum
## [1] 25
## 
## $indeks_maks
## [1] 1
## 
## $minimum
## [1] 15
## 
## $indeks_min
## [1] 5
## 
## $perbandingan
## [1] 8

Mencari hari dengan kenaikan harian terbesar DAX

# Memanggil dataset
data("EuStockMarkets")

# Mengambil data DAX
DAX <- EuStockMarkets[, "DAX"]

n <- length(DAX)

# Inisialisasi
maks <- DAX[2] - DAX[1]
hari <- 2

# Menghitung kenaikan harian
for (i in 2:n) {
  kenaikan <- DAX[i] - DAX[i-1]

  if (kenaikan > maks) {
    maks <- kenaikan
    hari <- i
  }
}

cat("Kenaikan harian terbesar =", maks, "\n")

## Kenaikan harian terbesar = 160.97

cat("Terjadi pada hari ke-", hari)

## Terjadi pada hari ke- 1653

Menghitung jumlah dan rata-rata per kolom matriks penjualan

# Membuat matriks penjualan
M <- matrix(c(
  10, 45, 34, 43,
  63, 69, 22, 13,
  13, 82, 23, 60
), nrow = 3, byrow = TRUE)

nbar <- nrow(M)
nkol <- ncol(M)

jumlah <- numeric(nkol)
rata <- numeric(nkol)

# Menghitung jumlah dan rata-rata per kolom
for (j in 1:nkol) {
  total <- 0

  for (i in 1:nbar) {
    total <- total + M[i, j]
  }

  jumlah[j] <- total
  rata[j] <- total / nbar
}

# Mencari minggu dengan penjualan tertinggi
maks <- jumlah[1]
minggu <- 1

for (j in 2:nkol) {
  if (jumlah[j] > maks) {
    maks <- jumlah[j]
    minggu <- j
  }
}

cat("Jumlah per minggu:\n")

## Jumlah per minggu:

print(jumlah)

## [1]  86 196  79 116

cat("Rata-rata per minggu:\n")

## Rata-rata per minggu:

print(rata)

## [1] 28.66667 65.33333 26.33333 38.66667

cat("Penjualan tertinggi pada minggu ke-", minggu)

## Penjualan tertinggi pada minggu ke- 2

Membuktikan matriks Python dengan baris saling terkait

# Membuat matriks 3 x 3
M <- matrix(0, nrow = 3, ncol = 3)

# Mengubah elemen baris 1 kolom 1
M[1, 1] <- 5

# Menampilkan matriks
print(M)

##      [,1] [,2] [,3]
## [1,]    5    0    0
## [2,]    0    0    0
## [3,]    0    0    0

Latihan Materi 2 1. Menelusuri SeqSearch1 dan SeqSearch2

SeqSearch1 <- function(L, x) {
  n <- length(L)
  i <- 1

  while (i < n && L[i] != x) {
    i <- i + 1
  }

  if (L[i] == x) {
    return(i)
  } else {
    return(0)
  }
}

SeqSearch2 <- function(L, x) {
  n <- length(L)
  i <- 1
  ketemu <- FALSE

  while (i <= n && !ketemu) {
    if (L[i] == x) {
      ketemu <- TRUE
    } else {
      i <- i + 1
    }
  }

  if (ketemu) return(i) else return(0)
}

L <- c(7, 3, 9, 3, 5)

print(SeqSearch1(L, 3))

## [1] 2

print(SeqSearch1(L, 8))

## [1] 0

print(SeqSearch2(L, 3))

## [1] 2

print(SeqSearch2(L, 8))

## [1] 0

Pengaruh tidak adanya evaluasi short-circuit

L <- c(7, 3, 9, 3, 5)
n <- length(L)
x <- 8

i <- 1
ketemu <- FALSE

while (i <= n && !ketemu) {
  if (L[i] == x) {
    ketemu <- TRUE
  } else {
    i <- i + 1
  }
}

if (ketemu) {
  print(i)
} else {
  print("Data tidak ditemukan")
}

## [1] "Data tidak ditemukan"

Menelusuri BinSearch1 dan BinSearch2

BinSearch1 <- function(L, x) {
  i <- 1
  j <- length(L)
  ketemu <- FALSE

  while (!ketemu && i <= j) {
    k <- (i + j) %/% 2

    if (L[k] == x) {
      ketemu <- TRUE
    } else if (L[k] < x) {
      i <- k + 1
    } else {
      j <- k - 1
    }
  }

  if (ketemu) return(k) else return(0)
}

BinSearch2 <- function(L, x) {
  i <- 1
  j <- length(L)

  while (i < j) {
    k <- (i + j) %/% 2

    if (L[k] < x) {
      i <- k + 1
    } else {
      j <- k
    }
  }

  if (L[i] == x) return(i) else return(0)
}

L <- c(2, 5, 8, 12, 16, 23, 38, 56, 72, 91)

print(BinSearch1(L, 23))

## [1] 6

print(BinSearch1(L, 6))

## [1] 0

print(BinSearch2(L, 23))

## [1] 6

print(BinSearch2(L, 6))

## [1] 0

Mengubah binary search untuk larik terurut menurun

BinaryMenurun <- function(L, x) {
  i <- 1
  j <- length(L)

  while (i <= j) {
    k <- (i + j) %/% 2

    if (L[k] == x) {
      return(k)
    } else if (L[k] > x) {
      i <- k + 1
    } else {
      j <- k - 1
    }
  }

  return(0)
}

L <- c(91, 72, 56, 38, 23, 16, 12, 8, 5, 2)

print(BinaryMenurun(L, 23))

## [1] 5

print(BinaryMenurun(L, 6))

## [1] 0

Mengurutkan nama kota dan mencari Seattle Tacoma

# Memanggil data precip
data("precip")

# Mengambil nama kota
kota <- names(precip)

# Mengurutkan nama kota
kota_urut <- kota[order(kota)]

# Nilai yang dicari
x <- "Seattle Tacoma"

# Binary Search
i <- 1
j <- length(kota_urut)
cmp_bin <- 0
idx <- 0

while (i <= j) {
  k <- (i + j) %/% 2
  cmp_bin <- cmp_bin + 1

  if (kota_urut[k] == x) {
    idx <- k
    break
  } else if (kota_urut[k] < x) {
    i <- k + 1
  } else {
    j <- k - 1
  }
}

# Sequential Search
cmp_seq <- 0
idx_seq <- 0

for (i in 1:length(kota)) {
  cmp_seq <- cmp_seq + 1

  if (kota[i] == x) {
    idx_seq <- i
    break
  }
}

cat("Posisi setelah diurutkan =", idx, "\n")

## Posisi setelah diurutkan = 64

cat("Perbandingan binary search =", cmp_bin, "\n")

## Perbandingan binary search = 5

cat("Posisi sequential search =", idx_seq, "\n")

## Posisi sequential search = 65

cat("Perbandingan sequential search =", cmp_seq)

## Perbandingan sequential search = 65

Membuat fungsi binary search rekursif

BinaryRekursif <- function(L, x,
                           kiri = 1,
                           kanan = length(L)) {

  # Kondisi berhenti
  if (kiri > kanan) {
    return(0)
  }

  # Menentukan titik tengah
  tengah <- (kiri + kanan) %/% 2

  if (L[tengah] == x) {
    return(tengah)

  } else if (L[tengah] < x) {

    return(BinaryRekursif(
      L, x, tengah + 1, kanan
    ))

  } else {

    return(BinaryRekursif(
      L, x, kiri, tengah - 1
    ))
  }
}

L <- c(2, 5, 8, 12, 16, 23, 38, 56, 72, 91)

print(BinaryRekursif(L, 23))

## [1] 6

print(BinaryRekursif(L, 6))

## [1] 0

Perbandingan maksimum binary search untuk n = 1.000.000

n <- 1000000

perbandingan <- ceiling(log2(n + 1))

cat("Jumlah data =", n, "\n")

## Jumlah data = 1e+06

cat("Perbandingan maksimum =", perbandingan)

## Perbandingan maksimum = 20

Latihan Materi 3 1. Menelusuri seleksi maksimum dan seleksi minimum secara menurun

#Seleksi Maksimum
SeleksiMaks <- function(L) {
  n <- length(L)

  for (i in 1:(n-1)) {
    imaks <- i

    for (j in (i+1):n) {
      if (L[j] > L[imaks]) {
        imaks <- j
      }
    }

    temp <- L[i]
    L[i] <- L[imaks]
    L[imaks] <- temp

    cat("Pass", i, ":", L, "\n")
  }

  return(L)
}

L <- c(25, 22, 18, 20, 15)

print(SeleksiMaks(L))

## Pass 1 : 25 22 18 20 15 
## Pass 2 : 25 22 18 20 15 
## Pass 3 : 25 22 20 18 15 
## Pass 4 : 25 22 20 18 15 
## [1] 25 22 20 18 15

#Seleksi Minimum
SeleksiMin <- function(L) {
  n <- length(L)

  for (i in n:2) {
    imin <- 1

    for (j in 2:i) {
      if (L[j] < L[imin]) {
        imin <- j
      }
    }

    temp <- L[i]
    L[i] <- L[imin]
    L[imin] <- temp

    cat("Pass", n-i+1, ":", L, "\n")
  }

  return(L)
}

L <- c(25, 22, 18, 20, 15)

print(SeleksiMin(L))

## Pass 1 : 25 22 18 20 15 
## Pass 2 : 25 22 20 18 15 
## Pass 3 : 25 22 20 18 15 
## Pass 4 : 25 22 20 18 15 
## [1] 25 22 20 18 15

Menelusuri insertion sort dan menghitung perbandingan serta pergeseran

InsertionSort <- function(L) {
  n <- length(L)
  perbandingan <- 0
  pergeseran <- 0

  for (i in 2:n) {
    y <- L[i]
    j <- i - 1

    while (j >= 1) {
      perbandingan <- perbandingan + 1

      if (y < L[j]) {
        L[j+1] <- L[j]
        pergeseran <- pergeseran + 1
        j <- j - 1
      } else {
        break
      }
    }

    L[j+1] <- y

    cat("Pass", i-1, ":", L, "\n")
  }

  cat("Perbandingan =", perbandingan, "\n")
  cat("Pergeseran =", pergeseran, "\n")

  return(L)
}

L1 <- c(5, 4, 3, 2, 1)
L2 <- c(1, 2, 3, 5, 4)

cat("Data pertama:\n")

## Data pertama:

print(InsertionSort(L1))

## Pass 1 : 4 5 3 2 1 
## Pass 2 : 3 4 5 2 1 
## Pass 3 : 2 3 4 5 1 
## Pass 4 : 1 2 3 4 5 
## Perbandingan = 10 
## Pergeseran = 10 
## [1] 1 2 3 4 5

cat("Data kedua:\n")

## Data kedua:

print(InsertionSort(L2))

## Pass 1 : 1 2 3 5 4 
## Pass 2 : 1 2 3 5 4 
## Pass 3 : 1 2 3 5 4 
## Pass 4 : 1 2 3 4 5 
## Perbandingan = 5 
## Pergeseran = 1 
## [1] 1 2 3 4 5

Apakah selection sort bersifat stabil?

# Data nama dan nilai
nama <- c("Ani", "Budi", "Cici")
nilai <- c(2, 2, 1)

n <- length(nilai)

# Selection sort
for (i in 1:(n-1)) {
  imin <- i

  for (j in (i+1):n) {
    if (nilai[j] < nilai[imin]) {
      imin <- j
    }
  }

  # Pertukaran nilai
  temp <- nilai[i]
  nilai[i] <- nilai[imin]
  nilai[imin] <- temp

  # Pertukaran nama
  temp <- nama[i]
  nama[i] <- nama[imin]
  nama[imin] <- temp
}

cat("Nama setelah pengurutan:\n")

## Nama setelah pengurutan:

print(nama)

## [1] "Cici" "Budi" "Ani"

cat("Nilai setelah pengurutan:\n")

## Nilai setelah pengurutan:

print(nilai)

## [1] 1 2 2

Memodifikasi insertion sort menggunakan binary search (binary insertion sort)

BinaryInsertionSort <- function(L) {
  n <- length(L)
  perbandingan <- 0
  pergeseran <- 0

  for (i in 2:n) {
    y <- L[i]

    # Binary search posisi sisip
    kiri <- 1
    kanan <- i

    while (kiri < kanan) {
      tengah <- (kiri + kanan) %/% 2
      perbandingan <- perbandingan + 1

      if (y < L[tengah]) {
        kanan <- tengah
      } else {
        kiri <- tengah + 1
      }
    }

    # Menggeser elemen
    j <- i - 1

    while (j >= kiri) {
      L[j+1] <- L[j]
      pergeseran <- pergeseran + 1
      j <- j - 1
    }

    # Menyisipkan elemen
    L[kiri] <- y

    cat("Pass", i-1, ":", L, "\n")
  }

  cat("Perbandingan =", perbandingan, "\n")
  cat("Pergeseran =", pergeseran, "\n")

  return(L)
}

L <- c(5, 4, 3, 2, 1)

print(BinaryInsertionSort(L))

## Pass 1 : 4 5 3 2 1 
## Pass 2 : 3 4 5 2 1 
## Pass 3 : 2 3 4 5 1 
## Pass 4 : 1 2 3 4 5 
## Perbandingan = 8 
## Pergeseran = 10 
## [1] 1 2 3 4 5

Mengurutkan 50 harga CAC pertama secara menurun

# Memanggil dataset
data("EuStockMarkets")

# Mengambil 50 harga CAC pertama
CAC <- EuStockMarkets[1:50, "CAC"]

# Selection sort menurun
SelectionSort <- function(L) {
  n <- length(L)
  perbandingan <- 0
  pertukaran <- 0

  for (i in 1:(n-1)) {
    imaks <- i

    for (j in (i+1):n) {
      perbandingan <- perbandingan + 1

      if (L[j] > L[imaks]) {
        imaks <- j
      }
    }

    if (imaks != i) {
      temp <- L[i]
      L[i] <- L[imaks]
      L[imaks] <- temp

      pertukaran <- pertukaran + 1
    }
  }

  cat("Perbandingan selection =", perbandingan, "\n")
  cat("Pertukaran selection =", pertukaran, "\n")

  return(L)
}

# Insertion sort menurun
InsertionSort <- function(L) {
  n <- length(L)
  perbandingan <- 0
  pergeseran <- 0

  for (i in 2:n) {
    y <- L[i]
    j <- i - 1

    while (j >= 1) {
      perbandingan <- perbandingan + 1

      if (L[j] < y) {
        L[j+1] <- L[j]
        pergeseran <- pergeseran + 1
        j <- j - 1
      } else {
        break
      }
    }

    L[j+1] <- y
  }

  cat("Perbandingan insertion =", perbandingan, "\n")
  cat("Pergeseran insertion =", pergeseran, "\n")

  return(L)
}

# Menjalankan kedua algoritma
cat("SELECTION SORT:\n")

## SELECTION SORT:

hasil1 <- SelectionSort(CAC)

## Perbandingan selection = 1225 
## Pertukaran selection = 47

cat("\nINSERTION SORT:\n")

## 
## INSERTION SORT:

hasil2 <- InsertionSort(CAC)

## Perbandingan insertion = 1069 
## Pergeseran insertion = 1031

cat("\nHasil selection sort:\n")

## 
## Hasil selection sort:

print(hasil1)

##  [1] 1873.2 1868.7 1864.3 1863.5 1860.8 1860.4 1857.7 1853.4 1851.8 1849.7
## [11] 1833.5 1820.3 1820.3 1820.3 1819.1 1808.8 1792.9 1789.5 1783.5 1782.4
## [21] 1780.4 1780.1 1778.1 1772.8 1768.9 1767.7 1766.8 1766.5 1763.5 1762.8
## [31] 1762.2 1759.8 1759.5 1758.1 1757.9 1757.5 1757.4 1756.6 1755.5 1754.7
## [41] 1754.3 1754.0 1750.5 1734.5 1725.6 1723.1 1718.0 1714.3 1708.1 1687.5

cat("\nHasil insertion sort:\n")

## 
## Hasil insertion sort:

print(hasil2)

##  [1] 1873.2 1868.7 1864.3 1863.5 1860.8 1860.4 1857.7 1853.4 1851.8 1849.7
## [11] 1833.5 1820.3 1820.3 1820.3 1819.1 1808.8 1792.9 1789.5 1783.5 1782.4
## [21] 1780.4 1780.1 1778.1 1772.8 1768.9 1767.7 1766.8 1766.5 1763.5 1762.8
## [31] 1762.2 1759.8 1759.5 1758.1 1757.9 1757.5 1757.4 1756.6 1755.5 1754.7
## [41] 1754.3 1754.0 1750.5 1734.5 1725.6 1723.1 1718.0 1714.3 1708.1 1687.5

cat("\nApakah hasilnya sama? ",
    all(hasil1 == hasil2))

## 
## Apakah hasilnya sama?  TRUE

Latihan Materi 1,2,dan 3

Pebriani Kristina

2026-11-14