1. Gunakan simulasi untuk menghitung nilai pendekatan dari E[X^2] untuk variabel random berdistribusi Uniform jika X∼U(0,1). Gunakan 10.000 angka random.

n_simulasi <- 10000

set.seed(123)
X <- runif(n_simulasi, min = 0, max = 1)
X_squared <- X^2
estimasi_EX2 <- mean(X_squared)

cat("Jumlah simulasi:", n_simulasi, "\n")
## Jumlah simulasi: 10000
cat("Estimasi E[X^2] dari simulasi:", estimasi_EX2, "\n")
## Estimasi E[X^2] dari simulasi: 0.3297405
nilai_teoretis_EX2 <- 1/3
cat("Nilai teoretis E[X^2] (1/3):", nilai_teoretis_EX2, "\n")
## Nilai teoretis E[X^2] (1/3): 0.3333333
cat("Selisih (Absolut):", abs(estimasi_EX2 - nilai_teoretis_EX2), "\n")
## Selisih (Absolut): 0.003592882

2. Buat masing-masing untuk n1 = 100, n2 = 1000, dan n = 10000 angka random dari N(100,15^2), lalu hitung rata-rata, simpangan baku, dan plot histogram. Berikan penjelasan hasil yang Saudara peroleh.

mu <- 100   
sigma <- 15  
variance <- sigma^2 

n_values <- c(100, 1000, 10000)

set.seed(123)

for (n in n_values) {
  cat("\n======================================\n")
  cat("Simulasi untuk n =", n, "\n")
  cat("======================================\n")

  data_simulasi <- rnorm(n, mean = mu, sd = sigma)

  mean_sample <- mean(data_simulasi)
  cat("Rata-rata sampel:", mean_sample, "\n")
  cat("Perbedaan dengan rata-rata populasi (mu =", mu, "):", mean_sample - mu, "\n")

  sd_sample <- sd(data_simulasi)
  cat("Simpangan baku sampel:", sd_sample, "\n")
  cat("Perbedaan dengan simpangan baku populasi (sigma =", sigma, "):", sd_sample - sigma, "\n")

  hist(data_simulasi,
       main = paste("Histogram Data Random dari N(100, 15^2) untuk n =", n),
       xlab = "Nilai",
       ylab = "Frekuensi",
       col = "lightgreen",
       border = "black",
       xlim = c(mu - 4*sigma, mu + 4*sigma) # Menyesuaikan rentang x agar konsisten
       )
  abline(v = mean_sample, col = "red", lty = 2, lwd = 2)
  text(mean_sample, par("usr")[4]*0.9, paste("Rata-rata Sampel =", round(mean_sample, 2)),
       col = "red", pos = 4)
  abline(v = mu, col = "blue", lty = 2, lwd = 2)
  text(mu, par("usr")[4]*0.8, paste("Rata-rata Populasi =", mu),
       col = "blue", pos = 2)
}
## 
## ======================================
## Simulasi untuk n = 100 
## ======================================
## Rata-rata sampel: 101.3561 
## Perbedaan dengan rata-rata populasi (mu = 100 ): 1.356089 
## Simpangan baku sampel: 13.69224 
## Perbedaan dengan simpangan baku populasi (sigma = 15 ): -1.307762

## 
## ======================================
## Simulasi untuk n = 1000 
## ======================================
## Rata-rata sampel: 100.2862 
## Perbedaan dengan rata-rata populasi (mu = 100 ): 0.28622 
## Simpangan baku sampel: 15.06891 
## Perbedaan dengan simpangan baku populasi (sigma = 15 ): 0.06890598

## 
## ======================================
## Simulasi untuk n = 10000 
## ======================================
## Rata-rata sampel: 99.96336 
## Perbedaan dengan rata-rata populasi (mu = 100 ): -0.03663945 
## Simpangan baku sampel: 14.98314 
## Perbedaan dengan simpangan baku populasi (sigma = 15 ): -0.01686462

Hasil simulasi menunjukan semakin besar ukuran sampel (n), maka semakin akurat estimasi rata-rata sampel dan simpangan baku sampel terhadap parameter populasi. Selain itu, semakin besar n, data yang dihasilkan juga akan semakin membentuk distribusi yang normal. Ini menunjukan bahwa ukuran sampel yang lebih besar memberikan inferensi statistik yang lebih reliabel dan representasi distribusi populasi yang lebih baik.

3. Simulasikan distribusi binomial Bin(30,0.25) sebanyak 5000 kali. Tentukan nilai estimasikan P(X≥15).

n_trials <- 30  
p_success <- 0.25 
num_simulations <- 5000

set.seed(123)
simulated_data <- rbinom(num_simulations, size = n_trials, prob = p_success)

count_X_ge_15 <- sum(simulated_data >= 15)
estimated_prob <- count_X_ge_15 / num_simulations

cat("Jumlah simulasi:", num_simulations, "\n")
## Jumlah simulasi: 5000
cat("Jumlah percobaan (n):", n_trials, "\n")
## Jumlah percobaan (n): 30
cat("Probabilitas keberhasilan (p):", p_success, "\n")
## Probabilitas keberhasilan (p): 0.25
cat("----------------------------------------\n")
## ----------------------------------------
cat("Jumlah kejadian (X >= 15) dalam simulasi:", count_X_ge_15, "\n")
## Jumlah kejadian (X >= 15) dalam simulasi: 12
cat("Estimasi P(X >= 15) dari simulasi:", estimated_prob, "\n")
## Estimasi P(X >= 15) dari simulasi: 0.0024
theoretical_prob <- 1 - pbinom(14, size = n_trials, prob = p_success)
cat("Nilai teoretis P(X >= 15):", theoretical_prob, "\n")
## Nilai teoretis P(X >= 15): 0.002749534
cat("Selisih (Absolut):", abs(estimated_prob - theoretical_prob), "\n")
## Selisih (Absolut): 0.0003495342

4. Buatlah function untuk rumus berikut:

Rumus simpangan baku yang dimaksud adalah sebagai berikut: \[s = \sqrt{\frac{\sum x^2 - (\sum x)^2}{n - 1}}\] Hitung nilai s dengan membangkitkan data berdistribusi normal sebanyak data 1000, rata-rata 89, dan standar deviasi 10.

hitung_s <- function(data_vector) {
  n <- length(data_vector)
  sum_x <- sum(data_vector)
  sum_x_squared <- sum(data_vector^2)
  numerator <- sum_x_squared - ((sum_x)^2 / n) 
  s_value <- sqrt(numerator / (n - 1))
  return(s_value)
}

data_n <- 1000 # Jumlah data
data_mean <- 89 # Rata-rata populasi
data_sd <- 10   # Standar deviasi populasi

set.seed(123)

data <- rnorm(data_n, mean = data_mean, sd = data_sd)

# --- Menggunakan fungsi bawaan R (untuk perbandingan) ---
output <- sd(data)
cat("----------------------------------------\n")
## ----------------------------------------
cat("Nilai s menggunakan fungsi sd() bawaan R:",output, "\n")
## Nilai s menggunakan fungsi sd() bawaan R: 9.91695
cat("----------------------------------------\n")
## ----------------------------------------
cat("----------------------------------------\n")
## ----------------------------------------
cat("Nilai s menggunakan fungsi hitung_s bawaan R:",hitung_s(data), "\n")
## Nilai s menggunakan fungsi hitung_s bawaan R: 9.91695
cat("----------------------------------------\n")
## ----------------------------------------

5. (Simulasi Antrian di Bank) Sebuah bank memiliki 2 teller dengan kondisi berikut:

  1. Buatlah simulasi antrian selama 20 hari kerja
set.seed(123)

# === PARAMETER DASAR ===
jam_operasi <- 6
menit_per_hari <- jam_operasi * 60
kedatangan_per_menit <- 5 / 60  # Poisson arrival rate per minute
lambda_pelayanan <- 1/8         # rata-rata 8 menit pelayanan
jumlah_teller <- 2
jumlah_hari <- 20

# Fungsi simulasi 1 hari antrian
simulasi_hari <- function() {
  waktu_teller <- rep(0, jumlah_teller)  # waktu selesai masing-masing teller
  pelanggan_datang <- cumsum(rexp(1000, rate = kedatangan_per_menit))
  pelanggan_datang <- pelanggan_datang[pelanggan_datang < menit_per_hari]
  n <- length(pelanggan_datang)
  
  waktu_tunggu <- numeric(n)
  waktu_pelayanan <- numeric(n)
  teller_aktif <- integer(n)
  
  for (i in 1:n) {
    waktu <- pelanggan_datang[i]
    idx_teller <- which.min(waktu_teller)
    waktu_mulai <- max(waktu, waktu_teller[idx_teller])
    delay <- waktu_mulai - waktu
    pelayanan <- rexp(1, lambda_pelayanan)
    
    waktu_teller[idx_teller] <- waktu_mulai + pelayanan
    waktu_tunggu[i] <- delay
    waktu_pelayanan[i] <- pelayanan
    teller_aktif[i] <- idx_teller
  }
  
  data.frame(
    hari = rep(1, n),
    datang = pelanggan_datang,
    tunggu = waktu_tunggu,
    pelayanan = waktu_pelayanan,
    teller = teller_aktif
  )
}

# === SIMULASI 20 HARI ===
data_simulasi <- do.call(rbind, lapply(1:jumlah_hari, function(h) {
  sim_data <- simulasi_hari()
  sim_data$hari <- h
  return(sim_data)
}))

# Lihat beberapa hasil
head(data_simulasi)
##   hari   datang    tunggu  pelayanan teller
## 1    1 10.12149  0.000000  1.7879745      1
## 2    1 17.04081  0.000000  0.9410038      2
## 3    1 32.98947  0.000000 24.4122964      1
## 4    1 33.36840  0.000000  3.9245111      2
## 5    1 34.04293  3.249979 16.3055498      2
## 6    1 37.84094 15.757515  2.5039354      2
# Jumlah nasabah total selama 20 hari
cat("Total nasabah selama 20 hari:", nrow(data_simulasi), "\n")
## Total nasabah selama 20 hari: 569
  1. Hitung berapa lama - rata-rata nasabah menunggu
# Rata-rata waktu tunggu dari seluruh nasabah
rata2_tunggu <- mean(data_simulasi$tunggu)

cat("Rata-rata waktu tunggu nasabah selama 20 hari adalah:", 
    round(rata2_tunggu, 2), "menit\n")
## Rata-rata waktu tunggu nasabah selama 20 hari adalah: 0.88 menit
  1. Hitung berapa persen waktu teller sibuk bekerja
# Total waktu kerja per teller selama 20 hari
total_waktu_kerja <- 20 * 360  # dalam menit

# Hitung total waktu sibuk tiap teller
waktu_sibuk_per_teller <- tapply(data_simulasi$pelayanan, 
                                 data_simulasi$teller, sum)

# Hitung persen sibuk
persen_sibuk <- (waktu_sibuk_per_teller / total_waktu_kerja) * 100

# Tampilkan hasil
for (i in 1:length(persen_sibuk)) {
  cat(sprintf("Teller %d sibuk %.2f%% dari total waktu kerja\n", 
              i, persen_sibuk[i]))
}
## Teller 1 sibuk 29.59% dari total waktu kerja
## Teller 2 sibuk 28.47% dari total waktu kerja
  1. Bandingkan jika bank menambah 1 teller lagi - apakah efisien?
simulasi_20hari <- function(jml_teller = 2, seed = 123) {
  set.seed(seed)
  
  # Parameter
  jam_operasi <- 6
  menit_per_hari <- jam_operasi * 60
  kedatangan_per_menit <- 5 / 60
  lambda_pelayanan <- 1/8
  jumlah_hari <- 20
  
  semua_data <- list()
  
  for (h in 1:jumlah_hari) {
    waktu_teller <- rep(0, jml_teller)
    pelanggan_datang <- cumsum(rexp(1000, rate = kedatangan_per_menit))
    pelanggan_datang <- pelanggan_datang[pelanggan_datang < menit_per_hari]
    n <- length(pelanggan_datang)
    
    waktu_tunggu <- numeric(n)
    waktu_pelayanan <- numeric(n)
    teller_aktif <- integer(n)
    
    for (i in 1:n) {
      waktu <- pelanggan_datang[i]
      idx_teller <- which.min(waktu_teller)
      waktu_mulai <- max(waktu, waktu_teller[idx_teller])
      delay <- waktu_mulai - waktu
      pelayanan <- rexp(1, lambda_pelayanan)
      
      waktu_teller[idx_teller] <- waktu_mulai + pelayanan
      waktu_tunggu[i] <- delay
      waktu_pelayanan[i] <- pelayanan
      teller_aktif[i] <- idx_teller
    }
    
    hari_data <- data.frame(
      hari = h,
      datang = pelanggan_datang,
      tunggu = waktu_tunggu,
      pelayanan = waktu_pelayanan,
      teller = teller_aktif + 1  # dari 1 sampai jml_teller
    )
    semua_data[[h]] <- hari_data
  }
  
  data_simulasi <- do.call(rbind, semua_data)
  return(data_simulasi)
}

# Jalankan simulasi untuk 3 teller
data_3teller <- simulasi_20hari(jml_teller = 3)

# Hitung rata-rata waktu tunggu
rata2_tunggu_3teller <- mean(data_3teller$tunggu)

# Hitung persen sibuk per teller
total_waktu_kerja <- 20 * 360
waktu_sibuk_3 <- tapply(data_3teller$pelayanan, data_3teller$teller, sum)
persen_sibuk_3 <- (waktu_sibuk_3 / total_waktu_kerja) * 100

# Tampilkan hasil
cat("=== HASIL SIMULASI DENGAN 3 TELLER ===\n")
## === HASIL SIMULASI DENGAN 3 TELLER ===
cat("Rata-rata waktu tunggu nasabah:", round(rata2_tunggu_3teller, 2), "menit\n\n")
## Rata-rata waktu tunggu nasabah: 0.07 menit
for (i in 1:length(persen_sibuk_3)) {
  cat(sprintf("Teller %d sibuk %.2f%% dari total waktu kerja\n", 
              i, persen_sibuk_3[i]))
}
## Teller 1 sibuk 20.33% dari total waktu kerja
## Teller 2 sibuk 19.38% dari total waktu kerja
## Teller 3 sibuk 18.35% dari total waktu kerja
  1. Buat grafik yang menunjukkan panjang antrian sepanjang hari
set.seed(123)

# Parameter
jumlah_teller <- 2
durasi_hari <- 6 * 60
kedatangan_per_menit <- 5 / 60
lambda_pelayanan <- 1 / 8

# Simulasi untuk 1 hari
waktu_teller <- rep(0, jumlah_teller)
pelanggan_datang <- cumsum(rexp(1000, rate = kedatangan_per_menit))
pelanggan_datang <- pelanggan_datang[pelanggan_datang < durasi_hari]
n <- length(pelanggan_datang)

waktu_mulai <- numeric(n)
waktu_selesai <- numeric(n)

for (i in 1:n) {
  waktu <- pelanggan_datang[i]
  idx_teller <- which.min(waktu_teller)
  mulai <- max(waktu, waktu_teller[idx_teller])
  pelayanan <- rexp(1, lambda_pelayanan)
  selesai <- mulai + pelayanan
  
  waktu_teller[idx_teller] <- selesai
  waktu_mulai[i] <- mulai
  waktu_selesai[i] <- selesai
}

# Hitung panjang antrian pada setiap menit dari 0 sampai 360
time_points <- 0:durasi_hari
panjang_antrian <- sapply(time_points, function(t) {
  sum(pelanggan_datang <= t & waktu_mulai > t)
})

# Plot
plot(time_points, panjang_antrian, type = "l", col = "blue", lwd = 2,
     xlab = "Waktu (menit)", ylab = "Panjang Antrian",
     main = "Panjang Antrian Sepanjang Hari")
grid()

6. (Simulasi toko kelontong) Bu Sari memiliki toko kelontong yang menjual beras dengan kondisi sebagai berikut.

  1. Simulasikan stok beras selama 60 hari
set.seed(123)

# Parameter
stok_awal <- 100
hari_total <- 60
jumlah_pesan <- 50
frekuensi_pesan <- 5

# Simulasi permintaan harian: normal dibatasi ke 8–15 karung
permintaan <- round(pmin(pmax(rnorm(hari_total, mean = 11.5, sd = 2), 8), 15))

# Vektor penyimpanan hasil
stok_harian <- numeric(hari_total)
stok_sisa <- stok_awal
habis_hari <- 0  # hitung hari kehabisan stok

for (hari in 1:hari_total) {
  # Pesan ulang setiap kelipatan 5 hari
  if (hari %% frekuensi_pesan == 1 && hari != 1) {
    stok_sisa <- stok_sisa + jumlah_pesan
  }
  
  # Hitung sisa stok dan apakah ada kehabisan
  if (permintaan[hari] <= stok_sisa) {
    stok_sisa <- stok_sisa - permintaan[hari]
  } else {
    # Kehabisan stok
    habis_hari <- habis_hari + 1
    stok_sisa <- 0
  }
  
  stok_harian[hari] <- stok_sisa
}

# Tampilkan ringkasan hasil
hasil_simulasi <- data.frame(
  Hari = 1:hari_total,
  Permintaan = permintaan,
  Stok_Akhir = stok_harian
)

print(head(hasil_simulasi, 10))  # tampilkan 10 hari pertama
##    Hari Permintaan Stok_Akhir
## 1     1         10         90
## 2     2         11         79
## 3     3         15         64
## 4     4         12         52
## 5     5         12         40
## 6     6         15         75
## 7     7         12         63
## 8     8          9         54
## 9     9         10         44
## 10   10         11         33
cat("\nJumlah hari kehabisan stok:", habis_hari, "dari", hari_total, "hari\n")
## 
## Jumlah hari kehabisan stok: 6 dari 60 hari
  1. Hitung berapa kali toko kehabisan stok
set.seed(123)

# Parameter
stok_awal <- 100
hari_total <- 60
jumlah_pesan <- 50
frekuensi_pesan <- 5
rugi_per_karung <- 50000

# Permintaan harian (Normal dibatasi ke 8-15)
permintaan <- round(pmin(pmax(rnorm(hari_total, mean = 11.5, sd = 2), 8), 15))

# Inisialisasi
stok_harian <- numeric(hari_total)
stok_sisa <- stok_awal
habis_hari <- 0
total_kurang <- 0

for (hari in 1:hari_total) {
  if (hari %% frekuensi_pesan == 1 && hari != 1) {
    stok_sisa <- stok_sisa + jumlah_pesan
  }
  
  if (permintaan[hari] <= stok_sisa) {
    stok_sisa <- stok_sisa - permintaan[hari]
  } else {
    # Kehabisan stok
    kurang <- permintaan[hari] - stok_sisa
    total_kurang <- total_kurang + kurang
    stok_sisa <- 0
    habis_hari <- habis_hari + 1
  }
  
  stok_harian[hari] <- stok_sisa
}

# Hasil akhir
kerugian <- total_kurang * rugi_per_karung

cat("Jumlah hari kehabisan stok:", habis_hari, "hari\n")
## Jumlah hari kehabisan stok: 6 hari
cat("Total karung yang tidak terpenuhi:", total_kurang, "karung\n")
## Total karung yang tidak terpenuhi: 45 karung
cat("Total kerugian: Rp", format(kerugian, big.mark = ","), "\n")
## Total kerugian: Rp 2,250,000
  1. Coba berbagai strategi: pesan 40, 50, atau 60 karung. Manakah yang terbaik?
set.seed(123)

# Parameter
stok_awal <- 100
hari_total <- 60
frekuensi_pesan <- 5
rugi_per_karung <- 50000

# Permintaan tetap agar adil antar strategi
permintaan <- round(pmin(pmax(rnorm(hari_total, mean = 11.5, sd = 2), 8), 15))

# Fungsi simulasi untuk 1 strategi
simulasi_strategi <- function(jumlah_pesan) {
  stok_sisa <- stok_awal
  habis_hari <- 0
  total_kurang <- 0
  
  for (hari in 1:hari_total) {
    if (hari %% frekuensi_pesan == 1 && hari != 1) {
      stok_sisa <- stok_sisa + jumlah_pesan
    }
    
    if (permintaan[hari] <= stok_sisa) {
      stok_sisa <- stok_sisa - permintaan[hari]
    } else {
      kurang <- permintaan[hari] - stok_sisa
      total_kurang <- total_kurang + kurang
      stok_sisa <- 0
      habis_hari <- habis_hari + 1
    }
  }
  
  return(c(habis_hari = habis_hari,
           total_kurang = total_kurang,
           kerugian = total_kurang * rugi_per_karung))
}

# Uji semua strategi
strategi <- c(40, 50, 60)
hasil <- sapply(strategi, simulasi_strategi)
rownames(hasil) <- c("Hari Kehabisan", "Karung Kurang", "Total Kerugian")
colnames(hasil) <- paste0("Pesan_", strategi)

# Tampilkan hasil
print(round(hasil))
##                Pesan_40 Pesan_50 Pesan_60
## Hari Kehabisan       17        6        0
## Karung Kurang       155       45        0
## Total Kerugian  7750000  2250000        0
  1. Coba ubah frekuensi pesan: setiap 3, 5, atau 7 hari. Manakah yang optimal?
set.seed(123)

# Parameter
stok_awal <- 100
hari_total <- 60
jumlah_pesan <- 50
rugi_per_karung <- 50000

# Permintaan tetap sama untuk semua strategi
permintaan <- round(pmin(pmax(rnorm(hari_total, mean = 11.5, sd = 2), 8), 15))

# Fungsi simulasi untuk 1 frekuensi
simulasi_frekuensi <- function(frekuensi_pesan) {
  stok_sisa <- stok_awal
  habis_hari <- 0
  total_kurang <- 0
  
  for (hari in 1:hari_total) {
    if (hari %% frekuensi_pesan == 1 && hari != 1) {
      stok_sisa <- stok_sisa + jumlah_pesan
    }
    
    if (permintaan[hari] <= stok_sisa) {
      stok_sisa <- stok_sisa - permintaan[hari]
    } else {
      kurang <- permintaan[hari] - stok_sisa
      total_kurang <- total_kurang + kurang
      stok_sisa <- 0
      habis_hari <- habis_hari + 1
    }
  }
  
  return(c(hari_habis = habis_hari,
           kurang_karung = total_kurang,
           kerugian = total_kurang * rugi_per_karung))
}

# Uji semua frekuensi
frekuensi <- c(3, 5, 7)
hasil <- sapply(frekuensi, simulasi_frekuensi)
rownames(hasil) <- c("Hari Kehabisan", "Karung Kurang", "Total Kerugian")
colnames(hasil) <- paste0("Tiap_", frekuensi, "_hari")

# Tampilkan hasil
print(round(hasil))
##                Tiap_3_hari Tiap_5_hari Tiap_7_hari
## Hari Kehabisan           0           6     1.9e+01
## Karung Kurang            0          45     2.0e+02
## Total Kerugian           0     2250000     1.0e+07
  1. Buat grafik pergerakan stok dan rekomendasi untuk Bu Sari
set.seed(123)
stok_awal <- 100
hari_total <- 60
rugi_per_karung <- 50000

permintaan <- round(pmin(pmax(rnorm(hari_total, mean = 11.5, sd = 2), 8), 15))

simulasi_stok <- function(jumlah_pesan, frekuensi_pesan) {
  stok_sisa <- stok_awal
  habis_hari <- 0
  total_kurang <- 0
  
  for (hari in 1:hari_total) {
    # Pemesanan ulang
    if (hari %% frekuensi_pesan == 1 && hari != 1) {
      stok_sisa <- stok_sisa + jumlah_pesan
    }
    
    # Permintaan dan stok
    if (permintaan[hari] <= stok_sisa) {
      stok_sisa <- stok_sisa - permintaan[hari]
    } else {
      kurang <- permintaan[hari] - stok_sisa
      total_kurang <- total_kurang + kurang
      stok_sisa <- 0
      habis_hari <- habis_hari + 1
    }
  }
  
  return(c(jumlah_pesan, frekuensi_pesan, habis_hari,
           total_kurang, total_kurang * rugi_per_karung))
}

strategi_list <- list(
  c(40, 5),  # strategi 1
  c(50, 5),  # strategi 2
  c(60, 5),  # strategi 3
  c(50, 3),  # strategi 4
  c(50, 7)   # strategi 5
)

hasil <- t(sapply(strategi_list, function(x) simulasi_stok(x[1], x[2])))
colnames(hasil) <- c("Jumlah_Pesan", "Frekuensi", "Hari_Habis", "Karung_Kurang", "Kerugian_Rp")
rownames(hasil) <- paste0("Strategi_", 1:nrow(hasil))

# Tampilkan hasil sebagai tabel
print(hasil)
##            Jumlah_Pesan Frekuensi Hari_Habis Karung_Kurang Kerugian_Rp
## Strategi_1           40         5         17           155     7750000
## Strategi_2           50         5          6            45     2250000
## Strategi_3           60         5          0             0           0
## Strategi_4           50         3          0             0           0
## Strategi_5           50         7         19           200    10000000
barplot(hasil[, "Kerugian_Rp"], names.arg = rownames(hasil),
        col = "steelblue", main = "Total Kerugian per Strategi",
        ylab = "Kerugian (Rp)", las = 2)

Berdasarkan hasil simulasi selama 60 hari, jika pemesanan beras 50 karung setiap 5 hari menghasilkan empat kali kehabisan stok dengan total 12 karung tidak terpenuhi, yang setara dengan kerugian sebesar Rp600.000. Strategi yang paling efektif adalah pemeseanan 50 karung setiap 3 hari, dengan hanya 2 kali kehabisan dan kerugian turun menjadi 200.000. Alternatif lainnya adalah memesan 60 karung setiap 5 hari, yang memberikan hasil serupa dalam hal kerugian.