From 98d209aa860e9114d4b298c093ca75f7d09182a9 Mon Sep 17 00:00:00 2001 From: frija Date: Sun, 3 Nov 2024 18:30:20 +0800 Subject: [PATCH 01/39] feat: dedicated id structure --- docs/.vitepress/id.ts | 81 ++ docs/id/algebra/function.md | 374 +++++++++ docs/id/algebra/graph.md | 0 docs/id/algebra/linear-equation.md | 329 ++++++++ docs/id/algebra/quadratic-equation.md | 219 ++++++ docs/id/arithmetic/factors.md | 381 ++++++++++ docs/id/arithmetic/numbers.md | 148 ++++ docs/id/arithmetic/operation-on-number.md | 232 ++++++ docs/id/arithmetic/percent.md | 113 +++ docs/id/guide/index.md | 40 + docs/id/index.md | 68 ++ .../linear-algebra/linear-transformation.md | 327 ++++++++ .../linear-algebra/matrix-multiplication.md | 256 +++++++ docs/id/linear-algebra/vector-space.md | 0 docs/id/linear-algebra/vector.md | 0 .../measures-concentration-dispersion.md | 713 ++++++++++++++++++ 16 files changed, 3281 insertions(+) create mode 100644 docs/.vitepress/id.ts create mode 100644 docs/id/algebra/function.md create mode 100644 docs/id/algebra/graph.md create mode 100644 docs/id/algebra/linear-equation.md create mode 100644 docs/id/algebra/quadratic-equation.md create mode 100644 docs/id/arithmetic/factors.md create mode 100644 docs/id/arithmetic/numbers.md create mode 100644 docs/id/arithmetic/operation-on-number.md create mode 100644 docs/id/arithmetic/percent.md create mode 100644 docs/id/guide/index.md create mode 100644 docs/id/index.md create mode 100644 docs/id/linear-algebra/linear-transformation.md create mode 100644 docs/id/linear-algebra/matrix-multiplication.md create mode 100644 docs/id/linear-algebra/vector-space.md create mode 100644 docs/id/linear-algebra/vector.md create mode 100644 docs/id/statistics/measures-concentration-dispersion.md diff --git a/docs/.vitepress/id.ts b/docs/.vitepress/id.ts new file mode 100644 index 0000000..378eea6 --- /dev/null +++ b/docs/.vitepress/id.ts @@ -0,0 +1,81 @@ +import { defineConfig } from "vitepress"; + +export const id = defineConfig({ + lang: 'id-ID', + description: 'Belajar matematika dengan barisan kode', + themeConfig: { + nav: [ + { + text: 'Belajar', link: '/guide/', + }, + { + text: 'Donasi', link: 'https://trakteer.id/xirf' + } + ], + sidebar: sidebar(), + outline: { + level: [2,3], + label: 'Di halaman ini' + }, + editLink: { + pattern: 'https://github.com/xirf/mathwithcode/edit/master/docs/:path', + text: 'Perbaiki halaman ini di GitHub' + }, + footer: { + message: 'Dirilis di bawah lisensi MIT', + copyright: 'Copyright © 2024-present Andika & Contributors' + } + }, +}) + +function sidebar() { + return [ + { text: "Panduan", link: "/guide/" }, + { + text: "Aritmatika", + collapsed: false, + items: [ + { text: "Bilangan", link: "/arithmetic/numbers" }, + { + text: "Operasi Bilangan", + link: "/arithmetic/operation-on-number", + }, + { text: "Faktor dan Kelipatan", link: "/arithmetic/factors" }, + { text: "Persen", link: "/arithmetic/percent" }, + ], + }, + { + text: "Aljabar", + collapsed: false, + items: [ + { text: "Fungsi", link: "/algebra/function" }, + { text: "Persamaan Linear", link: "/algebra/linear-equation" }, + { text: "Persamaan Kuadrat", link: "/algebra/quadratic-equation" }, + ], + }, + { + text: "Aljabar Linear", + collapsed: false, + items: [ + { + text: "Transformasi Linear", + link: "/linear-algebra/linear-transformation", + }, + { + text: "Perkalian Matriks", + link: "/linear-algebra/matrix-multiplication", + }, + ], + }, + { + text: "Statistika", + collapsed: false, + items: [ + { + text: "Ukuran Letak", + link: "/statistics/measures-concentration-dispersion", + }, + ], + }, + ] +} diff --git a/docs/id/algebra/function.md b/docs/id/algebra/function.md new file mode 100644 index 0000000..0e7eaf7 --- /dev/null +++ b/docs/id/algebra/function.md @@ -0,0 +1,374 @@ +--- +contributors: + - name: "Anka Tama" + username: "xirf" +--- +# Fungsi + +Dalam matematika fungsi aljabar merupakan suatu notasi yang menghubungkan dua himpunan bilangan. Fungsi ini biasanya ditulis dalam bentuk $f(x) = y$ dimana $f$ adalah fungsi, $x$ adalah input, dan $y$ adalah output. + +Fungsi aljabar memiliki konsep yang mirip dengan fungsi yang ada di pemrograman dimana keduanya memiliki *input* dan *output*. Misalnya fungsi $f(x) = 2x + 3$ apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: + +:::tabs +== Javascript +``` js +function fungsi(x) { + return 2 * x + 3; +} +``` +== C++ +``` cpp +int fungsi(int x) { + return 2 * x + 3; +} +``` +== Kotlin +``` kotlin +fun fungsi(x: Int): Int { + return 2 * x + 3 +} +``` +== Python +``` python +def fungsi(x): + return 2 * x + 3 +``` +::: + +## Domain, Kodomain, dan Range +**Domain** adalah himpunan semua nilai input yang diperbolehkan dalam fungsi. Dalam matematika, domain adalah himpunan semua nilai $ x $ yang memenuhi fungsi. + +**Kodomain** sendiri adalah himpunan semua nilai output yang mungkin dalam fungsi. Sedangkan **range** adalah himpunan semua nilai output yang benar-benar dihasilkan oleh fungsi. + +Dalam pemrograman, **domain** dan **kodomain** bisa diartikan sebagai tipe data input dan output dari fungsi yang didefinisikan. + +Dengan kata lain, domain dalam konteks pemrograman adalah jenis data yang bisa diterima oleh fungsi sebagai input (*parameter*), dan kodomain adalah jenis data yang dihasilkan oleh fungsi sebagai output. + +## Jenis-Jenis Fungsi +Ada beberapa jenis fungsi yang sering digunakan dalam matematika, diantaranya adalah: + +### Fungsi Linear +Fungsi linear adalah fungsi yang bentuknya $f(x) = ax + b$ dimana $a$ dan $b$ adalah konstanta. Fungsi ini memiliki grafik berbentuk garis lurus. +Misalnya fungsi $f(x) = 1x + 0.5$. akan menghasilkan grafik seperti berikut: + + + +### Fungsi Kuadrat +Fungsi kuadrat adalah fungsi yang bentuknya $f(x) = ax^2 + bx + c$ dimana $a$, $b$, dan $c$ adalah konstanta. Fungsi ini memiliki grafik berbentuk parabola. + + + +### Fungsi Eksponensial +Fungsi eksponensial adalah fungsi yang bentuknya $f(x) = a^x$ dimana $a$ adalah konstanta. Fungsi ini memiliki grafik berbentuk kurva yang semakin meningkat. + + +### Fungsi Logaritma +Fungsi logaritma adalah fungsi yang merupakan kebalikan dari fungsi eksponensial. Fungsi ini memiliki bentuk $f(x) = \log_a(x)$ dimana $a$ adalah konstanta. Fungsi ini memiliki grafik berbentuk kurva yang semakin menurun. + + +### Fungsi Trigonometri +Fungsi trigonometri adalah fungsi yang melibatkan fungsi trigonometri seperti sin, cos, tan, dan sebagainya. Fungsi ini memiliki grafik berbentuk gelombang. Dibawah ini adalah contoh grafik fungsi trigonometri dimana +- Merah adalah fungsi sin(x) +- Hijau adalah fungsi cos(x) +- Ungu adalah fungsi tan(x) + + +## Operasi pada Fungsi + +### Penjumlahan dan Pengurangan Fungsi +Penjumlahan dan pengurangan fungsi dilakukan dengan cara menambahkan atau mengurangkan fungsi satu dengan fungsi lainnya. Misalnya +$$f(x) = 2x + 3$$ +$$g(x) = 3x - 2$$ + +Maka penjumlahan kedua fungsi tersebut adalah + +$$\begin{align*} + (f + g)(x) &= f(x) + g(x) \\ + &= (2x + 3) + (3x - 2) \\ + &= 5x + 1 +\end{align*}$$ + +Apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: +:::tabs +== Javascript +``` js +function f(x) { + return 2 * x + 3; +} +function g(x) { + return 3 * x - 2; +} +function fg(x) { + return f(x) + g(x); +} +``` +== C++ +``` cpp +int f(int x) { + return 2 * x + 3; +} +int g(int x) { + return 3 * x - 2; +} +int fg(int x) { + return f(x) + g(x); +} +``` +== Kotlin +``` kotlin +fun f(x: Int): Int { + return 2 * x + 3; +} +fun g(x: Int): Int { + return 3 * x - 2; +} +fun fg(x: Int): Int { + return f(x) + g(x); +} +``` +== Python +``` python +def f(x): + return 2 * x + 3 + +def g(x): + return 3 * x - 2 + +def fg(x): + return f(x) + g(x) + +``` +::: + +### Perkalian Fungsi +Perkalian fungsi dilakukan dengan cara mengalikan fungsi satu dengan fungsi lainnya. Misalnya +$$f(x) = 2x + 3$$ +$$g(x) = 3x - 2$$ + +Maka perkalian kedua fungsi tersebut adalah + +$$\begin{align*} + (f \cdot g)(x) &= f(x) \cdot g(x) \\ + &= (2x + 3) \cdot (3x - 2) \\ + &= 6x^2 + 4x - 6 +\end{align*}$$ + +Apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: + +:::tabs +== Javascript +``` js +function f(x) { + return 2 * x + 3; +} +function g(x) { + return 3 * x - 2; +} +function fg(x) { + return f(x) * g(x); +} +``` +== C++ +``` cpp +int f(int x) { + return 2 * x + 3; +} +int g(int x) { + return 3 * x - 2; +} +int fg(int x) { + return f(x) * g(x); +} +``` +== Kotlin +``` kotlin +fun f(x: Int): Int { + return 2 * x + 3; +} +fun g(x: Int): Int { + return 3 * x - 2; +} +fun fg(x: Int): Int { + return f(x) * g(x); +} +``` +== Python +``` python +def f(x): + return 2 * x + 3 + +def g(x): + return 3 * x - 2 + +def fg(x): + return f(x) * g(x) +``` +::: + +### Fungsi Komposisi +Fungsi komposisi adalah fungsi yang hasilnya adalah fungsi lain. Misalnya + +$$f(x) = 2x + 3$$ +$$g(x) = 3x - 2$$ + +Maka fungsi komposisi dari kedua fungsi tersebut adalah + +$$\begin{align*} + (f \circ g)(x) &= f(g(x)) \\ + &= f(3x - 2) \\ + &= 2(3x - 2) + 3 \\ + &= 6x - 4 + 3 \\ + &= 6x - 1 +\end{align*}$$ + +Apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: +:::tabs +== Javascript +``` js +function f(x) { + return 2 * x + 3; +} +function g(x) { + return 3 * x - 2; +} +function fog(x) { + return f(g(x)); +} +``` +== C++ +``` cpp +int f(int x) { + return 2 * x + 3; +} +int g(int x) { + return 3 * x - 2; +} +int fog(int x) { + return f(g(x)); +} +``` +== Kotlin +``` kotlin +fun f(x: Int): Int { + return 2 * x + 3; +} +fun g(x: Int): Int { + return 3 * x - 2; +} +fun fog(x: Int): Int { + return f(g(x)); +} +``` +== Python +``` python +def f(x): + return 2 * x + 3 + +def g(x): + return 3 * x - 2 + +def fog(x): + return f(g(x)) +``` +::: + +> [!NOTE] Sifat dari fungsi komposisi +> - Fungsi komposisi tidak komutatif, artinya $f \circ g \neq g \circ f$ +> - Fungsi komposisi asosiatif, artinya $(f \circ g) \circ h = f \circ (g \circ h)$ +> - Fungsi komposisi memiliki elemen identitas, artinya $f \circ I = f$ dimana $I$ adalah fungsi identitas + +### Invers Fungsi + +Invers fungsi adalah fungsi yang hasilnya adalah fungsi lain yang merupakan kebalikan dari fungsi tersebut. Misalnya + +$$f(x) = 2x + 3$$ + +Maka untuk mencari invers dari fungsi tersebut, kita harus mencari $f^{-1}(x)$ dimana $f^{-1}(f(x)) = x$. + +Langkah-langkah untuk mencari invers fungsi adalah sebagai berikut: + +1. Ubah bentuk $y = f(x)$ menjadi $x = f^{-1}(y)$ +2. Selesaikan $x$ dari persamaan tersebut +3. Gantikan $x$ dengan $f^{-1}(y)$ +4. Selesaikan persamaan tersebut + +Contoh untuk mencari invers dari fungsi $f(x) = 2x + 6$ adalah sebagai berikut: + +$$\begin{align*} + y &= f(x) = 2x + 6 \\ + 2x &= y - 6 \\ + x &= \frac{1}{2}y-3 +\end{align*}$$ + +Maka invers dari fungsi $f(x) = 2x + 6$ adalah $f^{-1}(x) = \frac{1}{2}x-3$ + +Apabila kita jadikan sebagai fungsi di pemrograman dimana nilai $x$ sudah diketahui dan outputnya adalah nilai $y$, maka akan menjadi seperti berikut: +:::tabs +== Javascript +``` js +function inverseFunction(y, a, b) { + if (a === 0) { + throw new Error("Nilai a tidak boleh 0"); + } + return (y - b) / a; +} + +const a = 2; // Misalkan a = 2 +const b = 3; // Misalkan b = 3 +const y = 7; // Nilai y (f(x)) +// f(x) = 2x + 3 +const x = inverseFunction(y, a, b); +console.log(`Invers dari f(${y}) adalah x = ${x}`); +``` +== C++ +``` cpp +int inverseFunction(int y, int a, int b) { + if (a == 0) { + throw "Nilai a tidak boleh 0"; + } + return (y - b) / a; +} + +int main() { + int a = 2; // Misalkan a = 2 + int b = 3; // Misalkan b = 3 + int y = 7; // Nilai y (f(x)) + // f(x) = 2x + 3 + int x = inverseFunction(y, a, b); + cout << "Invers dari f(" << y << ") adalah x = " << x << endl; + return 0; +} +``` +== Kotlin +``` kotlin +fun inverseFunction(y: Int, a: Int, b: Int): Int { + if (a == 0) { + throw IllegalArgumentException("Nilai a tidak boleh 0") + } + return (y - b) / a +} + +fun main() { + val a = 2 // Misalkan a = 2 + val b = 3 // Misalkan b = 3 + val y = 7 // Nilai y (f(x)) + // f(x) = 2x + 3 + val x = inverseFunction(y, a, b) + println("Invers dari f($y) adalah x = $x") +} +``` +== Python +``` python +def inverseFunction(y, a, b): + if a == 0: + raise Exception("Nilai a tidak boleh 0") + return (y - b) / a + +a = 2 # Misalkan a = 2 +b = 3 # Misalkan b = 3 +y = 7 # Nilai y (f(x)) +# f(x) = 2x + 3 +x = inverseFunction(y, a, b) +print(f"Invers dari f({y}) adalah x = {x}") +``` +::: \ No newline at end of file diff --git a/docs/id/algebra/graph.md b/docs/id/algebra/graph.md new file mode 100644 index 0000000..e69de29 diff --git a/docs/id/algebra/linear-equation.md b/docs/id/algebra/linear-equation.md new file mode 100644 index 0000000..b12edae --- /dev/null +++ b/docs/id/algebra/linear-equation.md @@ -0,0 +1,329 @@ +# Persamaan Linear + +Persamaan linear bisa diartikan sebagai seuatu persamaan yang suku-sukunya memiliki konstanta (nilai tetap) dengan variabel tunggal. Persamaan ini disebut linear karena hubungan antara variabel-variabelnya membentuk garis lurus jika digambarkan dalam grafik dua dimensi. Sebelum memulai kita wajib paham beberapa hal dibawah ini + +1. **Variabel**: Pengganti bilangan yang nilainya belum diketahui. +2. **Koeffisien**: Bilangan yang mengalikan variabel. +3. **Konstanta**: Bilangan yang tidak memiliki variabel. +4. **Suku**: Bagian dari persamaan yang terdiri dari variabel, koefisien, dan konstanta. + +Persamaan linear juga memiliki beberapa aturan/sifat yang harus dipahami, diantaranya: + +- Penjumlahan dan pengurangan bilangan kedua ruas tak akan mengubah persamaan nilai. +- Perkalian dan pembagian bilangan kedua ruas tidak mengubah nilai persamaan +- Nilai persamaan tidak berubah jika kedua ruas ditambah atau dikurangi bilangan yang sama. +- Suatu persamaan jika dipindah ruas maka penjumlahan berubah jadi pengurangan, perkalian berubah menjadi pembagian, dan sebaliknya. + +## Persamaan Linear Satu Variabel + +Persamaan linear satu variabel adalah persamaan yang memiliki satu variabel. Persamaan ini biasanya ditulis dalam bentuk $ax + b = c$ dimana $a$, $b$, dan $c$ adalah bilangan riil dan $x$ adalah variabel. + +Contoh persamaan linear satu variabel: +$$ 2x + 3 = 7 $$ + +Untuk mengetahui nilai $x$ yang memenuhi persamaan tersebut, kita harus mencari nilai $x$ yang membuat kedua ruas persamaan sama. Berikut langkah-langkahnya: + +1. Eliminasi konstanta pada ruas kiri dengan cara mengurangkan konstanta pada ruas kiri dengan konstanta pada ruas kanan. + +$$\begin{align*} + 2x + 3 - 3 &= 7 - 3 \\ + 2x &= 4 +\end{align*}$$ + +2. Eliminasi koefisien variabel dengan cara membagi kedua ruas dengan koefisien variabel. + +$$\begin{align*} + \frac{2x}{2} &= \frac{4}{2} \\ + x &= 2\\ +\end{align*}$$ + +3. Sehingga nilai $x$ yang memenuhi persamaan tersebut adalah $x = 2$. + +Jika diimplementasikan dalam kode, maka hasilnya adalah seperti ini: +:::tabs +==javascript + +```js +function linearEquation(a, b, c) { + // Persamaan: a * x + b = c + const x = (c - b) / a; + return x; +} +console.log(linearEquation(2, 3, 7)); // Output: 2 +``` + +==kotlin + +```kotlin +val a = 2 +val b = 3 +val c = 7 + +// Persamaan: a * x + b = c +val x = (c - b) / a +println("Nilai x adalah: $x") +``` + +== C++ + +```cpp +int linearEquation(int a, int b, int c) { + // Persamaan: a * x + b = c + int x = (c - b) / a; + return x; +} + +int main() { + int a = 2; + int b = 3; + int c = 7; + int x = linearEquation(a, b, c); + cout << "Nilai x adalah: " << x << endl; + return 0; +} +``` + +==Python +```python +def linearEquation(a, b, c): + # Persamaan: a * x + b = c + x = (c - b) / a + return x + +a, b, c, = 2, 3, 7 +x = linearEquation(a, b, c) +print(f"Nilai x adalah: {x}") +``` + +::: + +## Persamaan Linear Dua Variabel + +Sesuai dengan namanya, persamaan ini memiliki dua variabel yang bisanya ditulis dalam bentuk $ax + by = c$ dimana $a$, $b$, dan $c$ adalah bilangan riil dan $x$ dan $y$ adalah variabel. + +Contoh persamaan linear dua variabel: +$$ 2x + 3y = 7 $$ + +Ada 2 cara untuk meyelesaikan persamaan yaitu dengan menggunakan metode substitusi dan eliminasi. Untuk metode substitusi, kita bisa mengganti salah satu variabel dengan nilai yang sudah diketahui. Sedangkan untuk metode eliminasi, kita bisa menghilangkan salah satu variabel dengan cara mengalikan salah satu persamaan dengan bilangan tertentu. + +### Metode Substitusi + +Berikut contoh penyelesaian persamaan diatas dengan menggunakan metode substitusi: + +1. Pertama kita pilih salah satu variable untuk diisolasi, misalnya kita pilih $x$. +2. variable yang kita isolasi kemudian kita simpan dan pindahkan lainnya ke kanan. + $$ 2x = 7 - 3y $$ +3. Karena nilai yang diisolasi adalah $2x$ maka kita bagi kedua ruas dengan $2$. + +$$\begin{align*} +x &= \frac{7 - 3y}{2} \\ +x &= \frac{7}{2} - \frac{3y}{2} \\ +\end{align*}$$ + +4. Nah kita dapat solusi parametrik dari $x$ + +Nila parametrik inilah yang nantinya berapapun nilai $y$ yang kita masukkan akan menghasilkan nilai $x$ yang sesuai. Misalnya nilai $y = 1$ maka: + + +$$\begin{align*} +x &= \frac{7 - 3(1)}{2} \\ +x &= \frac{4}{2} \\ +x &= 2 +\end{align*}$$ + +Bagaimana jika permasalahan ini kita jadikan kode? Berikut contoh implementasinya: +:::tabs +==javascript + +```js +function pldv(a, b, c, y) { + let x = (c - b * y) / a; + return { x, y }; +} + +// 2x + 3y = 7 dimana y = 1 +console.log(pldv(2, 3, 7, 1)); // Output: { x: 2, y: 1 } +``` + +==kotlin + +```kotlin +fun pldv(a: Int, b: Int, c: Int, y: Int): Pair { + val x = (c - b * y) / a + return Pair(x, y) +} + +// 2x + 3y = 7 dimana y = 1 +println(pldv(2, 3, 7, 1)) // Output: (2, 1) +``` + +== C++ + +```cpp +#include +#include + +std::pair pldv(int a, int b, int c, int y) { + int x = (c - b * y) / a; + return std::make_pair(x, y); +} + +int main() { + // 2x + 3y = 7 dimana y = 1 + auto result = pldv(2, 3, 7, 1); + std::cout << "Output: (" << result.first << ", " << result.second << ")" << std::endl; + return 0; +} +``` +== Python +``` python +def pldv(a, b, c, y): + x = (c - b * y) / a + return x, y + +# 2x + 3y = 7 dimana y = 1 +print(pldv(2, 3, 7, 1))# Output: (x: 2.0, y: 1) +``` +::: + +### Metode Eliminasi + +Jika menggunakan metode eliminasi, kita membutuhkan 2 persamaan sebagai perbandingan. Misalnya kita punya 2 persamaan berikut: +$$ 2x + 3y = 7 $$ +$$ 3x - 2y = 8 $$ +Jika sudah memiliki dua persamaan kita bisa menghilangkan salah satu variabel dengan cara mengalikan salah satu persamaan dengan bilangan tertentu. Berikut langkah-langkahnya: + +1. Ubah kedua persamaan menjadi bentuk standar. + $$ 2x + 3y = 7$$ + $$ 3x - 2y = 8$$ +2. Kita akan mengeleminasi variabel $y$ dengan cara mengalikan persamaan (1) dengan $2$ dan persamaan (2) dengan $3$ (koefisien yang sama kita pilih). + $$ 4x + (3 \times 2y) = 7 \times 2$$ + $$ 9x - (2 \times 3y) = 8 \times 3$$ +
+ + $$ 4x + 6y = 14$$ + $$ 9x - 6y = 24$$ +3. Nah nilai $y$ udah sama tinggal kita kurangkan persamaan (1) dengan persamaan (2). + $$ 4x + 6y = 14$$ + $$ 9x - 6y = 24$$ +
+ + $$ -5x = -10$$ + +4. Kita bagi kedua ruas dengan $-5$. + $$ \frac{-5x}{-5} = \frac{-10}{-5}$$ + $$ x = 2$$ + +5. Nah kita sudah mendapatkan nilai $x$ sekarang kita cari nilai $y$ dengan cara substitusi nilai $x$ ke salah satu persamaan. + + $$ 2x + 3y = 7$$ + $$ 2(2) + 3y = 7$$ + $$ 4 + 3y = 7$$ + $$ 3y = 3$$ + $$ y = 1$$ + +6. Sehingga nilai $x$ dan $y$ yang memenuhi persamaan tersebut adalah $x = 2$ dan $y = 1$. + +Bagaimana jika permasalahan ini kita jadikan kode? Berikut contoh implementasinya: +:::tabs +==javascript + +```js +function pldvEliminasi(a1, b1, c1, a2, b2, c2) { + // Menghitung koefisien untuk eliminasi + let factor = a2 / a1; + + // Membuat persamaan baru dengan mengurangi + let newB2 = b2 - factor * b1; + let newC2 = c2 - factor * c1; + + // Menyelesaikan untuk y + let y = newC2 / newB2; + + // Menghitung x dengan substitusi y ke dalam persamaan 1 + let x = (c1 - b1 * y) / a1; + + return { x: x, y: y }; +} + +// 2x - 3y = 7 dan 3x - 2y = 8 +console.log(pldvEliminasi(2, 3, 7, 3, -2, 8)); // Output: { x: 2, y: 1 } +``` +== kotlin + +```kotlin +fun pldvEliminasi(a1: Int, b1: Int, c1: Int, a2: Int, b2: Int, c2: Int): Pair { + // Menghitung koefisien untuk eliminasi + val factor = a2 / a1 + + // Membuat persamaan baru dengan mengurangi + val newB2 = b2 - factor * b1 + val newC2 = c2 - factor * c1 + + // Menyelesaikan untuk y + val y = newC2 / newB2 + + // Menghitung x dengan substitusi y ke dalam persamaan 1 + val x = (c1 - b1 * y) / a1 + + return Pair(x, y) +} + +// 2x - 3y = 7 dan 3x - 2y = 8 +println(pldvEliminasi(2, 3, 7, 3, -2, 8)) // Output: (2, 1) +``` +== C++ + +```cpp +#include +#include + +pair pldvEliminasi(double a1, double b1, double c1, double a2, double b2, double c2) { + // Menghitung koefisien untuk eliminasi + double factor = a2 / a1; + + // Membuat persamaan baru dengan mengurangi + double newB2 = b2 - factor * b1; + double newC2 = c2 - factor * c1; + + // Menyelesaikan untuk y + double y = newC2 / newB2; + + // Menghitung x dengan substitusi y ke dalam persamaan 1 + double x = (c1 - b1 * y) / a1; + + return make_pair(x, y); +} + +int main() { + auto result = pldvEliminasi(2, 3, 7, 4, -5, 10); + cout << "x: " << result.first << ", y: " << result.second << endl; + // Output: x: 3, y: -1 + return 0; +} +``` + +==Python + +```python +def pldvEliminasi(a1, b1, c1, a2, b2, c2): + # Menghitung koefisien untuk eliminasi + factor = a2 / a1 + + # Membuat persamaan baru dengan mengurangi + newB2 = b2 - factor * b1 + newC2 = c2 - factor * c1 + + # Menyelesaikan untuk y + y = newC2 / newB2 + + # Menghitung x dengan substitusi y ke dalam persamaan 1 + x = (c1 - b1 * y) / a1 + + return x, y + +# Contoh: 2x - 3y = 7 dan 3x - 2y = 8 +x, y = pldvEliminasi(2, 3, 7, 3, -2, 8) +print(f"x: {x}, y: {y}") # Output: x: 2, y: 1 +``` +::: diff --git a/docs/id/algebra/quadratic-equation.md b/docs/id/algebra/quadratic-equation.md new file mode 100644 index 0000000..72385b8 --- /dev/null +++ b/docs/id/algebra/quadratic-equation.md @@ -0,0 +1,219 @@ +--- +contributors: + - name: "Anka Tama" + username: "xirf" +--- + +# Persamaan Kuadrat + +Persamaan kuadrat (kuadratik) dapat didefinisikan sebagai persamaan polinomial (persamaan yang terdiri dari beberapa suku) tingkat dua, yang menyiratkan bahwa persamaan ini terdiri dari minimal satu suku yang dikuadratkan. Bentuk umum persamaan kuadrat adalah: + +$$ax^2 + bx + c = 0$$ + +Dimana $x$ adalah variabel yang tidak diketahui dan $a$, $b$, $c$ adalah koefisien numerik. Sebagai contoh, $x^2 + 2x +1$ adalah persamaan kuadrat atau kuadratik. Di sini, $a ≠ 0$ karena jika sama dengan nol maka persamaan tersebut tidak lagi berbentuk kuadratik dan akan menjadi persamaan linier, seperti $bx + c = 0$. + + +
+ +Grafik persamaan kuadrat $f(x) = 0.1x^2 + 0.5 - 0.3x$ + +
+ +## Rumus Umum + +Akar-akar dari persamaan kuadrat dapat ditemukan dengan menggunakan rumus kuadrat. Rumus kuadrat adalah: + +$$x = \frac{-b ± \sqrt{b^2 - 4ac}}{2a}$$ + +Dimana $±$ disini berarti dua kemungkinan nilai untuk $x$. Rumus ini dikenal sebagai rumus kuadrat atau rumus abc. Rumus ini dapat digunakan untuk menemukan akar-akar dari persamaan kuadrat $ax^2 + bx + c = 0$. + +## Diskriminan + +Diskriminan adalah bagian dari rumus kuadrat yang terletak di bawah tanda akar. Diskriminan digunakan untuk menentukan jenis akar dari persamaan kuadrat. Diskriminan didefinisikan sebagai: + +$$D = b^2 - 4ac$$ + +Dimana $a$, $b$, dan $c$ adalah koefisien dari persamaan kuadrat $ax^2 + bx + c = 0$. Berikut adalah beberapa kemungkinan nilai diskriminan: + +- Jika $D > 0$, maka persamaan kuadrat memiliki solusi bilangan real +- Jika $D = 0$, maka persamaan kuadrat memiliki dua akar real yang sama. +- Jika $D < 0$, maka persamaan kuadrat memiliki dua akar kompleks. + +## Menggunakan Rumus Kuadrat + +Akar-akar persamaan kuadrat adalah dua nilai $x$, yang diperoleh dengan menyelesaikan persamaan kuadrat. Akar-akar persamaan kuadrat ini juga disebut angka nol dari persamaan tersebut. Sebagai contoh, akar-akar persamaan $x^2 - 3x - 4 = 0$ dapat dicari dengan menggunakan cara berikut: + +$$\begin{align*} +x &= \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \\ +x &= \frac{-(-3) \pm \sqrt{3^2 - 4\cdot1\cdot(-4)}}{2\cdot1} \\ +x &= \frac{3 \pm \sqrt{9 - - 16}}{2} \\ +x &= \frac{3 \pm \sqrt{9 + 16}}{2} \\ +x &= \frac{3 \pm \sqrt{25}}{2} \\ +x &= \frac{3 \pm 5}{2} +\end{align*}$$ + +Mari kira sederhanakan menjadi +$$x = \frac{3 ± 5}{2}$$ +$$x = \frac{8}{2} \text{ atau } x = -\frac{2}{2}$$ + +Yang akhirnya menjadi $x = 4$ atau $x = -1$. Jadi, akar-akar dari persamaan $x^2 - 3x - 4 = 0$ adalah $x = 4$ dan $x = -1$. + +Jika diimplementasikan dalam kode, maka hasilnya adalah seperti ini: + +:::tabs +==Javascript + +```js +function findRootsStepByStep(a, b, c) { + // Langkah 1: Hitung b^2 dan 4ac + const bSquared = b * b; + const fourAC = 4 * a * c; + // Langkah 2: Hitung diskriminan + const discriminant = bSquared - fourAC; + + if (discriminant >= 0) { + // Jika diskriminan >= 0, lanjutkan dengan akar real + // Langkah 3: Hitung akar dari diskriminan + const sqrtDiscriminant = Math.sqrt(discriminant); + // Langkah 4: Hitung dua kemungkinan nilai untuk x + const root1 = (-b + sqrtDiscriminant) / (2 * a); + const root2 = (-b - sqrtDiscriminant) / (2 * a); + console.log(`x1 = (-${b} + ${sqrtDiscriminant}) / (2 * ${a}) = ${root1}`); + console.log(`x2 = (-${b} - ${sqrtDiscriminant}) / (2 * ${a}) = ${root2}`); + console.log(`Akar-akarnya adalah: x1 = ${root1} dan x2 = ${root2}`); + } else { + // Jika diskriminan < 0, akar kompleks + const realPart = -b / (2 * a); + const imaginaryPart = Math.sqrt(-discriminant) / (2 * a); + console.log(`x1 = ${realPart} + ${imaginaryPart}i`); + console.log(`x2 = ${realPart} - ${imaginaryPart}i`); + } +} + +// Contoh untuk persamaan x^2 - 3x - 4 = 0 +const a = 1; +const b = -3; +const c = -4; +findRootsStepByStep(a, b, c); +``` + +== C++ + +```cpp +import kotlin.math.sqrt + +fun akarPersamaan(a: Double, b: Double, c: Double) { + // Langkah 1: Hitung bagian-bagian dari rumus + val bSquared = b * b + val fourAC = 4 * a * c + + // Langkah 2: Hitung diskriminan + val discriminant = bSquared - fourAC + + if (discriminant >= 0) { + // Jika diskriminan >= 0, lanjutkan dengan akar real + // Langkah 3: Hitung akar dari diskriminan + val sqrtDiscriminant = sqrt(discriminant) + + // Langkah 4: Hitung dua kemungkinan nilai untuk x + val root1 = (-b + sqrtDiscriminant) / (2 * a) + val root2 = (-b - sqrtDiscriminant) / (2 * a) + println("x1 = (-$b + $sqrtDiscriminant) / (2 * $a) = $root1") + println("x2 = (-$b - $sqrtDiscriminant) / (2 * $a) = $root2") + + // Tampilkan hasil akhirnya + println("Akar-akarnya adalah: x1 = $root1 dan x2 = $root2") + } else { + // Jika diskriminan < 0, akar kompleks + val realPart = -b / (2 * a) + val imaginaryPart = sqrt(-discriminant) / (2 * a) + println("x1 = $realPart + ${imaginaryPart}i") + println("x2 = $realPart - ${imaginaryPart}i") + } +} + +fun main() { + // Contoh untuk persamaan x^2 - 3x - 4 = 0 + val a = 1.0 + val b = -3.0 + val c = -4.0 + akarPersamaan(a, b, c) +} + +``` + +== Kotlin + +```kotlin +import kotlin.math.sqrt + +fun akarPersamaan(a: Double, b: Double, c: Double) { + // Langkah 1: Hitung bagian-bagian dari rumus + val bSquared = b * b + val fourAC = 4 * a * c + + // Langkah 2: Hitung diskriminan + val discriminant = bSquared - fourAC + + if (discriminant >= 0) { + // Jika diskriminan >= 0, lanjutkan dengan akar real + // Langkah 3: Hitung akar dari diskriminan + val sqrtDiscriminant = sqrt(discriminant) + + // Langkah 4: Hitung dua kemungkinan nilai untuk x + val root1 = (-b + sqrtDiscriminant) / (2 * a) + val root2 = (-b - sqrtDiscriminant) / (2 * a) + println("x1 = (-$b + $sqrtDiscriminant) / (2 * $a) = $root1") + println("x2 = (-$b - $sqrtDiscriminant) / (2 * $a) = $root2") + println("Akar-akarnya adalah: x1 = $root1 dan x2 = $root2") + } else { + // Jika diskriminan < 0, akar kompleks + val realPart = -b / (2 * a) + val imaginaryPart = sqrt(-discriminant) / (2 * a) + println("x1 = $realPart + ${imaginaryPart}i") + println("x2 = $realPart - ${imaginaryPart}i") + } +} + +fun main() { + // Contoh untuk persamaan x^2 - 3x - 4 = 0 + val a = 1.0 + val b = -3.0 + val c = -4.0 + akarPersamaan(a, b, c) +} +``` +== Python +``` python +import math + +def findRootsStepByStep(a, b, c): + # Langkah 1: Hitung b^2 dan 4ac + bSquared = b * b + fourAC = 4 * a * c + # Langkah 2: Hitung diskriminan + discriminant = bSquared - fourAC + + if discriminant >= 0: + # Jika diskriminan >= 0, lanjutkan dengan akar real + # Langkah 3: Hitung akar dari diskriminan + sqrtDiscriminant = math.sqrt(discriminant) + # Langkah 4: Hitung dua kemungkinan nilai untuk x + root1 = (-b + sqrtDiscriminant) / (2 * a) + root2 = (-b - sqrtDiscriminant) / (2 * a) + print(f"x1 = (-{b} + {sqrtDiscriminant}) / (2 * {a}) = {root1}") + print(f"x2 = (-{b} - {sqrtDiscriminant}) / (2 * {a}) = {root2}") + print(f"Akar-akarnya adalah: x1 = {root1} dan x2 = {root2}") + else: + # Jika diskriminan < 0, akar kompleks + realPart = -b / (2 * a) + imaginaryPart = math.sqrt(-discriminant) / (2 * a) + print(f"x1 = {realPart} + {imaginaryPart}i") + print(f"x2 = {realPart} - {imaginaryPart}i") + +# Contoh untuk persamaan x^2 - 3x - 4 = 0 +a = 1 +b = -3 +c = -4 +findRootsStepByStep(a, b, c) +``` \ No newline at end of file diff --git a/docs/id/arithmetic/factors.md b/docs/id/arithmetic/factors.md new file mode 100644 index 0000000..e7cd22f --- /dev/null +++ b/docs/id/arithmetic/factors.md @@ -0,0 +1,381 @@ +--- +title: Faktor dan Kelipatan +description: Faktorisasi, faktorisasi prima, pohon faktor, FPB, KPK +--- + +# Faktorisasi + +Faktorisasi atau pemfaktoran adalah proses menguraikan suatu bilangan menjadi faktor-faktornya. Faktor disini kaya bilangan yang bisa dikalikan untuk menghasilkan bilangan yang kita mau. + +Contoh, faktorisasi dari 12 adalah 2 dan 6, karena $2 \times 6 = 12$. Faktorisasi dari 6 adalah 2 dan 3, karena $2 \times 3 = 6$. + +## Faktorisasi Prima + +Faktorisasi prima adalah faktorisasi dimana semua faktor yang dihasilkan adalah bilangan prima. Bilangan prima adalah bilangan yang hanya bisa dibagi oleh 1 dan bilangan itu sendiri. + +Contoh: + +- Faktorisasi prima dari 12 adalah $12=22×312=22×3$, karena 12 bisa dipecah menjadi 2 kali 6, lalu 6 dipecah lagi menjadi 2 kali 3. +- Faktorisasi prima dari 30 adalah $30=2×3×530=2×3×5$, karena 30 bisa dipecah menjadi 2, 3, dan 5, yang semuanya adalah bilangan prima. + +## Pohon Faktor + +Secara sederhana cara mencari faktorisasi kita bisa pakai pohon faktor dimana kita melakukan pembagian berulang-ulang sampai bilangan yang kita bagi adalah bilangan prima. + +Misalnya kita memiliki bilangan 100 maka pohon faktornya adalah seperti ini: + + + 2 + + 2 + + 5 + + 0 + 0 + 1 + + 0 + 5 + + 5 + 2 + + 5 + + +Dari pohon faktor diatas kita bisa lihat bahwa faktorisasi dari 100 adalah $2 \times 2 \times 5 \times 5$ atau $2^2 \times 5^2$. Kita bisa tulis faktorisasi dari 100 sebagai $2^2 \times 5^2$. + +Kalo di pemrograman kita bisa pake _loop_ dan [modulo](/arithmetic/operation-on-number#modulus) untuk mencari faktorisasi dari suatu bilangan. Berikut contoh implementasinya: + +:::tabs +== Javascript + +```js +function faktorisasi(bilangan) { + let faktor = 2; + let faktorisasi = []; + while (bilangan > 1) { + if (bilangan % faktor === 0) { + faktorisasi.push(faktor); + bilangan /= faktor; + } else { + faktor++; + } + } + return faktorisasi; +} + +let faktorisasi100 = faktorisasi(100); // [2, 2, 5, 5] +``` + +== Kotlin + +```kt +fun faktorisasi(bilangan: Int): List { + var faktor = 2 + val faktorisasi = mutableListOf() + var bilangan = bilangan + while (bilangan > 1) { + if (bilangan % faktor == 0) { + faktorisasi.add(faktor) + bilangan /= faktor + } else { + faktor++ + } + } + return faktorisasi +} + +val faktorisasi100 = faktorisasi(100) // [2, 2, 5, 5] +``` + +== C++ + +```cpp +#include +#include + +std::vector faktorisasi(int bilangan) { + int faktor = 2; + std::vector faktorisasi; + while (bilangan > 1) { + if (bilangan % faktor == 0) { + faktorisasi.push_back(faktor); + bilangan /= faktor; + } else { + faktor++; + } + } + return faktorisasi; +} + +int main() { + std::vector faktorisasi100 = faktorisasi(100); // [2, 2, 5, 5] + return 0; +} +``` +== Python +```python +def faktorisasi(bilangan): + faktor = 2 + faktorisasi = [] + while bilangan > 1: + if bilangan % faktor == 0: + faktorisasi.append(faktor) + bilangan /= faktor + else: + faktor += 1 + + return faktorisasi + +faktorisasi100 = faktorisasi(100) # [2, 2, 5, 5] +``` + +::: + +Btw diatas kita pakai `/=` itu sama aja dengan `bilangan = bilangan / faktor`, sama aja kaya `+= -= *=` yang biasa kita pakai. + + +## Kelipatan + +Kelipatan adalah hasil dari perkalian suatu bilangan dengan bilangan lain. Misalnya kamu memiliki bilangan $a$ dan dikaikan dengan bilangan $n$ (positif, negatif, atau nol), maka hasilnya adalah kelipatan dari $a$. + +Misalnya lagi jika $a = 3$ maka kelipatan dari 3 adalah: +- $3 \times 1 = 3$ +- $3 \times 2 = 6$ +- $3 \times 3 = 9$ +- dan seterusnya... + +Jika kelipatan diimplementasikan dalam pemrograman, kita bisa menggunakan _loop_ untuk melakukan perkalian berulang. Contohnya seperti ini: +:::tabs +== Javascript + +```js +function kelipatan(a, n) { + let kelipatan = []; + for (let i = 1; i <= n; i++) { + kelipatan.push(a * i); + } + return kelipatan; +} + +let kelipatan3 = kelipatan(3, 5); // [3, 6, 9, 12, 15] +``` +== Kotlin + +```kt +fun kelipatan(a: Int, n: Int): List { + val kelipatan = mutableListOf() + for (i in 1..n) { + kelipatan.add(a * i) + } + return kelipatan +} + +val kelipatan3 = kelipatan(3, 5) // [3, 6, 9, 12, 15] +``` +== C++ + +```cpp +std::vector kelipatan(int a, int n) { + std::vector kelipatan; + for (int i = 1; i <= n; i++) { + kelipatan.push_back(a * i); + } + return kelipatan; +} + +int main() { + std::vector kelipatan3 = kelipatan(3, 5); // [3, 6, 9, 12, 15] + return 0; +} +``` +== Python +```python +def kelipatan(a, n): + kelipatan = [] + for i in range(1, n+1): + kelipatan.append(a * i) + + return kelipatan + +kelipatan3 = kelipatan(3, 5) + +``` +::: + +## Faktor Persekutuan Terbesar (FPB) + +FPB itu angka terbesar yang bisa membagi dua bilangan tanpa sisa. FPB biasanya dipakai untuk mencari kesamaan dari dua bilangan yang berbeda. + +Nah untuk mencari FPB kita bisa mulai dengan mencari faktorisasi dari kedua bilangan tersebut, lalu kita cari faktor yang sama dari kedua bilangan tersebut. Contoh kalo kita mau cari FPB dari 12 dan 18 kita bisa lakukan seperti ini: + +$12 = 1,2,3,4,6,12$ + +$18 = 1,2,3,6,9,18$ + +Kita bisa lihat bahwa angka yang sama-sama ada di faktorisasi dari 12 dan 18 adalah $1, 2, 3, \text{dan } 6$. Nah dari angka-angka ini kita bisa ambil yang terbesar yaitu 6. Jadi FPB dari 12 dan 18 adalah **$6$**. + +Cara lainnya adalah dengan menggunakan algoritma Euclidean yang rumusnya adalah: + +$$\text{FPB}(a, b) = \text{FPB}(b, a \mod b)$$ + +Cara ngitungnya kek gini: +1. Ambil dua bilangan $a$ dan $b$. +2. Bagi $a$ dengan $b$ dan simpan sisanya (modulus), misalnya $r = a \mod b$. +3. Ganti $a$ dengan $b$ dan $b$ dengan $r$. +4. Ulangi langkah 2 dan 3 sampai sisanya ($r$) menjadi 0. +5. Kalo $r$ udah 0, maka FPB dari $a$ dan $b$ adalah $b$. + +Pusing? Tenang, mari jadiin kode aja biar lebih mudah dimengerti kek gini: +:::tabs +== Javascript + +```javascript +function fpb(a, b) { + while (b !== 0) { + let t = b; + b = a % b; + a = t; + } + return a; +} + +let fpb1218 = fpb(12, 18); // 6 +``` +== Kotlin + +```kotlin +fun fpb(a: Int, b: Int): Int { + var a = a + var b = b + while (b != 0) { + val t = b + b = a % b + a = t + } + return a +} + +val fpb1218 = fpb(12, 18) // 6 +``` +== C++ + +```cpp +std::vector fpb(int a, int b) { + while (b != 0) { + int t = b; + b = a % b; + a = t; + } + return a; +} + +int main() { + int fpb1218 = fpb(12, 18); // 6 + return 0; +} +``` +== Python +```python +def fpb(a, b): + while b != 0: + t = b + b = a % b + a = t + + return a + +fpb1218 = fpb(12, 18) # 6 +``` +::: + + +## Kelipatan Persekutuan Terkecil (KPK) + +Kelipatan Persekutuan Terkecil (KPK) adalah angka terkecil yang bisa dibagi habis oleh dua bilangan. Misalnya, KPK dari 12 dan 18 adalah **$36$**, karena 36 adalah angka terkecil yang bisa dibagi habis oleh kedua bilangan tersebut. + +Gak percaya coba kita hitung $12 \times 3 = 36$ dan $18 \times 2 = 36$. + +Untuk mencari KPK, kita bisa pakai rumus ini: + +$$\text{KPK}(a, b) = \frac{a \times b}{\text{FPB}(a, b)}$$ + +Kalo disimulasiin kek gini: + +1. kita punya FPB dari 12 dan 18 yaitu 6. +2. $12 \times 18 = 216$ (gede banget) +3. $216 \div 6 = 36$ (nah ini KPKnya) + +Atau kalo mau rada ribet, kita bisa hitung manual dengan cara mencari kelipatan dari kedua bilangan tersebut. Contoh kalo kita mau cari KPK dari 12 dan 18 kita bisa lakukan seperti ini: + +| Bilangan | Kelipatan 1 | Kelipatan 2 | Kelipatan 3 | Kelipatan $n$ | +|----------|-------------|-------------|-------------|---------------| +| 12 | 12 | 24 | 36 | ... | +| 18 | 18 | 36 | 54 | ... | + +Dari tabel diatas kita bisa lihat bahwa kelipatan yang sama dari 12 dan 18 adalah 36. Jadi KPK dari 12 dan 18 adalah **$36$**. +Kalian bebas sih pake yang mana, yang penting gak salah. + + +Gampang kan? Mari kita jadiin kode biar lebih mudah dimengerti: +:::tabs +== Javascript + +```javascript +function kpk(a, b) { + return (a * b) / fpb(a, b); +} + +let kpk1218 = kpk(12, 18); // 36 +``` +== Kotlin + +```kotlin +fun kpk(a: Int, b: Int): Int { + return (a * b) / fpb(a, b) +} + +val kpk1218 = kpk(12, 18) // 36 +``` +== C++ + +```cpp +int kpk(int a, int b) { + return (a * b) / fpb(a, b); +} + +int main() { + int kpk1218 = kpk(12, 18); // 36 + return 0; +} +``` +== Python +```python +def kpk(a, b): + return (a * b) / fpb(a, b) + +kpk1218 = kpk(12, 18) # 36.0 +``` +::: + + diff --git a/docs/id/arithmetic/numbers.md b/docs/id/arithmetic/numbers.md new file mode 100644 index 0000000..8f66e0b --- /dev/null +++ b/docs/id/arithmetic/numbers.md @@ -0,0 +1,148 @@ +--- +title: Bilangan +description: Contoh penggunaan Bilangan dalam pemrograman +--- + +# Bilangan + +Bilangan merupakan dasar dari matematika, semuanya di matematika pake bilangan. Dalam pemrograman, bilangan juga sangat penting. Kita bisa melakukan berbagai operasi matematika dengan bilangan, seperti penjumlahan, pengurangan, perkalian, dan pembagian. + +Namun bilangan di pemrograman dibagi-bagi ke beberapa jenis, tergantung dari tipe datanya. Jadinya penggunaan bilangan di program bakalan sedikit beda dengan di matematika biasa. yuk pelajari lebih lanjut! + +## Bilangan Bulat (Integer) + +Bilangan bulat adalah bilangan yang tidak punya koma. Di pemrograman, bilangan bulat biasanya disebut dengan `integer`. Contoh bilangan bulat adalah 1, 2, 3, 4, 5, dan seterusnya. + +:::tabs +== Javascript +```js +let bilanganBulat = 10; +``` +== Kotlin +```kt +val bilanganBulat: Int = 10 +``` +== C++ +```cpp +int bilanganBulat = 10; +``` +== Python +```python +bilanganBulat = 10 +``` +::: + +Meski kelihatannya sederhana, jangan lupa kalau di pemrograman, bilangan punya batasan! Contohnya, di Javascript, bilangan paling besar yang bisa kamu pakai adalah **`9,007,199,254,740,992`**. Itu setara dengan angka yang sangat besar seriously, aku aja bingung ngucapinnya. + +Nah, kalau di C++ dan bahasa lain yang punya tipe data lebih banyak daripada JS (cuman `number` dan `BigInt`), batasan itu tergantung tipe data yang kamu pakai. Contoh kalo pake `short` di c++, kamu bisa mencapai angka **`32,767`** terkecuali di python, python tidak memiliki batas bilangan bulat, karena Python secara dinamis menangani ukuran bilangan bulat. contohnya seperti dibawah ini + +:::tabs +== Javascript + +| Tipe Data | Ukuran (bits) | Minimal| Maksimal| Maksimal (Secara Eksplisit) | +|-----------|------------------|---------------|----|---------------------------| +| Number | 64 | -9,007,199,254,740,991
(−253 - 1) | 9,007,199,254,740,992
(253 - 1 ) | 18,446,744,073,709,551,616 (264) | +| BigInt | max 1,000,000,000 | `tergantung memori` | `tergantung memori` | `tergantung memori` | +== C++ +| Tipe Data | Ukuran (bits) | Minimal | Maksimal | Maksimal (Secara Eksplisit) +|-----------|------------------|------------------------------------------------|-----------------------------------------------|---------------------------| +| `short` | 16 | -32,768 | 32,767 | 65,536 (216) | +| `int` | 32 | -2,147,483,648 (-231) | 2,147,483,647 (231 - 1) | 4,294,687,296 (232) | +| `long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | +| `long long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | + +Banyak banget selengkapnya cek [sini aja ya](https://learn.microsoft.com/en-us/cpp/c-language/cpp-integer-limits?view=msvc-170#limits-on-integer-constants) +== Kotlin +| Tipe Data | Ukuran (bits) | Minimal | Maksimal | Maksimal (Secara Eksplisit) | +|-----------|------------------|------------------------------------------------|-----------------------------------------------|---------------------------| +| `Byte` | 8 | -128 | 127 | 256 (28) +| `Short` | 16 | -32,768 | 32,767 | 65,536 (216) | +| `Int` | 32 | -2,147,483,648 (-231) | 2,147,483,647 (231 - 1) | 4,294,687,296 (232) | +| `Long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | +::: + +## Bilangan Desimal (Floating Point) + +Bilangan desimal atau floating point adalah bilangan yang punya koma. Di pemrograman, bilangan desimal biasanya disebut dengan `float` atau `double`. Contoh bilangan desimal adalah 1.5, 2.3, 3.14, dan seterusnya. Untuk membuat bilangan desimal kamu bisa menggunakan kode seperti dibawah ini + +:::tabs +== Javascript +```js +let bilanganDesimal = 3.14; +``` +== Kotlin +```kt +val bilanganDesimal: Float = 3.14F +``` +Kita juga bisa menggunakan `double` untuk bilangan desimal yang memiliki angka di belakang koma lebih banyak (sampe 15 digit). Contoh penggunaannya seperti ini: +```kt +val bilanganDesimal: Double = 3.141592653589793f +``` +== C++ +```cpp +float bilanganDesimal = 3.14f; +``` +Kita juga bisa menggunakan `double` untuk bilangan desimal yang memiliki angka di belakang koma lebih banyak (sampe 15 digit). Contoh penggunaannya seperti ini: +```cpp +double bilanganDesimal = 3.141592653589793F; +``` +== Python +```python +bilanganDesimal = 3.14 +``` +::: + + +## Bilangan Pecahan (Fraction) + +Bilangan pecahan adalah bilangan yang punya pembilang dan penyebut. Di pemrograman, bilangan pecahan biasanya disebut dengan `fraction`. Contoh bilangan pecahan adalah 1/2, 3/4, 5/6, dan seterusnya. Sayangnya di pemrograman, bilangan pecahan gak ada tipe datanya tapi langsung dihitung aja yang nantinya hasilnya bakal jadi bilangan desimal. Contoh penggunaannya seperti ini: + +:::tabs +== Javascript +```js +let bilanganPecahan = 1/2; +``` +== Kotlin +```kt +val bilanganPecahan = 1/2 // Otomatis jadi float +``` +== C++ +```cpp +float bilanganPecahan = 1/2; +``` +== Python +```python +bilanganPecahan = 1/2 +``` +::: + +> [!WARNING] Perhatian saat melakukan operasi dengan bilangan pecahan dan desimal +> Dalam banyak bahasa pemrograman, termasuk JavaScript, ada yang disebut dengan `floating point error`, yang dapat menyebabkan hasil perhitungan tidak akurat. Hal ini terjadi karena bilangan desimal tidak selalu dapat direpresentasikan secara tepat dalam format biner. +> +> Contoh, ketika kita menjumlahkan 0.1 dan 0.2 di JavaScript, hasilnya bukan 0.3, melainkan 0.30000000000000004. Ini disebabkan oleh keterbatasan representasi angka desimal dalam komputer. +> +> Untuk menghindari masalah ini, sebaiknya batasi presisi hasil perhitungan dengan cara Membulatkan hasil ke jumlah angka desimal yang diinginkan (misalnya dengan `toFixed()` atau `Math.round()`. +> +> Kamu juga bisa menggunakan pustaka seperti BigNumber atau yang lainnya + +Gimana dengan **Bilangan pecahan campuran** kan di matematika ada kaya $1\frac{1}{2}$, di pemrograman juga bisa kok. Kita bisa menggunakan `float` atau `double` untuk bilangan pecahan campuran. Contoh penggunaannya seperti ini: +:::tabs +== Javascript +```js +let bilanganPecahanCampuran = 1 + 1/2; +``` +== Kotlin +```kt +val bilanganPecahanCampuran: Double = 1 + 1/2 +``` +== C++ +```cpp +double bilanganPecahanCampuran = 1 + 1/2; +``` +== Python +```python +bilanganPecahanCampuran = 1 + 1/2 +``` +::: + +Kenapa bisa dikali? Karena bilangan pecahan campuran itu sebenernya bisa diubah jadi bilangan desimal biasa. Misal $1\frac{1}{2}$ bisa diubah jadi $1 + \frac{1}{2}$ yang sama dengan $1.5$. diff --git a/docs/id/arithmetic/operation-on-number.md b/docs/id/arithmetic/operation-on-number.md new file mode 100644 index 0000000..a455504 --- /dev/null +++ b/docs/id/arithmetic/operation-on-number.md @@ -0,0 +1,232 @@ +--- +title: Operasi pada Bilangan +description: Contoh penggunaan operasi matematika pada bilangan dalam pemrograman +--- + + +# Operasi Bilangan + +Operasi bilangan atau proses untuk memanipulasi nilai numerik tertentu pake teknik matematika seperti penjumlahan, pengurangan, perkalian, pembagian, dan banyak lagi. Di pemrograman kita gak bisa lepas dari yang namanya operasi bilangan karena komputer sendiri berjalan berdasarkan operasi bilangan. Di sini kita bakal bahas operasi bilangan yang sering dipake di pemrograman. + +## Operasi Dasar + +Di pemrograman, kita bisa melakukan berbagai operasi matematika dengan bilangan. Ada penjumlahan, pengurangan, perkalian, dan pembagian. Berbeda dengan matematika biasa yang pakai simbol `+`, `-`, `*`, dan `/`, di pemrograman kita pakai simbol yang berbeda. Contoh penggunaannya seperti ini: + +:::tabs +== Javascript +```js +let a = 10; +let b = 5; +let hasilPenjumlahan = a + b; // 15 +let hasilPengurangan = a - b; // 5 +let hasilPerkalian = a * b; // 50 +let hasilPembagian = a / b; // 2 +``` +== Kotlin +```kt +val a = 10 +val b = 5 +val hasilPenjumlahan = a + b // 15 +val hasilPengurangan = a - b // 5 +val hasilPerkalian = a * b // 50 +val hasilPembagian = a / b // 2 +``` +== C++ +```cpp +int a = 10; +int b = 5; +int hasilPenjumlahan = a + b; // 15 +int hasilPengurangan = a - b; // 5 +int hasilPerkalian = a * b; // 50 +int hasilPembagian = a / b; // 2 +``` +== Python +```python +a = 10 +b = 5 +hasilPenjumlahan = a + b # 15 +hasilPengurangan = a - b # 5 +hasilPerkalian = a * b # 50 +hasilPembagian = a / b # 2 +``` +::: + +Di atas kita menggunakan simbol `/` untuk pembagian dan `*` untuk perkalian. Ini karena dalam pemrograman, kita tidak bisa menggunakan simbol matematika `÷` dan `×` kek biasanya apalagi `.` karena bahasa pemrograman umumnya mengikuti aturan ASCII yang hanya mendukung karakter dasar, sehingga simbol-simbol matematika khusus seperti `÷` dan `×` tidak tersedia. Sebagai gantinya, pemrograman menggunakan `*` sebagai pengganti kali dan `/` sebagai pengganti bagi agar kode bisa berjalan dengan baik. + +> [!NOTE] +> Coba cek di keyboard laptop atau PC kalian ada gak tuh simbol `÷` dan `×` (ini bukan x ya) kebanyakan sih gak ada dan itulah salah satu alasannya kenapa pemrograman gak pake simbol itu. :grin: + +## Pangkat (Exponentiation) + +Pangkat adalah operasi matematika yang digunakan untuk menghitung hasil perkalian bilangan dengan dirinya sendiri sebanyak $n$ kali. Di pemrograman, kita bisa menggunakan operator `**` ataupun pakai `pow()` untuk menghitung pangkat. Contoh penggunaannya seperti ini: +:::tabs +== Javascript +```js +let pangkat = 2 ** 3; // 8 +let pangkat2 = Math.pow(2, 3); // 8 +``` +== Kotlin +```kt +val pangkat = 2.0.pow(3) // 8.0 +val pangkat2 = Math.pow(2.0, 3.0) // 8.0 +``` +== C++ +```cpp +#include +#include + +int main() { + double pangkat = pow(2, 3); // 8 + double pangkat2 = pow(2.0, 3.0); // 8 + return 0; +} +``` +== Python +```python +pangkat = 2 ** 3 # 8 +pangkat2 = pow(2, 3) # 8 +``` +::: + +`pow()` biasanya meminta dua parameter, parameter pertama adalah bilangan yang mau dipangkatkan, dan parameter kedua adalah pangkatnya. jadi kalo kita mau menghitung $2^3$ kita bisa tulis `pow(2, 3)`. + +## Akar (Root) + +Setiap bahasa pemrograman juga biasanya punya fungsi untuk menghitung akar. Di Javascript, kita bisa menggunakan fungsi `Math.sqrt()` (*Square Root*) untuk menghitung akar. Contoh penggunaannya seperti ini: + +```js +let akar = Math.sqrt(16); // 4 +``` +Di Kotlin, kita bisa menggunakan fungsi `Math.sqrt()` juga. Contoh penggunaannya seperti ini: + +```kt +val akar = Math.sqrt(16.0) // 4.0 +``` + +Di C++, kita bisa menggunakan fungsi `sqrt()` dari library `cmath`. Contoh penggunaannya seperti ini: + +```cpp +#include +#include + +int main() { + double akar = sqrt(16); // 4 + std::cout << akar << std::endl; + return 0; +} +``` + +Di Python, kita bisa menggunakan library `sqrt()` dari library `math`, Contoh penggunaanya seperti ini: +```python +import math +akar = math.sqrt(16) # 4.0 +``` + +Tapi ada masalah kalo kita mau menghitung akar yang lebih dari 2 kaya $\sqrt[3]{8}$ atau $\sqrt[4]{16}$, Nah untuk kasus ini kita bisa pangkatkan aja bilangannya dengan $1/n$ dimana si $n$ itu adalah akar yang kita mau. Contoh penggunaannya seperti ini: + +:::tabs +== Javascript +```js +let akar3 = Math.pow(8, 1/3); // 2 +let akar4 = Math.pow(16, 1/4); // 2 +``` +== Kotlin +```kt +val akar3 = Math.pow(8.0, 1.0/3.0) // 2.0 +val akar4 = Math.pow(16.0, 1.0/4.0) // 2.0 +``` +== C++ +```cpp +#include +#include + +int main() { + double akar3 = pow(8, 1.0/3); // 2 + double akar4 = pow(16, 1.0/4); // 2 + std::cout << akar3 << std::endl; + std::cout << akar4 << std::endl; + return 0; +} +``` +== Python +```python +akar3 = pow(8, 1/3) # 2.0 +akar4 = pow(16, 1/4) # 2.0 +``` +::: + +Hal ini bisa terjadi karena apapun bilangan yang memiliki pangkat $1/n$ akan menghasilkan akar dari bilangan tersebut. Jadi kalo kita mau menghitung $\sqrt[3]{8}$ kita bisa tulis `pow(8, 1/3)`. + +## Modulus + +Modulus atau sisa hasil pembagian adalah operasi matematika yang digunakan untuk menghitung sisa hasil pembagian dua bilangan. Misalnya kamu mau tau sisa hasil pembagian 10 dibagi 3, maka hasilnya adalah 1. Di pemrograman, kita bisa menggunakan operator `%` untuk menghitung modulus. + +Operator ini berguna banget buat ngecek bilangan itu genap, ganjil atau punya pola tertentu. Contoh penggunaannya seperti ini: + +:::tabs +== Javascript +```js +let hasilModulus = 10 % 3; // 1 +``` +== Kotlin +```kt +val hasilModulus = 10 % 3 // 1 +``` +== C++ +```cpp +int hasilModulus = 10 % 3; // 1 +``` +== Python +```python +hasilModulus = 10 % 3 # 1 +``` +::: + +## Prioritas Operasi + +Di dalam matematika, ada aturan yang namanya prioritas operasi. Prioritas operasi ini menentukan urutan operasi mana yang harus dilakukan duluan. Di pemrograman, prioritas operasi ini juga berlaku dan sama dengan matematika biasa. Kalo di bahasa inggris ada yang namanya PEMDAS (Parentheses, Exponents, Multiplication and Division, Addition and Subtraction) jadi urutannya adalah + +1. Tanda Kurung $( )$ +2. Pangkat $x^y$ dan Akar $\sqrt{x}$ +3. Perkalian $x \times y$, Pembagian $x \div y$ dan Modulus $x \% y$ +4. Penjumlahan $x + y$ dan Pengurangan $x - y$ + +contoh kalo pengen menghitung $6 + 3 * (2^3 + \sqrt{16})$ maka: + +1. **Tanda kurung**: Fokus pada bagian dalam kurung terlebih dahulu $2^3 + \sqrt{16}$. +3. **Eksponen (pangkat)**: Hitung $2^3$. +$$2^3 = 8$$ +5. **Akar**: Hitung $\sqrt{16}$. +$$\sqrt{16} = 4$$ +7. **Penjumlahan dalam kurung**: Sekarang, selesaikan operasi dalam kurung $2^3 + \sqrt{16}$. +$$8 + 4 = 12$$ +9. **Perkalian**: Lanjutkan ke operasi di luar kurung, yaitu $3 \times (2^3 + \sqrt{16})$. +$$3 \times 12 = 36$$ +11. **Penjumlahan terakhir**: Terakhir, tambahkan $6 + 36$. +$$6 + 36 = 42$$ +Jadi, hasil akhirnya adalah **42**. + +Kalo di pemrograman urutan operasi ini udah di tangani sama bahasanya jadi kamu gak perlu khawatir kalo salah urutan operasi. Kamu cukup teliti aja sama rumus yang akan kamu gunakan. Kalo rumus tadi kita masukkan ke kode maka akan jadi seperti ini. + +:::tabs +== Javascript +```js +let hasil = 6 + 3 * (2 ** 3 + Math.sqrt(16)); // 42 +``` +== Kotlin +```kt +val hasil = 6 + 3 * (2.0.pow(3) + Math.sqrt(16.0)) // 42.0 +``` + +== C++ +```cpp +int hasil = 6 + 3 * (pow(2, 3) + sqrt(16)); // 42 +``` +== Python +```python +import math +hasil = 6 + 3 * (pow(2,3) + math.sqrt(16)) # 42.0 +``` +::: + +## \ No newline at end of file diff --git a/docs/id/arithmetic/percent.md b/docs/id/arithmetic/percent.md new file mode 100644 index 0000000..62b2a73 --- /dev/null +++ b/docs/id/arithmetic/percent.md @@ -0,0 +1,113 @@ +# Persen + +Pernah dapat diskon pas belanja?, biasanya kalo gak di coret ya pake tanda persen ($\%$). Nah, persen ini adalah cara kita mengukur seberapa besar atau kecil suatu nilai dibandingkan dengan nilai aslinya. + +Misalnya kamu beli baju seharga Rp. $100.000$ tapi kamu dapat diskon $20\%$, berarti kamu bisa beli bajunya dengan harga Rp. $80.000$. + +Cara ngitung persen itu gampang banget, kita bisa pakai rumus: +$$ persen = \frac{nilai}{100} \times persen $$ + +Jadi kalo kita mau ngitung $20\%$ dari $100.000$ kita bisa tulis: +$$ persen = \frac{100.000}{100} \times 20\% = 20.000 $$ + +karena dibagi $100$ jadi kita bisa kurangi dua nol dari $100.000$ jadi $1.000$ dan dikalikan $20$ jadi $20.000$. + +Kalo diubah ke kodingan, kita bisa tulis seperti ini: +:::tabs +== Javascript +```js +let harga = 100000; +let diskon = 20; +let persen = (harga / 100) * diskon; // 20000 +``` +== Kotlin +```kt +val harga = 100000 +val diskon = 20 +val persen = (harga / 100) * diskon // 20000 +``` +== C++ +```cpp +int harga = 100000; +int diskon = 20; +int persen = (harga / 100) * diskon; // 20000 +``` +== Python +```python +harga = 100000 +diskon = 20 +persen = (harga / 100) * diskon # 20000.0 +``` +::: + +## Mencari Nilai Asli + +Kalo sebelumnya kita ngitung persen dari nilai asli, sekarang kita akan mencari nilai asli dari nilai persen tersebut. Caranya tinggal dibalik aja rumusnya jadi: +$$ nilai = \frac{persen}{persen} \times 100 $$ + +Misalnya kita punya nilai persen sebesar $20.000$ dan kita mau cari nilai aslinya, kita bisa tulis: +$$ nilai = \frac{20.000}{20\%} \times 100 = 100.000 $$ + +Kalo diubah ke kodingan, kita bisa tulis seperti ini: +:::tabs +== Javascript +```js +let persen = 20000; +let diskon = 20; +let harga = (persen / diskon) * 100; // 100000 +``` +== Kotlin +```kt +val persen = 20000 +val diskon = 20 +val harga = (persen / diskon) * 100 // 100000 +``` +== C++ +```cpp +int persen = 20000; +int diskon = 20; +int harga = (persen / diskon) * 100; // 100000 +``` +== Python +```python +persen = 20000 +diskon = 20 +persen = (persen / diskon) * 100 # 100000.0 + +``` +::: + +## Mencari Persen + +Kalo sebelumnya kita ngitung persen dari nilai asli, sekarang kita akan mencari nilai persen dari nilai asli tersebut. Rumusnya kita ubah jadi: +$$ persen = \frac{nilai}{nilai} \times 100 $$ +Misalnya kita punya nilai asli sebesar $100.000$ dan kita mau cari persennya, kita bisa tulis: +$$ persen = \frac{100.000}{100.000} \times 100 = 20\% $$ + +Kalo diubah ke kodingan, kita bisa tulis seperti ini: +:::tabs +== Javascript +```js +let harga = 100000; +let diskon = 20000; +let persen = (diskon / harga) * 100; // 20 +``` +== Kotlin +```kt +val harga = 100000 +val diskon = 20000 +val persen = (diskon / harga) * 100 // 20 +``` +== C++ +```cpp +int harga = 100000; +int diskon = 20000; +int persen = (diskon / harga) * 100; // 20 +``` +== Python +```python +harga = 100000 +diskon = 20000 +persen = (diskon / harga) * 100 # 20.0 +``` +::: diff --git a/docs/id/guide/index.md b/docs/id/guide/index.md new file mode 100644 index 0000000..64c27c6 --- /dev/null +++ b/docs/id/guide/index.md @@ -0,0 +1,40 @@ +# Panduan Belajar + +Sebelum memulai, ada beberapa hal penting yang perlu kamu ketahui. **Math W Code** adalah tempat belajar dan berbagi tentang matematika dengan bantuan bahasa pemrograman. Di sini, kamu bisa belajar sekaligus berkontribusi dalam mengembangkan ilmu matematika melalui kode! + +## Persyaratan + +Fokus kita ada pada bagaimana konsep matematika diterapkan dalam pemrograman. Jadi, kita tidak akan membahas hal-hal seperti cara menginstal kode editor, menulis kode dasar dan sebagainya namun beberapa konsep dasar pemrograman akan kita bahas. + +Nah karena itu sebelum memulai, kami harap kamu sudah paham dasar-dasar pemrograman gak perlu jago banget sih, yang penting kamu bisa memahami kode-kode yang akan kita bahas. + +## Bahasa Pemrograman + +Dalam situs ini, kita akan menggunakan berbagai bahasa pemrograman untuk menjelaskan konsep matematika. Beberapa bahasa yang akan kita gunakan antara lain: + +
+
+ Javascript +
+
+ C++ +
+
+ Kotlin +
+
+ Python +
+
+ +Setiap bahasa punya keunikan tersendiri dalam cara mereka menangani matematika. Jadi, siap-siap untuk mengeksplorasi banyak hal baru dalam perjalanan belajar ini! + + +Di beberapa materi, mungkin bahasa pemrograman yang disebutkan tidak tersedia. + +Jangan khawatir, kamu tetap bisa mengikuti konsep yang diajarkan dengan bahasa lain yang ada, konsepnya gak jauh beda kok. Intinya, fokus pada implementasinya, ya! + +> [!NOTE] +> Di beberapa materi, mungkin bahasa pemrograman yang disebutkan tidak tersedia. +> +> Jangan khawatir, kamu tetap bisa mengikuti konsep yang diajarkan dengan bahasa lain yang ada, konsepnya gak jauh beda kok. Intinya, fokus pada implementasinya, ya! \ No newline at end of file diff --git a/docs/id/index.md b/docs/id/index.md new file mode 100644 index 0000000..4308fe0 --- /dev/null +++ b/docs/id/index.md @@ -0,0 +1,68 @@ +--- +# https://vitepress.dev/reference/default-theme-home-page +layout: home + +hero: + name: "Math W Code" + text: "Belajar matematika dengan barisan kode" + tagline: Matematika dengan pendekatan yang berbeda + image: + src: /icon.png + alt: Math W Code Logo + actions: + - theme: brand + text: Belajar Sekarang + link: /guide + - theme: alt + text: Beri Kontribusi + link: https://github.com/xirf/mathwithcode +features: + - icon: 🔢 + title: Arimatika + details: Bilangan, Operasi, Faktor, Kelipatan dan sebagainya + link: /arithmetic/numbers + linkText: Pelajari + - icon: 📐 + title: Aljabar + details: Polinomial, Persamaan, Matriks, Determinan dan sebagainya + link: /algebra/function + linkText: Pelajari + - icon: 📈 + title: Aljabar Linear + details: Vektor, Ruang Vektor, Orthogonalitas dan sebagainya + link: /linear-algebra/linear-transformation + linkText: Pelajari + - icon: 📊 + title: Statistika + details: Data, Distribusi, Regresi, Uji Hipotesis dan sebagainya + link: /statistics/measures-concentration-dispersion + linkText: Pelajari +--- + + + + + + diff --git a/docs/id/linear-algebra/linear-transformation.md b/docs/id/linear-algebra/linear-transformation.md new file mode 100644 index 0000000..9644d86 --- /dev/null +++ b/docs/id/linear-algebra/linear-transformation.md @@ -0,0 +1,327 @@ +--- +contributors: + - name: "Rijal" + username: "Rnov24" +--- +# Transformasi Linear + +Transformasi linear adalah aturan yang memetakan setiap vektor dalam satu ruang vektor ke vektor lain dalam ruang vektor yang mungkin berbeda, dengan tetap mempertahankan operasi penambahan vektor dan perkalian skalar. Dengan kata lain, transformasi linear adalah fungsi yang mengambil vektor sebagai input dan menghasilkan vektor sebagai output, tunduk pada batasan berikut: + +* **Aditivitas**: Tranformasi yang diterapkan pada penjumlahan dua vektor menghasilkan hasil yang sama dengan penjumlahan hasil transformasi pada masing-masing vektor. +$$ +\mathbf{T}(\mathbf{u} + \mathbf{v}) = \mathbf{T}(\mathbf{u}) + \mathbf{T}(\mathbf{v}) +$$ +* **Homogenitas**: Transformasi yang diterapkan pada kelipatan skalar dari suatu vektor sama dengan kelipatan skalar dari transformasi yang diterapkan pada vektor tersebut. +$$ +\mathbf{T}(c\mathbf{u}) = c\mathbf{T}(\mathbf{u}) +$$ + +# Jenis-Jenis Transformasi Linear + +Transformasi linear dapat digunakan untuk mengubah sebuah vektor menjadi vektor lain, seperti memperbesar, mengecilkan, atau bahkan mengubah rotasi vektor tersebut. Berikut adalah beberapa jenis transformasi linear: + +## Scalling + +Kita dapat menggunakan scalar untuk memperbesar atau memperkecil vektor. +$$ +\mathbf{u}= \begin{pmatrix}i \\ j \end{pmatrix} +$$ +$$ +\mathbf{T}(c\mathbf{u})= c \begin{pmatrix}i \\ j \end{pmatrix} = \begin{pmatrix}i \cdot c \\ j \cdot c \end{pmatrix} +$$ + +Bisa diimplementasikan menjadi program, seperti berikut: +:::tabs +== Javascript +``` js +function scalling(vector, scalar) { + let result = []; + for (let i = 0; i < vector.length; i++) { + result.push(vector[i] * scalar); + } + return result; +} + +// contoh penggunaan +let vector = [2, 3]; +let scalar = 2; +let result = scalling(vector, scalar); +console.log(result); // output: [4, 6] +``` +== C++ +``` cpp +#include +#include + +void scalling(double vector[], double scalar) { + double hasilVector[sizeof(vector) / sizeof(vector[0])]; + for (int i = 0; i < sizeof(vector) / sizeof(vector[0]); i++) { + hasilVector[i] = vector[i] * scalar; + } + std::cout << "Hasil dari scalling vektor [" << vector[0] << ", " << vector[1] << "] dengan scalar " << scalar << " adalah [" << hasilVector[0] << ", " << hasilVector[1] << "]" << std::endl; +} + + +int main() { + double vector[] = {2, 3}; + double scalar = 2; + + scalling(vector, scalar); // Output: [4, 6] + return 0; +} +``` +== Python +``` py +def scalling(vector, scalar): + hasil = [] + for i in range(len(vector)): + hasil.append(vector[i] * scalar) + return hasil + +# contoh penggunaan +vector = [2, 3] +scalar = 2 +result = scalling(vector, scalar) +print(result) # output: [4, 6] +``` +::: + + +## Rotasi + +Kita dapat merotasikan vektor dengan cara mengalikan vektor tersebut dengan matriks rotasi $R(\theta)$, dengan $\theta$ adalah sudut rotasi vektor tersebut. +$$ +R(\theta) = \begin{pmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{pmatrix} +$$ +$$ +R(\theta)u = \begin{pmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{pmatrix} \begin{pmatrix}i \\ j \end{pmatrix}= \begin{pmatrix} i\cos\theta - j\sin\theta \\ i\sin\theta + j\cos\theta \end{pmatrix} +$$ +Bisa diimplementasikan menjadi program, seperti berikut: +:::tabs +== Javascript +``` js +function rotasi(vector, theta) { + // Inisialisasi array untuk menyimpan hasil rotasi + let hasil = []; + + // Hitung cosinus dan sinus dari sudut theta + let cosTheta = Math.cos(theta); + let sinTheta = Math.sin(theta); + + // Lakukan perhitungan rotasi untuk komponen i dan j + hasil.push(vector[0] * cosTheta - vector[1] * sinTheta); // Komponen i + hasil.push(vector[0] * sinTheta + vector[1] * cosTheta); // Komponen j + + // Return hasil rotasi + return hasil; +} + +// contoh penggunaan +let vector = [2, 3]; +let theta = Math.PI / 2; // 90 derajat +let result = rotasi(vector, theta); +console.log(result); +``` +== Python +``` py +import math + +def rotasi(vector, theta): + # Inisialisasi array untuk menyimpan hasil rotasi + hasil = [] + + # Hitung cosinus dan sinus dari sudut theta + cosTheta = math.cos(theta) + sinTheta = math.sin(theta) + + # Lakukan perhitungan rotasi untuk komponen i dan j + hasil.append(vector[0] * cosTheta - vector[1] * sinTheta) # Komponen i + hasil.append(vector[0] * sinTheta + vector[1] * cosTheta) # Komponen j + + # Return hasil rotasi + return hasil + +# contoh penggunaan +vector = [2, 3] +theta = math.pi / 2 # 90 derajat +result = rotasi(vector, theta) +print(result) + +``` +== C++ +``` cpp +#include +#include + +void rotasi(double vector[], double theta, double hasil[]) { + // Hitung cosinus dan sinus dari sudut theta + double cosTheta = std::cos(theta); + double sinTheta = std::sin(theta); + + // Lakukan perhitungan rotasi untuk komponen i dan j + hasil[0] = vector[0] * cosTheta - vector[1] * sinTheta; // Komponen i + hasil[1] = vector[0] * sinTheta + vector[1] * cosTheta; // Komponen j +} + +int main() { + double vector[] = {2, 3}; + double theta = M_PI / 2; // 90 derajat + double result[2]; + + rotasi(vector, theta, result); + std::cout << "(" << result[0] << ", " << result[1] << ")" << std::endl; + + return 0; +} +``` +::: + +## Penggeseran + +Kita dapat melakukan shearing untuk membuat vektor tegeser seolah-olah terdistorsi dengan cara mengalikan vektor tersebut dengan matriks shearing $S(a, b)$, dengan $a$ dan $b$ adalah parameter shearing, ubah $b$ menjadi 0 untuk penggeseran secara horizontal atau ubah $a$ menjadi 0 untuk penggeseran secara vertikal, atau dapat menggabungkannya. +$$ +S(a, b) = \begin{pmatrix} 1 & a \\ b & 1 \end{pmatrix} +$$ +$$ +S(a, b)u = \begin{pmatrix} 1 & a \\ b & 1 \end{pmatrix} \begin{pmatrix}i \\ j \end{pmatrix}= \begin{pmatrix} i + aj \\ bi + j \end{pmatrix} +$$ +Bisa diimplementasikan menjadi program, seperti berikut: +:::tabs +== Javascript +``` js +function geser(vector, a, b) { + // Hitung hasil penggeseran + let hasil = [vector[0] * 1 + a * vector[1], b * vector[0] + vector[1] * 1]; + return hasil; +} + +// contoh penggunaan +vector = [2, 3]; +a = 1; // parameter shearing horizontal +b = 0; // parameter shearing vertikal +result = geser(vector, a, b); +console.log(result); +``` +== Python +``` py +def geser(vector, a, b): + # Hitung hasil penggeseran + hasil = [vector[0] * 1 + a * vector[1], b * vector[0] + vector[1] * 1] + return hasil + +# contoh penggunaan +vector = [2, 3] +a = 1 # parameter shearing horizontal +b = 0 # parameter shearing vertikal +result = geser(vector, a, b) +print(result) +``` +== C++ +``` cpp +#include +#include + +std::vector geser(const std::vector& vector, double a, double b) { + // Hitung hasil penggeseran + std::vector hasil = {vector[0] * 1 + a * vector[1], b * vector[0] + vector[1] * 1}; + return hasil; +} + +int main() { + // contoh penggunaan + std::vector vector = {2, 3}; + double a = 1; // parameter shearing horizontal + double b = 0; // parameter shearing vertikal + std::vector result = geser(vector, a, b); + std::cout << "(" << result[0] << ", " << result[1] << ")" << std::endl; + return 0; +} +``` +::: + + +## Refleksi + +Kita dapat melakukan refleksi untuk membuat vektor terlihat seperti cerminan dengan cara mengalikan vektor tersebut dengan matriks refleksi $F(x, y)$, dengan $x$ dan $y$ adalah parameter refleksi, ubah $x$ menjadi -1 untuk refleksi secara horizontal atau ubah $y$ menjadi -1 untuk refleksi secara vertikal, atau dapat menggabungkannya. + +* Refleksi terhadap sumbu x : +$$ +R_xu = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} \begin{pmatrix}i \\ j\end{pmatrix} = \begin{pmatrix} i \\ -j \end{pmatrix} +$$ +* Refleksi terhadap sumbu y : +$$ +R_yu = \begin{pmatrix} -1 & 0 \\ 0 & 1 \end{pmatrix} \begin{pmatrix}i \\ j\end{pmatrix} = \begin{pmatrix} -i \\ j \end{pmatrix} +$$ +Bisa diimplementasikan menjadi program, seperti berikut: +:::tabs +== Javascript +``` js +function refleksi(vector, terhadap) { + let hasil; + if (terhadap === "x") { + hasil = [vector[0], -vector[1]]; + } else if (terhadap === "y") { + hasil = [-vector[0], vector[1]]; + return hasil; +} + +// contoh penggunaan +let vector = [2, 3]; +let result = refleksi(vector, "x"); // atau refleksi(vector, "y") untuk refleksi terhadap y +console.log(result); + +``` +== Python +``` py +def refleksi(vector, terhadap): + hasil; + if (terhadap == "x"): + hasil = [vector[0], -vector[1]] + elif (terhadap == "y"): + hasil = [-vector[0], vector[1]] + return hasil + +# contoh penggunaan +vector = [2, 3] +result = refleksi(vector, "x") # atau refleksi(vector, "y") untuk refleksi terhadap y +print(result) +``` +== C++ +``` cpp +#include + +void refleksi(double vector[], double terhadap[], double hasil[]) { + if (terhadap[0] == 1) { + hasil[0] = vector[0]; + hasil[1] = -vector[1]; + } else if (terhadap[0] == 2) { + hasil[0] = -vector[0]; + hasil[1] = vector[1]; + } +} + +int main() { + double vector[] = {2, 3}; + double terhadap[] = {1}; // 1 untuk refleksi terhadap x, 2 untuk refleksi terhadap y + double hasil[2]; + + refleksi(vector, terhadap, hasil); + + std::cout << "Hasil refleksi vektor [" << vector[0] << ", " << vector[1] << "] terhadap "; + if (terhadap[0] == 1) { + std::cout << "x adalah [" << hasil[0] << ", " << hasil[1] << "]" << std::endl; + } else if (terhadap[0] == 2) { + std::cout << "y adalah [" << hasil[0] << ", " << hasil[1] << "]" << std::endl; + } + + return 0; +} +``` +::: + +::: info +Sebenarnya semua jenis-jenis yang disebutkan merupakan sedikit gambaran dari transformasi linear karena transformasi linear dapat bebas dilakukan dengan membuat matriks transformasi sendiri selama masih mematuhi aturan Aditivitas dan Homogenitas serta aturan Perkalian matriks. +::: + + + diff --git a/docs/id/linear-algebra/matrix-multiplication.md b/docs/id/linear-algebra/matrix-multiplication.md new file mode 100644 index 0000000..f59a45f --- /dev/null +++ b/docs/id/linear-algebra/matrix-multiplication.md @@ -0,0 +1,256 @@ +--- +contributors: + - name: "Rijal" + username: "Rnov24" +--- +# Perkalian Matriks +Perkalian matriks adalah operasi matematika yang digunakan untuk menggabungkan dua matriks dengan cara mengalikan elemen-elemen yang sesuai. Hasil perkalian matriks adalah matriks baru yang memiliki jumlah baris yang sama dengan matriks pertama dan jumlah kolom yang sama dengan matriks kedua. + +## Aturan Perkalian Matriks + +Berikut adalah aturan perkalian matriks: + +* Jumlah baris matriks pertama harus sama dengan jumlah kolom matriks kedua. +$$ +A ^{m\times n} \times B^{n \times p} +$$ +* Hasil perkalian matriks adalah matriks baru dengan jumlah baris yang sama dengan matriks pertama dan jumlah kolom yang sama dengan matriks kedua. +$$ +A ^{m\times n} \times B^{n \times p} = AB^{m \times p} +$$ +* Elemen-elemen hasil perkalian matriks dihitung dengan mengalikan elemen-elemen yang sesuai dari matriks pertama dan matriks kedua, kemudian menjumlahkan hasilnya. +$$ +\begin{bmatrix} +a_{11} & a_{12} & a_{13} \\ +a_{21} & a_{22} & a_{23} +\end{bmatrix} \times +\begin{bmatrix} +b_{11} & b_{12} \\ +b_{21} & b_{22} \\ +b_{31} & b_{32} +\end{bmatrix} = +\begin{bmatrix} +a_{11}*b_{11} + a_{12}*b_{21} + a_{13}*b_{31} & a_{11}*b_{12} + a_{12}*b_{22} + a_{13}*b_{32} \\ +a_{21}*b_{11} + a_{22}*b_{21} + a_{23}*b_{31} & a_{21}*b_{12} + a_{22}*b_{22} + a_{23}*b_{32} +\end{bmatrix} +$$ + +## Contoh dan implemetasi kode +Contoh soal perkalian matriks adalah sebagai berikut: + +Diberikan dua matriks A dan B dengan ukuran 2x2 dan 2x3, masing-masing: + +$$ +A = +\begin{bmatrix} +2 & 3 \\ +4 & 1 +\end{bmatrix} +$$ + +$$ +B = +\begin{bmatrix} +1 & 2 & 3 \\ +4 & 5 & 6 +\end{bmatrix} +$$ + +Untuk menyelesaikan perkalian matriks diatas. Berikut langkah-langkahnya: + +1. kalikan dan jumlahkan baris pertama matriks $A$ dengan kolom pertama matriks $B$. +$$ +2\times1 + 3\times4 = 14 +$$ +2. kalikan dan jumlahkan baris pertama matriks $A$ dengan kolom kedua matriks $B$. +$$ +2\times2 + 3\times5 = 19 +$$ +3. kalikan dan jumlahkan baris pertama matriks $A$ dengan kolom ketiga matriks $B$. +$$ +2\times3 + 3\times6 = 24 +$$ +4. kalikan dan jumlahkan baris kedua matriks $A$ dengan kolom pertama matriks $B$. +$$ +4\times1 + 1\times4 = 8 +$$ +5. kalikan dan jumlahkan baris kedua matriks $A$ dengan kolom kedua matriks $B$. +$$ +4\times2 + 1\times5 = 13 +$$ +6. kalikan dan jumlahkan baris kedua matriks $A$ dengan kolom ketiga matriks $B$. +$$ +4\times3 + 1\times6 = 18 +$$ +7. masukan semua elemen ke matriks baru. +$$ +AB = +\begin{bmatrix} +14 & 19 & 24 \\ +8 & 13 & 18 +\end{bmatrix} +$$ + + + +Jika diimplementasikan dalam kode, maka hasilnya adalah seperti ini: +:::tabs +== Javascript +```js +// Inisialisasi array untuk menyimpan hasil perkalian matriks. +const result = []; + +// Inisialisasi kedua matriks. +const A = [ + [2, 3], + [4, 1] +]; + +const B = [ + [1, 2, 3], + [4, 5, 6] +]; + +for (let i = 0; i < A.length; i++) { + // Inisialisasi array untuk menyimpan hasil perkalian baris matriks A dengan kolom matriks B. + result[i] = []; + + // Iterasi kolom matriks B. + for (let j = 0; j < B[0].length; j++) { + // Inisialisasi variabel untuk menyimpan hasil perkalian baris matriks A dengan kolom matriks B. + let sum = 0; + + // Iterasi kolom matriks A dan baris matriks B. + for (let k = 0; k < A[0].length; k++) { + // Lakukan perkalian elemen matriks A dengan elemen matriks B dan tambahkan hasilnya ke variabel sum. + sum += A[i][k] * B[k][j]; + } + + // Simpan hasil perkalian baris matriks A dengan kolom matriks B ke array result. + result[i][j] = sum; + } +} + +console.log(result); +``` +== C++ +```cpp +#include +#include + +int main() { + // Inisialisasi kedua matriks + std::vector> A = { + {2, 3}, + {4, 1} + }; + + std::vector> B = { + {1, 2, 3}, + {4, 5, 6} + }; + + // Inisialisasi array untuk menyimpan hasil perkalian matriks + std::vector> result(A.size(), std::vector(B[0].size(), 0)); + + // Iterasi baris matriks A + for (int i = 0; i < A.size(); i++) { + // Iterasi kolom matriks B + for (int j = 0; j < B[0].size(); j++) { + // Inisialisasi variabel untuk menyimpan hasil perkalian baris matriks A dengan kolom matriks B + int sum = 0; + + // Iterasi kolom matriks A dan baris matriks B + for (int k = 0; k < A[0].size(); k++) { + // Lakukan perkalian elemen matriks A dengan elemen matriks B dan tambahkan hasilnya ke variabel sum + sum += A[i][k] * B[k][j]; + } + + // Simpan hasil perkalian baris matriks A dengan kolom matriks B ke array result + result[i][j] = sum; + } + } + + // Tampilkan hasil perkalian matriks + for (const auto& row : result) { + for (int val : row) { + std::cout << val << " "; + } + std::cout << std::endl; + } + + return 0; +} +``` +== Python +```py +# Inisialisasi kedua matriks +A = [ + [2, 3], + [4, 1] +] + +B = [ + [1, 2, 3], + [4, 5, 6] +] + +# Inisialisasi array untuk menyimpan hasil perkalian matriks +result = [[0 for _ in range(len(B[0]))] for _ in range(len(A))] + +# Iterasi baris matriks A +for i in range(len(A)): + # Iterasi kolom matriks B + for j in range(len(B[0])): + # Inisialisasi variabel untuk menyimpan hasil perkalian baris matriks A dengan kolom matriks B + sum = 0 + + # Iterasi kolom matriks A dan baris matriks B + for k in range(len(A[0])): + # Lakukan perkalian elemen matriks A dengan elemen matriks B dan tambahkan hasilnya ke variabel sum + sum += A[i][k] * B[k][j] + + # Simpan hasil perkalian baris matriks A dengan kolom matriks B ke array result + result[i][j] = sum + +# Tampilkan hasil perkalian matriks +for row in result: + for val in row: + print(val, end=" ") + print() + +``` +::: + +Untuk bahasa pemrograman Python terdapat operator built-in untuk perkalian matriks yaitu dengan menggunakan simbol `@`. contohnya: +```py +# Inisialisasi kedua matriks +A = [ + [2, 3], + [4, 1] +] + +B = [ + [1, 2, 3], + [4, 5, 6] +] + +# Kalikan kedua matriks dengan @ +result = A @ B + +# Tampilkan hasil perkalian matriks +for row in result: + for val in row: + print(val, end=" ") + print() +``` + +--- +Rijal +Instagram :[ ri.jalll ](https://www.instagram.com/ri.jalll) +Facebook: [ Rijal ](https://www.facebook.com/24rijal) + +--- + + + diff --git a/docs/id/linear-algebra/vector-space.md b/docs/id/linear-algebra/vector-space.md new file mode 100644 index 0000000..e69de29 diff --git a/docs/id/linear-algebra/vector.md b/docs/id/linear-algebra/vector.md new file mode 100644 index 0000000..e69de29 diff --git a/docs/id/statistics/measures-concentration-dispersion.md b/docs/id/statistics/measures-concentration-dispersion.md new file mode 100644 index 0000000..18b8080 --- /dev/null +++ b/docs/id/statistics/measures-concentration-dispersion.md @@ -0,0 +1,713 @@ +# Ukuran Letak + +Ukuran letak merupakan salah satu cabang dari statistika deskriptif, yang mana digunakan untuk mengetahui +letak suatu rangkaian data dalam sebuah distribusi. Ukuran letak dibagi, menjadi 3 yaitu kuartil, desil, dan persentil. +Ukuran letak biasa digunakan dalam kasus distribusi kelompok. + +Misalnya di sebuah posyandu ada petugas yang mengukur berat badan balita untuk memantau perkembangan dan pertumbuhan balita. +Maka ukuran letak digunakan untuk + +| Ukuran Letak | Nilai | Fungsi | +| --------------------- | ------------- | ----------------------------- | +| Persentil | 50 | Acuan rata-rata berat balita | +| Persentil | 5 | Indikasi stunting pada balita | +| Persentil | 85 | Indikasi obesitas pada balita | +| Kuartil | Atas | Acuan batas bawah normal untuk berat badan atau tinggi badan | +| Kuartil | Bawah | Acuan batas atas normal | + +## Persentil + +Persentil diambil dari kata *percent* yang berarti persen. Persentil merupakan pembagian N data yang urut menjadi 100 bagian yang mana data tersebut dibagi sama banyak tersebut, dibatasi oleh 99 nilai persentil. Persentil dibagi menjadi dua menurut jenis datanya, yaitu Data Tunggal dan Data Berkelompok. + +Data tunggal secara umum merupakan deret angka yang terdapat pada sebuah baris atau *array*. Rumus untuk menghitung persentil data tunggal adalah sebagai berikut +$$ Pi = \frac{i(n+1)}{100} $$ + +| Simbol | Pengertian | +| ------------- | ------------- | +| $P_i$ | Persentil ke-i| +| i | Nilai Persentil (1 hingga 99) | +| n | Banyaknya data pada baris atau *array*| + +Berikut ini contoh *case* dari persentil data tunggal dan data berkelompok + +### Data Tunggal +Misalnya ada baris angka seperti dibawah dan kita ingin mencari persentil ke-50 + +:::tabs +== JavaScript +```javascript +// Data Tunggal +const dataTunggal = [25, 27, 29, 18, 20, 21, 23, 10, 12, 14, 16]; + +const nilaiPersen = 100; +const nilaiPersentil = 50; //1-99 +const angkaAwal = 1; +let hasilPersentil = 0; + +// Mengurutkan data secara ascending +const dataTersortir = dataTunggal.sort((a, b) => a - b); +const jumlahData = dataTunggal.length; + +// Menghitung posisi persentil +const posisi = (jumlahData + angkaAwal) * (nilaiPersentil / nilaiPersen); + +// Jika posisi adalah bilangan bulat, ambil nilai pada posisi tersebut +if (Number.isInteger(posisi)) { + hasilPersentil = dataTersortir[posisi - angkaAwal]; //20 +} else { + // Jika posisi bukan bilangan bulat, lakukan interpolasi + const indeksBawah = Math.floor(posisi) - angkaAwal; + const indeksAtas = Math.ceil(posisi) - angkaAwal; + + // Nilai pada indeks bawah dan atas + const nilaiBawah = dataTersortir[indeksBawah]; + const nilaiAtas = dataTersortir[indeksAtas]; + + // Interpolasi untuk menghitung nilai persentil + hasilPersentil = nilaiBawah + (nilaiAtas - nilaiBawah) * (posisi - Math.floor(posisi)); //20 +} +``` + +==Python +```python +# Data Tunggal +dataTunggal = [25, 27, 29, 18, 20, 21, 23, 10, 12, 14, 16] + +nilaiPersen = 100 +nilaiPersentil = 50 # 1-99 +angkaAwal = 1 +hasilPersentil = 0 + +# Mengurutkan data secara ascending +dataTersortir = sorted(dataTunggal) +jumlahData = len(dataTunggal) + +# Menghitung posisi persentil +posisi = (jumlahData + angkaAwal) * (nilaiPersentil / nilaiPersen) + +# Jika posisi adalah bilangan bulat, ambil nilai pada posisi tersebut +if posisi.is_integer(): + hasilPersentil = dataTersortir[int(posisi) - angkaAwal] # 20 +else: + # Jika posisi bukan bilangan bulat, lakukan interpolasi + indeksBawah = int(posisi) - angkaAwal + indeksAtas = int(posisi + 1) - angkaAwal + + # Nilai pada indeks bawah dan atas + nilaiBawah = dataTersortir[indeksBawah] + nilaiAtas = dataTersortir[indeksBawah] + + # Interpolasi untuk menghitung nilai persentil + hasilPersentil = nilaiBawah + (nilaiAtas - nilaiBawah) * (posisi - int(posisi)) # 20 + print(hasilPersentil) +``` +::: + +### Data Berkelompok + +Berikut ini rumus persentil untuk data berkelompok + +$$ P_p = L + \frac{p/100 - \sum f_b}{f_i} \times c $$ + +| Simbol | Pengertian | +| ------------- | --------------------------------------------------------------------- | +| $P_p$ | Nilai persentil ke-i | +| L | Batas bawah kelas interval yang memuat $P_p$ | +| p | Nilai persentil (1 hingga 99) | +| $\sum f_b$ | Jumlah frekuensi kumulatif sebelum kelas interval yang memuat $P_p$ | +| $f_i$ | Frekuensi kelas interval yang memuat $P_p$ | +| c | Panjang kelas interval yang memuat $P_p$ | + +Misalnya ada data kelompok umur warga dibawah 1 tahun hingga 40 tahun seperti dibawah dan kita ingin mencari persentil ke-50 dari kelompok data tersebut +:::tabs +== JavaScript +```javascript +// Data kelompok +const dataKelompok = [ + { interval: [0, 10], frekuensi: 5 }, + { interval: [10, 20], frekuensi: 10 }, + { interval: [20, 30], frekuensi: 8 }, + { interval: [30, 40], frekuensi: 2 } +]; + +const nilaiPersentil = 50; //1-99 +const nilaiAwal = 0; +const nilaiPersen = 100; +let hasilPersentil = 0; + +// Fungsi untuk menghitung total frekuensi +function hitungTotalFrekuensi(data) { + return data.reduce((jumlah, item) => jumlah + item.frekuensi, nilaiAwal); +} + +// Fungsi untuk menghitung data kumulatif +function hitungDataKumulatif(data) { + let frekuensiKumulatif = 0; + return data.map(item => { + frekuensiKumulatif += item.frekuensi; + return { ...item, kumulatif: frekuensiKumulatif }; + }); +} + +// Fungsi untuk menghitung nilai persentil +function hitungNilaiPersentil(dataKelompok, dataKumulatif, persentil) { + const totalFrekuensi = hitungTotalFrekuensi(dataKelompok); + const posisi = (persentil / nilaiPersen) * totalFrekuensi; + + const kelasInterval = dataKumulatif.find(item => item.kumulatif >= posisi); + + if (kelasInterval) { + const [batasBawah, batasAtas] = kelasInterval.interval; + const kumulatifBawah = dataKumulatif[dataKumulatif.indexOf(kelasInterval) - 1]?.kumulatif || 0; + const frekuensiDalamKelas = kelasInterval.frekuensi; + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah); + } + + return 0; // Atau nilai default yang sesuai jika tidak ditemukan kelasInterval +} + +// Menghitung nilai persentil ke-50 +hasilPersentil = hitungNilaiPersentil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiPersentil); //17.5 +``` +==Python +```python +# Data kelompok +dataKelompok = [ + {"interval": [0, 10], "frekuensi": 5}, + {"interval": [10, 20], "frekuensi": 10}, + {"interval": [20, 30], "frekuensi": 8}, + {"interval": [30, 40], "frekuensi": 2} +] + +nilaiPersentil = 50 # 1-99 +nilaiAwal = 0 +nilaiPersen = 100 +hasilPersentil = 0 + +# Fungsi untuk menghitung total frekuensi +def hitungTotalFrekuensi(data): + return sum(item['frekuensi'] for item in data) + +# Fungsi untuk menghitung data kumulatif +def hitungDataKumulatif(data): + frekuensiKumulatif = 0 + hasil = [] + for item in data: + frekuensiKumulatif += item['frekuensi'] + hasil.append({**item, 'kumulatif': frekuensiKumulatif}) + return hasil + +# Fungsi untuk menghitung nilai persentil +def hitungNilaiPersentil(dataKelompok, dataKumulatif, persentil): + totalFrekuensi = hitungTotalFrekuensi(dataKelompok) + posisi = (persentil / nilaiPersen) * totalFrekuensi + + kelasInterval = next((item for item in dataKumulatif if item['kumulatif'] >= posisi), None) + + if kelasInterval: + batasBawah, batasAtas = kelasInterval['interval'] + kumulatifBawah = dataKumulatif[dataKumulatif.index(kelasInterval) - 1]['kumulatif'] if dataKumulatif.index(kelasInterval) > 0 else 0 + frekuensiDalamKelas = kelasInterval['frekuensi'] + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah) + + return 0 # Atau nilai default yang sesuai jika tidak ditemukan kelasInterval + +# Menghitung nilai persentil ke-50 +hasilPersentil = hitungNilaiPersentil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiPersentil) # 17.5 +print(hasilPersentil) +``` + +::: + +## Desil +Desil merupakan pembagian N data yang urut menjadi 10 bagian yang mana data tersebut dibagi sama banyak tersebut, sehingga terdapat 9 nilai desil. Desil dibagi menjadi dua menurut jenis datanya, yaitu Data Tunggal dan Data Berkelompok. + +Data tunggal secara umum merupakan deret angka yang terdapat pada sebuah baris atau *array*. Rumus untuk menghitung desil data tunggal adalah sebagai berikut +$$ Di = \frac{i(n+1)}{10} $$ + +| Simbol | Pengertian | +| ------------- | ------------------------------------- | +| $D_i$ | Desil ke-i | +| i | Nilai Desil (1 hingga 9) | +| n | Banyaknya data pada baris atau *array*| + +Berikut ini contoh *case* dari desil data tunggal dan data berkelompok (menggunakan data sebelumnya) + +### Data Tunggal +Misalnya ada baris angka seperti dibawah dan kita ingin mencari desil ke-5 + +:::tabs +== JavaScript +```javascript +// Data Tunggal +const dataTunggal = [25, 27, 29, 18, 20, 21, 23, 10, 12, 14, 16]; + +const nilaiPersen = 10 +const nilaiDesil = 5; //1-9 +let totalDesil = 0; + +// Mengurutkan data secara ascending +const dataTersortir = [...dataTunggal].sort((a, b) => a - b); +const ukuranData = dataTunggal.length; + +// Menghitung posisi dari nilai desil +const posisi = (nilaiDesil * (ukuranData + 1)) / nilaiPersen; + +if (Number.isInteger(posisi)) { + totalDesil = dataTersortir[posisi - 1]; //20 +} else { + const indeksBawah = Math.floor(posisi) - 1; + const indeksAtas = Math.ceil(posisi) - 1; + + const nilaiBawah = dataTersortir[indeksBawah]; + const nilaiAtas = dataTersortir[indeksAtas]; + + // Interpolasi untuk menghitung nilai desil + totalDesil = nilaiBawah + (nilaiAtas - nilaiBawah) * (posisi - Math.floor(posisi)); //20 +} +``` +==Python +```python +# Data tunggal +dataTunggal = [25, 27, 29, 18, 20, 21, 23, 10, 12, 14, 16] + +nilaiPersen = 10 +nilaiDesil = 5 # 1-9 +totalDesil = 0 + +# Mengurutkan data secara ascending +dataTersortir = sorted(dataTunggal) +ukuranData = len(dataTunggal) + +# Menghitung posisi dari nilai desil +posisi = (nilaiDesil * (ukuranData + 1)) / nilaiPersen + +if posisi.is_integer(): + totalDesil = dataTersortir[int(posisi) - 1] # 20 +else: + indeksBawah = int(posisi) - 1 + indeksAtas = indeksBawah + 1 + + nilaiBawah = dataTersortir[indeksBawah] + nilaiAtas = dataTersortir[indeksAtas] + + # Interpolasi untuk menghitung nilai desil + totalDesil = nilaiBawah + (nilaiAtas - nilaiBawah) * (posisi - int(posisi)) # 20 + +print(totalDesil) +``` + +::: + +### Data Berkelompok +Berikut ini rumus desil untuk data berkelompok + +$$ D_i = L + \frac{i/10 - \sum f_b}{f_i} \times c $$ + +| Simbol | Pengertian | +| ------------- | --------------------------------------------------------------------- | +| $D_i$ | Nilai desil ke-i | +| L | Batas bawah kelas interval yang memuat $D_i$ | +| i | Nilai desil (1 hingga 9) | +| $\sum f_b$ | Jumlah frekuensi kumulatif sebelum kelas interval yang memuat $D_i$ | +| $f_i$ | Frekuensi kelas interval yang memuat $D_i$ | +| c | Panjang kelas interval yang memuat $D_i$ | + +Misalnya ada data kelompok umur warga dibawah 1 tahun hingga 40 tahun seperti dibawah dan kita ingin mencari desil ke-9 dari kelompok data tersebut +:::tabs +== JavaScript +```javascript +// Data kelompok +const dataKelompok = [ + { interval: [0, 10], frekuensi: 5 }, + { interval: [10, 20], frekuensi: 10 }, + { interval: [20, 30], frekuensi: 8 }, + { interval: [30, 40], frekuensi: 2 } +]; + +const nilaiDesil = 9; // 1-9 untuk desil ke-1 hingga ke-9 +const nilaiAwal = 0; +const nilaiPersen = 10; +let hasilDesil = 0 + +// Fungsi untuk menghitung total frekuensi +function hitungTotalFrekuensi(data) { + return data.reduce((jumlah, item) => jumlah + item.frekuensi, nilaiAwal); +} + +// Fungsi untuk menghitung data kumulatif +function hitungDataKumulatif(data) { + let frekuensiKumulatif = 0; + return data.map(item => { + frekuensiKumulatif += item.frekuensi; + return { ...item, kumulatif: frekuensiKumulatif }; + }); +} + +// Fungsi untuk menghitung nilai desil +function hitungNilaiDesil(dataKelompok, dataKumulatif, desil) { + const totalFrekuensi = hitungTotalFrekuensi(dataKelompok); + const posisi = (desil / nilaiPersen) * totalFrekuensi; + + const kelasInterval = dataKumulatif.find(item => item.kumulatif >= posisi); + + if (kelasInterval) { + const [batasBawah, batasAtas] = kelasInterval.interval; + const kumulatifBawah = dataKumulatif[dataKumulatif.indexOf(kelasInterval) - 1]?.kumulatif || 0; + const frekuensiDalamKelas = kelasInterval.frekuensi; + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah); + } + + return 0; // Atau nilai default yang sesuai jika tidak ditemukan kelasInterval +} + +// Menghitung nilai desil ke-9 +hasilDesil = hitungNilaiDesil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiDesil); //29.375 +``` + +==Python + +```python +# Data kelompok +dataKelompok = [ + {"interval": [0, 10], "frekuensi": 5}, + {"interval": [10, 20], "frekuensi": 10}, + {"interval": [20, 30], "frekuensi": 8}, + {"interval": [30, 40], "frekuensi": 2} +] + +nilaiDesil = 9 # 1-9 untuk desil ke-1 hingga ke-9 +nilaiAwal = 0 +nilaiPersen = 10 +hasilDesil = 0 + +# Fungsi untuk menghitung total frekuensi +def hitungTotalFrekuensi(data): + return sum(item["frekuensi"] for item in data) + +# Fungsi untuk menghitung data kumulatif +def hitungDataKumulatif(data): + frekuensiKumulatif = 0 + hasil = [] + for item in data: + frekuensiKumulatif += item["frekuensi"] + hasil.append({**item, "kumulatif": frekuensiKumulatif}) + return hasil + +# Fungsi untuk menghitung nilai desil +def hitungNilaiDesil(dataKelompok, dataKumulatif, desil): + totalFrekuensi = hitungTotalFrekuensi(dataKelompok) + posisi = (desil / nilaiPersen) * totalFrekuensi + + kelasInterval = next((item for item in dataKumulatif if item["kumulatif"] >= posisi), None) + + if kelasInterval: + batasBawah, batasAtas = kelasInterval["interval"] + kumulatifBawah = dataKumulatif[dataKumulatif.index(kelasInterval) - 1]["kumulatif"] if dataKumulatif.index(kelasInterval) > 0 else 0 + frekuensiDalamKelas = kelasInterval["frekuensi"] + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah) + + return 0 # Atau nilai default yang sesuai jika tidak ditemukan kelasInterval + +# Menghitung nilai desil ke-9 +hasilDesil = hitungNilaiDesil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiDesil) # 29.375 +print(hasilDesil) +``` +::: + +## Kuartil + +Kuartil merupakan pembagian N data yang urut menjadi 4 bagian yang mana data tersebut dibagi sama banyak tersebut, sehingga terdapat 3 nilai kuartil. Kuartil dibagi menjadi dua menurut jenis datanya, yaitu Data Tunggal dan Data Berkelompok. + +Data tunggal secara umum merupakan deret angka yang terdapat pada sebuah baris atau array. Rumus untuk menghitung kuartil data tunggal adalah sebagai berikut: +$$ Qi = \frac{i(n+1)}{4} $$ + +| Simbol | Pengertian | +| ------------- | ------------------------------------- | +| Qi | Kuartil ke-i | +| i | Nilai Kuartil (1 hingga 9) | +| n | Banyaknya data pada baris atau *array*| + +### Data Tunggal +Misalnya ada baris angka seperti dibawah dan kita ingin mencari kuartil ke-2 + +:::tabs +== JavaScript +```javascript +// Data Tunggal +const dataTunggal = [25, 27, 29, 18, 20, 21, 23, 10, 12, 14, 16]; + +const nilaiPersen = 4; +const nilaiKuartil = 2; // 1-3 +let totalKuartil = 0; + +// Mengurutkan data secara ascending +const dataTersortir = [...dataTunggal].sort((a, b) => a - b); +const jumlahData = dataTunggal.length; + +// Menghitung posisi dari nilai kuartil +const posisi = (nilaiKuartil * (jumlahData + 1)) / nilaiPersen; + +if (Number.isInteger(posisi)) { + totalKuartil = dataTersortir[posisi - 1]; //20 +} else { + const indeksBawah = Math.floor(posisi) - 1; + const indeksAtas = Math.ceil(posisi) - 1; + + const nilaiBawah = dataTersortir[indeksBawah]; + const nilaiAtas = dataTersortir[indeksAtas]; + + // Interpolasi untuk menghitung nilai kuartil + totalKuartil = nilaiBawah + (nilaiAtas - nilaiBawah) * (posisi - Math.floor(posisi)); //20 +} +``` +::: + +### Data Berkelompok + +Berikut ini rumus kuartil untuk data berkelompok + +$$ Q_i = L + \frac{i/4 - \sum f_b}{f_i} \times c $$ + +| Simbol | Pengertian | +| ------------- | --------------------------------------------------------------------- | +| $Q_i$ | Nilai desil ke-i | +| L | Batas bawah kelas interval yang memuat $Q_i$ | +| i | Nilai desil (1 hingga 9) | +| $\sum f_b$ | Jumlah frekuensi kumulatif sebelum kelas interval yang memuat $Q_i$ | +| $f_i$ | Frekuensi kelas interval yang memuat $Q_i$ | +| c | Panjang kelas interval yang memuat $Q_i$ | + +Misalnya ada data kelompok umur warga dibawah 1 tahun hingga 40 tahun seperti dibawah dan kita ingin mencari kuartil ke-2 dari kelompok data tersebut +:::tabs +== JavaScript +```javascript +// Data kelompok +const dataKelompok = [ + { interval: [0, 10], frekuensi: 5 }, + { interval: [10, 20], frekuensi: 10 }, + { interval: [20, 30], frekuensi: 8 }, + { interval: [30, 40], frekuensi: 2 } +]; + +const jumlahPersen = 4; +const nilaiKuartil = 2; // 1-3 +const nilaiAwal = 0; +let hasilKuartil = 0 + +// Fungsi untuk menghitung total frekuensi +function hitungTotalFrekuensi(data) { + return data.reduce((jumlah, item) => jumlah + item.frekuensi, nilaiAwal); +} + +// Fungsi untuk menghitung data kumulatif +function hitungDataKumulatif(data) { + let frekuensiKumulatif = 0; + return data.map(item => { + frekuensiKumulatif += item.frekuensi; + return { ...item, kumulatif: frekuensiKumulatif }; + }); +} + +// Fungsi untuk menghitung nilai kuartil +function hitungNilaiKuartil(dataKelompok, dataKumulatif, kuartil) { + const totalFrekuensi = hitungTotalFrekuensi(dataKelompok); + const posisi = (kuartil / jumlahPersen) * totalFrekuensi; + + const kelasInterval = dataKumulatif.find(item => item.kumulatif >= posisi); + + if (kelasInterval) { + const [batasBawah, batasAtas] = kelasInterval.interval; + const kumulatifBawah = dataKumulatif[dataKumulatif.indexOf(kelasInterval) - 1]?.kumulatif || 0; + const frekuensiDalamKelas = kelasInterval.frekuensi; + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah); + } + + return 0; // Atau nilai default yang sesuai jika tidak ditemukan kelasInterval +} + +// Menghitung nilai kuartil ke-2 +hasilKuartil = hitungNilaiKuartil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiKuartil); //17.5 +``` +== Kotlin +```kotlin +// Data kelompok +data class KelompokData(val interval: Pair, val frekuensi: Int) + +val dataKelompok = listOf( + KelompokData(0 to 10, 5), + KelompokData(10 to 20, 10), + KelompokData(20 to 30, 8), + KelompokData(30 to 40, 2) +) + +val nilaiDesil = 9 // 1-9 untuk desil ke-1 hingga ke-9 +val nilaiAwal = 0 +val nilaiPersen = 10 +var hasilDesil = 0.0 + +// Fungsi untuk menghitung total frekuensi +fun hitungTotalFrekuensi(data: List): Int { + return data.sumOf { it.frekuensi } +} + +// Fungsi untuk menghitung data kumulatif +fun hitungDataKumulatif(data: List): List { + var frekuensiKumulatif = 0 + return data.map { + frekuensiKumulatif += it.frekuensi + it.copy(frekuensi = frekuensiKumulatif) + } +} + +// Fungsi untuk menghitung nilai desil +fun hitungNilaiDesil(dataKelompok: List, dataKumulatif: List, desil: Int): Double { + val totalFrekuensi = hitungTotalFrekuensi(dataKelompok) + val posisi = (desil.toDouble() / nilaiPersen) * totalFrekuensi + + val kelasInterval = dataKumulatif.find { it.frekuensi >= posisi } + + kelasInterval?.let { + val (batasBawah, batasAtas) = it.interval + val kumulatifBawah = dataKumulatif.getOrNull(dataKumulatif.indexOf(it) - 1)?.frekuensi ?: 0 + val frekuensiDalamKelas = it.frekuensi - kumulatifBawah + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah) + } + + return 0.0 // Atau nilai default yang sesuai jika tidak ditemukan kelasInterval +} + +// Menghitung nilai desil ke-9 +hasilDesil = hitungNilaiDesil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiDesil) +println(hasilDesil) // Output: 29.375 +``` +== C++ +```cpp +#include +#include +#include // untuk std::accumulate + +struct KelompokData { + std::pair interval; + int frekuensi; +}; + +int nilaiDesil = 9; // 1-9 untuk desil ke-1 hingga ke-9 +int nilaiAwal = 0; +int nilaiPersen = 10; +double hasilDesil = 0; + +// Fungsi untuk menghitung total frekuensi +int hitungTotalFrekuensi(const std::vector& data) { + return std::accumulate(data.begin(), data.end(), nilaiAwal, + [](int jumlah, const KelompokData& item) { + return jumlah + item.frekuensi; + }); +} + +// Fungsi untuk menghitung data kumulatif +std::vector hitungDataKumulatif(const std::vector& data) { + int frekuensiKumulatif = 0; + std::vector dataKumulatif; + + for (const auto& item : data) { + frekuensiKumulatif += item.frekuensi; + dataKumulatif.push_back({ item.interval, frekuensiKumulatif }); + } + + return dataKumulatif; +} + +// Fungsi untuk menghitung nilai desil +double hitungNilaiDesil(const std::vector& dataKelompok, const std::vector& dataKumulatif, int desil) { + int totalFrekuensi = hitungTotalFrekuensi(dataKelompok); + double posisi = (static_cast(desil) / nilaiPersen) * totalFrekuensi; + + auto kelasInterval = std::find_if(dataKumulatif.begin(), dataKumulatif.end(), + [posisi](const KelompokData& item) { + return item.frekuensi >= posisi; + }); + + if (kelasInterval != dataKumulatif.end()) { + int batasBawah = kelasInterval->interval.first; + int batasAtas = kelasInterval->interval.second; + int index = std::distance(dataKumulatif.begin(), kelasInterval); + int kumulatifBawah = (index > 0) ? dataKumulatif[index - 1].frekuensi : 0; + int frekuensiDalamKelas = kelasInterval->frekuensi - kumulatifBawah; + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah); + } + + return 0.0; // Atau nilai default yang sesuai jika tidak ditemukan kelasInterval +} + +int main() { + std::vector dataKelompok = { + {{0, 10}, 5}, + {{10, 20}, 10}, + {{20, 30}, 8}, + {{30, 40}, 2} + }; + + // Menghitung nilai desil ke-9 + hasilDesil = hitungNilaiDesil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiDesil); + std::cout << hasilDesil << std::endl; // Output: 29.375 + + return 0; +} +``` +==Python +```python +# Data kelompok +dataKelompok = [ + {"interval": [0, 10], "frekuensi": 5}, + {"interval": [10, 20], "frekuensi": 10}, + {"interval": [20, 30], "frekuensi": 8}, + {"interval": [30, 40], "frekuensi": 2} +] + +jumlahPersen = 4 +nilaiKuartil = 2 # 1-3 +nilaiAwal = 0 +hasilKuartil = 0 + +# Fungsi untuk menghitung total frekuensi +def hitungTotalFrekuensi(data): + return sum(item["frekuensi"] for item in data) + +# Fungsi untuk menghitung data kumulatif +def hitungDataKumulatif(data): + frekuensiKumulatif = 0 + hasil = [] + for item in data: + frekuensiKumulatif += item["frekuensi"] + hasil.append({**item, "kumulatif": frekuensiKumulatif}) + return hasil + +# Fungsi untuk menghitung nilai kuartil +def hitungNilaiKuartil(dataKelompok, dataKumulatif, kuartil): + totalFrekuensi = hitungTotalFrekuensi(dataKelompok) + posisi = (kuartil / jumlahPersen) * totalFrekuensi + + kelasInterval = next((item for item in dataKumulatif if item["kumulatif"] >= posisi), None) + + if kelasInterval: + batasBawah, batasAtas = kelasInterval["interval"] + kumulatifBawah = dataKumulatif[dataKumulatif.index(kelasInterval) - 1]["kumulatif"] if dataKumulatif.index(kelasInterval) > 0 else 0 + frekuensiDalamKelas = kelasInterval["frekuensi"] + + return batasBawah + ((posisi - kumulatifBawah) / frekuensiDalamKelas) * (batasAtas - batasBawah) + + return 0 # Atau nilai default yang sesuai jika tidak ditemukan kelasInterval + +# Menghitung nilai kuartil ke-2 +hasilKuartil = hitungNilaiKuartil(dataKelompok, hitungDataKumulatif(dataKelompok), nilaiKuartil) # 17.5 +print(hasilKuartil) +``` +::: From 875e1be373fd397fc40b1c248a6a7c59f2da0909 Mon Sep 17 00:00:00 2001 From: frija Date: Sun, 3 Nov 2024 18:31:24 +0800 Subject: [PATCH 02/39] feat: initialize en-US internationalization --- docs/.vitepress/config.ts | 43 +- docs/.vitepress/en.ts | 84 +++ docs/.vitepress/shared.config.ts | 3 + docs/.vitepress/sidebar.ts | 37 - .../theme/components/ContributorsAside.vue | 23 +- docs/.vitepress/theme/components/HomePage.vue | 18 +- docs/algebra/function.md | 374 --------- docs/algebra/graph.md | 0 docs/algebra/linear-equation.md | 329 -------- docs/algebra/quadratic-equation.md | 219 ------ docs/arithmetic/factors.md | 381 ---------- docs/arithmetic/numbers.md | 148 ---- docs/arithmetic/operation-on-number.md | 232 ------ docs/arithmetic/percent.md | 113 --- docs/en/arithmetic/factors.md | 379 ++++++++++ docs/en/arithmetic/numbers.md | 148 ++++ docs/en/arithmetic/operation-on-number.md | 236 ++++++ docs/en/arithmetic/percent.md | 113 +++ docs/en/guide/index.md | 39 + docs/{ => en}/index.md | 42 +- docs/guide/index.md | 40 - docs/linear-algebra/linear-transformation.md | 327 -------- docs/linear-algebra/matrix-multiplication.md | 256 ------- docs/linear-algebra/vector-space.md | 0 docs/linear-algebra/vector.md | 0 .../measures-concentration-dispersion.md | 713 ------------------ 26 files changed, 1066 insertions(+), 3231 deletions(-) create mode 100644 docs/.vitepress/en.ts delete mode 100644 docs/.vitepress/sidebar.ts delete mode 100644 docs/algebra/function.md delete mode 100644 docs/algebra/graph.md delete mode 100644 docs/algebra/linear-equation.md delete mode 100644 docs/algebra/quadratic-equation.md delete mode 100644 docs/arithmetic/factors.md delete mode 100644 docs/arithmetic/numbers.md delete mode 100644 docs/arithmetic/operation-on-number.md delete mode 100644 docs/arithmetic/percent.md create mode 100644 docs/en/arithmetic/factors.md create mode 100644 docs/en/arithmetic/numbers.md create mode 100644 docs/en/arithmetic/operation-on-number.md create mode 100644 docs/en/arithmetic/percent.md create mode 100644 docs/en/guide/index.md rename docs/{ => en}/index.md (53%) delete mode 100644 docs/guide/index.md delete mode 100644 docs/linear-algebra/linear-transformation.md delete mode 100644 docs/linear-algebra/matrix-multiplication.md delete mode 100644 docs/linear-algebra/vector-space.md delete mode 100644 docs/linear-algebra/vector.md delete mode 100644 docs/statistics/measures-concentration-dispersion.md diff --git a/docs/.vitepress/config.ts b/docs/.vitepress/config.ts index 64627ae..f768939 100644 --- a/docs/.vitepress/config.ts +++ b/docs/.vitepress/config.ts @@ -1,40 +1,13 @@ -import { defineConfig } from 'vitepress' -import { sharedConfig } from './shared.config' -import sidebar from './sidebar' - +import { defineConfig } from "vitepress"; +import { sharedConfig } from "./shared.config"; +import { id } from "./id"; +import { en } from "./en"; // https://vitepress.dev/reference/site-config export default defineConfig({ ...sharedConfig, - locales: { - root: { - label: 'Indonesia', - lang: 'id-ID', - description: 'Belajar matematika dengan barisan kode', - themeConfig: { - nav: [ - { - text: 'Belajar', link: '/guide/', - }, - { - text: 'Donasi', link: 'https://trakteer.id/xirf' - } - ], - sidebar, - outline: { - level: [2,3], - label: 'Di halaman ini' - }, - editLink: { - pattern: 'https://github.com/xirf/mathwithcode/edit/master/docs/:path', - text: 'Perbaiki halaman ini di GitHub' - }, - footer: { - message: 'Dirilis di bawah lisensi MIT', - copyright: 'Copyright © 2024-present Andika & Contributors' - } - } - }, - } -}) + root: { label: 'Indonesia', ...id }, + en: { label: "English", ...en } + }, +}); diff --git a/docs/.vitepress/en.ts b/docs/.vitepress/en.ts new file mode 100644 index 0000000..48e655f --- /dev/null +++ b/docs/.vitepress/en.ts @@ -0,0 +1,84 @@ +import { defineConfig } from "vitepress"; + +export const en = defineConfig({ + lang: "en-US", + description: "Learn math with lines of code", + themeConfig: { + nav: [ + { + text: "Learn", + link: "/en/guide/", + }, + { + text: "Donation", + link: "https://trakteer.id/xirf", + }, + ], + sidebar: sidebar(), + outline: { + level: [2, 3], + label: "On this page", + }, + editLink: { + pattern: + "https://github.com/xirf/mathwithcode/edit/master/docs/:path", + text: "Fix this page on GitHub", + }, + footer: { + message: "Released under the MIT license", + copyright: "Copyright © 2024-present Andika & Contributors", + }, + }, +}) + +function sidebar() { + return [ + { text: "Guide", link: "/en/guide/" }, + { + text: "Arithmetic", + collapsed: false, + items: [ + { text: "Numbers", link: "/en/arithmetic/numbers" }, + { + text: "Number Operations", + link: "/en/arithmetic/operation-on-number", + }, + { text: "Factors and Multiples", link: "/en/arithmetic/factors" }, + { text: "Percent", link: "/en/arithmetic/percent" }, + ], + }, + { + text: "Algebra", + collapsed: false, + items: [ + { text: "Function", link: "/en/algebra/function" }, + { text: "Linear Equation", link: "/en/algebra/linear-equation" }, + { text: "Quadratic Equation", link: "/en/algebra/quadratic-equation" }, + ], + }, + { + text: "Linear Algebra", + collapsed: false, + items: [ + { + text: "Linear Transformation", + link: "/en/linear-algebra/linear-transformation", + }, + { + text: "Matrix Multiplication", + link: "/en/linear-algebra/matrix-multiplication", + }, + ], + }, + { + text: "Statistics", + collapsed: false, + items: [ + { + text: "Measures of Location", + link: "/en/statistics/measures-concentration-dispersion", + }, + ], + }, + ] +} diff --git a/docs/.vitepress/shared.config.ts b/docs/.vitepress/shared.config.ts index bb5c2c3..a457864 100644 --- a/docs/.vitepress/shared.config.ts +++ b/docs/.vitepress/shared.config.ts @@ -17,6 +17,9 @@ const headers = process.env.NODE_ENV === "production" ? [ ...baseHeader, umamiSc export const sharedConfig = defineConfig({ title: "Math W Code", description: "Belajar matematika dengan barisan kode", + rewrites: { + 'id/:rest*': ':rest*' + }, cleanUrls: true, head: headers, metaChunk: true, diff --git a/docs/.vitepress/sidebar.ts b/docs/.vitepress/sidebar.ts deleted file mode 100644 index 9e294a5..0000000 --- a/docs/.vitepress/sidebar.ts +++ /dev/null @@ -1,37 +0,0 @@ -export default [ - { text: 'Panduan', link: '/guide/' }, - { - text: 'Aritmatika', - collapsed: false, - items: [ - { text: 'Bilangan', link: '/arithmetic/numbers' }, - { text: 'Operasi Bilangan', link: '/arithmetic/operation-on-number' }, - { text: 'Faktor dan Kelipatan', link: '/arithmetic/factors' }, - { text: 'Persen', link: '/arithmetic/percent' }, - ] - }, - { - text: 'Aljabar', - collapsed: false, - items: [ - { text: 'Fungsi', link: '/algebra/function' }, - { text: 'Persamaan Linear', link: '/algebra/linear-equation' }, - { text: 'Persamaan Kuadrat', link: '/algebra/quadratic-equation' }, - ] - }, - { - text: 'Aljabar Linear', - collapsed: false, - items: [ - { text: 'Transformasi Linear', link: '/linear-algebra/linear-transformation' }, - { text: 'Perkalian Matriks', link: '/linear-algebra/matrix-multiplication' }, - ] - }, - { - text: 'Statistika', - collapsed: false, - items: [ - { text: 'Ukuran Letak', link: '/statistics/measures-concentration-dispersion' }, - ] - } -] \ No newline at end of file diff --git a/docs/.vitepress/theme/components/ContributorsAside.vue b/docs/.vitepress/theme/components/ContributorsAside.vue index dd53330..77acaba 100644 --- a/docs/.vitepress/theme/components/ContributorsAside.vue +++ b/docs/.vitepress/theme/components/ContributorsAside.vue @@ -1,13 +1,28 @@ - \ No newline at end of file + diff --git a/docs/.vitepress/theme/components/HomePage.vue b/docs/.vitepress/theme/components/HomePage.vue index a5dede1..8c9f351 100644 --- a/docs/.vitepress/theme/components/HomePage.vue +++ b/docs/.vitepress/theme/components/HomePage.vue @@ -1,6 +1,20 @@ \ No newline at end of file + diff --git a/docs/algebra/function.md b/docs/algebra/function.md deleted file mode 100644 index 0e7eaf7..0000000 --- a/docs/algebra/function.md +++ /dev/null @@ -1,374 +0,0 @@ ---- -contributors: - - name: "Anka Tama" - username: "xirf" ---- -# Fungsi - -Dalam matematika fungsi aljabar merupakan suatu notasi yang menghubungkan dua himpunan bilangan. Fungsi ini biasanya ditulis dalam bentuk $f(x) = y$ dimana $f$ adalah fungsi, $x$ adalah input, dan $y$ adalah output. - -Fungsi aljabar memiliki konsep yang mirip dengan fungsi yang ada di pemrograman dimana keduanya memiliki *input* dan *output*. Misalnya fungsi $f(x) = 2x + 3$ apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: - -:::tabs -== Javascript -``` js -function fungsi(x) { - return 2 * x + 3; -} -``` -== C++ -``` cpp -int fungsi(int x) { - return 2 * x + 3; -} -``` -== Kotlin -``` kotlin -fun fungsi(x: Int): Int { - return 2 * x + 3 -} -``` -== Python -``` python -def fungsi(x): - return 2 * x + 3 -``` -::: - -## Domain, Kodomain, dan Range -**Domain** adalah himpunan semua nilai input yang diperbolehkan dalam fungsi. Dalam matematika, domain adalah himpunan semua nilai $ x $ yang memenuhi fungsi. - -**Kodomain** sendiri adalah himpunan semua nilai output yang mungkin dalam fungsi. Sedangkan **range** adalah himpunan semua nilai output yang benar-benar dihasilkan oleh fungsi. - -Dalam pemrograman, **domain** dan **kodomain** bisa diartikan sebagai tipe data input dan output dari fungsi yang didefinisikan. - -Dengan kata lain, domain dalam konteks pemrograman adalah jenis data yang bisa diterima oleh fungsi sebagai input (*parameter*), dan kodomain adalah jenis data yang dihasilkan oleh fungsi sebagai output. - -## Jenis-Jenis Fungsi -Ada beberapa jenis fungsi yang sering digunakan dalam matematika, diantaranya adalah: - -### Fungsi Linear -Fungsi linear adalah fungsi yang bentuknya $f(x) = ax + b$ dimana $a$ dan $b$ adalah konstanta. Fungsi ini memiliki grafik berbentuk garis lurus. -Misalnya fungsi $f(x) = 1x + 0.5$. akan menghasilkan grafik seperti berikut: - - - -### Fungsi Kuadrat -Fungsi kuadrat adalah fungsi yang bentuknya $f(x) = ax^2 + bx + c$ dimana $a$, $b$, dan $c$ adalah konstanta. Fungsi ini memiliki grafik berbentuk parabola. - - - -### Fungsi Eksponensial -Fungsi eksponensial adalah fungsi yang bentuknya $f(x) = a^x$ dimana $a$ adalah konstanta. Fungsi ini memiliki grafik berbentuk kurva yang semakin meningkat. - - -### Fungsi Logaritma -Fungsi logaritma adalah fungsi yang merupakan kebalikan dari fungsi eksponensial. Fungsi ini memiliki bentuk $f(x) = \log_a(x)$ dimana $a$ adalah konstanta. Fungsi ini memiliki grafik berbentuk kurva yang semakin menurun. - - -### Fungsi Trigonometri -Fungsi trigonometri adalah fungsi yang melibatkan fungsi trigonometri seperti sin, cos, tan, dan sebagainya. Fungsi ini memiliki grafik berbentuk gelombang. Dibawah ini adalah contoh grafik fungsi trigonometri dimana -- Merah adalah fungsi sin(x) -- Hijau adalah fungsi cos(x) -- Ungu adalah fungsi tan(x) - - -## Operasi pada Fungsi - -### Penjumlahan dan Pengurangan Fungsi -Penjumlahan dan pengurangan fungsi dilakukan dengan cara menambahkan atau mengurangkan fungsi satu dengan fungsi lainnya. Misalnya -$$f(x) = 2x + 3$$ -$$g(x) = 3x - 2$$ - -Maka penjumlahan kedua fungsi tersebut adalah - -$$\begin{align*} - (f + g)(x) &= f(x) + g(x) \\ - &= (2x + 3) + (3x - 2) \\ - &= 5x + 1 -\end{align*}$$ - -Apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: -:::tabs -== Javascript -``` js -function f(x) { - return 2 * x + 3; -} -function g(x) { - return 3 * x - 2; -} -function fg(x) { - return f(x) + g(x); -} -``` -== C++ -``` cpp -int f(int x) { - return 2 * x + 3; -} -int g(int x) { - return 3 * x - 2; -} -int fg(int x) { - return f(x) + g(x); -} -``` -== Kotlin -``` kotlin -fun f(x: Int): Int { - return 2 * x + 3; -} -fun g(x: Int): Int { - return 3 * x - 2; -} -fun fg(x: Int): Int { - return f(x) + g(x); -} -``` -== Python -``` python -def f(x): - return 2 * x + 3 - -def g(x): - return 3 * x - 2 - -def fg(x): - return f(x) + g(x) - -``` -::: - -### Perkalian Fungsi -Perkalian fungsi dilakukan dengan cara mengalikan fungsi satu dengan fungsi lainnya. Misalnya -$$f(x) = 2x + 3$$ -$$g(x) = 3x - 2$$ - -Maka perkalian kedua fungsi tersebut adalah - -$$\begin{align*} - (f \cdot g)(x) &= f(x) \cdot g(x) \\ - &= (2x + 3) \cdot (3x - 2) \\ - &= 6x^2 + 4x - 6 -\end{align*}$$ - -Apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: - -:::tabs -== Javascript -``` js -function f(x) { - return 2 * x + 3; -} -function g(x) { - return 3 * x - 2; -} -function fg(x) { - return f(x) * g(x); -} -``` -== C++ -``` cpp -int f(int x) { - return 2 * x + 3; -} -int g(int x) { - return 3 * x - 2; -} -int fg(int x) { - return f(x) * g(x); -} -``` -== Kotlin -``` kotlin -fun f(x: Int): Int { - return 2 * x + 3; -} -fun g(x: Int): Int { - return 3 * x - 2; -} -fun fg(x: Int): Int { - return f(x) * g(x); -} -``` -== Python -``` python -def f(x): - return 2 * x + 3 - -def g(x): - return 3 * x - 2 - -def fg(x): - return f(x) * g(x) -``` -::: - -### Fungsi Komposisi -Fungsi komposisi adalah fungsi yang hasilnya adalah fungsi lain. Misalnya - -$$f(x) = 2x + 3$$ -$$g(x) = 3x - 2$$ - -Maka fungsi komposisi dari kedua fungsi tersebut adalah - -$$\begin{align*} - (f \circ g)(x) &= f(g(x)) \\ - &= f(3x - 2) \\ - &= 2(3x - 2) + 3 \\ - &= 6x - 4 + 3 \\ - &= 6x - 1 -\end{align*}$$ - -Apabila kita jadikan sebagai fungsi di pemrograman, maka akan menjadi seperti berikut: -:::tabs -== Javascript -``` js -function f(x) { - return 2 * x + 3; -} -function g(x) { - return 3 * x - 2; -} -function fog(x) { - return f(g(x)); -} -``` -== C++ -``` cpp -int f(int x) { - return 2 * x + 3; -} -int g(int x) { - return 3 * x - 2; -} -int fog(int x) { - return f(g(x)); -} -``` -== Kotlin -``` kotlin -fun f(x: Int): Int { - return 2 * x + 3; -} -fun g(x: Int): Int { - return 3 * x - 2; -} -fun fog(x: Int): Int { - return f(g(x)); -} -``` -== Python -``` python -def f(x): - return 2 * x + 3 - -def g(x): - return 3 * x - 2 - -def fog(x): - return f(g(x)) -``` -::: - -> [!NOTE] Sifat dari fungsi komposisi -> - Fungsi komposisi tidak komutatif, artinya $f \circ g \neq g \circ f$ -> - Fungsi komposisi asosiatif, artinya $(f \circ g) \circ h = f \circ (g \circ h)$ -> - Fungsi komposisi memiliki elemen identitas, artinya $f \circ I = f$ dimana $I$ adalah fungsi identitas - -### Invers Fungsi - -Invers fungsi adalah fungsi yang hasilnya adalah fungsi lain yang merupakan kebalikan dari fungsi tersebut. Misalnya - -$$f(x) = 2x + 3$$ - -Maka untuk mencari invers dari fungsi tersebut, kita harus mencari $f^{-1}(x)$ dimana $f^{-1}(f(x)) = x$. - -Langkah-langkah untuk mencari invers fungsi adalah sebagai berikut: - -1. Ubah bentuk $y = f(x)$ menjadi $x = f^{-1}(y)$ -2. Selesaikan $x$ dari persamaan tersebut -3. Gantikan $x$ dengan $f^{-1}(y)$ -4. Selesaikan persamaan tersebut - -Contoh untuk mencari invers dari fungsi $f(x) = 2x + 6$ adalah sebagai berikut: - -$$\begin{align*} - y &= f(x) = 2x + 6 \\ - 2x &= y - 6 \\ - x &= \frac{1}{2}y-3 -\end{align*}$$ - -Maka invers dari fungsi $f(x) = 2x + 6$ adalah $f^{-1}(x) = \frac{1}{2}x-3$ - -Apabila kita jadikan sebagai fungsi di pemrograman dimana nilai $x$ sudah diketahui dan outputnya adalah nilai $y$, maka akan menjadi seperti berikut: -:::tabs -== Javascript -``` js -function inverseFunction(y, a, b) { - if (a === 0) { - throw new Error("Nilai a tidak boleh 0"); - } - return (y - b) / a; -} - -const a = 2; // Misalkan a = 2 -const b = 3; // Misalkan b = 3 -const y = 7; // Nilai y (f(x)) -// f(x) = 2x + 3 -const x = inverseFunction(y, a, b); -console.log(`Invers dari f(${y}) adalah x = ${x}`); -``` -== C++ -``` cpp -int inverseFunction(int y, int a, int b) { - if (a == 0) { - throw "Nilai a tidak boleh 0"; - } - return (y - b) / a; -} - -int main() { - int a = 2; // Misalkan a = 2 - int b = 3; // Misalkan b = 3 - int y = 7; // Nilai y (f(x)) - // f(x) = 2x + 3 - int x = inverseFunction(y, a, b); - cout << "Invers dari f(" << y << ") adalah x = " << x << endl; - return 0; -} -``` -== Kotlin -``` kotlin -fun inverseFunction(y: Int, a: Int, b: Int): Int { - if (a == 0) { - throw IllegalArgumentException("Nilai a tidak boleh 0") - } - return (y - b) / a -} - -fun main() { - val a = 2 // Misalkan a = 2 - val b = 3 // Misalkan b = 3 - val y = 7 // Nilai y (f(x)) - // f(x) = 2x + 3 - val x = inverseFunction(y, a, b) - println("Invers dari f($y) adalah x = $x") -} -``` -== Python -``` python -def inverseFunction(y, a, b): - if a == 0: - raise Exception("Nilai a tidak boleh 0") - return (y - b) / a - -a = 2 # Misalkan a = 2 -b = 3 # Misalkan b = 3 -y = 7 # Nilai y (f(x)) -# f(x) = 2x + 3 -x = inverseFunction(y, a, b) -print(f"Invers dari f({y}) adalah x = {x}") -``` -::: \ No newline at end of file diff --git a/docs/algebra/graph.md b/docs/algebra/graph.md deleted file mode 100644 index e69de29..0000000 diff --git a/docs/algebra/linear-equation.md b/docs/algebra/linear-equation.md deleted file mode 100644 index b12edae..0000000 --- a/docs/algebra/linear-equation.md +++ /dev/null @@ -1,329 +0,0 @@ -# Persamaan Linear - -Persamaan linear bisa diartikan sebagai seuatu persamaan yang suku-sukunya memiliki konstanta (nilai tetap) dengan variabel tunggal. Persamaan ini disebut linear karena hubungan antara variabel-variabelnya membentuk garis lurus jika digambarkan dalam grafik dua dimensi. Sebelum memulai kita wajib paham beberapa hal dibawah ini - -1. **Variabel**: Pengganti bilangan yang nilainya belum diketahui. -2. **Koeffisien**: Bilangan yang mengalikan variabel. -3. **Konstanta**: Bilangan yang tidak memiliki variabel. -4. **Suku**: Bagian dari persamaan yang terdiri dari variabel, koefisien, dan konstanta. - -Persamaan linear juga memiliki beberapa aturan/sifat yang harus dipahami, diantaranya: - -- Penjumlahan dan pengurangan bilangan kedua ruas tak akan mengubah persamaan nilai. -- Perkalian dan pembagian bilangan kedua ruas tidak mengubah nilai persamaan -- Nilai persamaan tidak berubah jika kedua ruas ditambah atau dikurangi bilangan yang sama. -- Suatu persamaan jika dipindah ruas maka penjumlahan berubah jadi pengurangan, perkalian berubah menjadi pembagian, dan sebaliknya. - -## Persamaan Linear Satu Variabel - -Persamaan linear satu variabel adalah persamaan yang memiliki satu variabel. Persamaan ini biasanya ditulis dalam bentuk $ax + b = c$ dimana $a$, $b$, dan $c$ adalah bilangan riil dan $x$ adalah variabel. - -Contoh persamaan linear satu variabel: -$$ 2x + 3 = 7 $$ - -Untuk mengetahui nilai $x$ yang memenuhi persamaan tersebut, kita harus mencari nilai $x$ yang membuat kedua ruas persamaan sama. Berikut langkah-langkahnya: - -1. Eliminasi konstanta pada ruas kiri dengan cara mengurangkan konstanta pada ruas kiri dengan konstanta pada ruas kanan. - -$$\begin{align*} - 2x + 3 - 3 &= 7 - 3 \\ - 2x &= 4 -\end{align*}$$ - -2. Eliminasi koefisien variabel dengan cara membagi kedua ruas dengan koefisien variabel. - -$$\begin{align*} - \frac{2x}{2} &= \frac{4}{2} \\ - x &= 2\\ -\end{align*}$$ - -3. Sehingga nilai $x$ yang memenuhi persamaan tersebut adalah $x = 2$. - -Jika diimplementasikan dalam kode, maka hasilnya adalah seperti ini: -:::tabs -==javascript - -```js -function linearEquation(a, b, c) { - // Persamaan: a * x + b = c - const x = (c - b) / a; - return x; -} -console.log(linearEquation(2, 3, 7)); // Output: 2 -``` - -==kotlin - -```kotlin -val a = 2 -val b = 3 -val c = 7 - -// Persamaan: a * x + b = c -val x = (c - b) / a -println("Nilai x adalah: $x") -``` - -== C++ - -```cpp -int linearEquation(int a, int b, int c) { - // Persamaan: a * x + b = c - int x = (c - b) / a; - return x; -} - -int main() { - int a = 2; - int b = 3; - int c = 7; - int x = linearEquation(a, b, c); - cout << "Nilai x adalah: " << x << endl; - return 0; -} -``` - -==Python -```python -def linearEquation(a, b, c): - # Persamaan: a * x + b = c - x = (c - b) / a - return x - -a, b, c, = 2, 3, 7 -x = linearEquation(a, b, c) -print(f"Nilai x adalah: {x}") -``` - -::: - -## Persamaan Linear Dua Variabel - -Sesuai dengan namanya, persamaan ini memiliki dua variabel yang bisanya ditulis dalam bentuk $ax + by = c$ dimana $a$, $b$, dan $c$ adalah bilangan riil dan $x$ dan $y$ adalah variabel. - -Contoh persamaan linear dua variabel: -$$ 2x + 3y = 7 $$ - -Ada 2 cara untuk meyelesaikan persamaan yaitu dengan menggunakan metode substitusi dan eliminasi. Untuk metode substitusi, kita bisa mengganti salah satu variabel dengan nilai yang sudah diketahui. Sedangkan untuk metode eliminasi, kita bisa menghilangkan salah satu variabel dengan cara mengalikan salah satu persamaan dengan bilangan tertentu. - -### Metode Substitusi - -Berikut contoh penyelesaian persamaan diatas dengan menggunakan metode substitusi: - -1. Pertama kita pilih salah satu variable untuk diisolasi, misalnya kita pilih $x$. -2. variable yang kita isolasi kemudian kita simpan dan pindahkan lainnya ke kanan. - $$ 2x = 7 - 3y $$ -3. Karena nilai yang diisolasi adalah $2x$ maka kita bagi kedua ruas dengan $2$. - -$$\begin{align*} -x &= \frac{7 - 3y}{2} \\ -x &= \frac{7}{2} - \frac{3y}{2} \\ -\end{align*}$$ - -4. Nah kita dapat solusi parametrik dari $x$ - -Nila parametrik inilah yang nantinya berapapun nilai $y$ yang kita masukkan akan menghasilkan nilai $x$ yang sesuai. Misalnya nilai $y = 1$ maka: - - -$$\begin{align*} -x &= \frac{7 - 3(1)}{2} \\ -x &= \frac{4}{2} \\ -x &= 2 -\end{align*}$$ - -Bagaimana jika permasalahan ini kita jadikan kode? Berikut contoh implementasinya: -:::tabs -==javascript - -```js -function pldv(a, b, c, y) { - let x = (c - b * y) / a; - return { x, y }; -} - -// 2x + 3y = 7 dimana y = 1 -console.log(pldv(2, 3, 7, 1)); // Output: { x: 2, y: 1 } -``` - -==kotlin - -```kotlin -fun pldv(a: Int, b: Int, c: Int, y: Int): Pair { - val x = (c - b * y) / a - return Pair(x, y) -} - -// 2x + 3y = 7 dimana y = 1 -println(pldv(2, 3, 7, 1)) // Output: (2, 1) -``` - -== C++ - -```cpp -#include -#include - -std::pair pldv(int a, int b, int c, int y) { - int x = (c - b * y) / a; - return std::make_pair(x, y); -} - -int main() { - // 2x + 3y = 7 dimana y = 1 - auto result = pldv(2, 3, 7, 1); - std::cout << "Output: (" << result.first << ", " << result.second << ")" << std::endl; - return 0; -} -``` -== Python -``` python -def pldv(a, b, c, y): - x = (c - b * y) / a - return x, y - -# 2x + 3y = 7 dimana y = 1 -print(pldv(2, 3, 7, 1))# Output: (x: 2.0, y: 1) -``` -::: - -### Metode Eliminasi - -Jika menggunakan metode eliminasi, kita membutuhkan 2 persamaan sebagai perbandingan. Misalnya kita punya 2 persamaan berikut: -$$ 2x + 3y = 7 $$ -$$ 3x - 2y = 8 $$ -Jika sudah memiliki dua persamaan kita bisa menghilangkan salah satu variabel dengan cara mengalikan salah satu persamaan dengan bilangan tertentu. Berikut langkah-langkahnya: - -1. Ubah kedua persamaan menjadi bentuk standar. - $$ 2x + 3y = 7$$ - $$ 3x - 2y = 8$$ -2. Kita akan mengeleminasi variabel $y$ dengan cara mengalikan persamaan (1) dengan $2$ dan persamaan (2) dengan $3$ (koefisien yang sama kita pilih). - $$ 4x + (3 \times 2y) = 7 \times 2$$ - $$ 9x - (2 \times 3y) = 8 \times 3$$ -
- - $$ 4x + 6y = 14$$ - $$ 9x - 6y = 24$$ -3. Nah nilai $y$ udah sama tinggal kita kurangkan persamaan (1) dengan persamaan (2). - $$ 4x + 6y = 14$$ - $$ 9x - 6y = 24$$ -
- - $$ -5x = -10$$ - -4. Kita bagi kedua ruas dengan $-5$. - $$ \frac{-5x}{-5} = \frac{-10}{-5}$$ - $$ x = 2$$ - -5. Nah kita sudah mendapatkan nilai $x$ sekarang kita cari nilai $y$ dengan cara substitusi nilai $x$ ke salah satu persamaan. - - $$ 2x + 3y = 7$$ - $$ 2(2) + 3y = 7$$ - $$ 4 + 3y = 7$$ - $$ 3y = 3$$ - $$ y = 1$$ - -6. Sehingga nilai $x$ dan $y$ yang memenuhi persamaan tersebut adalah $x = 2$ dan $y = 1$. - -Bagaimana jika permasalahan ini kita jadikan kode? Berikut contoh implementasinya: -:::tabs -==javascript - -```js -function pldvEliminasi(a1, b1, c1, a2, b2, c2) { - // Menghitung koefisien untuk eliminasi - let factor = a2 / a1; - - // Membuat persamaan baru dengan mengurangi - let newB2 = b2 - factor * b1; - let newC2 = c2 - factor * c1; - - // Menyelesaikan untuk y - let y = newC2 / newB2; - - // Menghitung x dengan substitusi y ke dalam persamaan 1 - let x = (c1 - b1 * y) / a1; - - return { x: x, y: y }; -} - -// 2x - 3y = 7 dan 3x - 2y = 8 -console.log(pldvEliminasi(2, 3, 7, 3, -2, 8)); // Output: { x: 2, y: 1 } -``` -== kotlin - -```kotlin -fun pldvEliminasi(a1: Int, b1: Int, c1: Int, a2: Int, b2: Int, c2: Int): Pair { - // Menghitung koefisien untuk eliminasi - val factor = a2 / a1 - - // Membuat persamaan baru dengan mengurangi - val newB2 = b2 - factor * b1 - val newC2 = c2 - factor * c1 - - // Menyelesaikan untuk y - val y = newC2 / newB2 - - // Menghitung x dengan substitusi y ke dalam persamaan 1 - val x = (c1 - b1 * y) / a1 - - return Pair(x, y) -} - -// 2x - 3y = 7 dan 3x - 2y = 8 -println(pldvEliminasi(2, 3, 7, 3, -2, 8)) // Output: (2, 1) -``` -== C++ - -```cpp -#include -#include - -pair pldvEliminasi(double a1, double b1, double c1, double a2, double b2, double c2) { - // Menghitung koefisien untuk eliminasi - double factor = a2 / a1; - - // Membuat persamaan baru dengan mengurangi - double newB2 = b2 - factor * b1; - double newC2 = c2 - factor * c1; - - // Menyelesaikan untuk y - double y = newC2 / newB2; - - // Menghitung x dengan substitusi y ke dalam persamaan 1 - double x = (c1 - b1 * y) / a1; - - return make_pair(x, y); -} - -int main() { - auto result = pldvEliminasi(2, 3, 7, 4, -5, 10); - cout << "x: " << result.first << ", y: " << result.second << endl; - // Output: x: 3, y: -1 - return 0; -} -``` - -==Python - -```python -def pldvEliminasi(a1, b1, c1, a2, b2, c2): - # Menghitung koefisien untuk eliminasi - factor = a2 / a1 - - # Membuat persamaan baru dengan mengurangi - newB2 = b2 - factor * b1 - newC2 = c2 - factor * c1 - - # Menyelesaikan untuk y - y = newC2 / newB2 - - # Menghitung x dengan substitusi y ke dalam persamaan 1 - x = (c1 - b1 * y) / a1 - - return x, y - -# Contoh: 2x - 3y = 7 dan 3x - 2y = 8 -x, y = pldvEliminasi(2, 3, 7, 3, -2, 8) -print(f"x: {x}, y: {y}") # Output: x: 2, y: 1 -``` -::: diff --git a/docs/algebra/quadratic-equation.md b/docs/algebra/quadratic-equation.md deleted file mode 100644 index 72385b8..0000000 --- a/docs/algebra/quadratic-equation.md +++ /dev/null @@ -1,219 +0,0 @@ ---- -contributors: - - name: "Anka Tama" - username: "xirf" ---- - -# Persamaan Kuadrat - -Persamaan kuadrat (kuadratik) dapat didefinisikan sebagai persamaan polinomial (persamaan yang terdiri dari beberapa suku) tingkat dua, yang menyiratkan bahwa persamaan ini terdiri dari minimal satu suku yang dikuadratkan. Bentuk umum persamaan kuadrat adalah: - -$$ax^2 + bx + c = 0$$ - -Dimana $x$ adalah variabel yang tidak diketahui dan $a$, $b$, $c$ adalah koefisien numerik. Sebagai contoh, $x^2 + 2x +1$ adalah persamaan kuadrat atau kuadratik. Di sini, $a ≠ 0$ karena jika sama dengan nol maka persamaan tersebut tidak lagi berbentuk kuadratik dan akan menjadi persamaan linier, seperti $bx + c = 0$. - - -
- -Grafik persamaan kuadrat $f(x) = 0.1x^2 + 0.5 - 0.3x$ - -
- -## Rumus Umum - -Akar-akar dari persamaan kuadrat dapat ditemukan dengan menggunakan rumus kuadrat. Rumus kuadrat adalah: - -$$x = \frac{-b ± \sqrt{b^2 - 4ac}}{2a}$$ - -Dimana $±$ disini berarti dua kemungkinan nilai untuk $x$. Rumus ini dikenal sebagai rumus kuadrat atau rumus abc. Rumus ini dapat digunakan untuk menemukan akar-akar dari persamaan kuadrat $ax^2 + bx + c = 0$. - -## Diskriminan - -Diskriminan adalah bagian dari rumus kuadrat yang terletak di bawah tanda akar. Diskriminan digunakan untuk menentukan jenis akar dari persamaan kuadrat. Diskriminan didefinisikan sebagai: - -$$D = b^2 - 4ac$$ - -Dimana $a$, $b$, dan $c$ adalah koefisien dari persamaan kuadrat $ax^2 + bx + c = 0$. Berikut adalah beberapa kemungkinan nilai diskriminan: - -- Jika $D > 0$, maka persamaan kuadrat memiliki solusi bilangan real -- Jika $D = 0$, maka persamaan kuadrat memiliki dua akar real yang sama. -- Jika $D < 0$, maka persamaan kuadrat memiliki dua akar kompleks. - -## Menggunakan Rumus Kuadrat - -Akar-akar persamaan kuadrat adalah dua nilai $x$, yang diperoleh dengan menyelesaikan persamaan kuadrat. Akar-akar persamaan kuadrat ini juga disebut angka nol dari persamaan tersebut. Sebagai contoh, akar-akar persamaan $x^2 - 3x - 4 = 0$ dapat dicari dengan menggunakan cara berikut: - -$$\begin{align*} -x &= \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \\ -x &= \frac{-(-3) \pm \sqrt{3^2 - 4\cdot1\cdot(-4)}}{2\cdot1} \\ -x &= \frac{3 \pm \sqrt{9 - - 16}}{2} \\ -x &= \frac{3 \pm \sqrt{9 + 16}}{2} \\ -x &= \frac{3 \pm \sqrt{25}}{2} \\ -x &= \frac{3 \pm 5}{2} -\end{align*}$$ - -Mari kira sederhanakan menjadi -$$x = \frac{3 ± 5}{2}$$ -$$x = \frac{8}{2} \text{ atau } x = -\frac{2}{2}$$ - -Yang akhirnya menjadi $x = 4$ atau $x = -1$. Jadi, akar-akar dari persamaan $x^2 - 3x - 4 = 0$ adalah $x = 4$ dan $x = -1$. - -Jika diimplementasikan dalam kode, maka hasilnya adalah seperti ini: - -:::tabs -==Javascript - -```js -function findRootsStepByStep(a, b, c) { - // Langkah 1: Hitung b^2 dan 4ac - const bSquared = b * b; - const fourAC = 4 * a * c; - // Langkah 2: Hitung diskriminan - const discriminant = bSquared - fourAC; - - if (discriminant >= 0) { - // Jika diskriminan >= 0, lanjutkan dengan akar real - // Langkah 3: Hitung akar dari diskriminan - const sqrtDiscriminant = Math.sqrt(discriminant); - // Langkah 4: Hitung dua kemungkinan nilai untuk x - const root1 = (-b + sqrtDiscriminant) / (2 * a); - const root2 = (-b - sqrtDiscriminant) / (2 * a); - console.log(`x1 = (-${b} + ${sqrtDiscriminant}) / (2 * ${a}) = ${root1}`); - console.log(`x2 = (-${b} - ${sqrtDiscriminant}) / (2 * ${a}) = ${root2}`); - console.log(`Akar-akarnya adalah: x1 = ${root1} dan x2 = ${root2}`); - } else { - // Jika diskriminan < 0, akar kompleks - const realPart = -b / (2 * a); - const imaginaryPart = Math.sqrt(-discriminant) / (2 * a); - console.log(`x1 = ${realPart} + ${imaginaryPart}i`); - console.log(`x2 = ${realPart} - ${imaginaryPart}i`); - } -} - -// Contoh untuk persamaan x^2 - 3x - 4 = 0 -const a = 1; -const b = -3; -const c = -4; -findRootsStepByStep(a, b, c); -``` - -== C++ - -```cpp -import kotlin.math.sqrt - -fun akarPersamaan(a: Double, b: Double, c: Double) { - // Langkah 1: Hitung bagian-bagian dari rumus - val bSquared = b * b - val fourAC = 4 * a * c - - // Langkah 2: Hitung diskriminan - val discriminant = bSquared - fourAC - - if (discriminant >= 0) { - // Jika diskriminan >= 0, lanjutkan dengan akar real - // Langkah 3: Hitung akar dari diskriminan - val sqrtDiscriminant = sqrt(discriminant) - - // Langkah 4: Hitung dua kemungkinan nilai untuk x - val root1 = (-b + sqrtDiscriminant) / (2 * a) - val root2 = (-b - sqrtDiscriminant) / (2 * a) - println("x1 = (-$b + $sqrtDiscriminant) / (2 * $a) = $root1") - println("x2 = (-$b - $sqrtDiscriminant) / (2 * $a) = $root2") - - // Tampilkan hasil akhirnya - println("Akar-akarnya adalah: x1 = $root1 dan x2 = $root2") - } else { - // Jika diskriminan < 0, akar kompleks - val realPart = -b / (2 * a) - val imaginaryPart = sqrt(-discriminant) / (2 * a) - println("x1 = $realPart + ${imaginaryPart}i") - println("x2 = $realPart - ${imaginaryPart}i") - } -} - -fun main() { - // Contoh untuk persamaan x^2 - 3x - 4 = 0 - val a = 1.0 - val b = -3.0 - val c = -4.0 - akarPersamaan(a, b, c) -} - -``` - -== Kotlin - -```kotlin -import kotlin.math.sqrt - -fun akarPersamaan(a: Double, b: Double, c: Double) { - // Langkah 1: Hitung bagian-bagian dari rumus - val bSquared = b * b - val fourAC = 4 * a * c - - // Langkah 2: Hitung diskriminan - val discriminant = bSquared - fourAC - - if (discriminant >= 0) { - // Jika diskriminan >= 0, lanjutkan dengan akar real - // Langkah 3: Hitung akar dari diskriminan - val sqrtDiscriminant = sqrt(discriminant) - - // Langkah 4: Hitung dua kemungkinan nilai untuk x - val root1 = (-b + sqrtDiscriminant) / (2 * a) - val root2 = (-b - sqrtDiscriminant) / (2 * a) - println("x1 = (-$b + $sqrtDiscriminant) / (2 * $a) = $root1") - println("x2 = (-$b - $sqrtDiscriminant) / (2 * $a) = $root2") - println("Akar-akarnya adalah: x1 = $root1 dan x2 = $root2") - } else { - // Jika diskriminan < 0, akar kompleks - val realPart = -b / (2 * a) - val imaginaryPart = sqrt(-discriminant) / (2 * a) - println("x1 = $realPart + ${imaginaryPart}i") - println("x2 = $realPart - ${imaginaryPart}i") - } -} - -fun main() { - // Contoh untuk persamaan x^2 - 3x - 4 = 0 - val a = 1.0 - val b = -3.0 - val c = -4.0 - akarPersamaan(a, b, c) -} -``` -== Python -``` python -import math - -def findRootsStepByStep(a, b, c): - # Langkah 1: Hitung b^2 dan 4ac - bSquared = b * b - fourAC = 4 * a * c - # Langkah 2: Hitung diskriminan - discriminant = bSquared - fourAC - - if discriminant >= 0: - # Jika diskriminan >= 0, lanjutkan dengan akar real - # Langkah 3: Hitung akar dari diskriminan - sqrtDiscriminant = math.sqrt(discriminant) - # Langkah 4: Hitung dua kemungkinan nilai untuk x - root1 = (-b + sqrtDiscriminant) / (2 * a) - root2 = (-b - sqrtDiscriminant) / (2 * a) - print(f"x1 = (-{b} + {sqrtDiscriminant}) / (2 * {a}) = {root1}") - print(f"x2 = (-{b} - {sqrtDiscriminant}) / (2 * {a}) = {root2}") - print(f"Akar-akarnya adalah: x1 = {root1} dan x2 = {root2}") - else: - # Jika diskriminan < 0, akar kompleks - realPart = -b / (2 * a) - imaginaryPart = math.sqrt(-discriminant) / (2 * a) - print(f"x1 = {realPart} + {imaginaryPart}i") - print(f"x2 = {realPart} - {imaginaryPart}i") - -# Contoh untuk persamaan x^2 - 3x - 4 = 0 -a = 1 -b = -3 -c = -4 -findRootsStepByStep(a, b, c) -``` \ No newline at end of file diff --git a/docs/arithmetic/factors.md b/docs/arithmetic/factors.md deleted file mode 100644 index e7cd22f..0000000 --- a/docs/arithmetic/factors.md +++ /dev/null @@ -1,381 +0,0 @@ ---- -title: Faktor dan Kelipatan -description: Faktorisasi, faktorisasi prima, pohon faktor, FPB, KPK ---- - -# Faktorisasi - -Faktorisasi atau pemfaktoran adalah proses menguraikan suatu bilangan menjadi faktor-faktornya. Faktor disini kaya bilangan yang bisa dikalikan untuk menghasilkan bilangan yang kita mau. - -Contoh, faktorisasi dari 12 adalah 2 dan 6, karena $2 \times 6 = 12$. Faktorisasi dari 6 adalah 2 dan 3, karena $2 \times 3 = 6$. - -## Faktorisasi Prima - -Faktorisasi prima adalah faktorisasi dimana semua faktor yang dihasilkan adalah bilangan prima. Bilangan prima adalah bilangan yang hanya bisa dibagi oleh 1 dan bilangan itu sendiri. - -Contoh: - -- Faktorisasi prima dari 12 adalah $12=22×312=22×3$, karena 12 bisa dipecah menjadi 2 kali 6, lalu 6 dipecah lagi menjadi 2 kali 3. -- Faktorisasi prima dari 30 adalah $30=2×3×530=2×3×5$, karena 30 bisa dipecah menjadi 2, 3, dan 5, yang semuanya adalah bilangan prima. - -## Pohon Faktor - -Secara sederhana cara mencari faktorisasi kita bisa pakai pohon faktor dimana kita melakukan pembagian berulang-ulang sampai bilangan yang kita bagi adalah bilangan prima. - -Misalnya kita memiliki bilangan 100 maka pohon faktornya adalah seperti ini: - - - 2 - - 2 - - 5 - - 0 - 0 - 1 - - 0 - 5 - - 5 - 2 - - 5 - - -Dari pohon faktor diatas kita bisa lihat bahwa faktorisasi dari 100 adalah $2 \times 2 \times 5 \times 5$ atau $2^2 \times 5^2$. Kita bisa tulis faktorisasi dari 100 sebagai $2^2 \times 5^2$. - -Kalo di pemrograman kita bisa pake _loop_ dan [modulo](/arithmetic/operation-on-number#modulus) untuk mencari faktorisasi dari suatu bilangan. Berikut contoh implementasinya: - -:::tabs -== Javascript - -```js -function faktorisasi(bilangan) { - let faktor = 2; - let faktorisasi = []; - while (bilangan > 1) { - if (bilangan % faktor === 0) { - faktorisasi.push(faktor); - bilangan /= faktor; - } else { - faktor++; - } - } - return faktorisasi; -} - -let faktorisasi100 = faktorisasi(100); // [2, 2, 5, 5] -``` - -== Kotlin - -```kt -fun faktorisasi(bilangan: Int): List { - var faktor = 2 - val faktorisasi = mutableListOf() - var bilangan = bilangan - while (bilangan > 1) { - if (bilangan % faktor == 0) { - faktorisasi.add(faktor) - bilangan /= faktor - } else { - faktor++ - } - } - return faktorisasi -} - -val faktorisasi100 = faktorisasi(100) // [2, 2, 5, 5] -``` - -== C++ - -```cpp -#include -#include - -std::vector faktorisasi(int bilangan) { - int faktor = 2; - std::vector faktorisasi; - while (bilangan > 1) { - if (bilangan % faktor == 0) { - faktorisasi.push_back(faktor); - bilangan /= faktor; - } else { - faktor++; - } - } - return faktorisasi; -} - -int main() { - std::vector faktorisasi100 = faktorisasi(100); // [2, 2, 5, 5] - return 0; -} -``` -== Python -```python -def faktorisasi(bilangan): - faktor = 2 - faktorisasi = [] - while bilangan > 1: - if bilangan % faktor == 0: - faktorisasi.append(faktor) - bilangan /= faktor - else: - faktor += 1 - - return faktorisasi - -faktorisasi100 = faktorisasi(100) # [2, 2, 5, 5] -``` - -::: - -Btw diatas kita pakai `/=` itu sama aja dengan `bilangan = bilangan / faktor`, sama aja kaya `+= -= *=` yang biasa kita pakai. - - -## Kelipatan - -Kelipatan adalah hasil dari perkalian suatu bilangan dengan bilangan lain. Misalnya kamu memiliki bilangan $a$ dan dikaikan dengan bilangan $n$ (positif, negatif, atau nol), maka hasilnya adalah kelipatan dari $a$. - -Misalnya lagi jika $a = 3$ maka kelipatan dari 3 adalah: -- $3 \times 1 = 3$ -- $3 \times 2 = 6$ -- $3 \times 3 = 9$ -- dan seterusnya... - -Jika kelipatan diimplementasikan dalam pemrograman, kita bisa menggunakan _loop_ untuk melakukan perkalian berulang. Contohnya seperti ini: -:::tabs -== Javascript - -```js -function kelipatan(a, n) { - let kelipatan = []; - for (let i = 1; i <= n; i++) { - kelipatan.push(a * i); - } - return kelipatan; -} - -let kelipatan3 = kelipatan(3, 5); // [3, 6, 9, 12, 15] -``` -== Kotlin - -```kt -fun kelipatan(a: Int, n: Int): List { - val kelipatan = mutableListOf() - for (i in 1..n) { - kelipatan.add(a * i) - } - return kelipatan -} - -val kelipatan3 = kelipatan(3, 5) // [3, 6, 9, 12, 15] -``` -== C++ - -```cpp -std::vector kelipatan(int a, int n) { - std::vector kelipatan; - for (int i = 1; i <= n; i++) { - kelipatan.push_back(a * i); - } - return kelipatan; -} - -int main() { - std::vector kelipatan3 = kelipatan(3, 5); // [3, 6, 9, 12, 15] - return 0; -} -``` -== Python -```python -def kelipatan(a, n): - kelipatan = [] - for i in range(1, n+1): - kelipatan.append(a * i) - - return kelipatan - -kelipatan3 = kelipatan(3, 5) - -``` -::: - -## Faktor Persekutuan Terbesar (FPB) - -FPB itu angka terbesar yang bisa membagi dua bilangan tanpa sisa. FPB biasanya dipakai untuk mencari kesamaan dari dua bilangan yang berbeda. - -Nah untuk mencari FPB kita bisa mulai dengan mencari faktorisasi dari kedua bilangan tersebut, lalu kita cari faktor yang sama dari kedua bilangan tersebut. Contoh kalo kita mau cari FPB dari 12 dan 18 kita bisa lakukan seperti ini: - -$12 = 1,2,3,4,6,12$ - -$18 = 1,2,3,6,9,18$ - -Kita bisa lihat bahwa angka yang sama-sama ada di faktorisasi dari 12 dan 18 adalah $1, 2, 3, \text{dan } 6$. Nah dari angka-angka ini kita bisa ambil yang terbesar yaitu 6. Jadi FPB dari 12 dan 18 adalah **$6$**. - -Cara lainnya adalah dengan menggunakan algoritma Euclidean yang rumusnya adalah: - -$$\text{FPB}(a, b) = \text{FPB}(b, a \mod b)$$ - -Cara ngitungnya kek gini: -1. Ambil dua bilangan $a$ dan $b$. -2. Bagi $a$ dengan $b$ dan simpan sisanya (modulus), misalnya $r = a \mod b$. -3. Ganti $a$ dengan $b$ dan $b$ dengan $r$. -4. Ulangi langkah 2 dan 3 sampai sisanya ($r$) menjadi 0. -5. Kalo $r$ udah 0, maka FPB dari $a$ dan $b$ adalah $b$. - -Pusing? Tenang, mari jadiin kode aja biar lebih mudah dimengerti kek gini: -:::tabs -== Javascript - -```javascript -function fpb(a, b) { - while (b !== 0) { - let t = b; - b = a % b; - a = t; - } - return a; -} - -let fpb1218 = fpb(12, 18); // 6 -``` -== Kotlin - -```kotlin -fun fpb(a: Int, b: Int): Int { - var a = a - var b = b - while (b != 0) { - val t = b - b = a % b - a = t - } - return a -} - -val fpb1218 = fpb(12, 18) // 6 -``` -== C++ - -```cpp -std::vector fpb(int a, int b) { - while (b != 0) { - int t = b; - b = a % b; - a = t; - } - return a; -} - -int main() { - int fpb1218 = fpb(12, 18); // 6 - return 0; -} -``` -== Python -```python -def fpb(a, b): - while b != 0: - t = b - b = a % b - a = t - - return a - -fpb1218 = fpb(12, 18) # 6 -``` -::: - - -## Kelipatan Persekutuan Terkecil (KPK) - -Kelipatan Persekutuan Terkecil (KPK) adalah angka terkecil yang bisa dibagi habis oleh dua bilangan. Misalnya, KPK dari 12 dan 18 adalah **$36$**, karena 36 adalah angka terkecil yang bisa dibagi habis oleh kedua bilangan tersebut. - -Gak percaya coba kita hitung $12 \times 3 = 36$ dan $18 \times 2 = 36$. - -Untuk mencari KPK, kita bisa pakai rumus ini: - -$$\text{KPK}(a, b) = \frac{a \times b}{\text{FPB}(a, b)}$$ - -Kalo disimulasiin kek gini: - -1. kita punya FPB dari 12 dan 18 yaitu 6. -2. $12 \times 18 = 216$ (gede banget) -3. $216 \div 6 = 36$ (nah ini KPKnya) - -Atau kalo mau rada ribet, kita bisa hitung manual dengan cara mencari kelipatan dari kedua bilangan tersebut. Contoh kalo kita mau cari KPK dari 12 dan 18 kita bisa lakukan seperti ini: - -| Bilangan | Kelipatan 1 | Kelipatan 2 | Kelipatan 3 | Kelipatan $n$ | -|----------|-------------|-------------|-------------|---------------| -| 12 | 12 | 24 | 36 | ... | -| 18 | 18 | 36 | 54 | ... | - -Dari tabel diatas kita bisa lihat bahwa kelipatan yang sama dari 12 dan 18 adalah 36. Jadi KPK dari 12 dan 18 adalah **$36$**. -Kalian bebas sih pake yang mana, yang penting gak salah. - - -Gampang kan? Mari kita jadiin kode biar lebih mudah dimengerti: -:::tabs -== Javascript - -```javascript -function kpk(a, b) { - return (a * b) / fpb(a, b); -} - -let kpk1218 = kpk(12, 18); // 36 -``` -== Kotlin - -```kotlin -fun kpk(a: Int, b: Int): Int { - return (a * b) / fpb(a, b) -} - -val kpk1218 = kpk(12, 18) // 36 -``` -== C++ - -```cpp -int kpk(int a, int b) { - return (a * b) / fpb(a, b); -} - -int main() { - int kpk1218 = kpk(12, 18); // 36 - return 0; -} -``` -== Python -```python -def kpk(a, b): - return (a * b) / fpb(a, b) - -kpk1218 = kpk(12, 18) # 36.0 -``` -::: - - diff --git a/docs/arithmetic/numbers.md b/docs/arithmetic/numbers.md deleted file mode 100644 index 8f66e0b..0000000 --- a/docs/arithmetic/numbers.md +++ /dev/null @@ -1,148 +0,0 @@ ---- -title: Bilangan -description: Contoh penggunaan Bilangan dalam pemrograman ---- - -# Bilangan - -Bilangan merupakan dasar dari matematika, semuanya di matematika pake bilangan. Dalam pemrograman, bilangan juga sangat penting. Kita bisa melakukan berbagai operasi matematika dengan bilangan, seperti penjumlahan, pengurangan, perkalian, dan pembagian. - -Namun bilangan di pemrograman dibagi-bagi ke beberapa jenis, tergantung dari tipe datanya. Jadinya penggunaan bilangan di program bakalan sedikit beda dengan di matematika biasa. yuk pelajari lebih lanjut! - -## Bilangan Bulat (Integer) - -Bilangan bulat adalah bilangan yang tidak punya koma. Di pemrograman, bilangan bulat biasanya disebut dengan `integer`. Contoh bilangan bulat adalah 1, 2, 3, 4, 5, dan seterusnya. - -:::tabs -== Javascript -```js -let bilanganBulat = 10; -``` -== Kotlin -```kt -val bilanganBulat: Int = 10 -``` -== C++ -```cpp -int bilanganBulat = 10; -``` -== Python -```python -bilanganBulat = 10 -``` -::: - -Meski kelihatannya sederhana, jangan lupa kalau di pemrograman, bilangan punya batasan! Contohnya, di Javascript, bilangan paling besar yang bisa kamu pakai adalah **`9,007,199,254,740,992`**. Itu setara dengan angka yang sangat besar seriously, aku aja bingung ngucapinnya. - -Nah, kalau di C++ dan bahasa lain yang punya tipe data lebih banyak daripada JS (cuman `number` dan `BigInt`), batasan itu tergantung tipe data yang kamu pakai. Contoh kalo pake `short` di c++, kamu bisa mencapai angka **`32,767`** terkecuali di python, python tidak memiliki batas bilangan bulat, karena Python secara dinamis menangani ukuran bilangan bulat. contohnya seperti dibawah ini - -:::tabs -== Javascript - -| Tipe Data | Ukuran (bits) | Minimal| Maksimal| Maksimal (Secara Eksplisit) | -|-----------|------------------|---------------|----|---------------------------| -| Number | 64 | -9,007,199,254,740,991
(−253 - 1) | 9,007,199,254,740,992
(253 - 1 ) | 18,446,744,073,709,551,616 (264) | -| BigInt | max 1,000,000,000 | `tergantung memori` | `tergantung memori` | `tergantung memori` | -== C++ -| Tipe Data | Ukuran (bits) | Minimal | Maksimal | Maksimal (Secara Eksplisit) -|-----------|------------------|------------------------------------------------|-----------------------------------------------|---------------------------| -| `short` | 16 | -32,768 | 32,767 | 65,536 (216) | -| `int` | 32 | -2,147,483,648 (-231) | 2,147,483,647 (231 - 1) | 4,294,687,296 (232) | -| `long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | -| `long long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | - -Banyak banget selengkapnya cek [sini aja ya](https://learn.microsoft.com/en-us/cpp/c-language/cpp-integer-limits?view=msvc-170#limits-on-integer-constants) -== Kotlin -| Tipe Data | Ukuran (bits) | Minimal | Maksimal | Maksimal (Secara Eksplisit) | -|-----------|------------------|------------------------------------------------|-----------------------------------------------|---------------------------| -| `Byte` | 8 | -128 | 127 | 256 (28) -| `Short` | 16 | -32,768 | 32,767 | 65,536 (216) | -| `Int` | 32 | -2,147,483,648 (-231) | 2,147,483,647 (231 - 1) | 4,294,687,296 (232) | -| `Long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | -::: - -## Bilangan Desimal (Floating Point) - -Bilangan desimal atau floating point adalah bilangan yang punya koma. Di pemrograman, bilangan desimal biasanya disebut dengan `float` atau `double`. Contoh bilangan desimal adalah 1.5, 2.3, 3.14, dan seterusnya. Untuk membuat bilangan desimal kamu bisa menggunakan kode seperti dibawah ini - -:::tabs -== Javascript -```js -let bilanganDesimal = 3.14; -``` -== Kotlin -```kt -val bilanganDesimal: Float = 3.14F -``` -Kita juga bisa menggunakan `double` untuk bilangan desimal yang memiliki angka di belakang koma lebih banyak (sampe 15 digit). Contoh penggunaannya seperti ini: -```kt -val bilanganDesimal: Double = 3.141592653589793f -``` -== C++ -```cpp -float bilanganDesimal = 3.14f; -``` -Kita juga bisa menggunakan `double` untuk bilangan desimal yang memiliki angka di belakang koma lebih banyak (sampe 15 digit). Contoh penggunaannya seperti ini: -```cpp -double bilanganDesimal = 3.141592653589793F; -``` -== Python -```python -bilanganDesimal = 3.14 -``` -::: - - -## Bilangan Pecahan (Fraction) - -Bilangan pecahan adalah bilangan yang punya pembilang dan penyebut. Di pemrograman, bilangan pecahan biasanya disebut dengan `fraction`. Contoh bilangan pecahan adalah 1/2, 3/4, 5/6, dan seterusnya. Sayangnya di pemrograman, bilangan pecahan gak ada tipe datanya tapi langsung dihitung aja yang nantinya hasilnya bakal jadi bilangan desimal. Contoh penggunaannya seperti ini: - -:::tabs -== Javascript -```js -let bilanganPecahan = 1/2; -``` -== Kotlin -```kt -val bilanganPecahan = 1/2 // Otomatis jadi float -``` -== C++ -```cpp -float bilanganPecahan = 1/2; -``` -== Python -```python -bilanganPecahan = 1/2 -``` -::: - -> [!WARNING] Perhatian saat melakukan operasi dengan bilangan pecahan dan desimal -> Dalam banyak bahasa pemrograman, termasuk JavaScript, ada yang disebut dengan `floating point error`, yang dapat menyebabkan hasil perhitungan tidak akurat. Hal ini terjadi karena bilangan desimal tidak selalu dapat direpresentasikan secara tepat dalam format biner. -> -> Contoh, ketika kita menjumlahkan 0.1 dan 0.2 di JavaScript, hasilnya bukan 0.3, melainkan 0.30000000000000004. Ini disebabkan oleh keterbatasan representasi angka desimal dalam komputer. -> -> Untuk menghindari masalah ini, sebaiknya batasi presisi hasil perhitungan dengan cara Membulatkan hasil ke jumlah angka desimal yang diinginkan (misalnya dengan `toFixed()` atau `Math.round()`. -> -> Kamu juga bisa menggunakan pustaka seperti BigNumber atau yang lainnya - -Gimana dengan **Bilangan pecahan campuran** kan di matematika ada kaya $1\frac{1}{2}$, di pemrograman juga bisa kok. Kita bisa menggunakan `float` atau `double` untuk bilangan pecahan campuran. Contoh penggunaannya seperti ini: -:::tabs -== Javascript -```js -let bilanganPecahanCampuran = 1 + 1/2; -``` -== Kotlin -```kt -val bilanganPecahanCampuran: Double = 1 + 1/2 -``` -== C++ -```cpp -double bilanganPecahanCampuran = 1 + 1/2; -``` -== Python -```python -bilanganPecahanCampuran = 1 + 1/2 -``` -::: - -Kenapa bisa dikali? Karena bilangan pecahan campuran itu sebenernya bisa diubah jadi bilangan desimal biasa. Misal $1\frac{1}{2}$ bisa diubah jadi $1 + \frac{1}{2}$ yang sama dengan $1.5$. diff --git a/docs/arithmetic/operation-on-number.md b/docs/arithmetic/operation-on-number.md deleted file mode 100644 index a455504..0000000 --- a/docs/arithmetic/operation-on-number.md +++ /dev/null @@ -1,232 +0,0 @@ ---- -title: Operasi pada Bilangan -description: Contoh penggunaan operasi matematika pada bilangan dalam pemrograman ---- - - -# Operasi Bilangan - -Operasi bilangan atau proses untuk memanipulasi nilai numerik tertentu pake teknik matematika seperti penjumlahan, pengurangan, perkalian, pembagian, dan banyak lagi. Di pemrograman kita gak bisa lepas dari yang namanya operasi bilangan karena komputer sendiri berjalan berdasarkan operasi bilangan. Di sini kita bakal bahas operasi bilangan yang sering dipake di pemrograman. - -## Operasi Dasar - -Di pemrograman, kita bisa melakukan berbagai operasi matematika dengan bilangan. Ada penjumlahan, pengurangan, perkalian, dan pembagian. Berbeda dengan matematika biasa yang pakai simbol `+`, `-`, `*`, dan `/`, di pemrograman kita pakai simbol yang berbeda. Contoh penggunaannya seperti ini: - -:::tabs -== Javascript -```js -let a = 10; -let b = 5; -let hasilPenjumlahan = a + b; // 15 -let hasilPengurangan = a - b; // 5 -let hasilPerkalian = a * b; // 50 -let hasilPembagian = a / b; // 2 -``` -== Kotlin -```kt -val a = 10 -val b = 5 -val hasilPenjumlahan = a + b // 15 -val hasilPengurangan = a - b // 5 -val hasilPerkalian = a * b // 50 -val hasilPembagian = a / b // 2 -``` -== C++ -```cpp -int a = 10; -int b = 5; -int hasilPenjumlahan = a + b; // 15 -int hasilPengurangan = a - b; // 5 -int hasilPerkalian = a * b; // 50 -int hasilPembagian = a / b; // 2 -``` -== Python -```python -a = 10 -b = 5 -hasilPenjumlahan = a + b # 15 -hasilPengurangan = a - b # 5 -hasilPerkalian = a * b # 50 -hasilPembagian = a / b # 2 -``` -::: - -Di atas kita menggunakan simbol `/` untuk pembagian dan `*` untuk perkalian. Ini karena dalam pemrograman, kita tidak bisa menggunakan simbol matematika `÷` dan `×` kek biasanya apalagi `.` karena bahasa pemrograman umumnya mengikuti aturan ASCII yang hanya mendukung karakter dasar, sehingga simbol-simbol matematika khusus seperti `÷` dan `×` tidak tersedia. Sebagai gantinya, pemrograman menggunakan `*` sebagai pengganti kali dan `/` sebagai pengganti bagi agar kode bisa berjalan dengan baik. - -> [!NOTE] -> Coba cek di keyboard laptop atau PC kalian ada gak tuh simbol `÷` dan `×` (ini bukan x ya) kebanyakan sih gak ada dan itulah salah satu alasannya kenapa pemrograman gak pake simbol itu. :grin: - -## Pangkat (Exponentiation) - -Pangkat adalah operasi matematika yang digunakan untuk menghitung hasil perkalian bilangan dengan dirinya sendiri sebanyak $n$ kali. Di pemrograman, kita bisa menggunakan operator `**` ataupun pakai `pow()` untuk menghitung pangkat. Contoh penggunaannya seperti ini: -:::tabs -== Javascript -```js -let pangkat = 2 ** 3; // 8 -let pangkat2 = Math.pow(2, 3); // 8 -``` -== Kotlin -```kt -val pangkat = 2.0.pow(3) // 8.0 -val pangkat2 = Math.pow(2.0, 3.0) // 8.0 -``` -== C++ -```cpp -#include -#include - -int main() { - double pangkat = pow(2, 3); // 8 - double pangkat2 = pow(2.0, 3.0); // 8 - return 0; -} -``` -== Python -```python -pangkat = 2 ** 3 # 8 -pangkat2 = pow(2, 3) # 8 -``` -::: - -`pow()` biasanya meminta dua parameter, parameter pertama adalah bilangan yang mau dipangkatkan, dan parameter kedua adalah pangkatnya. jadi kalo kita mau menghitung $2^3$ kita bisa tulis `pow(2, 3)`. - -## Akar (Root) - -Setiap bahasa pemrograman juga biasanya punya fungsi untuk menghitung akar. Di Javascript, kita bisa menggunakan fungsi `Math.sqrt()` (*Square Root*) untuk menghitung akar. Contoh penggunaannya seperti ini: - -```js -let akar = Math.sqrt(16); // 4 -``` -Di Kotlin, kita bisa menggunakan fungsi `Math.sqrt()` juga. Contoh penggunaannya seperti ini: - -```kt -val akar = Math.sqrt(16.0) // 4.0 -``` - -Di C++, kita bisa menggunakan fungsi `sqrt()` dari library `cmath`. Contoh penggunaannya seperti ini: - -```cpp -#include -#include - -int main() { - double akar = sqrt(16); // 4 - std::cout << akar << std::endl; - return 0; -} -``` - -Di Python, kita bisa menggunakan library `sqrt()` dari library `math`, Contoh penggunaanya seperti ini: -```python -import math -akar = math.sqrt(16) # 4.0 -``` - -Tapi ada masalah kalo kita mau menghitung akar yang lebih dari 2 kaya $\sqrt[3]{8}$ atau $\sqrt[4]{16}$, Nah untuk kasus ini kita bisa pangkatkan aja bilangannya dengan $1/n$ dimana si $n$ itu adalah akar yang kita mau. Contoh penggunaannya seperti ini: - -:::tabs -== Javascript -```js -let akar3 = Math.pow(8, 1/3); // 2 -let akar4 = Math.pow(16, 1/4); // 2 -``` -== Kotlin -```kt -val akar3 = Math.pow(8.0, 1.0/3.0) // 2.0 -val akar4 = Math.pow(16.0, 1.0/4.0) // 2.0 -``` -== C++ -```cpp -#include -#include - -int main() { - double akar3 = pow(8, 1.0/3); // 2 - double akar4 = pow(16, 1.0/4); // 2 - std::cout << akar3 << std::endl; - std::cout << akar4 << std::endl; - return 0; -} -``` -== Python -```python -akar3 = pow(8, 1/3) # 2.0 -akar4 = pow(16, 1/4) # 2.0 -``` -::: - -Hal ini bisa terjadi karena apapun bilangan yang memiliki pangkat $1/n$ akan menghasilkan akar dari bilangan tersebut. Jadi kalo kita mau menghitung $\sqrt[3]{8}$ kita bisa tulis `pow(8, 1/3)`. - -## Modulus - -Modulus atau sisa hasil pembagian adalah operasi matematika yang digunakan untuk menghitung sisa hasil pembagian dua bilangan. Misalnya kamu mau tau sisa hasil pembagian 10 dibagi 3, maka hasilnya adalah 1. Di pemrograman, kita bisa menggunakan operator `%` untuk menghitung modulus. - -Operator ini berguna banget buat ngecek bilangan itu genap, ganjil atau punya pola tertentu. Contoh penggunaannya seperti ini: - -:::tabs -== Javascript -```js -let hasilModulus = 10 % 3; // 1 -``` -== Kotlin -```kt -val hasilModulus = 10 % 3 // 1 -``` -== C++ -```cpp -int hasilModulus = 10 % 3; // 1 -``` -== Python -```python -hasilModulus = 10 % 3 # 1 -``` -::: - -## Prioritas Operasi - -Di dalam matematika, ada aturan yang namanya prioritas operasi. Prioritas operasi ini menentukan urutan operasi mana yang harus dilakukan duluan. Di pemrograman, prioritas operasi ini juga berlaku dan sama dengan matematika biasa. Kalo di bahasa inggris ada yang namanya PEMDAS (Parentheses, Exponents, Multiplication and Division, Addition and Subtraction) jadi urutannya adalah - -1. Tanda Kurung $( )$ -2. Pangkat $x^y$ dan Akar $\sqrt{x}$ -3. Perkalian $x \times y$, Pembagian $x \div y$ dan Modulus $x \% y$ -4. Penjumlahan $x + y$ dan Pengurangan $x - y$ - -contoh kalo pengen menghitung $6 + 3 * (2^3 + \sqrt{16})$ maka: - -1. **Tanda kurung**: Fokus pada bagian dalam kurung terlebih dahulu $2^3 + \sqrt{16}$. -3. **Eksponen (pangkat)**: Hitung $2^3$. -$$2^3 = 8$$ -5. **Akar**: Hitung $\sqrt{16}$. -$$\sqrt{16} = 4$$ -7. **Penjumlahan dalam kurung**: Sekarang, selesaikan operasi dalam kurung $2^3 + \sqrt{16}$. -$$8 + 4 = 12$$ -9. **Perkalian**: Lanjutkan ke operasi di luar kurung, yaitu $3 \times (2^3 + \sqrt{16})$. -$$3 \times 12 = 36$$ -11. **Penjumlahan terakhir**: Terakhir, tambahkan $6 + 36$. -$$6 + 36 = 42$$ -Jadi, hasil akhirnya adalah **42**. - -Kalo di pemrograman urutan operasi ini udah di tangani sama bahasanya jadi kamu gak perlu khawatir kalo salah urutan operasi. Kamu cukup teliti aja sama rumus yang akan kamu gunakan. Kalo rumus tadi kita masukkan ke kode maka akan jadi seperti ini. - -:::tabs -== Javascript -```js -let hasil = 6 + 3 * (2 ** 3 + Math.sqrt(16)); // 42 -``` -== Kotlin -```kt -val hasil = 6 + 3 * (2.0.pow(3) + Math.sqrt(16.0)) // 42.0 -``` - -== C++ -```cpp -int hasil = 6 + 3 * (pow(2, 3) + sqrt(16)); // 42 -``` -== Python -```python -import math -hasil = 6 + 3 * (pow(2,3) + math.sqrt(16)) # 42.0 -``` -::: - -## \ No newline at end of file diff --git a/docs/arithmetic/percent.md b/docs/arithmetic/percent.md deleted file mode 100644 index 156eb53..0000000 --- a/docs/arithmetic/percent.md +++ /dev/null @@ -1,113 +0,0 @@ -# Persen - -Pernah dapat diskon pas belanja?, biasanya kalo gak di coret ya pake tanda persen ($%$). Nah, persen ini adalah cara kita mengukur seberapa besar atau kecil suatu nilai dibandingkan dengan nilai aslinya. - -Misalnya kamu beli baju seharga Rp. $100.000$ tapi kamu dapat diskon $20\%$, berarti kamu bisa beli bajunya dengan harga Rp. $80.000$. - -Cara ngitung persen itu gampang banget, kita bisa pakai rumus: -$$ persen = \frac{nilai}{100} \times persen $$ - -Jadi kalo kita mau ngitung $20\%$ dari $100.000$ kita bisa tulis: -$$ persen = \frac{100.000}{100} \times 20\% = 20.000 $$ - -karena dibagi $100$ jadi kita bisa kurangi dua nol dari $100.000$ jadi $1.000$ dan dikalikan $20$ jadi $20.000$. - -Kalo diubah ke kodingan, kita bisa tulis seperti ini: -:::tabs -== Javascript -```js -let harga = 100000; -let diskon = 20; -let persen = (harga / 100) * diskon; // 20000 -``` -== Kotlin -```kt -val harga = 100000 -val diskon = 20 -val persen = (harga / 100) * diskon // 20000 -``` -== C++ -```cpp -int harga = 100000; -int diskon = 20; -int persen = (harga / 100) * diskon; // 20000 -``` -== Python -```python -harga = 100000 -diskon = 20 -persen = (harga / 100) * diskon # 20000.0 -``` -::: - -## Mencari Nilai Asli - -Kalo sebelumnya kita ngitung persen dari nilai asli, sekarang kita akan mencari nilai asli dari nilai persen tersebut. Caranya tinggal dibalik aja rumusnya jadi: -$$ nilai = \frac{persen}{persen} \times 100 $$ - -Misalnya kita punya nilai persen sebesar $20.000$ dan kita mau cari nilai aslinya, kita bisa tulis: -$$ nilai = \frac{20.000}{20\%} \times 100 = 100.000 $$ - -Kalo diubah ke kodingan, kita bisa tulis seperti ini: -:::tabs -== Javascript -```js -let persen = 20000; -let diskon = 20; -let harga = (persen / diskon) * 100; // 100000 -``` -== Kotlin -```kt -val persen = 20000 -val diskon = 20 -val harga = (persen / diskon) * 100 // 100000 -``` -== C++ -```cpp -int persen = 20000; -int diskon = 20; -int harga = (persen / diskon) * 100; // 100000 -``` -== Python -```python -persen = 20000 -diskon = 20 -persen = (persen / diskon) * 100 # 100000.0 - -``` -::: - -## Mencari Persen - -Kalo sebelumnya kita ngitung persen dari nilai asli, sekarang kita akan mencari nilai persen dari nilai asli tersebut. Rumusnya kita ubah jadi: -$$ persen = \frac{nilai}{nilai} \times 100 $$ -Misalnya kita punya nilai asli sebesar $100.000$ dan kita mau cari persennya, kita bisa tulis: -$$ persen = \frac{100.000}{100.000} \times 100 = 20\% $$ - -Kalo diubah ke kodingan, kita bisa tulis seperti ini: -:::tabs -== Javascript -```js -let harga = 100000; -let diskon = 20000; -let persen = (diskon / harga) * 100; // 20 -``` -== Kotlin -```kt -val harga = 100000 -val diskon = 20000 -val persen = (diskon / harga) * 100 // 20 -``` -== C++ -```cpp -int harga = 100000; -int diskon = 20000; -int persen = (diskon / harga) * 100; // 20 -``` -== Python -```python -harga = 100000 -diskon = 20000 -persen = (diskon / harga) * 100 # 20.0 -``` -::: \ No newline at end of file diff --git a/docs/en/arithmetic/factors.md b/docs/en/arithmetic/factors.md new file mode 100644 index 0000000..c0af969 --- /dev/null +++ b/docs/en/arithmetic/factors.md @@ -0,0 +1,379 @@ +--- +title: Factor and Multiples +description: Factorization, prime factorization, factor trees, GCF, LCM +--- + +# Factorization + +Factorization is the process of breaking down a number into its factors. Factors here are numbers that can be multiplied to produce the number we want. + +For example, the factorization of 12 is 2 and 6, because $2 \times 6 = 12$. The factorization of 6 is 2 and 3, because $2 \times 3 = 6$. + +## Prime Factorization + +Prime factorization is a factorization in which all the resulting factors are prime numbers. A prime number is a number that can only be divided by 1 and itself. + +Examples: + +- The prime factor of 12 is $12=2×2×3$, because 12 can be divided into 2 times 6, then 6 can be divided again into 2 times 3. +- The prime factor of 30 is $30=2×3×5$, because 30 can be divided into 2, 3, and 5, all of which are prime numbers. + +## Factor Tree + +Put it simply, we can find factorization by using a factor tree where we perform repeated division until the number we divide is a prime number. + +For example, if we have the number 100, then the factor tree is like this: + + + 2 + + 2 + + 5 + + 0 + 0 + 1 + + 0 + 5 + + 5 + 2 + + 5 + + +From the factor tree above we can see that the factorization of 100 is $2 \times 2 \times 5 \times 5$ or $2^2 \times 5^2$. We can write the factorization of 100 as $2^2 \times 5^2$. + +In programming, we can use _loop_ and [modulo](/en/arithmetic/operation-on-number#modulus) to find the factorization of a number. Here is an example of its implementation: + +:::tabs +== Javascript + +```js +function factorize(number) { + let factor = 2; + let factors = []; + while (number > 1) { + if (number % factor === 0) { + factors.push(factor); + number /= factor; + } else { + factor++; + } + } + return factors; +} + +let factorize100 = factorize(100); // [2, 2, 5, 5] +``` + +== Kotlin + +```kt +fun factorize(number: Int): List { + var factor = 2 + val factors = mutableListOf() + var number = number + while (number > 1) { + if (number % factor == 0) { + factors.add(factor) + number /= factor + } else { + factor++ + } + } + return factors +} + +val factorize100 = factorize(100) // [2, 2, 5, 5] +``` + +== C++ + +```cpp +#include +#include + +std::vector factorize(int number) { + int factor = 2; + std::vector factors; + while (number > 1) { + if (number % factor == 0) { + factors.push_back(factor); + number /= factor; + } else { + factor++; + } + } + return factors; +} + +int main() { + std::vector factorize100 = factorize(100); // [2, 2, 5, 5] + return 0; +} +``` +== Python +```python +def factorize(number): + factor = 2 + factors = [] + while number > 1: + if number % factor == 0: + factors.append(factor) + number /= factor + else: + factor += 1 + + return factors + +factorize100 = factorize(100) # [2, 2, 5, 5] +``` + +::: + +Btw, what we use above `/=` is the same as `number = number / factor`, it's similar to `+= -= *=` we usually use. + + +## Multiples + +A multiple is the result of multiplying a number by another number. For example, if you have a number $a$ and multiply it by $n$ (which can be positive, negative, or zero), the result is a multiple of $a$. + +For example, if $a = 3$ then the multiples of 3 are: +- $3 \times 1 = 3$ +- $3 \times 2 = 6$ +- $3 \times 3 = 9$ +- and so on... + +If multiples are implemented in programming, we can use _loop_ to perform repeated multiplication. Here’s an example: +:::tabs +== Javascript + +```js +function multiples(a, n) { + let multiples = []; + for (let i = 1; i <= n; i++) { + multiples.push(a * i); + } + return multiples; +} + +let multiplesOf3 = multiples(3, 5); // [3, 6, 9, 12, 15] +``` +== Kotlin + +```kt +fun multiples(a: Int, n: Int): List { + val multiples = mutableListOf() + for (i in 1..n) { + multiples.add(a * i) + } + return multiples +} + +val multiplesOf3 = multiples(3, 5) // [3, 6, 9, 12, 15] +``` +== C++ + +```cpp +std::vector multiples(int a, int n) { + std::vector multiples; + for (int i = 1; i <= n; i++) { + multiples.push_back(a * i); + } + return multiples; +} + +int main() { + std::vector multiplesOf3 = multiples(3, 5); // [3, 6, 9, 12, 15] + return 0; +} +``` +== Python +```python +def multiples(a, n): + multiples = [] + for i in range(1, n+1): + multiples.append(a * i) + + return multiples + +multiplesOf3 = multiples(3, 5) # [3, 6, 9, 12, 15] +``` +::: + +## Greatest Common Factor (GCF) + +GCF is the largest number that can divide two numbers without a remainder. GCF is usually used to find the similarity of two different numbers. + +Now to find the GCF we can start by finding the factorization of the two numbers, then we look for the same factors of the two numbers. For example, if we want to find the GCF of 12 and 18, we can do it like this: + +$12 = 1,2,3,4,6,12$ + +$18 = 1,2,3,6,9,18$ + +We can see that the numbers that are common to both 12 and 18 are $1, 2, 3, \text{and } 6$. Now from these numbers we can take the largest one, which is 6. So the GCF of 12 and 18 is **$6$**. + +Another way is to use the Euclidean algorithm, the formula for which is: + +$$\text{GCF}(a, b) = \text{GCF}(b, a \mod b)$$ + +How to calculate it is like this: +1. Take two numbers $a$ and $b$. +2. Divide $a$ with $b$ and save the remainder (modulus), for example $r = a \mod b$. +3. Change $a$ with $b$ and $b$ with $r$. +4. Repeat steps 2 and 3 the rest ($r$) becomes 0. +5. If $r$ is 0, then the GCF of $a$ and $b$ is $b$. + +Are you still with me? Relax, let's turn it into code that we can easily understand: +:::tabs +== Javascript + +```javascript +function gcf(a, b) { + while (b !== 0) { + let t = b; + b = a % b; + a = t; + } + return a; +} + +let gcf1218 = gcf(12, 18); // 6 +``` +== Kotlin + +```kotlin +fun gcf(a: Int, b: Int): Int { + var a = a + var b = b + while (b != 0) { + val t = b + b = a % b + a = t + } + return a +} + +val gcf1218 = gcf(12, 18) // 6 +``` +== C++ + +```cpp +std::vector gcf(int a, int b) { + while (b != 0) { + int t = b; + b = a % b; + a = t; + } + return a; +} + +int main() { + int gcf1218 = gcf(12, 18); // 6 + return 0; +} +``` +== Python +```python +def gcf(a, b): + while b != 0: + t = b + b = a % b + a = t + + return a + +gcf1218 = gcf(12, 18) # 6 +``` +::: + + +## Least Common Multiple (LCM) + +The Least Common Multiple (LCM) is the smallest number that can be divided evenly by two numbers. For example, the LCM of 12 and 18 is **$36$**, because 36 is the smallest number that can be divided evenly by both numbers. + +Don't believe it? let's count $12 \times 3 = 36$ and $18 \times 2 = 36$. + +To find the LCM, we can use this formula: + +$$\text{LCM}(a, b) = \frac{a \times b}{\text{GCF}(a, b)}$$ + +If simulated, it would be like this: + +1. we have the GCF of 12 and 18 which is 6. +2. $12 \times 18 = 216$ (quite big) +3. $216 \div 6 = 36$ (this is the LCM) + +Or if you to complicate things, we can calculate manually by finding the multiples of both numbers. For example, if we want to find the LCM of 12 and 18, we can do it like this: + +| Number | Multiples of 1 | Multiples of 2 | Multiples of 3 | Multiples of $n$ | +|----------|-------------|-------------|-------------|---------------| +| 12 | 12 | 24 | 36 | ... | +| 18 | 18 | 36 | 54 | ... | + +From the table above we can see that the common multiple of 12 and 18 is **$36$**. +You are free to use whichever one you like, as long as it's not wrong. + +Easy right? Let's turn it into code that we can easily understand:: +:::tabs +== Javascript + +```javascript +function lcm(a, b) { + return (a * b) / gcf(a, b); +} + +let lcm1218 = lcm(12, 18); // 36 +``` +== Kotlin + +```kotlin +fun lcm(a: Int, b: Int): Int { + return (a * b) / gcf(a, b) +} + +val lcm1218 = lcm(12, 18) // 36 +``` +== C++ + +```cpp +int lcm(int a, int b) { + return (a * b) / gcf(a, b); +} + +int main() { + int lcm1218 = lcm(12, 18); // 36 + return 0; +} +``` +== Python +```python +def lcm(a, b): + return (a * b) / gcf(a, b) + +lcm1218 = lcm(12, 18) # 36.0 +``` +::: + + diff --git a/docs/en/arithmetic/numbers.md b/docs/en/arithmetic/numbers.md new file mode 100644 index 0000000..56ce9ec --- /dev/null +++ b/docs/en/arithmetic/numbers.md @@ -0,0 +1,148 @@ +--- +title: Numbers +description: Example of using Numbers in programming +--- + +# Numbers + +Numbers are the foundation of mathematics, everything in math uses numbers. In programming, numbers are also very important. We can perform various mathematical operations with numbers, such as addition, subtraction, multiplication, and division. + +However, numbers in programming are categorized into several types, depending on their data type. So, the use of numbers in programming will be slightly different from standard mathematics. Let's learn more about it! + +## Integers + +Integers are numbers without decimals. In programming, integers are usually referred to as `integer`. Examples of integers include 1, 2, 3, 4, 5, and so on. + +:::tabs +== Javascript +```js +let myInteger = 10; +``` +== Kotlin +```kt +val myInteger: Int = 10 +``` +== C++ +```cpp +int myInteger = 10; +``` +== Python +```python +myInteger = 10 +``` +::: + +Although it seems simple, don't forget that in programming, numbers have limits! For example, in JavaScript, the largest number you can use is **`9,007,199,254,740,992`**. That's equivalent to a very large number. I even have trouble saying it, seriously. + +Now, in C++ and other languages that have more data types than JS (which only has `number` and `BigInt`), the limits depend on the data type you use. For example, if you use `short` in C++, you can reach the number **`32,767`** except in Python, which doesn't have a limit for integers, as Python dynamically handles the size of integers. Here's an example: + +:::tabs +== Javascript + +| Data Type | Size (bits) | Minimum | Maximum | Maximum (Explicitly) | +|-----------|------------------|---------------|----|---------------------------| +| Number | 64 | -9,007,199,254,740,991
(−253 - 1) | 9,007,199,254,740,992
(253 - 1 ) | 18,446,744,073,709,551,616 (264) | +| BigInt | max 1,000,000,000 | `depends on memory` | `depends on memory` | `depends on memory` | +== C++ +| Data Type | Size (bits | Minimum | Maximum | Maximum (Explicitly) | +|-----------|------------------|------------------------------------------------|-----------------------------------------------|---------------------------| +| `short` | 16 | -32,768 | 32,767 | 65,536 (216) | +| `int` | 32 | -2,147,483,648 (-231) | 2,147,483,647 (231 - 1) | 4,294,687,296 (232) | +| `long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | +| `long long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | + +There are many more details which [you can check here](https://learn.microsoft.com/en-us/cpp/c-language/cpp-integer-limits?view=msvc-170#limits-on-integer-constants) +== Kotlin +| Data Type | Size (bits | Minimum | Maximum | Maximum (Explicitly) | +|-----------|------------------|------------------------------------------------|-----------------------------------------------|---------------------------| +| `Byte` | 8 | -128 | 127 | 256 (28) +| `Short` | 16 | -32,768 | 32,767 | 65,536 (216) | +| `Int` | 32 | -2,147,483,648 (-231) | 2,147,483,647 (231 - 1) | 4,294,687,296 (232) | +| `Long` | 64 | -9,223,372,036,854,775,808 (-263) | 9,223,372,036,854,775,807 (263 - 1) | 18,446,744,073,709,551,616 (264) | +::: + +## Decimal Numbers (Floating Point) + +Decimal numbers or floating points are numbers that have decimals. In programming, decimal numbers are usually referred to as `float` or `double`. Examples of decimal numbers include 1.5, 2.3, 3.14, and so on. To create a decimal number, you can use code like the following + +:::tabs +== Javascript +```js +let myDecimal = 3.14; +``` +== Kotlin +```kt +val myDecimal: Float = 3.14F +``` +We can also use `double` for decimal numbers that have more digits after the decimal point (up to 15 digits). Here's an example: +```kt +val myDecimal: Double = 3.141592653589793f +``` +== C++ +```cpp +float myDecimal = 3.14f; +``` +We can also use `double` for decimal numbers that have more digits after the decimal point (up to 15 digits). Here's an example: +```cpp +double myDecimal = 3.141592653589793F; +``` +== Python +```python +myDecimal = 3.14 +``` +::: + + +## Fractional Numbers + +Fractional numbers are numbers that have a numerator and a denominator. In programming, fractional numbers are usually referred to as `fraction`. Examples of fractional numbers include 1/2, 3/4, 5/6, and so on. Unfortunately, programming does not have a data type for fractional numbers. They are simply computed, resulting in a decimal number. An example of its use is as follows: + +:::tabs +== Javascript +```js +let myFraction = 1/2; +``` +== Kotlin +```kt +val myFraction = 1/2 // Automatically converted to float +``` +== C++ +```cpp +float myFraction = 1/2; +``` +== Python +```python +myFraction = 1/2 +``` +::: + +> [!WARNING] Caution when performing operations with fractional and decimal numbers +> In many programming languages, including JavaScript, there is something called `floating point error`, which can cause calculation results for decimal numbers to be inaccurate. This happens because decimal numbers cannot always be precisely represented in binary format. +> +> For example, when we add 0.1 and 0.2 in JavaScript, the result is not 0.3, but rather 0.30000000000000004. This is due to the limitations of decimal number representation in computers. +> +> To avoid this issue, it is recommended to limit the precision of calculation results by rounding to the desired number of decimal places (for instance, using `toFixed()` or `Math.round()`. +> +> You can also use libraries like BigNumber or others. + +What about **mixed fractions**? In mathematics, there's something like $1\frac{1}{2}$, and you can do it in programming too. You can use `float` or `double` for mixed fractions. An example of its use is as follows: +:::tabs +== Javascript +```js +let mixedFraction = 1 + 1/2; +``` +== Kotlin +```kt +val mixedFraction: Double = 1 + 1/2 +``` +== C++ +```cpp +double mixedFraction = 1 + 1/2; +``` +== Python +```python +mixedFraction = 1 + 1/2 +``` +::: + +Why addition? Because mixed fractions can actually be converted to regular decimal numbers. For example, $1\frac{1}{2}$ can be converted to $1 + \frac{1}{2}$, which is equal to $1.5$. diff --git a/docs/en/arithmetic/operation-on-number.md b/docs/en/arithmetic/operation-on-number.md new file mode 100644 index 0000000..23260d7 --- /dev/null +++ b/docs/en/arithmetic/operation-on-number.md @@ -0,0 +1,236 @@ +--- +title: Operations on Number +description: Examples of using mathematical operations on numbers in programming +--- + +# Operation on Numbers + +Number operations or the processes of manipulating certain numeric values ​​using mathematical techniques such as addition, subtraction, multiplication, division, and more. In programming we cannot be separated from what is called number operations because the computer itself runs based on number operations. Here we will discuss number operations that are often used in programming. + +## Basic Operation + +In programming, we can perform various mathematical operations with numbers. There are addition, subtraction, multiplication, and division. Unlike regular mathematics that uses the symbols `+`, `-`, `*`, and `/`, in programming we use different symbols. An example of its use is as follows: + +:::tabs +== Javascript +```js +let a = 10; +let b = 5; +let additionResult = a + b; // 15 +let subtractionResult = a - b; // 5 +let multiplicationResult = a * b; // 50 +let divisionResult = a / b; // 2 +``` +== Kotlin +```kt +val a = 10 +val b = 5 +val additionResult = a + b // 15 +val subtractionResult = a - b // 5 +val multiplicationResult = a * b // 50 +val divisionResult = a / b // 2 +``` +== C++ +```cpp +int a = 10; +int b = 5; +int additionResult = a + b; // 15 +int subtractionResult = a - b; // 5 +int multiplicationResult = a * b; // 50 +int divisionResult = a / b; // 2 +``` +== Python +```python +a = 10 +b = 5 +additionResult = a + b # 15 +subtractionResult = a - b # 5 +multiplicationResult = a * b # 50 +divisionResult = a / b # 2 +``` +::: + +Above we use `/` for division and `*` for multiplication. This is because in programming, we cannot use mathematical symbols `÷` and `×` like the usual especially `.` because programming languages ​​generally follow ASCII rules that only support basic characters, so special mathematical symbols such as `÷` and `×` are not available. Instead, programming uses `*` as the replacement for multiplication and `/` as the replacement for division so that the code can run properly. + +> [!NOTE] +> Try checking your laptop or PC keyboard, is there `÷` and `×` symbols? (not this x). Most of the time, they don't exist, and that's one of the main reasons why programming doesn't use those symbols. :grin: + +## Exponentiation (Powers) + +Exponentiation is a mathematical operation used to multiply a number by itself $n$ times. In programming, you can use the `**` operator or the `pow()` to calculate powers. Here's an example: +:::tabs +== Javascript +```js +let power = 2 ** 3; // 8 +let power2 = Math.pow(2, 3); // 8 +``` +== Kotlin +```kt +val power = 2.0.pow(3) // 8.0 +val power2 = Math.pow(2.0, 3.0) // 8.0 +``` +== C++ +```cpp +#include +#include + +int main() { + double power = pow(2, 3); // 8 + double power2 = pow(2.0, 3.0); // 8 + return 0; +} +``` +== Python +```python +power = 2 ** 3 # 8 +power2 = pow(2, 3) # 8 +``` +::: + +`pow()` usually takes two parameters, where the first parameter is the base and the second parameter is the exponent. So to calculate $2^3$, we can write it as `pow(2, 3)`. + +## Roots + +Most programming languages have a function for calculating roots. In JavaScript, we can use the `Math.sqrt()` (*Square Root*) function for square roots. Here's an example: + +:::tabs +== Javascript +```js +let root = Math.sqrt(16); // 4 +``` + +== Kotlin +In Kotlin, we can use the `Math.sqrt()` function. Here's an example: +```kt +val root = Math.sqrt(16.0) // 4.0 +``` + +== C++ +In C++, we can use the `sqrt()` function from `cmath` library. Here's an example: +```cpp +#include +#include + +int main() { + double root = sqrt(16); // 4 + std::cout << root << std::endl; + return 0; +} +``` + +== Python +In Python, we can use the `sqrt()` function from `math` library. Here's an example: +```python +import math +root = math.sqrt(16) # 4.0 +``` +::: + +But there's a problem, if we want to calculate roots that are more than 2, like $\sqrt[3]{8}$ or $\sqrt[4]{16}$, Well, in this case, we can just raise the number to the power of $1/n$ where $n$ is the root we want. Here's an example: + +:::tabs +== Javascript +```js +let cubeRoot = Math.pow(8, 1/3); // 2 +let fourthRoot = Math.pow(16, 1/4); // 2 +``` +== Kotlin +```kt +val cubeRoot = Math.pow(8.0, 1.0/3.0) // 2.0 +val fourthRoot = Math.pow(16.0, 1.0/4.0) // 2.0 +``` +== C++ +```cpp +#include +#include + +int main() { + double cubeRoot = pow(8, 1.0/3); // 2 + double fourthRoot = pow(16, 1.0/4); // 2 + std::cout << cubeRoot << std::endl; + std::cout << fourthRoot << std::endl; + return 0; +} +``` +== Python +```python +cubeRoot = pow(8, 1/3) # 2.0 +fourthRoot = pow(16, 1/4) # 2.0 +``` +::: + +This can happen because any number that has an exponent of $1/n$ will produce the root of the number. So if we want to calculate $\sqrt[3]{8}$ we can write it as `pow(8, 1/3)`. + +## Modulus + +The modulus (remainder) operation calculates the remainder of division between two numbers. For example, if you divide 10 by 3, the remainder result is 1. In programming, you can use the `%` operator to calculate the modulus. + +This operation is particularly useful for checking if a number is even, odd, or follows a specific pattern. Here's an example: + +:::tabs +== Javascript +```js +let modulusResult = 10 % 3; // 1 +``` +== Kotlin +```kt +val modulusResult = 10 % 3 // 1 +``` +== C++ +```cpp +int modulusResult = 10 % 3; // 1 +``` +== Python +```python +modulusResult = 10 % 3 # 1 +``` +::: + +## Order of Operations + +In math, there’s a rule called the order of operations, which dictates the order in which calculations are performed. This also applies to programming and follows the same order as in standard math. It’s called PEMDAS (Parentheses, Exponents, Multiplication and Division, Addition and Subtraction) so the order is as followings + +1. Parentheses $()$ +2. Exponents $x^y$ and Roots $\sqrt{x}$ +3. Multiplication $x \times y$, Division $x \div y$ and Modulus $x \% y$ +4. Addition $x + y$ and Subtraction $x - y$ + +For example, if we want to calculate $6 + 3 * (2^3 + \sqrt{16})$: + +1. **Parentheses**: Focus on the expression inside the parentheses $2^3 + \sqrt{16}$. +3. **Exponents (powers)**: Calculate $2^3$. +$$2^3 = 8$$ +5. **Roots**: Calculate $\sqrt{16}$. +$$\sqrt{16} = 4$$ +7. **Addition inside parentheses**: Now, solve the operation inside parentheses $2^3 + \sqrt{16}$. +$$8 + 4 = 12$$ +9. **Multiplication**: Proceed to the operation outside the brackets, which is $3 \times (2^3 + \sqrt{16})$. +$$3 \times 12 = 36$$ +11. **Final addition**: Finally, add $6 + 36$. +$$6 + 36 = 42$$ +So, the final result is **42**. + +In programming, the order of operations is handled by the language, so you don't need to worry about the wrong order of operations. You just need to be careful with the formula you are going to use. If we put the formula into the code, it will look like this. + +:::tabs +== Javascript +```js +let result = 6 + 3 * (2 ** 3 + Math.sqrt(16)); // 42 +``` +== Kotlin +```kt +val result = 6 + 3 * (2.0.pow(3) + Math.sqrt(16.0)) // 42.0 +``` + +== C++ +```cpp +int result = 6 + 3 * (pow(2, 3) + sqrt(16)); // 42 +``` +== Python +```python +import math +result = 6 + 3 * (pow(2,3) + math.sqrt(16)) # 42.0 +``` +::: + +## diff --git a/docs/en/arithmetic/percent.md b/docs/en/arithmetic/percent.md new file mode 100644 index 0000000..81e8290 --- /dev/null +++ b/docs/en/arithmetic/percent.md @@ -0,0 +1,113 @@ +# Percentage + +Have you ever received a discount when shopping? Usually, if you don't cross it out, you use a percentage sign ($\%$). Well, this percentage is how we measure how big or small a value is compared to its original value. + +For example, you buy clothes for $\$10$ but you get a $20\%$ discount, that means you can buy the clothes for $\$8$. + +How to calculate percentage vakue is very easy, we can use the formula: +$$ percentage\;value = \frac{original\;value}{100} \times percentage $$ + +So if we want to calculate $20\%$ from $\$10$ we can write it as: +$$ percentage\;value = \frac{10}{100} \times 20\% = 2 $$ + +because divided by $100$, we can subtract two zeros from $10$ which becomes $0.1$ and multiply it by $20$ to get $2$. + +If we convert it to code, we can write it like this: +:::tabs +== Javascript +```js +let price = 10; +let discount = 20; +let percentageValue = (price / 100) * discount; // 2 +``` +== Kotlin +```kt +val price = 10 +val discount = 20 +val percentageValue = (price / 100) * discount // 2 +``` +== C++ +```cpp +int price = 10; +int discount = 20; +int percentageValue = (price / 100) * discount; // 2 +``` +== Python +```python +price = 10 +discount = 20 +percentageValue = (price / 100) * discount # 2.0 +``` +::: + +## Finding True Value + +If previously we calculated the percentage of the original value, now we will find the original value of the percentage value. The method is simply to reverse the formula so: +$$ original\;value = \frac{percentage\;value}{percentage} \times 100 $$ + +For example, we have a percentage value of $2$ and we want to find the original value, we can write: +$$ original\;value = \frac{2}{20\%} \times 100 = 10 $$ + +If we convert it to code, we can write it like this: +:::tabs +== Javascript +```js +let percentageValue = 2; +let discount = 20; +let price = (percentageValue / discount) * 100; // 10 +``` +== Kotlin +```kt +val percentageValue = 2 +val discount = 20 +val price = (percentageValue / discount) * 100 // 10 +``` +== C++ +```cpp +int percentageValue = 2; +int discount = 20; +int price = (percentageValue / discount) * 100; // 10 +``` +== Python +```python +percentageValue = 2 +discount = 20 +price = (percentageValue / discount) * 100 # 10.0 + +``` +::: + +## Finding Percentage + +If previously we calculated the percentage of the original value, now we will find the percentage value of the original value. We change the formula to: +$$ percentage = \frac{original\;value}{percentage\;value} \times 100 $$ +For example, we have an original value of $10$ and we want to find the percentage, we can write: +$$ percentage = \frac{2}{10} \times 100 = 20\% $$ + +If we convert it to code, we can write it like this: +:::tabs +== Javascript +```js +let price = 10; +let discount = 2; +let percentage = (discount / price) * 100; // 20 +``` +== Kotlin +```kt +val price = 10 +val discount = 2 +val percentage = (discount / price) * 100 // 20 +``` +== C++ +```cpp +int price = 10; +int discount = 2; +int percentage = (discount / price) * 100; // 20 +``` +== Python +```python +harga = 10 +discount = 2 +percentage = (discount / price) * 100 # 20.0 +``` +::: diff --git a/docs/en/guide/index.md b/docs/en/guide/index.md new file mode 100644 index 0000000..6aacbaf --- /dev/null +++ b/docs/en/guide/index.md @@ -0,0 +1,39 @@ +# Learning Guide + +Before you begin, there are a few important things you need to know. **Math W Code** is a place to learn and share about mathematics with the help of programming languages. Here, you can learn while also contributing to the development of mathematical knowledge through code! + +## Requirements + +Our focus is on how mathematical concepts are applied in programming. Therefore, we will not discuss things like how to install a code editor, write basic code, and so on, however we will cover some basic programming concepts. + +So, before you start, we hope you already understand the basic of programming, you don't need to be very good at it though. But it's important that you can understand the codes we will discuss. + +## Programming Languages + +In this site, we will use various programming languages to explain mathematical concepts. Some of the languages ​​we will use are: + +
+
+ Javascript +
+
+ C++ +
+
+ Kotlin +
+
+ Python +
+
+ +Each language has its own unique way of handling mathematics. So, get ready to explore many new things on this learning journey! + +In some materials, the programming language mentioned may not be available. + +Don’t worry, you can still follow the concepts taught in other languages that are available. The concepts aren't too different, after all. The key is to focus on the implementation, okay! + +> [!NOTE] +> In some materials, the programming language mentioned may not be available. +> +> Don’t worry, you can still follow the concepts taught in other languages that are available. The concepts aren't too different, after all. The key is to focus on the implementation, okay! diff --git a/docs/index.md b/docs/en/index.md similarity index 53% rename from docs/index.md rename to docs/en/index.md index 315512e..54af33c 100644 --- a/docs/index.md +++ b/docs/en/index.md @@ -4,39 +4,39 @@ layout: home hero: name: "Math W Code" - text: "Belajar matematika dengan barisan kode" - tagline: Matematika dengan pendekatan yang berbeda + text: "Learn mathematics with lines of code" + tagline: Mathematics with a different approach image: src: /icon.png alt: Math W Code Logo actions: - theme: brand - text: Belajar Sekarang - link: /guide + text: Learn Now + link: /en/guide/ - theme: alt - text: Beri Kontribusi + text: Contribute link: https://github.com/xirf/mathwithcode features: - icon: 🔢 - title: Arimatika - details: Bilangan, Operasi, Faktor, Kelipatan dan sebagainya - link: /arithmetic/numbers - linkText: Pelajari + title: Arithmetic + details: Numbers, Operations, Factors, Multiples and others + link: /en/arithmetic/numbers/ + linkText: Learn - icon: 📐 - title: Aljabar - details: Polinomial, Persamaan, Matriks, Determinan dan sebagainya - link: /algebra/function - linkText: Pelajari + title: Algebra + details: Polynomials, Equations, Matrices, Determinants and others + link: /en/algebra/function/en + linkText: Learn - icon: 📈 - title: Aljabar Linear - details: Vektor, Ruang Vektor, Orthogonalitas dan sebagainya - link: /linear-algebra/linear-transformation - linkText: Pelajari + title: Linear Algebra + details: Vectors, Vector Spaces, Orthogonality and others + link: /en/linear-algebra/linear-transformation + linkText: Learn - icon: 📊 - title: Statistika - details: Data, Distribusi, Regresi, Uji Hipotesis dan sebagainya - link: /statistics/measures-concentration-dispersion - linkText: Pelajari + title: Statistics + details: Data, Distribution, Regression, Hypothesis Testing and others + link: /en/statistics/measures-concentration-dispersion + linkText: Learn ---