├── Books └── draft-diktat-struktur-data-2008.pdf ├── Codes ├── Algorithm │ ├── brute-force │ │ └── c++ │ │ │ └── cases │ │ │ ├── bubble-sort.cpp │ │ │ ├── closest-pair.cpp │ │ │ ├── factorization.cpp │ │ │ ├── matrix-multiplication.cpp │ │ │ ├── min-max.cpp │ │ │ ├── polynom-value.cpp │ │ │ ├── primality-testing.cpp │ │ │ ├── sequential-search.cpp │ │ │ └── string-matching.cpp │ ├── divide-and-conquer │ │ └── c++ │ │ │ └── cases │ │ │ ├── 3-way-quick-sort.cpp │ │ │ ├── binary-search.cpp │ │ │ ├── counting-inversions.cpp │ │ │ ├── fibonacci-sequence.cpp │ │ │ ├── interpolation-search.cpp │ │ │ ├── merge-sort.cpp │ │ │ ├── min-max.cpp │ │ │ ├── modular-exponentiation.cpp │ │ │ ├── power.cpp │ │ │ └── quick-sort.cpp │ ├── dynamic-programming │ │ └── c++ │ │ │ ├── cases │ │ │ ├── bell-number.cpp │ │ │ ├── binomial-coefficient.cpp │ │ │ ├── catalan-number.cpp │ │ │ ├── distinct-way-to-climb-stair.cpp │ │ │ ├── fibonacci-sequence.cpp │ │ │ ├── permutatioin-coefficient.cpp │ │ │ ├── super-ugly-numbers.cpp │ │ │ └── ugly-numbers.cpp │ │ │ ├── dynamic-programming-1.cpp │ │ │ └── dynamic-programming-2.cpp │ ├── greedy │ │ └── c++ │ │ │ ├── cases │ │ │ ├── activity-selection.cpp │ │ │ ├── coin-change.cpp │ │ │ ├── egyptian-fraction.cpp │ │ │ ├── fractional-knapsack.cpp │ │ │ ├── integer-knapsack.cpp │ │ │ ├── job-sequencing-loss-minimization.cpp │ │ │ ├── job-sequencing.cpp │ │ │ └── minimum-queue-time.cpp │ │ │ └── greedy.cpp │ ├── mathematic │ │ └── c++ │ │ │ └── cases │ │ │ ├── bits │ │ │ ├── arithmetic.cpp │ │ │ ├── copy.cpp │ │ │ ├── manipulation.cpp │ │ │ ├── swap.cpp │ │ │ └── testing.cpp │ │ │ ├── geometry │ │ │ ├── angle-between-vectors.cpp │ │ │ ├── closest-pair.cpp │ │ │ ├── colinear-points.cpp │ │ │ └── line-line-intersection.cpp │ │ │ └── numbers │ │ │ ├── gcd.cpp │ │ │ ├── lcm.cpp │ │ │ ├── number-type │ │ │ ├── achilles-number.cpp │ │ │ ├── buzz-number.cpp │ │ │ ├── duck-number.cpp │ │ │ ├── emirp-number.cpp │ │ │ ├── euclid-number.cpp │ │ │ ├── fibonacci-number.cpp │ │ │ ├── flavius-number.cpp │ │ │ ├── krishnamurthy-number.cpp │ │ │ ├── mystery-number.cpp │ │ │ ├── non-hypotenuse-number.cpp │ │ │ ├── palindrome-number.cpp │ │ │ ├── pentagonal-number.cpp │ │ │ ├── perfect-number.cpp │ │ │ ├── perfect-power-number.cpp │ │ │ ├── perfect │ │ │ │ ├── k-perfect-number.cpp │ │ │ │ └── triperfect-number.cpp │ │ │ ├── plus-perfect-number.cpp │ │ │ ├── powerful-number.cpp │ │ │ ├── prime │ │ │ │ ├── circular-prime-number.cpp │ │ │ │ ├── full-prime-number.cpp │ │ │ │ ├── pythagorean-prime-number.cpp │ │ │ │ ├── quartan-prime-number.cpp │ │ │ │ ├── semi-prime-number.cpp │ │ │ │ └── strong-prime-number.cpp │ │ │ ├── proth-number.cpp │ │ │ ├── trojan-number.cpp │ │ │ ├── ugly-number.cpp │ │ │ └── unusual-number.cpp │ │ │ ├── primality-testing │ │ │ ├── fermat-little-theorem.cpp │ │ │ ├── lucas-primality-test.cpp │ │ │ └── naive-primality-test.cpp │ │ │ ├── prime-factors.cpp │ │ │ ├── prime-generator │ │ │ ├── sieve-of-atkin.cpp │ │ │ ├── sieve-of-eratosthenes.cpp │ │ │ └── sieve-of-sundaram.cpp │ │ │ └── root-simplification.cpp │ ├── searching │ │ └── c++ │ │ │ ├── cases │ │ │ ├── binary-search.cpp │ │ │ ├── exponential-search.cpp │ │ │ ├── interpolation-search.cpp │ │ │ ├── jump-search.cpp │ │ │ ├── sequential-search.cpp │ │ │ └── ternary-search.cpp │ │ │ └── searching.cpp │ ├── sorting │ │ └── c++ │ │ │ ├── cases │ │ │ ├── bubble-sort.cpp │ │ │ ├── comb-sort.cpp │ │ │ ├── counting-sort.cpp │ │ │ ├── cycle-sort.cpp │ │ │ ├── exchange-sort.cpp │ │ │ ├── heap-sort.cpp │ │ │ ├── insertion-sort.cpp │ │ │ ├── merge-sort.cpp │ │ │ ├── quick-sort.cpp │ │ │ ├── radix-sort.cpp │ │ │ ├── selection-sort.cpp │ │ │ └── shell-sort.cpp │ │ │ └── sorting.cpp │ └── strings │ │ └── c++ │ │ └── cases │ │ └── pattern-matching │ │ ├── boyer-moore.cpp │ │ ├── finite-automata.cpp │ │ ├── knuth-morris-pratt.cpp │ │ ├── naive-string-matching.cpp │ │ ├── rabin-karp.cpp │ │ └── z-array.cpp ├── Data-Structure │ ├── Array │ │ └── README.md │ ├── Graph │ │ └── README.md │ ├── List │ │ ├── Doubly-Linked-List │ │ │ ├── README.md │ │ │ └── c │ │ │ │ ├── circular.c │ │ │ │ ├── head-tail.c │ │ │ │ └── head.c │ │ ├── README.md │ │ ├── Singly-Linked-List │ │ │ ├── README.md │ │ │ └── c │ │ │ │ ├── circular.c │ │ │ │ ├── head-tail.c │ │ │ │ ├── head.c │ │ │ │ ├── self-sentinel.c │ │ │ │ ├── self.c │ │ │ │ ├── sentinel-both.c │ │ │ │ ├── sentinel-first.c │ │ │ │ └── sentinel-last.c │ │ └── Xor-Linked-List │ │ │ ├── README.md │ │ │ └── c │ │ │ └── head.c │ ├── Queue │ │ └── c │ │ │ ├── circular-array.c │ │ │ └── list-head-tail.c │ ├── README.md │ ├── Stack │ │ ├── array.c │ │ └── linked-list.c │ └── Tree │ │ └── README.md ├── Design-Pattern │ ├── Behavioral │ │ ├── Chain-of-Responsibility │ │ │ └── c++ │ │ │ │ ├── cases │ │ │ │ ├── logger.cpp │ │ │ │ └── purchase.cpp │ │ │ │ ├── chain-1.cpp │ │ │ │ └── chain-2.cpp │ │ ├── Command │ │ │ └── c++ │ │ │ │ ├── cases │ │ │ │ └── light.cpp │ │ │ │ └── command-1.cpp │ │ ├── Interpreter │ │ │ └── c++ │ │ │ │ ├── cases │ │ │ │ └── rpn.cpp │ │ │ │ └── interpreter-1.cpp │ │ ├── Iterator │ │ │ └── c++ │ │ │ │ ├── iterator-1.cpp │ │ │ │ └── iterator-2.cpp │ │ ├── Mediator │ │ │ └── c++ │ │ │ │ ├── mediator-1.cpp │ │ │ │ └── mediator-2.cpp.wip │ │ ├── Memento │ │ │ └── c++ │ │ │ │ ├── memento-1.cpp │ │ │ │ └── memento-2.cpp │ │ ├── Observer │ │ │ └── c++ │ │ │ │ └── observer-1.cpp │ │ ├── README.md │ │ ├── State │ │ │ └── c++ │ │ │ │ ├── cases │ │ │ │ └── fighter.cpp.wip │ │ │ │ ├── state-1.cpp │ │ │ │ └── state-2.cpp │ │ ├── Strategy │ │ │ └── c++ │ │ │ │ └── strategy-1.cpp │ │ ├── Template-Method │ │ │ └── c++ │ │ │ │ └── template-1.cpp │ │ └── Visitor │ │ │ └── c++ │ │ │ └── visitor-1.cpp │ ├── Creational │ │ ├── Abstract-Factory │ │ │ └── c++ │ │ │ │ ├── abstract-factory-1.cpp │ │ │ │ ├── abstract-factory-1b.cpp │ │ │ │ └── cases │ │ │ │ ├── hot-drink.cpp.wip │ │ │ │ ├── maze-game.cpp.wip │ │ │ │ └── window.cpp │ │ ├── Builder │ │ │ └── c++ │ │ │ │ ├── builder-1.cpp │ │ │ │ ├── builder-2.cpp │ │ │ │ └── cases │ │ │ │ ├── car-builder.cpp │ │ │ │ ├── dist-package.cpp │ │ │ │ └── html-builder.cpp │ │ ├── Factory-Method │ │ │ └── c++ │ │ │ │ ├── cases │ │ │ │ ├── figure-manipulator.cpp.wip │ │ │ │ ├── maze-game.cpp.wip │ │ │ │ ├── people.cpp │ │ │ │ ├── transport-company.cpp │ │ │ │ └── warung-soto.cpp │ │ │ │ ├── factory-method-1.cpp │ │ │ │ ├── factory-method-1b.cpp │ │ │ │ ├── factory-method-2.cpp │ │ │ │ ├── factory-method-3.cpp │ │ │ │ └── factory-method-4.cpp │ │ ├── Multiton │ │ │ └── c++ │ │ │ │ ├── multiton-1.cpp │ │ │ │ └── multiton-2.cpp │ │ ├── Named-Factory │ │ │ └── c++ │ │ │ │ ├── cases │ │ │ │ ├── color.cpp │ │ │ │ └── point.cpp │ │ │ │ └── named-factory-1.cpp │ │ ├── ObjectPool │ │ │ └── c++ │ │ │ │ └── object-pool-1.cpp │ │ ├── Prototype │ │ │ └── c++ │ │ │ │ ├── cases │ │ │ │ ├── monster.cpp.wip │ │ │ │ ├── shape.cpp │ │ │ │ └── vehicle-record.cpp │ │ │ │ ├── prototype-1.cpp │ │ │ │ └── prototype-1b.cpp │ │ ├── README.md │ │ └── Singleton │ │ │ └── c++ │ │ │ ├── cases │ │ │ └── file-repository.cpp │ │ │ ├── singleton-1.cpp │ │ │ ├── singleton-2.cpp │ │ │ ├── singleton-3.cpp │ │ │ └── singleton-4.cpp │ └── Structural │ │ ├── Adapter │ │ └── c++ │ │ │ ├── adapter-1.cpp │ │ │ ├── adapter-1b.cpp │ │ │ └── adapter-2.cpp │ │ ├── Bridge │ │ └── c++ │ │ │ ├── bridge-1.cpp │ │ │ └── cases │ │ │ └── drawing-api.cpp │ │ ├── Composite │ │ └── c++ │ │ │ └── composite-1.cpp │ │ ├── Decorator │ │ └── c++ │ │ │ ├── cases │ │ │ ├── messenger.cpp │ │ │ └── shape.cpp │ │ │ └── decorator-1.cpp │ │ ├── Facade │ │ └── c++ │ │ │ ├── cases │ │ │ └── facility.cpp │ │ │ └── facade-1.cpp │ │ ├── Flyweight │ │ └── c++ │ │ │ └── flyweight-1.cpp │ │ ├── Proxy │ │ └── c++ │ │ │ └── proxy-1.cpp │ │ └── README.md └── Language │ └── c++ │ └── basic │ ├── 0.skeleton.cpp │ ├── 1.declare.cpp │ ├── 10.switch.cpp │ ├── 11.for.cpp │ ├── 12.while.cpp │ ├── 13.do-while.cpp │ ├── 14.function.cpp │ ├── 15.string.cpp │ ├── 2.array.cpp │ ├── 3.struct.cpp │ ├── 4.enum.cpp │ ├── 5.ptr.cpp │ ├── 6.operators.cpp │ ├── 7.if.cpp │ ├── 8.if-else.cpp │ └── 9.if2.cpp ├── LICENSE ├── README.EN.md ├── README.md └── References ├── Algorithm ├── backtrack.md ├── branch-and-bound.md ├── breadth-first-search.md ├── brute-force.md ├── depth-first-search.md ├── divide-and-conquer.md ├── dynamic-programming.md └── greedy.md ├── Architecture ├── CQRS.md ├── _imgs_ │ ├── cqrs-command.png │ ├── cqrs-query.png │ ├── hexagonal-2.png │ ├── hexagonal.png │ ├── microkernel.png │ ├── microservice.png │ └── onion.png ├── event-sourcing.md ├── hexagonal.md ├── layered.md ├── microkernel.md ├── microservice.md ├── onion.md └── serverless.md ├── Data-Structure ├── List │ ├── README.md │ └── _imgs_ │ │ ├── component.png │ │ ├── list-append.png │ │ ├── list-delete.png │ │ ├── list-insert.png │ │ ├── list-prepend.png │ │ └── list.png └── README.md ├── Design-Pattern ├── Behavioral │ ├── chain-of-responsibility.md │ ├── command.md │ ├── interpreter.md │ ├── iterator.md │ ├── mediator.md │ ├── memento.md │ ├── observer.md │ ├── state.md │ ├── strategy.md │ ├── template-method.md │ └── visitor.md ├── Creational │ ├── abstract-factory.md │ ├── builder.md │ ├── factory-method.md │ ├── multiton.md │ ├── named-constructor.md │ ├── object-pool.md │ ├── prototype.md │ └── singleton.md ├── README.md ├── Structural │ ├── adapter.md │ ├── bridge.md │ ├── composite.md │ ├── decorator.md │ ├── facade.md │ ├── flyweight.md │ └── proxy.md ├── _imgs_ │ └── periodic_table.png └── general-techniques.md └── README.md /Books/draft-diktat-struktur-data-2008.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/Books/draft-diktat-struktur-data-2008.pdf -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/bubble-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Bubble Sort 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ bubble-sort.cpp -o bubble-sort 9 | 10 | [gcc] 11 | $ g++ bubble-sort.cpp -o bubble-sort 12 | 13 | [msvc] 14 | $ cl bubble-sort.cpp 15 | 16 | Run: 17 | $ bubble-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Bubble Sort. 23 | 24 | Langkah: 25 | - scan rentang array 26 | - pindahkan elemen besar menuju ujung. 27 | */ 28 | 29 | // ====================================================================================== 30 | 31 | template 32 | void swap(T & a, T & b) 33 | { 34 | T t = b; 35 | b = a; 36 | a = t; 37 | } 38 | 39 | // ====================================================================================== 40 | 41 | /** Recursive Solution **/ 42 | 43 | template 44 | void algorithm(T arr[], size_t size) 45 | { 46 | // base case adalah 1 elemen 47 | if (size > 1) 48 | { 49 | /* 50 | Melakukan satu pass Bubble Sort. 51 | Setelah ini, elemen terbesar akan dipindahkan ke akhir. 52 | */ 53 | for (size_t i = 0; i < size - 1; i++) 54 | if (arr[i] > arr[i + 1]) 55 | swap(arr[i], arr[i + 1]); 56 | 57 | // lakukan rekursi ke rentang array tersisa 58 | algorithm(arr, size - 1); 59 | } 60 | } 61 | 62 | // ====================================================================================== 63 | 64 | /** Iterative Solution **/ 65 | 66 | template 67 | void algorithm(T arr[], size_t size) 68 | { 69 | for (size_t i = 0; i < size; i++) 70 | for (size_t j = 0; j < size - i - 1; j++) 71 | if (arr[j] > arr[j + 1]) 72 | swap(arr[j], arr[j + 1]); 73 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/closest-pair.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Closest Pair 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ closest-pair.cpp -o closest-pair 9 | 10 | [gcc] 11 | $ g++ closest-pair.cpp -o closest-pair 12 | 13 | [msvc] 14 | $ cl closest-pair.cpp 15 | 16 | Run: 17 | $ closest-pair 18 | */ 19 | 20 | 21 | /* 22 | Masalah: 23 | Diberikan n buah titik. Tentukan dua buah titik yang memiliki jarak terdekat satu sama 24 | lain. 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | struct point_t 30 | { 31 | double x, y; 32 | }; 33 | 34 | double distance(point_t p1, point_t p2) 35 | { 36 | double x = p1.x - p2.x; 37 | double y = p1.y - p2.y; 38 | 39 | return sqrt(x*x + y*y); 40 | } 41 | 42 | // ====================================================================================== 43 | 44 | void algorithm(point_t arr[], size_t size, size_t & idx1, size_t & idx2) 45 | { 46 | double d, dmin = 0; 47 | size_t i, j; 48 | 49 | for (i = 0; i < size; i++) 50 | { 51 | for (j = i + 1; j < size; j++) 52 | { 53 | // periksa jarak kedua titik dalam 2D 54 | d = distance(arr[i], arr[j]); 55 | 56 | if (d < dmin || dmin == 0) 57 | { 58 | dmin = d; 59 | idx1 = i; 60 | idx2 = j; 61 | } 62 | } 63 | } 64 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/factorization.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Factorization 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ factorization.cpp -o factorization 9 | 10 | [gcc] 11 | $ g++ factorization.cpp -o factorization 12 | 13 | [msvc] 14 | $ cl factorization.cpp 15 | 16 | Run: 17 | $ factorization 18 | */ 19 | #include 20 | 21 | /* 22 | Masalah: 23 | Diberikan sebuah bilangan bulat `n`. Tentukan semua faktor bilangan bulat `n` 24 | dengan nilai selain 1 dan `n` itu sendiri. 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | auto algorithm(int n) 30 | { 31 | std::vector factors; 32 | for (int i = 2; i < n - 1; i++) 33 | { 34 | // factor adalah angka yang habis membagi 35 | if (n % i == 0) 36 | factors.push_back(i); 37 | } 38 | 39 | return factors; 40 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/matrix-multiplication.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Matrix Multiplication 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ matrix-multiplication.cpp -o matrix-multiplication 9 | 10 | [gcc] 11 | $ g++ matrix-multiplication.cpp -o matrix-multiplication 12 | 13 | [msvc] 14 | $ cl matrix-multiplication.cpp 15 | 16 | Run: 17 | $ matrix-multiplication 18 | */ 19 | 20 | // ====================================================================================== 21 | 22 | /* 23 | Melakukan perkalian terhadap matriks dengan dimensi tertentu. 24 | Syarat perkalian matriks: 25 | jumlah kolom M1 sama dengan jumlah baris M2. 26 | 27 | M3 -> m x n 28 | M1 -> m x k 29 | M2 -> k x n 30 | 31 | */ 32 | 33 | template 34 | void algorithm(T M3 [][], T M1[][], T M2[][], size_t m, size_t n) 35 | { 36 | size_t i, j, k; 37 | 38 | for (i = 0; i < m; i++) 39 | { 40 | for (j = i; j < n; j++) 41 | { 42 | M3 [i][j] = 0; 43 | 44 | for (k = 0; k < n; k++) 45 | { 46 | M3 [i][j] = M3 [i][k] + M1 [i][k] * M2 [k][j]; 47 | } 48 | } 49 | } 50 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/min-max.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Min or Max Value 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ min-max.cpp -o min-max 9 | 10 | [gcc] 11 | $ g++ min-max.cpp -o min-max 12 | 13 | [msvc] 14 | $ cl min-max.cpp 15 | 16 | Run: 17 | $ min-max 18 | */ 19 | 20 | /* 21 | Masalah: 22 | Diberikan senarai beranggotakan N buah bilangan bulat. Cari elemen terkecil dan 23 | terbesar di dalam elemen tersebut. 24 | */ 25 | 26 | // ====================================================================================== 27 | 28 | template 29 | void algorithm(T arr[], size_t size, T & min, T & max) 30 | { 31 | T _min, _max; 32 | 33 | _min = _max = arr[0]; 34 | 35 | for (size_t i = 1; i < size; i++) 36 | { 37 | if (arr[i] < _min) 38 | _min = arr[i]; 39 | 40 | if (arr[i] > _max) 41 | _max = arr[i]; 42 | } 43 | 44 | min = _min; 45 | max = _max; 46 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/polynom-value.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Polynom Value 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ polynom-value.cpp -o polynom-value 9 | 10 | [gcc] 11 | $ g++ polynom-value.cpp -o polynom-value 12 | 13 | [msvc] 14 | $ cl polynom-value.cpp 15 | 16 | Run: 17 | $ polynom-value 18 | */ 19 | #include 20 | 21 | 22 | /* 23 | Masalah: 24 | Diberikan sebuah senarai merepresentasikan koefisien polinom. Berapa nilai polinom jika 25 | variabel X disubstitusikan dengan suatu nilai? 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | int algorithm(int coeff[], size_t size, int x) 31 | { 32 | size_t i, j; 33 | int val = coeff[0]; 34 | int pangkat = 1; 35 | 36 | for (i = 1; i < size; i++) 37 | { 38 | pangkat *= x; 39 | val += coeff[i] * pangkat; 40 | } 41 | 42 | return val; 43 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/primality-testing.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Primality Testing 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ primality-testing.cpp -o primality-testing 9 | 10 | [gcc] 11 | $ g++ primality-testing.cpp -o primality-testing 12 | 13 | [msvc] 14 | $ cl primality-testing.cpp 15 | 16 | Run: 17 | $ primality-testing 18 | */ 19 | #include 20 | 21 | 22 | /* 23 | Masalah: 24 | Diberikan sebuah bilangan bulat positif. Ujilah apakah bilangan tersebut merupakan 25 | bilangan prima atau bukan. 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | bool algorithm(int x) 31 | { 32 | if (x < 2) // 1 bukan bilangan prima 33 | return false; 34 | else if (x == 2) // 2 bilangan prima 35 | return true; 36 | else 37 | { 38 | int batas = sqrt(x); 39 | int i; 40 | 41 | for (i = 2; i <= batas; i++) 42 | { 43 | if (x % i == 0) 44 | return false; 45 | } 46 | 47 | return true; 48 | } 49 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/sequential-search.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Sequential Search 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ sequential-search.cpp -o sequential-search 9 | 10 | [gcc] 11 | $ g++ sequential-search.cpp -o sequential-search 12 | 13 | [msvc] 14 | $ cl sequential-search.cpp 15 | 16 | Run: 17 | $ sequential-search 18 | */ 19 | 20 | /* 21 | Masalah: 22 | Diberikan senarai beranggotakan N buah elemen. Tentukan apakah X terdapat 23 | di dalam senarai tersebut. 24 | 25 | Solusi: 26 | - Ambil elemen pertama dari senarai 27 | - Lakukan perbandingan dengan X (nilai yang dicari) 28 | - Jika keduanya bernilai sama, kembalikan index 29 | - Ulangi pencarian untuk elemen berikutnya hingga akhir jika belum ketemu. 30 | - Jika tidak ada elemen yang memenuhi kriteria, kembalikan nilai -1 31 | */ 32 | 33 | // ====================================================================================== 34 | 35 | template 36 | bool algorithm(T arr[], size_t size, T val, size_t & idx) 37 | { 38 | for (size_t i = 0; i < size; i++) 39 | { 40 | if (arr[i] == val) 41 | { 42 | idx = i; 43 | return true; 44 | } 45 | } 46 | 47 | return false; 48 | } -------------------------------------------------------------------------------- /Codes/Algorithm/brute-force/c++/cases/string-matching.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | String Matching 3 | Archive of Reversing.ID 4 | Algorithm (Brute-Force) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ string-matching.cpp -o string-matching 9 | 10 | [gcc] 11 | $ g++ string-matching.cpp -o string-matching 12 | 13 | [msvc] 14 | $ cl string-matching.cpp 15 | 16 | Run: 17 | $ string-matching 18 | */ 19 | 20 | 21 | /* 22 | Masalah: 23 | Diberikan sebuah string Text dengan panjang n karakter serta sebuah string Pattern 24 | dengan panjang m karakter. Tentukan apakah Pattern merupakan substring dari Text. 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | bool algorithm(char text[], size_t n, char pattern[], size_t m) 30 | { 31 | size_t i, j; 32 | 33 | for (i = 0; i < n; i++) 34 | { 35 | // apakah huruf ini sama dengan huruf awalan pattern 36 | if (text[i] == pattern[0]) 37 | { 38 | // cocokkan huruf per huruf 39 | for (j = 1; j < m && (i + j) < n; j++) 40 | { 41 | if (text[i + j] != pattern[j]) 42 | break; 43 | } 44 | 45 | if (j >= m) 46 | return true; 47 | } 48 | } 49 | 50 | return false; 51 | } -------------------------------------------------------------------------------- /Codes/Algorithm/divide-and-conquer/c++/cases/fibonacci-sequence.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Fibonacci Sequence 3 | Archive of Reversing.ID 4 | Algorithm (Dynamic Programming) 5 | 6 | Solusi Memoization dan Tabulation 7 | 8 | Compile: 9 | [clang] 10 | $ clang++ fibonacci-sequence.cpp -o fibonacci-sequence 11 | 12 | [gcc] 13 | $ g++ fibonacci-sequence.cpp -o fibonacci-sequence 14 | 15 | [msvc] 16 | $ cl fibonacci-sequence.cpp 17 | 18 | Run: 19 | $ fibonacci-sequence 20 | */ 21 | 22 | /* 23 | Masalah: 24 | Baris Fibonacci didefinisikan memiliki hubungan rekursif dengan nilai elemen saat ini 25 | merupakan penjumlahan dua elemen sebelumnya. 26 | 27 | fib[0] = 1 28 | fib[1] = 1 29 | fib[n] = fib[n - 1] + fib[n - 2] 30 | 31 | Baris: 32 | 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... 33 | */ 34 | 35 | // ====================================================================================== 36 | 37 | // perkalian 2 matrix F dan M berukuran 2x2 dengan hasil disimpan kembali ke F 38 | void multiply(int F[2][2], int M[2][2]) 39 | { 40 | int w = F[0][0] * M[0][0] + F[0][1] * M[1][0]; 41 | int x = F[0][0] * M[0][1] + F[0][1] * M[1][1]; 42 | int y = F[1][0] * M[0][0] + F[1][1] * M[1][0]; 43 | int z = F[1][0] * M[0][1] + F[1][1] * M[1][1]; 44 | 45 | F[0][0] = w; 46 | F[0][1] = x; 47 | F[1][0] = y; 48 | F[1][1] = z; 49 | } 50 | 51 | /* 52 | menghitung nilai F pangkat n dan hasil disimpan kembali ke F 53 | optimisasi dengan Divide and Conquer pada fungsi power 54 | */ 55 | void power(int F[2][2], int n) 56 | { 57 | if (n == 0 || n == 1) 58 | return; 59 | 60 | int i; 61 | int M[2][2] = {{1, 1}, {1, 0}}; 62 | 63 | power(F, n/2); 64 | multiply(F, F); 65 | 66 | if (n % 2 -- 1) 67 | multiply(F, M); 68 | } 69 | 70 | // ====================================================================================== 71 | 72 | /** Matrix Multiplication **/ 73 | 74 | int algorithm(int idx) 75 | { 76 | int F[2][2] = {{1, 1}, {1, 0}}; 77 | 78 | if (idx == 0) 79 | return 0; 80 | 81 | // melakukan update terhadap F 82 | power(F, idx - 1); 83 | 84 | return F[0][0]; 85 | } -------------------------------------------------------------------------------- /Codes/Algorithm/divide-and-conquer/c++/cases/min-max.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Min or Max Value 3 | Archive of Reversing.ID 4 | Algorithm (Divide and Conquer) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ min-max.cpp -o min-max 9 | 10 | [gcc] 11 | $ g++ min-max.cpp -o min-max 12 | 13 | [msvc] 14 | $ cl min-max.cpp 15 | 16 | Run: 17 | $ min-max 18 | */ 19 | 20 | /* 21 | Masalah: 22 | Diberikan senarai beranggotakan N buah bilangan bulat. Cari elemen terkecil dan 23 | terbesar di dalam elemen tersebut. 24 | */ 25 | 26 | // ====================================================================================== 27 | 28 | template 29 | void algorithm(T arr[], size_t low, size_t high, T & min, T & max) 30 | { 31 | // Conquer 32 | if (low == high) 33 | min = max = arr[low]; 34 | else if (high - low == 1) 35 | { 36 | if (arr[low] < arr[high]) 37 | { 38 | min = arr[low]; 39 | max = arr[high]; 40 | } 41 | else 42 | { 43 | min = arr[high]; 44 | max = arr[low]; 45 | } 46 | } 47 | else 48 | { 49 | T min2, max2; 50 | size_t mid = (low + high) / 2; 51 | 52 | // Divide 53 | algorithm(arr, low, mid, min, max); 54 | algorithm(arr, mid + 1, high, min2, max2); 55 | 56 | // Merge 57 | if (min2 < min) min = min2; 58 | if (max2 > max) max = max2; 59 | } 60 | } 61 | 62 | template 63 | void algorithm(T arr[], size_t N, T & min, T & max) 64 | { 65 | algorithm(arr, 0, N - 1, min, max); 66 | } -------------------------------------------------------------------------------- /Codes/Algorithm/divide-and-conquer/c++/cases/modular-exponentiation.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Modular Exponentiation 3 | Archive of Reversing.ID 4 | Algorithm (Divide and Conquer) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ modular-exponentiation.cpp -o modular-exponentiation 9 | 10 | [gcc] 11 | $ g++ modular-exponentiation.cpp -o modular-exponentiation 12 | 13 | [msvc] 14 | $ cl modular-exponentiation.cpp 15 | 16 | Run: 17 | $ modular-exponentiation 18 | */ 19 | #include 20 | 21 | /* 22 | Problem: 23 | Menghitung nilai perpangkatan suatu nilai dalam modular aritmetik. Perhitungna sisa 24 | bagi didapatkan dengan memanfaatkan sifat: 25 | 26 | (ab) mod p = ((a mod p) * (b mod p)) mod p 27 | 28 | Langkah: 29 | Divide: bagi jadi subproblem berdasarkan jumlah pangkat. 30 | Conquer: lakukan pangkat dua yaitu perkalian antara base dan base 31 | Combine: lakukan perkalian terhadap hasil sebelumnya 32 | */ 33 | 34 | // ====================================================================================== 35 | 36 | /** 37 | * Single-function solve 38 | * Recursive 39 | */ 40 | 41 | uint64_t algorithm(uint64_t base, uint64_t exp, uint64_t mod) 42 | { 43 | if (exp == 0) 44 | return 1; 45 | 46 | uint64_t val = algorithm(base, exp / 2, mod) % mod; 47 | if (exp % 2 == 0) 48 | return (val * val) % mod; 49 | else 50 | return (base * val * val) % mod; 51 | } 52 | 53 | // ====================================================================================== 54 | 55 | /** 56 | * Single-function solve 57 | * Non-Recursive 58 | */ 59 | 60 | uint64_t algorithm(uint64_t base, uint64_t exp, uint64_t mod) 61 | { 62 | uint64_t result = 1; 63 | 64 | base = base % mod; 65 | 66 | while (exp > 0) 67 | { 68 | if (exp & 1) 69 | result = (result * base) % mod; 70 | 71 | exp = exp / 2; 72 | base = (base * base) % mod; 73 | } 74 | 75 | return result; 76 | } -------------------------------------------------------------------------------- /Codes/Algorithm/divide-and-conquer/c++/cases/power.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Power 3 | Archive of Reversing.ID 4 | Algorithm (Divide and Conquer) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ power.cpp -o power 9 | 10 | [gcc] 11 | $ g++ power.cpp -o power 12 | 13 | [msvc] 14 | $ cl power.cpp 15 | 16 | Run: 17 | $ power 18 | */ 19 | #include 20 | 21 | /* 22 | Problem: 23 | Menghitung perpangkatan dengan melakukan perkalian secara rekursif. 24 | 25 | Langkah: 26 | Divide: bagi jadi subproblem berdasarkan jumlah pangkat. 27 | Conquer: lakukan pangkat dua yaitu perkalian antara base dan base 28 | Combine: lakukan perkalian terhadap hasil sebelumnya 29 | */ 30 | 31 | // ====================================================================================== 32 | 33 | /** 34 | * Single-function solve 35 | * Recursive 36 | */ 37 | 38 | uint64_t algorithm(uint64_t base, uint64_t exp) 39 | { 40 | // Divide 41 | if (exp == 0) 42 | return 1; 43 | else if (exp % 2 == 0) 44 | return algorithm(base, exp / 2) * algorithm(base, exp / 2); 45 | else 46 | return base * algorithm(base, exp / 2) * algorithm(base, exp / 2); 47 | } 48 | 49 | // ====================================================================================== 50 | 51 | /** 52 | * Single-function solve 53 | * Non-Recursive 54 | */ 55 | 56 | uint64_t algorithm(uint64_t base, uint64_t exp) 57 | { 58 | uint64_t result = 1; 59 | 60 | while (exp > 0) 61 | { 62 | if (exp & 1) 63 | result = result * base; // conquer + combine 64 | 65 | exp = exp / 2; // divide 66 | base = base * base; // conquer 67 | } 68 | 69 | return result; 70 | } -------------------------------------------------------------------------------- /Codes/Algorithm/dynamic-programming/c++/cases/bell-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Bell Numbers 3 | Archive of Reversing.ID 4 | Algorithm (Dynamic Programming) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ bell-numbers.cpp -o bell-numbers 9 | 10 | [gcc] 11 | $ g++ bell-numbers.cpp -o bell-numbers 12 | 13 | [msvc] 14 | $ cl bell-numbers.cpp 15 | 16 | Run: 17 | $ bell-numbers 18 | */ 19 | 20 | /* 21 | Bell numbers adalah barisan angka natural yang muncul di beberapa permasalahan 22 | menarik bidang pencacahan. 23 | 24 | B(n) = sum S(n, k) 25 | S(n + 1, k) = k * S(n, k) + S(n, k - 1) 26 | 27 | Masalah: 28 | Tentukan suku ke-n dari baris Bell. 29 | */ 30 | 31 | // ====================================================================================== 32 | 33 | /** Iterative Solution -- Tabulation **/ 34 | 35 | size_t algorithm(size_t N) 36 | { 37 | // lookup table 38 | int table[N + 1][N + 1]; 39 | 40 | // setup nilai awal 41 | table[0][0] = 1; 42 | 43 | for (size_t i = 1; i <= N; i++) 44 | { 45 | // secara eksplisit mengisi untuk j = 0 46 | table[i][0] = table[i - 1][i - 1]; 47 | 48 | for (size_t j = 1; j <= i; j++) 49 | table[i][j] = table[i - 1][j - 1] + table[i][j - 1]; 50 | } 51 | 52 | return table[N][0]; 53 | } -------------------------------------------------------------------------------- /Codes/Algorithm/dynamic-programming/c++/cases/permutatioin-coefficient.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Permutation Coefficient 3 | Archive of Reversing.ID 4 | Algorithm (Dynamic Programming) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ permutation-coefficient.cpp -o permutation-coefficient 9 | 10 | [gcc] 11 | $ g++ permutation-coefficient.cpp -o permutation-coefficient 12 | 13 | [msvc] 14 | $ cl permutation-coefficient.cpp 15 | 16 | Run: 17 | $ permutation-coefficient 18 | */ 19 | #include 20 | 21 | /* 22 | Permutation Coefficient didefinisikan sebagai: 23 | 24 | P(n, k) = n! / (n-k)! 25 | 26 | solusi rekursif: 27 | 28 | P(n, k) = P(n - 1, k) + k * P(n - 1, k - 1) 29 | P(n, 0) = 1 30 | 31 | Masalah: 32 | Diberikan bilangan bulat positif n dan k. Tentukan Permutation Coefficient dari C(n, k) 33 | */ 34 | 35 | // ====================================================================================== 36 | 37 | /** Iterative Solution -- Tabulation **/ 38 | 39 | int algorithm(size_t N, size_t K) 40 | { 41 | // lookup table 42 | int table[N + 1][K + 1]; 43 | size_t batas; 44 | 45 | // bangun solusi 46 | for (size_t i = 0; i <= N; i++) 47 | { 48 | batas = std::min(i, K); 49 | for (size_t j = 0; j <= batas; j++) 50 | { 51 | if (j == 0) 52 | table[i][j] = 1; 53 | else 54 | table[i][j] = 55 | table[i - 1][j] + 56 | (j * table[i - 1][j - 1]); 57 | } 58 | } 59 | 60 | return table[N][K]; 61 | } 62 | 63 | // ====================================================================================== 64 | 65 | /** Iterative Solution -- Tabulation with Space Optimization **/ 66 | 67 | /* 68 | Misalkan terdapat array 1 dimensi yang menghitung faktorial N. 69 | Kita dapat menggunakan nilai faktorial tersebut untuk mengaplikasikan P(n, k) = n!/(n-k)! 70 | */ 71 | 72 | int algorithm(size_t N, size_t K) 73 | { 74 | // lookup table 75 | int table[N + 1]; 76 | size_t batas; 77 | 78 | // setup nilai awal 79 | table[0] = 1; 80 | 81 | // bangun solusi 82 | for (size_t i = 1; i <= N; i++) 83 | table[i] = i * table[i - 1]; 84 | 85 | return table[N] / table[N - K]; 86 | } -------------------------------------------------------------------------------- /Codes/Algorithm/dynamic-programming/c++/dynamic-programming-1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Dynamic Programming 3 | Archive of Reversing.ID 4 | Algorithm 5 | 6 | Dynamic Programming dengan pendekatan Memoization. 7 | 8 | 9 | Compile: 10 | [clang] 11 | $ clang++ dynamic-programming.cpp -o dynamic-programming 12 | 13 | [gcc] 14 | $ g++ dynamic-programming.cpp -o dynamic-programming 15 | 16 | [msvc] 17 | $ cl dynamic-programming.cpp 18 | 19 | Run: 20 | $ dynamic-programming 21 | */ 22 | 23 | #define NIL -1 24 | #define MAX 100 25 | 26 | /* 27 | Memoization 28 | Top-down approach. 29 | 30 | Melakukan lookup ke sebuah tabel sebelum komputasi dilakukan dan hanya melakukan 31 | komputasi bila hasil komputasi tidak tercatat. 32 | */ 33 | 34 | // ====================================================================================== 35 | 36 | // Misal nilai komputasi merupakan bilangan bulat 37 | int lookup[MAX]; 38 | 39 | 40 | /* 41 | Inisialisasi lookup tabel dengan NIL atau nilai apapun yang menandai bahwa komputasi 42 | belum dilakukan. 43 | */ 44 | void initialize() 45 | { 46 | size_t i; 47 | 48 | for (i = 0; i < MAX; i++) 49 | lookup[i] = NIL; 50 | } 51 | 52 | 53 | /* 54 | Fungsi rekursif. 55 | */ 56 | int algorithm(int sub) 57 | { 58 | // evaluasi apakah nilai pada subproblem telah dicatat 59 | if (lookup[sub] == NIL) 60 | { 61 | // komputasi 62 | int result = sub; 63 | 64 | // simpan hasil komputasi ke dalam tabel 65 | lookup[sub] = result; 66 | } 67 | 68 | // berikan hasil komputasi 69 | return lookup[sub]; 70 | } -------------------------------------------------------------------------------- /Codes/Algorithm/dynamic-programming/c++/dynamic-programming-2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Dynamic Programming 3 | Archive of Reversing.ID 4 | Algorithm 5 | 6 | Dynamic Programming dengan pendekatan Tabulation. 7 | 8 | 9 | Compile: 10 | [clang] 11 | $ clang++ dynamic-programming.cpp -o dynamic-programming 12 | 13 | [gcc] 14 | $ g++ dynamic-programming.cpp -o dynamic-programming 15 | 16 | [msvc] 17 | $ cl dynamic-programming.cpp 18 | 19 | Run: 20 | $ dynamic-programming 21 | */ 22 | 23 | #define NIL -1 24 | #define MAX 100 25 | 26 | /* 27 | Tabulation 28 | Bottom-up approach. 29 | 30 | Membangun table berisi nilai setiap kemungkinan dan membangun solusi dengan data terakhir 31 | hasil pemrosesan di tabel. 32 | */ 33 | 34 | // ====================================================================================== 35 | 36 | /* 37 | Fungsi iteratif 38 | */ 39 | int algorithm(int size) 40 | { 41 | int table[size + 1]; 42 | 43 | int i; 44 | 45 | // inisialisasi elemen dasar dari tabel. 46 | table[0] = 0; 47 | 48 | /* 49 | iterasi semua kemungkinan subproblem dan catat hasilnya untuk membangun solusi lebih 50 | besar 51 | */ 52 | for (i = 1; i <= size; i++) 53 | { 54 | // komputasi solusi saat ini 55 | int result = compute(table[i - 1], i); 56 | 57 | // simpan nilai hasil komputasi ke tabel 58 | table[i] = result; 59 | } 60 | 61 | // solusi utama merupakanelemen terakhir yang dibangun di tabel 62 | return table[size]; 63 | } -------------------------------------------------------------------------------- /Codes/Algorithm/greedy/c++/cases/coin-change.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Coin Change 3 | Archive of Reversing.ID 4 | Algorithm (Greedy) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ coin-change.cpp -o coin-change 9 | 10 | [gcc] 11 | $ g++ coin-change.cpp -o coin-change 12 | 13 | [msvc] 14 | $ cl coin-change.cpp 15 | 16 | Run: 17 | $ coin-change 18 | */ 19 | #include 20 | #include 21 | 22 | /* 23 | Masalah: 24 | Terdapat sekumpulan uang koin dari berbagai satuan nilai (denomination). Tentukan 25 | jumlah minimum koin yang diperlukan untuk menukar uang dengan nilai V. 26 | 27 | Langkah: 28 | - inisialisasi result sebagai himpunan kosong 29 | - cari denomination terbesar yang bernilai kurang dari V. 30 | - tambahkan denomination ke result dan kurangi V dengan denomination 31 | - jika V bernilai 0, proses berakhir. 32 | sebaliknya, ulangi tahap 2 dan 3 untuk nilai V yang baru. 33 | */ 34 | 35 | // ====================================================================================== 36 | 37 | auto algorithm(int denomination[], size_t size, int val) 38 | { 39 | // menyimpan daftar denomination yang mungkin 40 | std::vector result; 41 | 42 | // urutkan denomination (nilai mata uang) dari terbesar ke terkecil 43 | std::sort(denomination, denomination + size, std::greater()); 44 | 45 | // telusuri seluruh jenis denomination 46 | for (size_t i = 0; i < size; i++) 47 | { 48 | // jumlah koin suatu denomination bisa lebih dari satu 49 | while (val >= denomination[i]) 50 | { 51 | val -= denomination[i]; 52 | result.push_back(denomination[i]); 53 | } 54 | } 55 | 56 | return result; 57 | } -------------------------------------------------------------------------------- /Codes/Algorithm/greedy/c++/cases/job-sequencing-loss-minimization.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Job Sequencing - Loss Minimization 3 | Archive of Reversing.ID 4 | Algorithm (Greedy) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ job-sequencing-loss-minimization.cpp -o job-sequencing-loss-minimization 9 | 10 | [gcc] 11 | $ g++ job-sequencing-loss-minimization.cpp -o job-sequencing-loss-minimization 12 | 13 | [msvc] 14 | $ cl job-sequencing-loss-minimization.cpp 15 | 16 | Run: 17 | $ job-sequencing-loss-minimization 18 | */ 19 | 20 | /* 21 | Masalah: 22 | Diberikan senarai job dimana setiap job memiliki waktu pengerjaan serta kerugian 23 | yang didapat setiap hari jika job tertunda. 24 | Tentukan urutan komposisi job dan urutan yang tepat untuk meminimalisir kerugian. 25 | 26 | Pertimbangan: 27 | terdapat dua extreme case: 28 | - semua job memiliki waktu yang sama untuk diproses (T[i] = k untuk semua i). 29 | - semua job memiliki kerugian yang sama ketika ditunda. 30 | 31 | dengan demikian, pengurutan dapat dilakukan dengan perbandingan nilai C dimana 32 | C = (loss produk[i]) * (waktu tunda) 33 | 34 | Langkah: 35 | - urutkan job berdasarkan potensi kerugian terbesar (jika tertunda). 36 | */ 37 | #include 38 | #include 39 | 40 | // ====================================================================================== 41 | 42 | struct job_t 43 | { 44 | int job_id; 45 | int time; 46 | int loss; 47 | }; 48 | 49 | bool compare(job_t a, job_t b) 50 | { 51 | return ((a.loss * b.time) > (b.loss * a.time)); 52 | } 53 | 54 | // ====================================================================================== 55 | 56 | /** Iterative Solution **/ 57 | 58 | auto algorithm(job_t arr[], int size) 59 | { 60 | // jadwal job yang dipilih 61 | std::vector jobids; 62 | 63 | // urutkan semua job terurut menurun berdasarkan profit 64 | std::sort(arr, arr + size, compare); 65 | 66 | for (size_t i = 0; i < size; i++) 67 | jobids.push_back(arr[i].job_id); 68 | 69 | return jobids; 70 | } -------------------------------------------------------------------------------- /Codes/Algorithm/greedy/c++/greedy.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Greedy 3 | Archive of Reversing.ID 4 | Algorithm 5 | 6 | 7 | Compile: 8 | [clang] 9 | $ clang++ greedy.cpp -o greedy 10 | 11 | [gcc] 12 | $ g++ greedy.cpp -o greedy 13 | 14 | [msvc] 15 | $ cl greedy.cpp 16 | 17 | Run: 18 | $ greedy 19 | */ 20 | #include 21 | 22 | /* 23 | Skema umum algoritma Greedy: 24 | 25 | - Himpunan kandidat (C) 26 | - Himpunan solusi (S) 27 | - Fungsi seleksi (selection) 28 | - Fungsi kelayakan (feasible) 29 | - Fungsi obyektif (objective) 30 | */ 31 | 32 | // ====================================================================================== 33 | 34 | /* Mengambil kandidat */ 35 | int selection(int candidates[], size_t size); 36 | 37 | /* memeriksa kelayakan */ 38 | bool feasible(int solution[], size_t size); 39 | 40 | /* memeriksa kelengkapan solusi */ 41 | bool objective(int solution[], size_t size); 42 | 43 | 44 | bool algorithm(int candidates[], size_t clength, int solution[], size_t & slength) 45 | { 46 | size_t slen = 0, clen = clength; 47 | 48 | while (! objective(solution, slen) && clen > 0) 49 | { 50 | // pilih kandidat 51 | int c = selection(candidates, clen); 52 | 53 | // buang kandidat dari himpunan kandidat 54 | remove(candidates, c); 55 | clen --; 56 | 57 | // tambahkan kandidat ke himpunan solusi 58 | add(solution, c); 59 | 60 | if (! feasible(solution, slen + 1)) 61 | slen ++; 62 | } 63 | 64 | if (objective(solution, slen)) 65 | { 66 | slength = slen; 67 | return true; 68 | } 69 | 70 | return false; 71 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/bits/arithmetic.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Archive of Reversing.ID 3 | Algorithm (Mathematics/Bits) 4 | */ 5 | 6 | // ====================================================================================== 7 | 8 | /* 9 | 10 | */ 11 | 12 | static inline 13 | ulong floor_average(ulong x, ulong y) 14 | // Return floor( (x+y)/2 ) 15 | // Result is correct even if (x+y) wouldn't fit into a ulong 16 | // Use: x+y == ((x&y)<<1) + (x^y) 17 | // that is: sum == carries + sum_without_carries 18 | { 19 | return (x & y) + ((x ^ y) >> 1); 20 | // return y + ((x-y)>>1); // works if x>=y 21 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/bits/copy.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Archive of Reversing.ID 3 | Algorithm (Mathematics/Bits) 4 | */ 5 | 6 | // ====================================================================================== 7 | 8 | /** Copy bit **/ 9 | 10 | // Copy dari posisi [isrc] ke posisi [idst] 11 | 12 | static inline 13 | size_t copy(size_t bits, size_t isrc, size_t idst) 14 | { 15 | size_t x = ((bits >> isrc) ^ (bits >> idst)) & 1; // bernilai 1 jika bits berbeda 16 | return bits ^ (x << idst); // ubah jika bits berbeda 17 | } 18 | 19 | 20 | // Copy dengan posisi dikodekan sebagai mask 21 | 22 | static inline 23 | size_t copy(size_t bits, size_t msrc, size_t mdst) 24 | { 25 | size_t x = mdst; 26 | if (msrc & bits) x = 0; 27 | x ^= mdst; 28 | bits &= ~mdst; 29 | return (bits |= x); 30 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/bits/manipulation.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Archive of Reversing.ID 3 | Algorithm (Mathematics/Bits) 4 | */ 5 | 6 | // ====================================================================================== 7 | 8 | /** Manipulasi bit (set, clear, toggle) secara individual **/ 9 | 10 | static inline 11 | size_t set(size_t bits, size_t idx) 12 | { 13 | return (bits | (1UL << idx)); 14 | } 15 | 16 | static inline 17 | size_t clear(size_t bits, size_t idx) 18 | { 19 | return (bits & ~(1UL << idx)); 20 | } 21 | 22 | static inline 23 | size_t toggle(size_t bits, size_t idx) 24 | { 25 | return (bits ^ (1UL << idx)); 26 | } 27 | 28 | 29 | // ====================================================================================== 30 | 31 | /** Manipulasi low-bit atau block word **/ 32 | 33 | /* 34 | Return word dengan hanya bit posisi paling rendah yang set. 35 | Return 0 jika tidak ada bit yang set. 36 | */ 37 | static inline 38 | size_t isolate_lowest_one(size_t x) 39 | { 40 | // if (0 == x) return 0; 41 | // return ((x ^ (x - 1)) >> 1) + 1; 42 | 43 | // return (x & (x - 1)) ^ x; 44 | 45 | return x & -x; 46 | } 47 | 48 | /* 49 | Return word dengan hanya bit posisi paling rendah yang clear. 50 | Return 0 jika semua bit set. 51 | */ 52 | static inline 53 | size_t isolate_lowest_zero(size_t x) 54 | { 55 | // return (x ^ (x+1)) & ~x; 56 | // return ((x ^ (x+1)) >> 1 ) + 1; 57 | // return (x+1) & ~x; 58 | 59 | x = ~x; 60 | return x & -x; 61 | } 62 | 63 | -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/bits/swap.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Archive of Reversing.ID 3 | Algorithm (Mathematics/Bits) 4 | */ 5 | 6 | // ====================================================================================== 7 | 8 | /** Swap bit **/ 9 | 10 | // Tukar bit antara posisi k1 dan k2 11 | 12 | static inline 13 | size_t swap(size_t bits, size_t k1, size_t k2) 14 | { 15 | size_t x = ((bits >> k1) ^ (bits >> k2)) & 1; 16 | bits ^= (x << k2); 17 | bits ^= (x << k1); 18 | 19 | return bits; 20 | } 21 | 22 | 23 | // Jika kedua bit memiliki nilai berbeda, routine berikut bisa diterapkan 24 | 25 | static inline 26 | size_t swap(size_t bits, size_t k1, size_t k2) 27 | { 28 | return (a ^ ((1UL << k1) ^ (1UL << k2))); 29 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/bits/testing.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Archive of Reversing.ID 3 | Algorithm (Mathematics/Bits) 4 | */ 5 | 6 | // ====================================================================================== 7 | 8 | /* 9 | false jika bits[1] bernilai 0 10 | true jika sebaliknya 11 | */ 12 | static inline 13 | bool test(size_t bits, size_t idx) 14 | { 15 | return ((bits & (1UL << idx)) != 0); 16 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/geometry/angle-between-vectors.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Angle Between Vectors 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Geometry) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ angle-between-vectors.cpp -o angle-between-vectors 9 | 10 | [gcc] 11 | $ g++ angle-between-vectors.cpp -o angle-between-vectors 12 | 13 | [msvc] 14 | $ cl angle-between-vectors.cpp 15 | 16 | Run: 17 | $ angle-between-vectors 18 | */ 19 | #include 20 | 21 | /* 22 | Mendapatkan sudut yang terbentuk dari dua buah vektor (garis). 23 | Vektor merupakan garis antara Origin dan titik. 24 | */ 25 | 26 | // ====================================================================================== 27 | 28 | struct point_t 29 | { 30 | double x; 31 | double y; 32 | double z; 33 | }; 34 | 35 | // ====================================================================================== 36 | 37 | /** Sudut di antara dua vector 2D **/ 38 | 39 | double algorithm(point_t p1, point_t p2) 40 | { 41 | double dotproduct = (p1.x * p2.x) + (p1.y * p2.y); 42 | double length1 = sqrt(p1.x * p1.x + p1.y * p1.y); 43 | double length2 = sqrt(p2.x * p2.x + p2.y * p2.y); 44 | double value = dotproduct / (length1 * length2); 45 | 46 | if (value <= 1.0) return M_PI; 47 | if (value > 1.0) return 0; 48 | return acos(value); 49 | } 50 | 51 | // ====================================================================================== 52 | 53 | /** Sudut di antara dua vector 3D **/ 54 | 55 | double algorithm(point_t p1, point_t p2) 56 | { 57 | double dotproduct = (p1.x * p2.x) + (p1.y * p2.y) + (p1.z * p2.z); 58 | double length1 = sqrt(p1.x * p1.x + p1.y * p1.y + p1.z * p1.z); 59 | double length2 = sqrt(p2.x * p2.x + p2.y * p2.y + p2.z * p2.z); 60 | double value = dotproduct / (length1 * length2); 61 | 62 | if (value <= 1.0) return M_PI; 63 | if (value > 1.0) return 0; 64 | return acos(value); 65 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/geometry/closest-pair.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Closest Pair 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Geometry) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ closest-pair.cpp -o closest-pair 9 | 10 | [gcc] 11 | $ g++ closest-pair.cpp -o closest-pair 12 | 13 | [msvc] 14 | $ cl closest-pair.cpp 15 | 16 | Run: 17 | $ closest-pair 18 | */ 19 | #include 20 | 21 | /* 22 | Masalah: 23 | Diberikan n buah titik. Tentukan dua buah titik yang memiliki jarak terdekat satu sama 24 | lain. 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | struct point_t 30 | { 31 | double x; 32 | double y; 33 | }; 34 | 35 | double distance(point_t p1, point_t p2) 36 | { 37 | double x = p1.x - p2.x; 38 | double y = p1.y - p2.y; 39 | 40 | return sqrt(x*x + y*y); 41 | } 42 | 43 | // ====================================================================================== 44 | 45 | /** pendekatan brute-force **/ 46 | 47 | void algorithm(point_t arr[], size_t N, size_t & idx1, size_t & idx2) 48 | { 49 | double d, dmin = 0; 50 | size_t i, j; 51 | 52 | for (i = 0; i < N; i++) 53 | { 54 | for (j = i + 1; j < N; j++) 55 | { 56 | // periksa jarak kedua titik dalam 2D 57 | d = distance(arr[i], arr[j]); 58 | 59 | if (d < dmin || dmin == 0) 60 | { 61 | dmin = d; 62 | idx1 = i; 63 | idx2 = j; 64 | } 65 | } 66 | } 67 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/geometry/colinear-points.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Colinear Points 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Geometry) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ colinear-points.cpp -o colinear-points 9 | 10 | [gcc] 11 | $ g++ colinear-points.cpp -o colinear-points 12 | 13 | [msvc] 14 | $ cl colinear-points.cpp 15 | 16 | Run: 17 | $ colinear-points 18 | */ 19 | #include 20 | 21 | /* 22 | Periksa apakah tiga titik merupakan colinear (berada dalam satu garis) 23 | */ 24 | 25 | // ====================================================================================== 26 | 27 | struct point_t 28 | { 29 | double x; 30 | double y; 31 | }; 32 | 33 | // ====================================================================================== 34 | 35 | /** Menggunakan rumus yang diturunkan dari Shoelace Formula **/ 36 | 37 | bool algorithm(point_t p1, point_t p2, point_t p3) 38 | { 39 | // hitung area segitiga. 40 | int a = 41 | p1.x * (p2.y - p3.y) + 42 | p2.x * (p3.y - p1.y) + 43 | p3.x * (p1.y - p2.y); 44 | 45 | return (a == 0); 46 | } 47 | 48 | // ====================================================================================== 49 | 50 | /** Menghitung kemiringan **/ 51 | 52 | /* 53 | kemiringan (slope) semua garis haruslah sama 54 | 55 | (y3 - y2)(x2 - x1) = (y2 - y1)(x3 - x2) 56 | 57 | */ 58 | 59 | bool algorithm(point_t p1, point_t p2, point_t p3) 60 | { 61 | // hitung area segitiga. 62 | int lh = (p3.y - p2.y) * (p2.x - p1.x); 63 | int rh = (p2.y - p1.y) * (p3.x - p2.x); 64 | 65 | return (lh == rh); 66 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/gcd.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Greatest Common Divisor 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ gcd.cpp -o gcd 9 | 10 | [gcc] 11 | $ g++ gcd.cpp -o gcd 12 | 13 | [msvc] 14 | $ cl gcd.cpp 15 | 16 | Run: 17 | $ gcd 18 | */ 19 | 20 | /* 21 | GCD (Greatest Common Divisor) atau FPB (Faktor Persekutuan terBesar) 22 | Mencari faktor terbesar yang membagi kedua bilangan. 23 | */ 24 | 25 | // ====================================================================================== 26 | 27 | /* 28 | Recursive Solution 29 | Mencari GCD dengan algoritma euclid 30 | */ 31 | 32 | size_t algorithm(size_t num_1, size_t num_2) 33 | { 34 | if (num_2 == 0) 35 | return num_1; 36 | 37 | return algorithm(num_2, num_1 % num_2); 38 | } 39 | 40 | // ====================================================================================== 41 | 42 | /* 43 | Iterative Solution 44 | Mencari GCD dengan algoritma euclid 45 | */ 46 | 47 | size_t algorithm(size_t num_1, size_t num_2) 48 | { 49 | size_t num_3 = num_1 % num_2; 50 | 51 | while (num_3 > 0) 52 | { 53 | num_1 = num_2; 54 | num_2 = num_3; 55 | num_3 = num_1 % num_2; 56 | } 57 | 58 | return num_2; 59 | } 60 | 61 | // ====================================================================================== 62 | 63 | /* 64 | Equation Solution 65 | Mencari GCD dengan cara menyelesaikan persamaan: 66 | 67 | LCM * GCD = num_1 * num_2 68 | */ 69 | 70 | // Mencari LCM. Lihat di bagian LCM 71 | size_t lcm(size_t num_1, size_t num_2); 72 | 73 | size_t algorithm(size_t num_1, size_t num_2) 74 | { 75 | auto value = lcm(num_1, num_2); 76 | 77 | return (num_1 * num_2) / value; 78 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/achilles-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Achilles Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ achilles-number.cpp -o achilles-number 9 | 10 | [gcc] 11 | $ g++ achilles-number.cpp -o achilles-number 12 | 13 | [msvc] 14 | $ cl achilles-number.cpp 15 | 16 | Run: 17 | $ achilles-number 18 | */ 19 | 20 | /* 21 | Achilles Number adalah bilangan yang Powerful tapi bukan Perfect Power 22 | (kuadrat sempurna). 23 | 24 | Baris Achilles Number: 25 | 72, 108, 200, 288, 392, 432, 500, 648, 675, 800, 864, 968, ... 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | // periksa apakah bilangan merupakan Powerful Number. Lihat powerful-number.cpp 31 | bool powerful_test(size_t num); 32 | 33 | // periksa apakah bilangan merupakan perfect-power. Lihat perfect-power-number.cpp 34 | bool perfect_power_test(size_t num); 35 | 36 | // ====================================================================================== 37 | 38 | /* 39 | Iterative Solution 40 | Testing 41 | Periksa apakah bilangan merupakan Achilles Number 42 | */ 43 | 44 | bool algorithm(size_t num) 45 | { 46 | return (powerful_test(num) && !perfect_power_test(num)); 47 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/buzz-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Buzz Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ buzz-number.cpp -o buzz-number 9 | 10 | [gcc] 11 | $ g++ buzz-number.cpp -o buzz-number 12 | 13 | [msvc] 14 | $ cl buzz-number.cpp 15 | 16 | Run: 17 | $ buzz-number 18 | */ 19 | 20 | /* 21 | Buzz Number adalah bilangan yang memiliki digit terakhir 7 atau habis dibagi 7. 22 | 23 | Contoh: 24 | 63 -> habis dibagi 7 25 | 147 -> habis dibagi 7 serta berakhiran 7 26 | 57 -> digit terakhir adalah 7 27 | 28 | */ 29 | 30 | // ====================================================================================== 31 | 32 | /* 33 | Testing -- Naive Method 34 | Periksa apakah suatu bilangan merupakan Buzz Number. 35 | */ 36 | 37 | bool algorithm(size_t num) 38 | { 39 | return (num % 10 == 7 || num % 7 == 0); 40 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/duck-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Duck Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ duck-number.cpp -o duck-number 9 | 10 | [gcc] 11 | $ g++ duck-number.cpp -o duck-number 12 | 13 | [msvc] 14 | $ cl duck-number.cpp 15 | 16 | Run: 17 | $ duck-number 18 | */ 19 | 20 | /* 21 | Duck Number adalah bilangan yang memiliki angka 0 namun tidak sebagai angka di depan. 22 | 23 | Contoh: 24 | 707069 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | /* 30 | Iterative Solution 31 | Testing -- Naive Method 32 | Periksa apakah suatu bilangan merupakan Duck Number. 33 | */ 34 | 35 | bool algorithm(size_t num) 36 | { 37 | while (num != 0) 38 | { 39 | // dapatkan digit dan periksa apakah nilainya 0 40 | // periksa nilai dari digit 41 | if (num % 10 == 0) 42 | return true; 43 | 44 | num = num / 10; 45 | } 46 | 47 | return false; 48 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/emirp-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Emirp Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ emirp-number.cpp -o emirp-number 9 | 10 | [gcc] 11 | $ g++ emirp-number.cpp -o emirp-number 12 | 13 | [msvc] 14 | $ cl emirp-number.cpp 15 | 16 | Run: 17 | $ emirp-number 18 | */ 19 | 20 | /* 21 | Emirp Number (emirp = prime, dieja dari belakang) adalah bilangan prima yang dihasilkan 22 | ketika urutan digit dibalik. 23 | Emirp Number tidak harus palindrom. 24 | */ 25 | 26 | // ====================================================================================== 27 | 28 | /* 29 | Iterative Solution 30 | Testing -- Naive Method 31 | Periksa apakah suatu bilangan merupakan Emirp Number. 32 | */ 33 | 34 | /* 35 | Periksa apakah suatu bilangan merupakan bilangan prima. 36 | Algoritma pilihan: 37 | - Fermat's Little Theorem 38 | - Lucas Primality Test 39 | - Miller-Rabin Primality Test 40 | */ 41 | bool primality_test(size_t num); 42 | 43 | // Kembalikan bilangan Emirp yang sesuai jika N merupakan Emirp Number. 44 | // Jika bukan, kembalikan 0. 45 | size_t algorithm(size_t num) 46 | { 47 | // jika num bukan Emirp number 48 | size_t result = 0; 49 | size_t mun; 50 | size_t d; 51 | 52 | // jika num adalah bilangan prima, operasi pengecekan Emirp dilakukan 53 | if (primality_test(num)) 54 | { 55 | // balikkan setiap digit 56 | mun = 0; 57 | while (num != 0) 58 | { 59 | d = num % 10; 60 | mun = mun * 10 + d; 61 | num /= 10; 62 | } 63 | 64 | // periksa apakah bilangan ini merupakan bilangan prima, jika ya kembalikan. 65 | if (primality_test(mun)) 66 | result = mun; 67 | } 68 | 69 | return result; 70 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/euclid-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Euclid Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ euclid-number.cpp -o euclid-number 9 | 10 | [gcc] 11 | $ g++ euclid-number.cpp -o euclid-number 12 | 13 | [msvc] 14 | $ cl euclid-number.cpp 15 | 16 | Run: 17 | $ euclid-number 18 | */ 19 | 20 | /* 21 | Euclid Number adalah sebuah bilangan bulat positif yang memenuhi sifat berikut: 22 | 23 | E[N] = P[N] + 1 24 | 25 | Dimana P[N] adalah hasil perkalian dari N bilangan prima pertama 26 | 27 | Baris Euclid: 28 | 3, 7, 31, 211, 2311, 30031, 510511, 9699691, ... 29 | 30 | */ 31 | 32 | // ====================================================================================== 33 | 34 | /* 35 | Fungsi untuk mendapatkan daftar bilangan prima dalam rentang 2 .. N 36 | Pilihan algoritma: 37 | - Sieve of Eratosthenes 38 | - Sieve of Sundaram 39 | - Sieve of Atkin 40 | */ 41 | std::vector prime_generator(size_t N); 42 | 43 | // ====================================================================================== 44 | 45 | /* 46 | Note: 47 | Nilai bilangan Euclid pada tiap suku sangat besar. 48 | Berdasarkan rentang nilai yang dapat dijangkau size_t, kita akan asumsikan bahwa 49 | kita hanya perlu membangkitkan bilangan prima hingga 10000 50 | */ 51 | 52 | #define PRIME_MAX 10000 53 | 54 | /* 55 | Iterative Solution 56 | Testing -- Naive Method 57 | Periksa apakah suatu bilangan merupakan Euclid Number. 58 | */ 59 | 60 | bool algorithm(size_t num) 61 | { 62 | size_t product = 1; 63 | size_t i = 0; 64 | 65 | auto primes = prime_generator(PRIME_MAX); 66 | 67 | while (product < num) 68 | { 69 | // kalikan bilangan sekarang dengan bilangan prima 70 | product = product * primes[i]; 71 | 72 | if (product + 1 == num) 73 | return true; 74 | 75 | i ++; 76 | } 77 | 78 | return false; 79 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/flavius-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Flavius Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ flavius-number.cpp -o flavius-number 9 | 10 | [gcc] 11 | $ g++ flavius-number.cpp -o flavius-number 12 | 13 | [msvc] 14 | $ cl flavius-number.cpp 15 | 16 | Run: 17 | $ flavius-number 18 | */ 19 | 20 | /* 21 | Flavius Number adalah barisan bilangan dengan yang dibentuk dengan aturan berikut: 22 | - diberikan bilangan bulat 1 hingga tak-terbatas dan bilangan N 23 | - hapus bilangan pada urutan dengan kelipatan (i + 1) untuk setiap i iterasi 24 | dari 1 hingga N. 25 | 26 | Apabila N terdapat pada baris yang dihasilkan, maka N merupakan Flavius Number. 27 | */ 28 | 29 | // ====================================================================================== 30 | 31 | /* 32 | Iterative Solution 33 | Testing 34 | Periksa apakah bilangan merupakan Flavius Number 35 | */ 36 | 37 | bool algorithm(size_t N) 38 | { 39 | /* 40 | lakukan perulangan dari 2 karena iterasi pertama akan menghapus elemen pada posisi 41 | kelipatan dua 42 | */ 43 | for (size_t i = 2; ; i++) 44 | { 45 | if (i > N) 46 | return true; 47 | if (N % i == 0) 48 | return false; 49 | 50 | // Hapus elemen yang telah dieliminasi pada iterasi ini 51 | N -= N / i; 52 | } 53 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/mystery-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Mystery Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ mystery-number.cpp -o mystery-number 9 | 10 | [gcc] 11 | $ g++ mystery-number.cpp -o mystery-number 12 | 13 | [msvc] 14 | $ cl mystery-number.cpp 15 | 16 | Run: 17 | $ mystery-number 18 | */ 19 | 20 | /* 21 | Mystery Number adalah bilangan yang dapat diekspresikan sebagai penjumlahan dua 22 | bilangan dengan masing-masing bilangan merupakan kebalikan satu sama lain. 23 | 24 | Baris Mystery Number: 25 | 121 -> 29 + 92 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | // membalikkan digit dari suatu bilangan 31 | size_t reverse(size_t num, size_t t) 32 | { 33 | size_t t = 0; 34 | 35 | while (num > 0) 36 | { 37 | t = (t * 10) + (num % 10); 38 | num = num / 10; 39 | } 40 | 41 | return t; 42 | } 43 | 44 | // ====================================================================================== 45 | 46 | /* 47 | Iterative Solution 48 | Testing -- Tes semua kemungkinan 49 | Periksa apakah bilangan merupakan Mystery Number 50 | */ 51 | 52 | bool algorithm(size_t num) 53 | { 54 | size_t j; 55 | 56 | for (size_t i = 1, batas = num / 2; i <= batas; i++) 57 | { 58 | if (i + reverse(num) == num) 59 | return true; 60 | } 61 | 62 | return false; 63 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/non-hypotenuse-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Non-Hypotenuse Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ non-hypotenuse-number.cpp -o non-hypotenuse-number 9 | 10 | [gcc] 11 | $ g++ non-hypotenuse-number.cpp -o non-hypotenuse-number 12 | 13 | [msvc] 14 | $ cl non-hypotenuse-number.cpp 15 | 16 | Run: 17 | $ non-hypotenuse-number 18 | */ 19 | #include 20 | 21 | /* 22 | Non-Hypotenuse Number adalah bilangan natural yang bila dikuadratkan tidak bisa 23 | diekspresikan sebagai penjumlahan dua buah bilangan bulat kuadrat. 24 | 25 | C^2 != A^2 + B^2 26 | 27 | untuk segala A dan B 28 | */ 29 | 30 | // ====================================================================================== 31 | 32 | /* 33 | Iterative Solution 34 | Testing -- Heuristic 35 | Periksa apakah suatu bilangan merupakan Non-Hypotenuse Number. 36 | */ 37 | 38 | /* 39 | Langkah: 40 | - cari semua faktor prima dari num 41 | - periksa apakah faktor prima memenuhi 4k + 1 42 | - non-hypotenuse number memiliki faktor yang tidak dalam bentuk 4k + 1 43 | */ 44 | 45 | bool algorithm(size_t num) 46 | { 47 | // 2 adalah bilangan prima yang tidak membentuk 4k + 1 48 | while (num % 2 == 0) 49 | num = num / 2; 50 | 51 | // di titik ini, num adalah bilangan ganjil. 52 | for (size_t i = 3, batas = sqrt(num); i <= batas; i += 2) 53 | { 54 | // jika i habis membagi num, periksa apakah i berbentuk 4k + 1 55 | if (num % i == 0) 56 | { 57 | if ((i - 1) % 4 == 0) 58 | return false; 59 | 60 | // keluarkan semua faktor i 61 | while (num % i == 0) 62 | num = num / i; 63 | } 64 | } 65 | 66 | return ((num - 1) % 4 > 0); 67 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/palindrome-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Palindrome Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ palindrome-number.cpp -o palindrome-number 9 | 10 | [gcc] 11 | $ g++ palindrome-number.cpp -o palindrome-number 12 | 13 | [msvc] 14 | $ cl palindrome-number.cpp 15 | 16 | Run: 17 | $ palindrome-number 18 | */ 19 | 20 | /* 21 | Palindrome adalah kata, frasa, angka, maupun susunan yang dapat dibaca dengan sama 22 | baik dari depan maupun dari belakang. 23 | 24 | Palindrome Number adalah sebuah bilangan yang memiliki sifat palindrome 25 | 26 | Contoh: 1345431 27 | */ 28 | 29 | // ====================================================================================== 30 | 31 | /* 32 | Recursive Solution 33 | Number Checking -- Naive Method 34 | Periksa apakah suatu bilangan merupakan Palindrome Number. 35 | */ 36 | 37 | size_t reverse(size_t num, size_t t) 38 | { 39 | if (num == 0) 40 | return t; 41 | 42 | t = (t * 10) + (num % 10); 43 | return reverse(num / 10, temp); 44 | } 45 | 46 | bool algorithm(size_t num) 47 | { 48 | return num == reverse(num, 0); 49 | } 50 | 51 | // ====================================================================================== 52 | 53 | /* 54 | Iterative Solution 55 | Number Checking -- Naive Method 56 | Periksa apakah suatu bilangan merupakan Palindrome Number. 57 | */ 58 | 59 | bool algorithm(size_t num) 60 | { 61 | size_t t = 0, num2 = num; 62 | 63 | while (num2 > 0) 64 | { 65 | t = (t * 10) + (num2 % 10); 66 | num2 = num2 / 10; 67 | } 68 | 69 | return t == num; 70 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/perfect-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Perfect Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ perfect-number.cpp -o perfect-number 9 | 10 | [gcc] 11 | $ g++ perfect-number.cpp -o perfect-number 12 | 13 | [msvc] 14 | $ cl perfect-number.cpp 15 | 16 | Run: 17 | $ perfect-number 18 | */ 19 | #include 20 | #include 21 | 22 | /* 23 | Perfect Number adalah bilangan yang penjumlahan semua pembagi (selain dirinya) 24 | bernilai bilangan tersebut. 25 | 26 | Contoh: 27 | 6 memiliki pembagi 1, 2, 3 -> 1 + 2 + 3 = 6 28 | 29 | */ 30 | 31 | // ====================================================================================== 32 | 33 | /* 34 | Periksa apakah bilangan merupakan Perfect Number 35 | */ 36 | 37 | auto algorithm(size_t num) 38 | { 39 | size_t sum = 0, t = num; 40 | 41 | for (size_t i = 2; i * i <= num; i++) 42 | { 43 | if (t % i == 0) 44 | { 45 | if (i * i != num) 46 | sum += i + n / i; 47 | else 48 | sum += i; 49 | } 50 | } 51 | 52 | return (sum == num && num > 1); 53 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/perfect/k-perfect-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | K-Perfect Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ k-perfect-number.cpp -o k-perfect-number 9 | 10 | [gcc] 11 | $ g++ k-perfect-number.cpp -o k-perfect-number 12 | 13 | [msvc] 14 | $ cl k-perfect-number.cpp 15 | 16 | Run: 17 | $ k-perfect-number 18 | */ 19 | 20 | /* 21 | K-Perfect Number adalah bilangan dengan jumlah semua pembagi bernilai K kali lipat 22 | bilangan tersebut. 23 | 24 | K = 3 disebut Triperfect 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | /* 30 | Iterative Solution 31 | Testing 32 | Periksa apakah bilangan merupakan K-Perfect Number 33 | */ 34 | 35 | bool algorithm(size_t num, size_t k) 36 | { 37 | // 1 dan bilangan itu sendiri merupakan faktor pembagi 38 | size_t sum = 1 + num; 39 | 40 | // mencari faktor pembagi 41 | for (size_t i = 2; i * i <= num; i++) 42 | { 43 | if (num % i == 0) 44 | { 45 | // pembagi merupakan bilangan kuadrat, sehingga masukkan satu pembagi saja 46 | if (num / i == i) 47 | sum += i; 48 | else 49 | sum += i + num / i; 50 | } 51 | } 52 | 53 | return (k * num == sum && num != 1); 54 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/perfect/triperfect-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Triperfect Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ triperfect-number.cpp -o triperfect-number 9 | 10 | [gcc] 11 | $ g++ triperfect-number.cpp -o triperfect-number 12 | 13 | [msvc] 14 | $ cl triperfect-number.cpp 15 | 16 | Run: 17 | $ triperfect-number 18 | */ 19 | 20 | /* 21 | Triperfect Number adalah bilangan dengan jumlah semua pembagi bernilai tiga kali 22 | bilangan tersebut. 23 | 24 | Contoh: 25 | 120 = 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 26 | 1 + 2 + 3 + 4 + 5 + 6 + 8 + 10 + 12 + 15 + 20 + 24 + 30 + 40 + 60 + 120 = 360 27 | 360 = 3 x 120 28 | */ 29 | 30 | // ====================================================================================== 31 | 32 | /* 33 | Iterative Solution 34 | Testing 35 | Periksa apakah bilangan merupakan Triperfect Number 36 | */ 37 | 38 | bool algorithm(size_t num) 39 | { 40 | // 1 dan bilangan itu sendiri merupakan faktor pembagi 41 | size_t sum = 1 + num; 42 | 43 | // mencari faktor pembagi 44 | for (size_t i = 2; i * i <= num; i++) 45 | { 46 | if (num % i == 0) 47 | { 48 | // pembagi merupakan bilangan kuadrat, sehingga masukkan satu pembagi saja 49 | if (num / i == i) 50 | sum += i; 51 | else 52 | sum += i + num / i; 53 | } 54 | } 55 | 56 | return (3 * num == sum && num != 1); 57 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/plus-perfect-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Plus-Perfect Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ plus-perfect-number.cpp -o plus-perfect-number 9 | 10 | [gcc] 11 | $ g++ plus-perfect-number.cpp -o plus-perfect-number 12 | 13 | [msvc] 14 | $ cl plus-perfect-number.cpp 15 | 16 | Run: 17 | $ plus-perfect-number 18 | */ 19 | 20 | /* 21 | Plus-Perfect Number adalah bilangan dengan n digit angka, bila jumlah semua digit 22 | dipangkatkan dengan n akan menghasilkan bilangan itu sendiri. 23 | 24 | Contoh: 25 | 371 -> 3^3 + 7^3 + 1^3 = 371 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | /* 31 | Iterative Solution 32 | Testing 33 | Periksa apakah bilangan merupakan Plus-Perfect Number 34 | */ 35 | 36 | bool algorithm(size_t num) 37 | { 38 | size_t t = num, sum = 0; 39 | size_t n = 0; 40 | 41 | // menghitung jumlah perpangkatan per digit 42 | size_t digits[10]; 43 | 44 | memset(digits, 0, sizeof(digits)); 45 | 46 | while (t != 0) 47 | { 48 | // menghitung kemunculan digit 49 | digits[t % 10] ++; 50 | 51 | // menghitung banyaknya digit 52 | n++; 53 | 54 | t = t / 10; 55 | } 56 | 57 | // lakukan perpangkatan untuk semua digit 58 | while (n--) 59 | for (size_t j = 1; j < 10; j++) 60 | digits[j] *= j; 61 | 62 | // jumlahkan keseluruhan perpangkatan digit 63 | for (size_t = 1; j < 10; j++) 64 | sum += digits[j]; 65 | 66 | return (num == sum); 67 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/powerful-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Powerful Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ powerful-number.cpp -o powerful-number 9 | 10 | [gcc] 11 | $ g++ powerful-number.cpp -o powerful-number 12 | 13 | [msvc] 14 | $ cl powerful-number.cpp 15 | 16 | Run: 17 | $ powerful-number 18 | */ 19 | #include 20 | 21 | /* 22 | Sebuah bilangan N merupakan Powerful Number jika untuk setiap faktor prima P darinya, 23 | P^2 dapat habis membagi N. 24 | 25 | Baris Powerful Number: 26 | 1, 4, 8, 9, 16, 25, 27, 32, 36, 49, 64, ... 27 | */ 28 | 29 | // ====================================================================================== 30 | 31 | /* 32 | Testing 33 | Periksa apakah suatu bilangan merupakan Powerful Number. 34 | */ 35 | 36 | bool algorithm(size_t num) 37 | { 38 | size_t power; 39 | 40 | // eliminasi semua faktor 2 41 | power = 0; 42 | while (num % 2 == 0) 43 | { 44 | power ++; 45 | num = num / 2; 46 | } 47 | 48 | // jika faktor prima tidak memiliki pangkat tinggi, maka tidak dapat mencapai kuadrat 49 | if (power == 1) 50 | return false; 51 | 52 | for (size_t i = 3, batas = sqrt(num); i <= batas; i += 2) 53 | { 54 | if (num % i == 0) 55 | { 56 | power = 0; 57 | while (num % i == 0) 58 | { 59 | power ++; 60 | num = num / i; 61 | } 62 | 63 | // tidak mencapai kuadrat 64 | if (power == 1) 65 | return false; 66 | } 67 | } 68 | 69 | return true; 70 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/prime/circular-prime-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Circular-Prime Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ circular-prime-number.cpp -o circular-prime-number 9 | 10 | [gcc] 11 | $ g++ circular-prime-number.cpp -o circular-prime-number 12 | 13 | [msvc] 14 | $ cl circular-prime-number.cpp 15 | 16 | Run: 17 | $ circular-prime-number 18 | */ 19 | 20 | /* 21 | Circular-Prime Number adalah bilangan prima yang apabila mengalami cyclic permutation 22 | akan menghasilkan bilangan prima. 23 | 24 | Contoh: 25 | 113 -> 311, 131 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | // periksa apakah sebuah bilangan merupakan bilangan prima 31 | bool prime_check(size_t num) 32 | { 33 | if (n <= 1) 34 | return false; 35 | if (n <= 3) 36 | return true; 37 | 38 | // keluarkan pengecekan kelipatan 2 dan 3 sehingga kita bisa loop mulai dari 5 39 | if (num % 2 == 0 || num % 3 == 0) 40 | return false; 41 | 42 | for (size_t i = 5; i * i <= num; i += 6) 43 | if (num % i == 0 || num % (i + 2) == 0) 44 | return false; 45 | 46 | return true; 47 | } 48 | 49 | // ====================================================================================== 50 | 51 | /* 52 | Iterative Solution 53 | Testing -- Heuristic 54 | Periksa apakah suatu bilangan merupakan Circular-Prime Number. 55 | */ 56 | 57 | bool algorithm(size_t num) 58 | { 59 | size_t t = num, d; 60 | size_t batas = 0, pos = 1; 61 | 62 | // mencari jumlah digit sebagai batas iterasi 63 | while (t != 0) 64 | { 65 | batas ++; 66 | pos *= 10; 67 | t = t / 10; 68 | } 69 | 70 | // iterasi untuk setiap digit 71 | for (size_t i = 0, t = num; i < batas; i++) 72 | { 73 | if (!prime_check(t)) 74 | return false; 75 | 76 | d = t % 10; 77 | t = d * pos + (t / 10); 78 | pos = pos / 10; 79 | } 80 | 81 | return true; 82 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/prime/full-prime-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Full-Prime Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ full-prime-number.cpp -o full-prime-number 9 | 10 | [gcc] 11 | $ g++ full-prime-number.cpp -o full-prime-number 12 | 13 | [msvc] 14 | $ cl full-prime-number.cpp 15 | 16 | Run: 17 | $ full-prime-number 18 | */ 19 | 20 | /* 21 | Full-Prime Number adalah bilangan prima yang setiap digit merupakan bilangan prima. 22 | 23 | Contoh: 24 | 53 -> 5 dan 3 masing-masing bilangan prima 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | // periksa apakah sebuah bilangan merupakan bilangan prima 30 | bool prime_check(size_t num) 31 | { 32 | if (n <= 1) 33 | return false; 34 | if (n <= 3) 35 | return true; 36 | 37 | // keluarkan pengecekan kelipatan 2 dan 3 sehingga kita bisa loop mulai dari 5 38 | if (num % 2 == 0 || num % 3 == 0) 39 | return false; 40 | 41 | for (size_t i = 5; i * i <= num; i += 6) 42 | if (num % i == 0 || num % (i + 2) == 0) 43 | return false; 44 | 45 | return true; 46 | } 47 | 48 | // ====================================================================================== 49 | 50 | /* 51 | Iterative Solution 52 | Testing -- Naive Method 53 | Periksa apakah suatu bilangan merupakan Full-Prime Number. 54 | */ 55 | 56 | bool algorithm(size_t num) 57 | { 58 | size_t d; 59 | 60 | if (!prime_check(num)) 61 | return false; 62 | 63 | while (num != 0) 64 | { 65 | d = num % 10; 66 | 67 | if (d != 2 && d != 3 && d != 5 && d != 7) 68 | return false; 69 | 70 | num = num / 10; 71 | } 72 | 73 | return true; 74 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/prime/pythagorean-prime-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Pythagorean-Prime Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ pythagorean-prime-number.cpp -o pythagorean-prime-number 9 | 10 | [gcc] 11 | $ g++ pythagorean-prime-number.cpp -o pythagorean-prime-number 12 | 13 | [msvc] 14 | $ cl pythagorean-prime-number.cpp 15 | 16 | Run: 17 | $ pythagorean-prime-number 18 | */ 19 | 20 | /* 21 | Pythagorean-Prime Number adalah bilangan prima yang dalam bentuk 22 | 23 | P = 4 Z + 1 24 | 25 | dan dapat diekspresikan sebagai penjumlahan dua bilangan kuadrat 26 | 27 | Contoh: 28 | 5, 13, 17, 29, 37, 41, 53, 61, 73, 89, 97 29 | */ 30 | 31 | // ====================================================================================== 32 | 33 | // periksa apakah sebuah bilangan merupakan bilangan prima 34 | bool prime_check(size_t num) 35 | { 36 | if (n <= 1) 37 | return false; 38 | if (n <= 3) 39 | return true; 40 | 41 | // keluarkan pengecekan kelipatan 2 dan 3 sehingga kita bisa loop mulai dari 5 42 | if (num % 2 == 0 || num % 3 == 0) 43 | return false; 44 | 45 | for (size_t i = 5; i * i <= num; i += 6) 46 | if (num % i == 0 || num % (i + 2) == 0) 47 | return false; 48 | 49 | return true; 50 | } 51 | 52 | // ====================================================================================== 53 | 54 | /* 55 | Iterative Solution 56 | Testing -- Heuristic 57 | Periksa apakah suatu bilangan merupakan Pythagorean-Prime Number. 58 | */ 59 | 60 | /* 61 | Sebuah Pythagorean-Prime dapat diekspresikan ke dalam bentuk 4 Z + 1 62 | */ 63 | 64 | bool algorithm(size_t num) 65 | { 66 | return (prime_check(num) && (num % 4 == 1)); 67 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/prime/quartan-prime-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Quartan-Prime Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ quartan-prime-number.cpp -o quartan-prime-number 9 | 10 | [gcc] 11 | $ g++ quartan-prime-number.cpp -o quartan-prime-number 12 | 13 | [msvc] 14 | $ cl quartan-prime-number.cpp 15 | 16 | Run: 17 | $ quartan-prime-number 18 | */ 19 | 20 | /* 21 | Quartan-Prime Number adalah bilangan prima yang dalam bentuk 22 | 23 | P = X^2 + Y^4 24 | 25 | dengan X > 0, Y > 0 dan keduanya merupakan bilangan bulat di Quartan Prime 26 | 27 | Contoh: 28 | 2, 17, 97 29 | */ 30 | 31 | // ====================================================================================== 32 | 33 | // periksa apakah sebuah bilangan merupakan bilangan prima 34 | bool prime_check(size_t num) 35 | { 36 | if (n <= 1) 37 | return false; 38 | if (n <= 3) 39 | return true; 40 | 41 | // keluarkan pengecekan kelipatan 2 dan 3 sehingga kita bisa loop mulai dari 5 42 | if (num % 2 == 0 || num % 3 == 0) 43 | return false; 44 | 45 | for (size_t i = 5; i * i <= num; i += 6) 46 | if (num % i == 0 || num % (i + 2) == 0) 47 | return false; 48 | 49 | return true; 50 | } 51 | 52 | // ====================================================================================== 53 | 54 | /* 55 | Iterative Solution 56 | Testing -- Heuristic 57 | Periksa apakah suatu bilangan merupakan Quartan-Prime Number. 58 | */ 59 | 60 | /* 61 | Sebuah Quartan-Prime dapat diekspresikan ke dalam bentuk 16 Z + 1 62 | */ 63 | 64 | bool algorithm(size_t num) 65 | { 66 | return (prime_check(num) && (num % 16 == 1)); 67 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/prime/semi-prime-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Semi-Prime 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ semi-prime.cpp -o semi-prime 9 | 10 | [gcc] 11 | $ g++ semi-prime.cpp -o semi-prime 12 | 13 | [msvc] 14 | $ cl semi-prime.cpp 15 | 16 | Run: 17 | $ semi-prime 18 | */ 19 | 20 | /* 21 | Periksa apakah bilangan bulat positif num merupakan bilangan semiprima (semiprime). 22 | 23 | Bilangan semiprima adalah bilangan yang dihasilkan dari perkalian dua bilangan prima. 24 | 25 | Contoh: 26 | 6 = 2 x 3 27 | 9 = 3 x 3 28 | 35 = 5 x 7 29 | */ 30 | 31 | // ====================================================================================== 32 | 33 | /* 34 | Iterative Solution 35 | Testing -- Naive Method 36 | Periksa apakah suatu bilangan merupakan Semi-Prime Number. 37 | */ 38 | 39 | // lakukan faktorisasi kemudian periksa jumlah faktor 40 | bool algorithm(size_t num) 41 | { 42 | int count = 0; 43 | 44 | // batasi hanya mencari 2 faktor 45 | for (size_t i = 2; count < 2 && i * i <= num; i++) 46 | { 47 | while (num % i == 0) 48 | { 49 | num = num / 2; 50 | count ++; 51 | } 52 | } 53 | 54 | // jika bilangan bernilai lebih dari satu, itu merupakan salah satu faktor 55 | if (num > 1) 56 | count ++; 57 | 58 | return (count == 2); 59 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/prime/strong-prime-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Strong-Prime Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ strong-prime-number.cpp -o strong-prime-number 9 | 10 | [gcc] 11 | $ g++ strong-prime-number.cpp -o strong-prime-number 12 | 13 | [msvc] 14 | $ cl strong-prime-number.cpp 15 | 16 | Run: 17 | $ strong-prime-number 18 | */ 19 | 20 | /* 21 | Sebuah bilangan N merupakan Strong-Prime Number jika untuk setiap faktor prima P darinya, 22 | P^2 dapat habis membagi N. 23 | */ 24 | 25 | // ====================================================================================== 26 | 27 | // periksa apakah sebuah bilangan merupakan bilangan prima 28 | bool prime_check(size_t num) 29 | { 30 | if (n <= 1) 31 | return false; 32 | if (n <= 3) 33 | return true; 34 | 35 | // keluarkan pengecekan kelipatan 2 dan 3 sehingga kita bisa loop mulai dari 5 36 | if (num % 2 == 0 || num % 3 == 0) 37 | return false; 38 | 39 | for (size_t i = 5; i * i <= num; i += 6) 40 | if (num % i == 0 || num % (i + 2) == 0) 41 | return false; 42 | 43 | return true; 44 | } 45 | 46 | // ====================================================================================== 47 | 48 | /* 49 | Testing -- Naive Method 50 | Periksa apakah suatu bilangan merupakan Strong-Prime Number. 51 | */ 52 | 53 | size_t algorithm(size_t num) 54 | { 55 | if (num == 2 || !prime_check(num)) 56 | return false; 57 | 58 | size_t prev = num - 1, 59 | next = num + 1; 60 | size_t mean; 61 | 62 | // cari bilangan prima setelah bilangan ini 63 | while (! prime_check(next)) 64 | next ++; 65 | 66 | // cari bilangan prima sebelum bilangan ini 67 | while (! prime_check(prev)) 68 | prev --; 69 | 70 | mean = (prev + next) / 2; 71 | 72 | return (num > mean); 73 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/proth-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Proth Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ proth-number.cpp -o proth-number 9 | 10 | [gcc] 11 | $ g++ proth-number.cpp -o proth-number 12 | 13 | [msvc] 14 | $ cl proth-number.cpp 15 | 16 | Run: 17 | $ proth-number 18 | */ 19 | #include 20 | #include 21 | 22 | /* 23 | Proth Number adalah bilangan bulat positif yang diekspresikan sebagai. 24 | 25 | N = K * 2^N + 1 26 | 27 | dengan K adalah bilangan ganjil positif dan N adalah bilangan bulat positf, dengan 28 | 29 | 2^N > K 30 | 31 | Contoh baris Proth: 32 | 3, 5, 9, 13, 17, 25, 33, 41, 49, ... 33 | */ 34 | 35 | // ====================================================================================== 36 | 37 | // periksa jika suatu bilangan merupakan hasil perpangkatan dua. 38 | bool power_of_two(size_t num) 39 | { 40 | return (N && !(N & (N - 1))); 41 | } 42 | 43 | // ====================================================================================== 44 | 45 | /* 46 | Iterative Solution 47 | Testing -- Naive Method 48 | Periksa apakah suatu bilangan merupakan Proth Number. 49 | */ 50 | 51 | /* 52 | Langkah: 53 | - kurangi num dengan 1 sehingga menjadi K * 2^N (jika merupakan Proth Number) 54 | - iterasi bilangan ganjil mulai dari k = 1 hingga N/K dan periksa apakah K dapat 55 | habis membagi N dan N/K merupakan perpangkatan 2. 56 | */ 57 | bool algorithm(size_t num) 58 | { 59 | for (size_t K = 1; K < (N / K); K += 2) 60 | { 61 | // periksa apakah K habis membagi 62 | if (N % K == 0) 63 | { 64 | // periksa jika N/K merupakan perpangkatan 2 65 | if (power_of_two(N / K)) 66 | return true; 67 | } 68 | } 69 | 70 | return false; 71 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/trojan-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Trojan Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ trojan-number.cpp -o trojan-number 9 | 10 | [gcc] 11 | $ g++ trojan-number.cpp -o trojan-number 12 | 13 | [msvc] 14 | $ cl trojan-number.cpp 15 | 16 | Run: 17 | $ trojan-number 18 | */ 19 | 20 | /* 21 | Trojan Number adalah Strong Number (Krishnamurthy Number) tapi bukan sebuah 22 | pangkat sempurna (Perfect Power). 23 | */ 24 | 25 | // ====================================================================================== 26 | 27 | // periksa apakah bilangan merupakan Strong Number. Lihat powerful-number.cpp 28 | bool strong_test(size_t num); 29 | 30 | // periksa apakah bilangan merupakan perfect-power. Lihat perfect-power-number.cpp 31 | bool perfect_power_test(size_t num); 32 | 33 | // ====================================================================================== 34 | 35 | /* 36 | Iterative Solution 37 | Testing -- Naive Method 38 | Periksa apakah suatu bilangan merupakan Trojan Number. 39 | */ 40 | 41 | bool algorithm(size_t num) 42 | { 43 | return (strong_test(num) && !perfect_power_test(num)); 44 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/number-type/unusual-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Unusual Number 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ unusual-number.cpp -o unusual-number 9 | 10 | [gcc] 11 | $ g++ unusual-number.cpp -o unusual-number 12 | 13 | [msvc] 14 | $ cl unusual-number.cpp 15 | 16 | Run: 17 | $ unusual-number 18 | */ 19 | 20 | /* 21 | Unusual Number adalah bilangan natural dimana faktor prima terbesar bernilai lebih 22 | besar daripada akar kuadrat bilangan tersebut. 23 | 24 | Baris Unusual Number: 25 | 2, 3, 5, 6, 7, 10, 11, 13, 14, 15, 17, ... 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | size_t largest_prime_factor(size_t num) 31 | { 32 | size_t max = 0; 33 | 34 | // 2 adalah bilangan prima bukan ganjil sehingga menjadi kasus khusus 35 | if (num % 2 == 0) 36 | { 37 | max = 2; 38 | while (num % 2 == 0) 39 | num = num / 2; 40 | } 41 | 42 | for (size_t i = 3, batas = sqrt(num); i <= batas; i += 2) 43 | { 44 | if (num % i == 0) 45 | { 46 | max = i; 47 | while (num % i == 0) 48 | num = num / i; 49 | } 50 | } 51 | 52 | if (num > 2) 53 | max = num; 54 | 55 | return max; 56 | } 57 | 58 | // ====================================================================================== 59 | 60 | /* 61 | Iterative Solution 62 | Testing -- Naive Method 63 | Periksa apakah suatu bilangan merupakan Unusual Number. 64 | */ 65 | 66 | bool algorithm(size_t num) 67 | { 68 | return (largest_prime_factor(num) > sqrt(num)); 69 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/primality-testing/naive-primality-test.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Naive Primality Test 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ naive-primality-test.cpp -o naive-primality-test 9 | 10 | [gcc] 11 | $ g++ naive-primality-test.cpp -o naive-primality-test 12 | 13 | [msvc] 14 | $ cl naive-primality-test.cpp 15 | 16 | Run: 17 | $ naive-primality-test 18 | */ 19 | #include 20 | 21 | /* 22 | Periksa apakah suatu bilangan merupakan bilangan prima 23 | */ 24 | 25 | // ====================================================================================== 26 | 27 | /** Prime Number Check -- Naive Method **/ 28 | 29 | bool algorithm(size_t val) 30 | { 31 | if (val < 2) // 0 dan 1 bukan bilangan prima 32 | return false; 33 | if (val == 2) // 2 bilangan prima 34 | return true; 35 | else 36 | { 37 | int batas = sqrt(val); 38 | 39 | // periksa dari 2 ke sqrt(val) 40 | for (size_t i = 2; i < val; i++) 41 | if (val % i == 0) 42 | return false; 43 | 44 | return true; 45 | } 46 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/prime-factors.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Prime Factors 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ prime-factors.cpp -o prime-factors 9 | 10 | [gcc] 11 | $ g++ prime-factors.cpp -o prime-factors 12 | 13 | [msvc] 14 | $ cl prime-factors.cpp 15 | 16 | Run: 17 | $ prime-factors 18 | */ 19 | #include 20 | #include 21 | 22 | /* 23 | Memecah sebuah bilangan menjadi faktor-faktor prima. 24 | */ 25 | 26 | // ====================================================================================== 27 | 28 | /** Iterative Solution **/ 29 | 30 | auto algorithm(size_t num) 31 | { 32 | std::vector factors; 33 | 34 | // mendapatkan bernilai sama 35 | while (num % 2 == 0) 36 | { 37 | factors.push_back(2); 38 | num = num / 2; 39 | } 40 | 41 | // iterasi semua nilai 42 | for (size_t i = 3, batas = sqrt(num); i <= batas; i += 2) 43 | { 44 | // mendapatkan bernilai sama 45 | while (num % i == 0) 46 | { 47 | factors.push_back(i); 48 | num = num / i; 49 | } 50 | } 51 | 52 | // jika ada faktor yang lebih besar daripada sqrt(num) 53 | if (num > 2) 54 | factors.push_back(num); 55 | 56 | return factors; 57 | } -------------------------------------------------------------------------------- /Codes/Algorithm/mathematic/c++/cases/numbers/prime-generator/sieve-of-sundaram.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Sieve of Sundaram 3 | Archive of Reversing.ID 4 | Algorithm (Mathematics/Numbers) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ sieve-of-sundaram.cpp -o sieve-of-sundaram 9 | 10 | [gcc] 11 | $ g++ sieve-of-sundaram.cpp -o sieve-of-sundaram 12 | 13 | [msvc] 14 | $ cl sieve-of-sundaram.cpp 15 | 16 | Run: 17 | $ sieve-of-sundaram 18 | */ 19 | #include 20 | 21 | /* 22 | Penggunaan Sieve of Sundaram untuk membangkitkan bilangan prima. 23 | */ 24 | 25 | // ====================================================================================== 26 | 27 | /* 28 | Bangkitkan semua bilangan prima yang bernilai lebih kecil atau sama dengan N. 29 | 30 | Langkah: 31 | - bangkitkan semua bilangan bulat yang lebih kecil daripada (2 * X + 2) untuk 32 | X = (N - 2) / 2 33 | - bentuk senarai berisi bilangan bulat dari 2 hingga N (2, 3, 4, ..., N) 34 | - lakukan penghapusan untuk nilai I + J + 2IJ, dimana 35 | 1 <= I <= J 36 | */ 37 | 38 | auto algorithm(size_t N) 39 | { 40 | // menyimpan bilangan prima 41 | std::vector primes; 42 | 43 | size_t X = (N - 2) / 2; 44 | 45 | // daftar bilangan 46 | bool marks[X + 1]; 47 | memset(marks, true, sizeof(marks)); 48 | 49 | // tandai semua bilangan dalam rentang I + J + 2IJ 50 | for (size_t i = 1; i <= X; i++) 51 | for (size_t j = i; (i + j + 2*i*j) <= X; j++) 52 | marks[i + j + 2*i*j] = false; 53 | 54 | // 2 adalah bilangan prima 55 | primes.push_back(2); 56 | 57 | // masukkan bilangan yang belum ditandai 58 | for (size_t i = 1; i <= X; i++) 59 | { 60 | if (marks[i]) 61 | primes.push_back(2 * i + 1); 62 | } 63 | 64 | return primes; 65 | } -------------------------------------------------------------------------------- /Codes/Algorithm/searching/c++/cases/binary-search.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Binary Search 3 | Archive of Reversing.ID 4 | Algorithm (Searching) 5 | 6 | Decrease and Conquer. 7 | 8 | Compile: 9 | [clang] 10 | $ clang++ binary-search.cpp -o binary-search 11 | 12 | [gcc] 13 | $ g++ binary-search.cpp -o binary-search 14 | 15 | [msvc] 16 | $ cl binary-search.cpp 17 | 18 | Run: 19 | $ binary-search 20 | */ 21 | 22 | /* 23 | Implementasi Binary Search. 24 | 25 | Kode yang sama ada di bagian Divide and Conquer. 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | /** Recursive Solution **/ 31 | 32 | template 33 | bool algorithm(T arr[], size_t low, size_t high, T val, size_t & idx) 34 | { 35 | // Pencarian tidak berhasil karena ruang pencarian sudah tidak ada. 36 | if (low > high) 37 | return false; 38 | else 39 | { 40 | // Decrease 41 | size_t mid = (low + high)/2; 42 | T v = arr[mid]; 43 | 44 | if (v == val) 45 | { 46 | idx = mid; 47 | return true; 48 | } 49 | else if (val < v) 50 | return algorithm(arr, low, mid - 1, val, idx); 51 | else 52 | return algorithm(arr, mid + 1, high, val, idx); 53 | } 54 | } 55 | 56 | template 57 | bool algorithm(T arr[], size_t size, T val, size_t & idx) 58 | { 59 | return algorithm(arr, 0, size - 1, val); 60 | } 61 | 62 | // ====================================================================================== 63 | 64 | /** Iterative solution **/ 65 | 66 | template 67 | bool algorithm(T arr[], size_t size, T val, size_t & idx) 68 | { 69 | size_t mid; 70 | size_t low = 0, high = size - 1; 71 | T v; 72 | 73 | while (low <= high) 74 | { 75 | mid = (low + high)/2; 76 | v = arr[mid]; 77 | 78 | if (v == val) 79 | { 80 | idx = mid; 81 | return true; 82 | } 83 | else if (val < v) 84 | high = mid - 1; 85 | else 86 | low = mid + 1; 87 | } 88 | 89 | return false; 90 | } -------------------------------------------------------------------------------- /Codes/Algorithm/searching/c++/cases/interpolation-search.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Interpolation Search 3 | Archive of Reversing.ID 4 | Algorithm (Searching) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ interpolation-search.cpp -o interpolation-search 9 | 10 | [gcc] 11 | $ g++ interpolation-search.cpp -o interpolation-search 12 | 13 | [msvc] 14 | $ cl interpolation-search.cpp 15 | 16 | Run: 17 | $ interpolation-search 18 | */ 19 | 20 | /* 21 | Implementasi Interpolation Search. 22 | 23 | Kode yang sama ada di bagian Divide and Conquer. 24 | */ 25 | 26 | // ====================================================================================== 27 | 28 | template 29 | ssize_t algorithm(T arr[], size_t low, size_t high, T val) 30 | { 31 | // Pencarian tidak berhasil karena ruang pencarian sudah tidak ada. 32 | if (low > high) 33 | return -1; 34 | else 35 | { 36 | // Decrease 37 | size_t mid = (low + high)/2; 38 | T v = arr[mid]; 39 | 40 | if (v == val) 41 | return mid; 42 | else if (val < v) 43 | return algorithm(arr, low, mid - 1, val); 44 | else 45 | return algorithm(arr, mid + 1, high, val); 46 | } 47 | } 48 | 49 | template 50 | size_t algorithm(T arr[], size_t size, T val) 51 | { 52 | return algorithm(arr, 0, size - 1, val); 53 | } 54 | 55 | // ====================================================================================== 56 | 57 | template 58 | ssize_t algorithm(T arr[], size_t size, T val) 59 | { 60 | size_t pos; 61 | size_t low = 0, high = size - 1; 62 | T delta, v; 63 | 64 | while (low <= high && val >= arr[low] && val <= arr[high]) 65 | { 66 | delta = (val - arr[low]) / (arr[high] - arr[low]); 67 | pos = low + floor((high - low) * delta); 68 | v = arr[pos]; 69 | 70 | if (v == val) 71 | return pos; 72 | else if (val < v) 73 | high = pos - 1; 74 | else 75 | low = pos + 1; 76 | } 77 | 78 | return -1; 79 | } -------------------------------------------------------------------------------- /Codes/Algorithm/searching/c++/cases/jump-search.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Jump Search 3 | Archive of Reversing.ID 4 | Algorithm (Searching) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ jump-search.cpp -o jump-search 9 | 10 | [gcc] 11 | $ g++ jump-search.cpp -o jump-search 12 | 13 | [msvc] 14 | $ cl jump-search.cpp 15 | 16 | Run: 17 | $ jump-search 18 | */ 19 | 20 | /* 21 | Implementasi Jump Search. 22 | 23 | Jump Search adalah algoritma pencarian untuk senarai terurut. 24 | Ide dasarnya adalah memeriksa sesedikit mungkin elemen dengan melompat beberapa langkah 25 | ke depan (melewati beberapa elemen). 26 | 27 | Langkah: 28 | - cari rentang (blok) dimana elemen kemungkinan berada 29 | - lakukan Sequential Search pada blok tersebut. 30 | */ 31 | 32 | // ====================================================================================== 33 | 34 | template 35 | T min(T a, T b) 36 | { 37 | if (a < b) return a; 38 | else return b; 39 | } 40 | 41 | /* Sequential Search - digunakan untuk mencari elemen di block */ 42 | template 43 | bool search(T arr[], size_t size, T val, size_t & idx) 44 | { 45 | for (size_t i = 0; i < size; i++) 46 | { 47 | if (arr[i] == val) 48 | { 49 | idx = i; 50 | return true; 51 | } 52 | } 53 | return false; 54 | } 55 | 56 | // ====================================================================================== 57 | 58 | template 59 | bool algorithm(T arr[], size_t size, T val, size_t & idx) 60 | { 61 | // Menentukan banyaknya langkah per lompatan 62 | size_t step = sqrt(size); 63 | 64 | // Mencari blok dimana elemen mungkin berada 65 | size_t prev = 0; 66 | size_t next = step; 67 | while (arr[min(next, size) - 1] < val) 68 | { 69 | prev = next; 70 | next += step; 71 | 72 | if (prev >= size) 73 | return false; 74 | } 75 | 76 | // lakukan sequential search untuk mencari val di blok 77 | if (search(&arr[prev], next - prev, val, idx)) 78 | { 79 | idx += prev; 80 | return true; 81 | } 82 | 83 | return false; 84 | } -------------------------------------------------------------------------------- /Codes/Algorithm/searching/c++/cases/sequential-search.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Sequential Search 3 | Archive of Reversing.ID 4 | Algorithm (Searching) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ sequential-search.cpp -o sequential-search 9 | 10 | [gcc] 11 | $ g++ sequential-search.cpp -o sequential-search 12 | 13 | [msvc] 14 | $ cl sequential-search.cpp 15 | 16 | Run: 17 | $ sequential-search 18 | */ 19 | 20 | /* 21 | Implementasi Sequential Search / Linear Search. 22 | 23 | Kode yang sama ada di bagian Brute Force 24 | */ 25 | 26 | // ====================================================================================== 27 | 28 | template 29 | bool algorithm(T arr[], size_t size, T val, size_t & idx) 30 | { 31 | for (size_t i = 0; i < size; i++) 32 | { 33 | if (arr[i] == val) 34 | { 35 | idx = i; 36 | return true; 37 | } 38 | } 39 | 40 | return false; 41 | } -------------------------------------------------------------------------------- /Codes/Algorithm/searching/c++/searching.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Searching 3 | Archive of Reversing.ID 4 | Algorithm 5 | 6 | Prototipe algoritma 7 | */ 8 | 9 | // ====================================================================================== 10 | 11 | /* 12 | Eksekusi algoritma 13 | 14 | Parameter: 15 | - [T] arr: array tempat pencarian dilakukan. 16 | - [size_t] size: ukuran array 17 | - [T] val: nilai yang akan dicari 18 | - [size_t] idx: lokasi (indeks) elemen yang ditemukan 19 | 20 | Return: 21 | - [bool]: status pencarian (true = berhasil, false = gagal) 22 | */ 23 | 24 | template 25 | bool algorithm(T arr[], size_t size, T val, size_t & idx) 26 | { } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/bubble-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Bubble Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ bubble-sort.cpp -o bubble-sort 9 | 10 | [gcc] 11 | $ g++ bubble-sort.cpp -o bubble-sort 12 | 13 | [msvc] 14 | $ cl bubble-sort.cpp 15 | 16 | Run: 17 | $ bubble-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Bubble Sort 23 | 24 | Langkah: 25 | - scan rentang array 26 | - pindahkan elemen besar menuju ujung. 27 | */ 28 | 29 | // ====================================================================================== 30 | 31 | template 32 | void swap(T & a, T & b) 33 | { 34 | T t = b; 35 | b = a; 36 | a = t; 37 | } 38 | 39 | // ====================================================================================== 40 | 41 | /** Recursive Solution **/ 42 | 43 | template 44 | void algorithm(T arr[], size_t size) 45 | { 46 | // base case adalah 1 elemen 47 | if (size > 1) 48 | { 49 | /* 50 | Melakukan satu pass Bubble Sort. 51 | Setelah ini, elemen terbesar akan dipindahkan ke akhir. 52 | */ 53 | for (size_t i = 0; i < size - 1; i++) 54 | if (arr[i] > arr[i + 1]) 55 | swap(arr[i], arr[i + 1]); 56 | 57 | // lakukan rekursi ke rentang array tersisa 58 | algorithm(arr, size - 1); 59 | } 60 | } 61 | 62 | // ====================================================================================== 63 | 64 | /** Iterative Solution **/ 65 | 66 | template 67 | void algorithm(T arr[], size_t size) 68 | { 69 | for (size_t i = 0; i < size; i++) 70 | for (size_t j = 0; j < size - i - 1; j++) 71 | if (arr[j] > arr[j + 1]) 72 | swap(arr[j], arr[j + 1]); 73 | } 74 | -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/comb-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Comb Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ comb-sort.cpp -o comb-sort 9 | 10 | [gcc] 11 | $ g++ comb-sort.cpp -o comb-sort 12 | 13 | [msvc] 14 | $ cl comb-sort.cpp 15 | 16 | Run: 17 | $ comb-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Comb Sort 23 | 24 | Peningkatan dari Bubble Sort. 25 | Bubble Sort selalu membandingkan nilai yang bertetangga. Sementara Comb Sort menggunakan 26 | jarak ukuran lebih dari 1. 27 | */ 28 | 29 | // ====================================================================================== 30 | 31 | template 32 | void swap(T & a, T & b) 33 | { 34 | T t = b; 35 | b = a; 36 | a = t; 37 | } 38 | 39 | int getNextGap(int gap) 40 | { 41 | // perkecil gap dengan shrink factor 42 | gap = (gap * 10) / 13; 43 | 44 | if (gap < 1) 45 | return 1; 46 | 47 | return gap; 48 | } 49 | 50 | // ====================================================================================== 51 | 52 | /** Iterative Solution **/ 53 | 54 | void algorithm(int arr[], size_t size) 55 | { 56 | // inisialisasi gap 57 | size_t gap = size; 58 | bool swapped = true; 59 | 60 | while (gap != 1 || swapped) 61 | { 62 | // cari gap berikutnya 63 | gap = getNextGap(gap); 64 | 65 | // inisialisasi swapp 66 | swapped = false; 67 | 68 | // bandingkan semua elemen dengan gap sekarang 69 | for (size_t i = 0; i < size - gap; i++) 70 | { 71 | if (arr[i] > arr[i + gap]) 72 | { 73 | swap(arr[i], arr[i + gap]); 74 | swapped = true; 75 | } 76 | } 77 | } 78 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/counting-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Counting Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ counting-sort.cpp -o counting-sort 9 | 10 | [gcc] 11 | $ g++ counting-sort.cpp -o counting-sort 12 | 13 | [msvc] 14 | $ cl counting-sort.cpp 15 | 16 | Run: 17 | $ counting-sort 18 | */ 19 | #include // untuk memset 20 | 21 | #define RANGE 255 22 | 23 | /* 24 | Implementasi Counting Sort. 25 | 26 | Melakukan sorting berdasarkan kemunculan key (key unik penanda nilai suatu elemen). 27 | Pengurutan dilakukan dengan perhitungan kemunculan key. 28 | 29 | Kelemahan: 30 | Hanya dapat melakukan pengurutan terhadap elemen bertipe bilangan bulat dengan rentang 31 | nilai terbatas. 32 | */ 33 | 34 | // ====================================================================================== 35 | 36 | /** Iterative Solution **/ 37 | 38 | void algorithm(int arr[], size_t size) 39 | { 40 | size_t i, j; 41 | int counter[RANGE + 1]; 42 | 43 | // inisialisasi array dengan 0 44 | memset(counter, 0, sizeof(counter)); 45 | 46 | // hitung kemunculan tiap elemen 47 | for (i = 0; i < size; i++) 48 | ++ counter[arr[i]]; 49 | 50 | /* 51 | iterasi dari awal hingga akhir, jika counter menunjukkan nilai positif maka proses 52 | sebagai elemen array 53 | */ 54 | for (i = 0, j = 0; i <= RANGE; i++) 55 | { 56 | while (counter[i]--) 57 | arr[j++] = i; 58 | } 59 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/exchange-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Exchange Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ exchange-sort.cpp -o exchange-sort 9 | 10 | [gcc] 11 | $ g++ exchange-sort.cpp -o exchange-sort 12 | 13 | [msvc] 14 | $ cl exchange-sort.cpp 15 | 16 | Run: 17 | $ exchange-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Exchange Sort. 23 | 24 | Mirip dengan Bubble Sort. 25 | Exchange Sort membandingkan elemen pertama dengan setiap elemen berikutnya di array. 26 | */ 27 | 28 | // ====================================================================================== 29 | 30 | template 31 | void swap(T & a, T & b) 32 | { 33 | T t = b; 34 | b = a; 35 | a = t; 36 | } 37 | 38 | template 39 | void algorithm(T arr[], size_t size) 40 | { 41 | ssize_t i, j; 42 | 43 | for (i = 0; i < size - 1; i++) 44 | for (j = i + 1; j < size; j++) 45 | if (arr[i] > arr[j]) 46 | swap(arr[i], arr[j]); 47 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/heap-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Heap Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ heap-sort.cpp -o heap-sort 9 | 10 | [gcc] 11 | $ g++ heap-sort.cpp -o heap-sort 12 | 13 | [msvc] 14 | $ cl heap-sort.cpp 15 | 16 | Run: 17 | $ heap-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Heap Sort. 23 | 24 | Binary Heap adalah Complete Binary Tree dengan item tersimpan berdasarkan urutan khusus. 25 | Nilai di node parent lebih besar (atau lebih kecil) daripada nilai di kedua node children. 26 | 27 | Heap Sort berusaha mentransformasikan array menjadi representasi Binary Heap. 28 | 29 | Langkah: 30 | - bangun max heap pada rentang array tertentu 31 | - tukar root max-heap dengan elemen terakhir array 32 | - kembali ke langkah pertama hingga ukuran heap lebih dari 1 33 | */ 34 | 35 | // ====================================================================================== 36 | 37 | template 38 | void swap(T & a, T & b) 39 | { 40 | T t = b; 41 | b = a; 42 | a = t; 43 | } 44 | 45 | // ====================================================================================== 46 | 47 | /** Recursive Solution **/ 48 | 49 | // membentuk array dengan property heap. 50 | template 51 | void heapify(T arr[], size_t size, size_t idx) 52 | { 53 | size_t largest = idx; 54 | size_t left = 2 * idx + 1; 55 | size_t right = 2 * idx + 2; 56 | 57 | if (left < size && arr[left] > arr[largest]) 58 | largest = left; 59 | 60 | if (right < size && arr[right] > arr[largest]) 61 | largest = right; 62 | 63 | if (largest != idx) 64 | { 65 | swap(arr[idx], arr[largest]); 66 | heapify(arr, size, largest); 67 | } 68 | } 69 | 70 | template 71 | void algorithm(T arr[], size_t size) 72 | { 73 | ssize_t i; 74 | 75 | // build heap 76 | for (i = size / 2 - 1; i >= 0; i--) 77 | heapify(arr, size, i); 78 | 79 | // mengambil elemen paling besar 80 | for (i = size - 1; i >= 0; i--) 81 | { 82 | swap(arr[0], arr[i]); 83 | heapify(arr, i, 0); 84 | } 85 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/insertion-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Insertion Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ insertion-sort.cpp -o insertion-sort 9 | 10 | [gcc] 11 | $ g++ insertion-sort.cpp -o insertion-sort 12 | 13 | [msvc] 14 | $ cl insertion-sort.cpp 15 | 16 | Run: 17 | $ insertion-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Insertion Sort. 23 | 24 | Array dibangun dengan cara penyusunan ulang. 25 | Elemen array dibandingkan satu sama lain secara sekuensial dan disusun secara simultan 26 | dengan urutan tertentu. 27 | */ 28 | 29 | // ====================================================================================== 30 | 31 | /** Recursive Solution **/ 32 | 33 | template 34 | void algorithm(T arr[], size_t size) 35 | { 36 | // base case adalah 1 elemen 37 | if (size > 1) 38 | { 39 | // urutkan (size - 1) elemen terlebih daulu 40 | algorithm(arr, size - 1); 41 | 42 | // sisipkan elemen terakhir ke posisi yang tepat di array terurut 43 | T key = arr[size - 1]; 44 | size_t j = size - 2; 45 | 46 | // pindahkan elemen [0 .. j-1] yang lebih besar dari key 47 | for (; j >= 0 && arr[j] > key; j--) 48 | arr[j + 1] = arr[j]; 49 | 50 | arr[j + 1] = key; 51 | } 52 | } 53 | 54 | // ====================================================================================== 55 | 56 | /** Iterative Solution **/ 57 | 58 | template 59 | void algorithm(T arr[], size_t size) 60 | { 61 | ssize_t i, j; 62 | T key; 63 | 64 | for (i = 1; i < size; i++) 65 | { 66 | // ambil key sebagai pivot 67 | key = arr[i]; 68 | 69 | // geser semua elemen yang lebih besar daripada key ke kanan. 70 | for (j = i - 1; j >= 0 && arr[j] > key; j--) 71 | arr[j + 1] = arr[j]; 72 | 73 | arr[j + 1] = key; 74 | } 75 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/merge-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Merge Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ merge-sort.cpp -o merge-sort 9 | 10 | [gcc] 11 | $ g++ merge-sort.cpp -o merge-sort 12 | 13 | [msvc] 14 | $ cl merge-sort.cpp 15 | 16 | Run: 17 | $ merge-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Merge Sort. 23 | 24 | Kode yang sama ada di bagian Divide and Conquer. 25 | */ 26 | 27 | // ====================================================================================== 28 | 29 | template 30 | void algorithm(T arr[], size_t low, size_t high) 31 | { 32 | if (high > low) 33 | { 34 | size_t size = high - low + 1; 35 | size_t mid = low + (high - low) / 2; 36 | 37 | algorithm(arr, low, mid); 38 | algorithm(arr, mid + 1, high); 39 | 40 | auto arr2 = std::make_unique(size); 41 | 42 | size_t k = 0; 43 | size_t i = low; 44 | size_t j = mid + 1; 45 | 46 | while (i <= mid && j <= high) 47 | { 48 | if (arr[i] <= arr[j]) 49 | arr2[k++] = arr[i++]; 50 | else 51 | arr2[k++] = arr[j++]; 52 | } 53 | 54 | while (i <= mid) 55 | arr2[k++] = arr[i++]; 56 | 57 | while (j <= high) 58 | arr2[k++] = arr[j++]; 59 | 60 | for (k = 0; k < size; k++) 61 | arr[low + k] = arr2[k]; 62 | } 63 | } 64 | 65 | template 66 | void algorithm(T arr[], size_t size) 67 | { 68 | algorithm(arr, 0, size - 1); 69 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/selection-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Selection Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ selection-sort.cpp -o selection-sort 9 | 10 | [gcc] 11 | $ g++ selection-sort.cpp -o selection-sort 12 | 13 | [msvc] 14 | $ cl selection-sort.cpp 15 | 16 | Run: 17 | $ selection-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Selection Sort. 23 | 24 | Array dibangun dengan cara penyusunan ulang. 25 | Elemen array dibandingkan satu sama lain secara sekuensial dan disusun secara simultan 26 | dengan urutan tertentu. 27 | 28 | Langkah: 29 | - mencari nilai terkecil pada suatu rentang 30 | - menukar elemen terkecil dengan elemen pertama pada rentang 31 | - memperkecil rentang dengan mengeluarkan elemen pertama dari rentang dan ulangi 32 | operasi dari langkah pertama. 33 | */ 34 | 35 | // ====================================================================================== 36 | 37 | template 38 | void swap(T & a, T & b) 39 | { 40 | T t = b; 41 | b = a; 42 | a = t; 43 | } 44 | 45 | template 46 | void algorithm(T arr[], size_t size) 47 | { 48 | size_t i, j, min_idx; 49 | 50 | // perlahan memindahkan batas dari unsorted array 51 | for (i = 0; i < size - 1; i++) 52 | { 53 | // cari elemen dengna nilai minimum 54 | min_idx = i; 55 | for (j = i + 1; j < size; j++) 56 | if (arr[j] < arr[min_idx]) 57 | min_idx = j; 58 | 59 | swap(arr[min_idx], arr[i]); 60 | } 61 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/cases/shell-sort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Shell Sort 3 | Archive of Reversing.ID 4 | Algorithm (Sorting) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ shell-sort.cpp -o shell-sort 9 | 10 | [gcc] 11 | $ g++ shell-sort.cpp -o shell-sort 12 | 13 | [msvc] 14 | $ cl shell-sort.cpp 15 | 16 | Run: 17 | $ shell-sort 18 | */ 19 | 20 | 21 | /* 22 | Implementasi Shell Sort. 23 | */ 24 | 25 | // ====================================================================================== 26 | 27 | template 28 | void swap(T & a, T & b) 29 | { 30 | T t = b; 31 | b = a; 32 | a = t; 33 | } 34 | 35 | template 36 | void algorithm(T arr[], size_t size) 37 | { 38 | ssize_t i, j; 39 | ssize_t d = size; 40 | bool flag = true; 41 | 42 | while (flag && d > 1) 43 | { 44 | flag = false; 45 | d = (d + 1) / 2; 46 | 47 | for (i = 0; i < size - d; i++) 48 | { 49 | if (arr[i + d] < arr[i]) 50 | { 51 | swap(arr[i + d], arr[i]); 52 | flag = true; 53 | } 54 | } 55 | } 56 | } -------------------------------------------------------------------------------- /Codes/Algorithm/sorting/c++/sorting.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Sorting 3 | Archive of Reversing.ID 4 | Algorithm 5 | 6 | Prototipe algoritma 7 | */ 8 | 9 | // ====================================================================================== 10 | 11 | /* 12 | Eksekusi algoritma 13 | 14 | Parameter: 15 | - [T] arr: array yang akan diurutkan 16 | - [size_t] size: ukuran array 17 | */ 18 | 19 | template 20 | void algorithm(T arr[], size_t size) 21 | { } -------------------------------------------------------------------------------- /Codes/Algorithm/strings/c++/cases/pattern-matching/naive-string-matching.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Naive String Matching 3 | Archive of Reversing.ID 4 | Algorithm (Strings) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ naive-string-matching.cpp -o naive-string-matching 9 | 10 | [gcc] 11 | $ g++ naive-string-matching.cpp -o naive-string-matching 12 | 13 | [msvc] 14 | $ cl naive-string-matching.cpp 15 | 16 | Run: 17 | $ naive-string-matching 18 | */ 19 | #include 20 | 21 | /* 22 | Pattern Searching. 23 | 24 | Masalah: 25 | Diberikan teks dengan panjang N, dan pola dengan panjang M. 26 | Jika teks memuat pola, tentukan posisi awal kemunculan pola tersebut. 27 | 28 | Contoh: 29 | teks = "archive of REVERSING.ID " 30 | pola = "REV" 31 | output = pattern found at index 11 32 | 33 | */ 34 | 35 | // ====================================================================================== 36 | 37 | auto algorithm(char text[], int N, char pattern[], int M) 38 | { 39 | int t, p; 40 | 41 | // posisi ditemukan pola 42 | std::vector result; 43 | 44 | // geser pattern satu per satu 45 | for (t = 0; t <= N - M; t++) 46 | { 47 | p = 0; 48 | while (p < M && text[t + p] == pattern[p]) p++; 49 | 50 | if (p == M) 51 | result.push_back(t); 52 | } 53 | 54 | return result; 55 | } -------------------------------------------------------------------------------- /Codes/Data-Structure/Array/README.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Array implementation and reversing 4 | 5 | ## Overview 6 | 7 | Array adalah struktur data sederhana untuk menyimpan elemen data yang homogen di lokasi yang kontigu. Ukuran array harus didefinisikan terlebih dahulu sebelum penyimpanan data dapat dilakukan. 8 | 9 | * Accessing Time: O(1) 10 | * Search Time: O(n) untuk pencarian sekuensial, O(log n) untuk binary search jika array dalam keadaan terurut. 11 | * Insertion Time: O(n) 12 | * Deletion Time: O(n) 13 | 14 | ## Reversing Notes 15 | 16 | #### Code 17 | 18 | Sebagai kumpulan elemen kontigu, akses elemen Array dilakukan berdasarkan dua informasi: `base address` dan `offset`. Base address adalah alamat dimana penyimpanan Array dimulai. Sementara offset adalah jarak dari base address dimana elemen dapat ditemukan. 19 | 20 | Array dapat dideklarasikan secara global maupun lokal (dalam fungsi). Ketika dideklarasikan secara global, Array akan dialokasikan di section data yang dapat diakses (baca/tulis). Base address akan bernilai sebuah alamat statis. Sementara ketika dideklarasikan secara lokal, Array akan dialokasikan di Stack. Base address akan relatif terhadap `Stack Pointer` dan hanya berlaku pada scope fungsi saja. 21 | 22 | Nilai offset bergantung kepada index dan ukuran elemen. Index adalah urutan sebuah elemen di dalam deretan Array. Elemen pertama diidentifikasi dengan index 0. Karena Array adalah struktur data yang homogen, maka jarak antar elemen proporsional dengan ukuran elemen itu sendiri. 23 | 24 | Sehingga untuk mendapatkan alamat dari suatu elemen, maka perhitungan berikut dapat digunakan. 25 | 26 | ``` 27 | address = base + index * size 28 | ``` -------------------------------------------------------------------------------- /Codes/Data-Structure/Graph/README.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Graph implementation and reversing. 4 | 5 | ### Overview 6 | 7 | `Graph` adalah struktur data nonlinier yang terdiri atas himpunan `node` (simpul) yang dihubungkan oleh `edge` (sisi). 8 | 9 | Terdapat dua cara mengekspresikan `Graph`, yaitu: `adjacency list` dan `adjacency matrix`. 10 | 11 | `Adjacency matrix` (matrix tetangga) adalah array dua dimensi yang digunakan untuk menyimpan informasi koneksi antarsimpul dan dapat melakukan penelusuran dengan sangat cepat. Namun sebagai konsekuensinya, ukuran memory yang harus disediakan menjadi besar. Jika graph relatif renggang (sparse), maka akan terdapat banyak ruang yang terbuang. 12 | 13 | `Adjacency list` merupakan sebuah linked-list, dimana setiap simpul memiliki Array yang menyimpan koneksi ke simpul lain. Pendekatan ini lebih fleksibel dan dapat menghemat ruang memory yang digunakan. 14 | 15 | ### Reversing Notes 16 | 17 | ### References 18 | 19 | Definisi, karakteristik, variasi, dan informasi lain tentang Graph: -------------------------------------------------------------------------------- /Codes/Data-Structure/List/Doubly-Linked-List/README.md: -------------------------------------------------------------------------------- 1 | ## Linked List 2 | 3 | ### Doubly Linked List 4 | 5 | Senarai dengan setiap node memiliki dua tautan, satu menuju elemen penerus (successor) dan satu menuju elemen pendahulu (predecessor). Hal ini berarti penelusuran dapat dilakukan dua arah yakni maju (dari awalhingga akhir) dan mundur (dari akhir ke awal). 6 | 7 | Terdapat beberapa variasi yang memungkinkan, yakni: 8 | 9 | - __head__, sebuah plain linked-list dengan sebuah pointer khusus untuk menunjuk posisi HEAD atau node mula-mula. 10 | - __head & tail__, sebuah plain linked-list dengan pointer menunjuk ke posisi mula-mula (HEAD) dan posisi akhir (TAIL). 11 | - __self-pointed__, node akhir pada senarai akan menunjuk ke diri sendiri sebagai penanda (bahwa node tersebut merupakan node akhir). 12 | - __circular__, sebuah plain linked-list dengan node awal dan node akhir saling menunjuk, TAIL menunjuk HEAD sebagai node penerus dan HEAD menunjuk TAIL sebagai pendahulu. 13 | 14 | ## Reversing Notes -------------------------------------------------------------------------------- /Codes/Data-Structure/List/README.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Linked-list implementation and reversing. 4 | 5 | ## Overview 6 | 7 | `Linked-list` (senarai bertautan) adalah sekumpulan elemen yang saling terhubung membentuk rantai dan dapat diakses secara sekuensial. Setiap elemen dapat memiliki penerus (successor) dan pendahulu (predecessor). Elemen mungkin tidak terletak bersebelahan secara fisik di memory, namun antar elemen terletak bersebelahan secara logis. 8 | 9 | Masing-masing elemen dalam senarai disimpan dalam struktur yang disebut `node` (simpul). Node berperan sebagai kontainer nilai dan juga definisi untuk mengakses elemen penerus. 10 | 11 | ## Reversing Notes 12 | 13 | ## References 14 | 15 | Definisi, karakteristik, variasi, dan informasi lain tentang Linked-List: 16 | 17 | - [Referensi](../../../References/Data-Structure/List/README.md) -------------------------------------------------------------------------------- /Codes/Data-Structure/List/Singly-Linked-List/README.md: -------------------------------------------------------------------------------- 1 | ## Linked List 2 | 3 | Singly Linked-List implementation and reversing. 4 | 5 | ### Overview 6 | 7 | Senarai dengan setiap node hanya memiliki satu tautan menuju elemen penerus (successor). Hal ini berarti penelusuran hanya dapat dilakukan satu arah yakni dari awal (node mula) hingga akhir. 8 | 9 | Terdapat beberapa variasi yang memungkinkan, yakni: 10 | 11 | - __head__, sebuah plain linked-list dengan sebuah pointer khusus untuk menunjuk posisi HEAD atau node mula-mula. 12 | - __head & tail__, sebuah plain linked-list dengan pointer menunjuk ke posisi mula-mula (HEAD) dan posisi akhir (TAIL). 13 | - __self-pointed__, node akhir pada senarai akan menunjuk ke diri sendiri sebagai penanda (bahwa node tersebut merupakan node akhir). 14 | - __sentinel-first__, sebuah sentinel (node fiktif) sengaja diletakkan di awal untuk menghindari adanya kasus list kosong. 15 | - __sentinel-last__, sebuah sentinel (node fiktif) sengaja diletakkan di akhir untuk menyeragamkan penanganan terhadap kasus list kosong. 16 | - __self-sentinel__, sebuah sentinel yang menunjuk ke diri sendiri (self-pointed). 17 | - __circular__, sebuah plain linked-list dengan node akhir menunjuk ke node awal, TAIL menunjuk HEAD sebagai node penerus. 18 | 19 | ## Reversing Notes -------------------------------------------------------------------------------- /Codes/Data-Structure/List/Xor-Linked-List/README.md: -------------------------------------------------------------------------------- 1 | ## Linked List 2 | 3 | Xor Linked-List implementation and reversing. 4 | 5 | ### Overview 6 | 7 | Senarai dengan setiap node memiliki satu tautan yang mengarah ke elemen penerus (successor) dan pendahulu (predecessor) sekaligus. Alamat yng disimpan pada tautan merupakan alamat hasil operasi XOR antara alamat penerus dan pendahulu. 8 | 9 | Hal ini berarti struktur Xor-Linked List dapat menyimpan tautan secara efisien namun perlu operasi ekstra untuk mendapatkan alamat node lain. 10 | 11 | Terdapat beberapa variasi yang memungkinkan, yakni: 12 | 13 | - __head__, sebuah plain linked-list dengan sebuah pointer khusus untuk menunjuk posisi HEAD atau node mula-mula. 14 | - __head & tail__, sebuah plain linked-list dengan pointer menunjuk ke posisi mula-mula (HEAD) dan posisi akhir (TAIL). 15 | - __circular__, sebuah plain linked-list dengan node awal dan node akhir saling menunjuk, TAIL menunjuk HEAD sebagai node penerus dan HEAD menunjuk TAIL sebagai pendahulu. 16 | 17 | ## Reversing Notes 18 | 19 | Xorlist memiliki dua field yaitu `data` dan `link`. Nilai alamat yang disimpan dalam `link` merupakan hasil operasi XOR. Nilai ini tidak secara eksplisit terindikasi sebagai sebuah alamat. -------------------------------------------------------------------------------- /Codes/Data-Structure/README.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Data Structure 4 | 5 | ## Overview 6 | 7 | Bagian ini akan membahas tentang `struktur data` secara umum dengan menyertakan sudut pandang Reverse Engineering dalam pembahasannya. Materi ini diharapkan dapat memberikan pemahaman dalam melakukan analisis, terutama dalam mengidentifikasi struktur data. 8 | 9 | Hampir seluruh struktur data diturunkan dari dua pendekatan: `Array` (penyimpanan sekuensial) dan `Linked-List` (penyimpanan berantai). Struktur data yang lebih kompleks seperti `Stack`, `Queue`, `Heap`, `Tree`, `Graph`, dsb menggunakan `Array` atau `Linked-List` di implementasinya. 10 | 11 | Meski masing-masing struktur data memiliki operasi yang unik namun secara garis besar operasi struktur data merupakan operasi penelusuran (akses elemen) serta perubahan struktur (add, delete, get value, modify). 12 | 13 | ## General Instruction 14 | 15 | Setiap topik memiliki source code dalam bahasa pemrograman tertentu. Masing-masing source code akan memiliki instruksi kompilasi secara manual. Lakukan kompilasi, amati hasil kompilasi, dan identifikasi operasi-operasi struktur data. Gunakan source sebagai perbandingan untuk mengidentifikasi fungsi/method yang sesuai. 16 | 17 | ## Reverse Engineering 18 | 19 | Sebagian algoritma memanfaatkan struktur data untuk mengelola data secara efisien. Identifikasi struktur data diperlukan untuk memahami alur algoritma. 20 | 21 | Source code yang dikompilasi menjadi [instruksi tingkat rendah](https://github.com/ReversingID/LowLevelCode-Reference) (assembly dan bytecode) akan memberikan tantangan tersendiri. Karakteristik struktur data menjadi kabur dimana hanya terdapat data dan operasi terkait yang dapat diamati. Identifikasi kemudian dilakukan dengan mengamati ruang memory yang dialokasikan serta operasi-operasi yang terjadi. Dalam beberapa kasus, nama fungsi akan hilang atau berubah sebagai efek dari kompilasi atau obfuscation. Dengan demikian, analisis harus dilakukan dari awal untuk setiap operasi. -------------------------------------------------------------------------------- /Codes/Data-Structure/Tree/README.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Tree implementation and reversing. 4 | 5 | ## Overview 6 | 7 | `Tree` (pohon) adalah variasi dari `Linked-List` (senarai bertautan), dimana sebuah simpul dapat terhubung ke 2 atau lebih simpul lain. Tree membentuk sebuah hirarki dengan simpul asal, atau pendahulu dari simpul lain, disebut sebagai `root`. 8 | 9 | Tree secara alamiah diimplementasikan sebagai linked-list. Namun dalam beberapa kasus, Tree dengan karakteristik khusus dapat diimplementasikan sebagai array. 10 | 11 | ## Reversing Notes 12 | 13 | ## References 14 | 15 | Definisi, karakteristik, variasi, dan informasi lain tentang Tree: -------------------------------------------------------------------------------- /Codes/Design-Pattern/Behavioral/README.md: -------------------------------------------------------------------------------- 1 | # Design Pattern 2 | 3 | ## Behavioral Pattern 4 | 5 | Beberapa pattern dalam behavioral design pattern: 6 | 7 | - Chain of Responsibility 8 | - Command 9 | - Interpreter 10 | - Mediator 11 | - Memento 12 | - Observer 13 | - State 14 | - Strategy 15 | - Template 16 | - Visitor -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Named-Factory/c++/cases/point.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Point 3 | Archive of Reversing.ID 4 | Design Pattern (Creational/Named Factory) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ point.cpp -o point 9 | 10 | [gcc] 11 | $ g++ point.cpp -o point 12 | 13 | [msvc] 14 | $ cl point.cpp 15 | 16 | Run: 17 | $ point 18 | */ 19 | #include 20 | #include 21 | 22 | /* *********************************** DECLARATION *********************************** */ 23 | 24 | /** 25 | * Point (concrete) 26 | * 27 | * Representasi titik dalam 2 dimensi (X-Y) 28 | */ 29 | struct Point 30 | { 31 | Point(double x, double y) : x{x}, y{y} 32 | { } 33 | 34 | double x, y; 35 | 36 | static Point cartesian(double x, double y) 37 | { 38 | return Point{x, y}; 39 | } 40 | 41 | static Point polar(double r, double theta) 42 | { 43 | return Point{ r*cos(theta), r*sin(theta) }; 44 | } 45 | }; 46 | 47 | /* *********************************** USAGE *********************************** */ 48 | 49 | int main(int argc, char* argv[]) 50 | { 51 | Point p0{1, 5}; 52 | Point p1 = Point::cartesian(10, 20); 53 | Point p2 = Point::polar(10, 45); 54 | 55 | return 0; 56 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Named-Factory/c++/named-factory-1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Named Factory 3 | Archive of Reversing.ID 4 | Design Pattern (Creational) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ named-factory.cpp -o named-factory 9 | 10 | [gcc] 11 | $ g++ named-factory.cpp -o named-factory 12 | 13 | [msvc] 14 | $ cl named-factory.cpp 15 | 16 | Run: 17 | $ named-factory 18 | */ 19 | #include 20 | #include 21 | 22 | /* *********************************** DECLARATION *********************************** */ 23 | /** 24 | * NamedFactory (concrete) 25 | * 26 | * Menciptakan objek dengan sebuah static method. 27 | * 28 | * Named Factory dapat berupa sebuah factory dengan class abstract yang akan menghasilkan 29 | * objek lain. 30 | * 31 | * Method dapat pula dikelompokkan menjadi satu ke dalam inner class yang bertindak sebagai 32 | * factory. 33 | */ 34 | class NamedFactory 35 | { 36 | uint8_t _param1, _param2; 37 | 38 | public: 39 | NamedFactory(uint8_t param1, uint8_t param2) : _param1(param1), _param2(param2) { } 40 | 41 | /* -- Membangun objek dari representasi berbeda -- */ 42 | 43 | static NamedFactory fromA(uint8_t param1, uint8_t param2) 44 | { 45 | return std::move(NamedFactory(param1, param2)); 46 | } 47 | 48 | static NamedFactory fromB(uint64_t param) 49 | { 50 | return std::move(NamedFactory(param & 0xFF, (param >> 8) & 0xFF)); 51 | } 52 | }; 53 | 54 | /* *********************************** USAGE *********************************** */ 55 | 56 | int main(int argc, char* argv[]) 57 | { 58 | NamedFactory nf1 = NamedFactory::fromA(135, 182); 59 | NamedFactory nf2 = NamedFactory::fromB(0xB687); 60 | 61 | return 0; 62 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Prototype/c++/prototype-1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Prototype 3 | Archive of Reversing.ID 4 | Design Pattern (Creational) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ prototype.cpp -o prototype 9 | 10 | [gcc] 11 | $ g++ prototype.cpp -o prototype 12 | 13 | [msvc] 14 | $ cl prototype.cpp 15 | 16 | Run: 17 | $ prototype 18 | */ 19 | #include 20 | 21 | 22 | /* *********************************** DECLARATION *********************************** */ 23 | /** 24 | * Prototype (abstract) 25 | * 26 | * Kelas abstrak yang mendefinisikan method clone() untuk membentuk salinan diri. 27 | */ 28 | class Prototype 29 | { 30 | public: 31 | virtual ~Prototype() { } 32 | virtual auto clone() -> std::unique_ptr = 0; 33 | }; 34 | 35 | // ====================================================================================== 36 | 37 | /** 38 | * ConcreteProduct (concrete) 39 | */ 40 | class ConcreteProduct : public Prototype 41 | { 42 | public: 43 | ConcreteProduct() { } 44 | 45 | // Menyalin informasi dari prototype 46 | ConcreteProduct(const ConcreteProduct & cp) 47 | { } 48 | 49 | // Memberikan objek baru sebagai salinan dari prototype. 50 | auto clone() -> std::unique_ptr 51 | { 52 | return std::make_unique(*this); 53 | } 54 | }; 55 | 56 | 57 | /* *********************************** USAGE *********************************** */ 58 | #include 59 | 60 | int main(int argc, char* argv[]) 61 | { 62 | // Buat sebuah prototype sebuah objek 63 | auto proto = std::make_unique(); 64 | 65 | // Salin objek dari prototype proto 66 | auto clone1 = proto->clone(); 67 | 68 | // Salin objek dari prototype proto 69 | auto clone2 = proto->clone(); 70 | 71 | std::cout << proto.get() << std::endl; 72 | std::cout << clone1.get() << std::endl; 73 | std::cout << clone2.get() << std::endl; 74 | 75 | return 0; 76 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Prototype/c++/prototype-1b.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Prototype 3 | Archive of Reversing.ID 4 | Design Pattern (Creational) 5 | 6 | Compile: 7 | [clang] 8 | $ clang++ prototype.cpp -o prototype 9 | 10 | [gcc] 11 | $ g++ prototype.cpp -o prototype 12 | 13 | [msvc] 14 | $ cl prototype.cpp 15 | 16 | Run: 17 | $ prototype 18 | */ 19 | 20 | 21 | /* *********************************** DECLARATION *********************************** */ 22 | /** 23 | * Prototype (abstract) 24 | * 25 | * Kelas abstrak yang mendefinisikan method clone() untuk membentuk salinan diri. 26 | */ 27 | class Prototype 28 | { 29 | public: 30 | virtual ~Prototype() { } 31 | virtual Prototype * clone() = 0; 32 | }; 33 | 34 | // ====================================================================================== 35 | 36 | /** 37 | * ConcreteProduct (concrete) 38 | */ 39 | class ConcreteProduct : public Prototype 40 | { 41 | public: 42 | ConcreteProduct() { } 43 | 44 | // Menyalin informasi dari prototype 45 | ConcreteProduct(const ConcreteProduct & cp) 46 | { } 47 | 48 | // Memberikan objek baru sebagai salinan dari prototype. 49 | Prototype * clone() 50 | { 51 | return new ConcreteProduct(*this); 52 | } 53 | }; 54 | 55 | 56 | /* *********************************** USAGE *********************************** */ 57 | #include 58 | 59 | int main(int argc, char* argv[]) 60 | { 61 | // Buat sebuah prototype sebuah objek 62 | Prototype * proto = new ConcreteProduct(); 63 | 64 | // Salin objek dari prototype proto 65 | Prototype * clone1 = proto->clone(); 66 | 67 | // Salin objek dari prototype proto 68 | Prototype * clone2 = proto->clone(); 69 | 70 | delete proto; 71 | delete clone1; 72 | delete clone2; 73 | 74 | return 0; 75 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/README.md: -------------------------------------------------------------------------------- 1 | # Design Pattern 2 | 3 | ## Creational Patterns 4 | 5 | Creational pattern berfokus terhadap mekanisme penciptaan objek atau sekelompok objek yang terkait. 6 | 7 | Beberapa pattern dalam creational design pattern: 8 | 9 | - Abstract Factory 10 | - Builder 11 | - Factory Method 12 | - Multiton 13 | - Object Pool 14 | - Prototype 15 | - Singleton -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Singleton/c++/singleton-1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Singleton 3 | Archive of Reversing.ID 4 | Design Pattern (Creational) 5 | 6 | Modern C++ 7 | 8 | Membuat instance di heap yang akan dikelola oleh unique_ptr<> 9 | 10 | Compile: 11 | [clang] 12 | $ clang++ singleton.cpp -o singleton 13 | 14 | [gcc] 15 | $ g++ singleton.cpp -o singleton 16 | 17 | [msvc] 18 | $ cl singleton.cpp 19 | 20 | Run: 21 | $ singleton 22 | */ 23 | #include 24 | 25 | 26 | /* *********************************** DECLARATION *********************************** */ 27 | /** 28 | * Singleton (concrete) 29 | */ 30 | class Singleton 31 | { 32 | Singleton() = default; 33 | 34 | Singleton(const Singleton &) = delete; 35 | Singleton(Singleton&&) = delete; 36 | Singleton& operator=(const Singleton &) = delete; 37 | Singleton& operator=(Singleton &&) = delete; 38 | 39 | public: 40 | ~Singleton() = default; 41 | 42 | static Singleton& getInstance() 43 | { 44 | // Instance didefinisikan sebagai static 45 | static auto _instance = std::unique_ptr{nullptr}; 46 | 47 | if (!_instance) 48 | _instance.reset(new Singleton); 49 | 50 | return *_instance.get(); 51 | } 52 | }; 53 | 54 | /* *********************************** USAGE *********************************** */ 55 | 56 | int main(int argc, char* argv[]) 57 | { 58 | /* Instansiasi awal akan menciptakan objek baru (Singleton&) */ 59 | auto& inst1 = Singleton::getInstance(); 60 | 61 | /* 62 | Instansiasi selanjutnya akan mengambil instance 63 | yang telah diciptakan sebelumnya. 64 | */ 65 | auto& inst2 = Singleton::getInstance(); 66 | 67 | return 0; 68 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Singleton/c++/singleton-2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Singleton 3 | Archive of Reversing.ID 4 | Design Pattern (Creational) 5 | 6 | Modern C++ 7 | 8 | Menggunakan sebuah instance yang didefinisikan sebagai static dan menjadikannya 9 | sebagai instance rujukan. 10 | 11 | Compile: 12 | [clang] 13 | $ clang++ singleton.cpp -o singleton 14 | 15 | [gcc] 16 | $ g++ singleton.cpp -o singleton 17 | 18 | [msvc] 19 | $ cl singleton.cpp 20 | 21 | Run: 22 | $ singleton 23 | */ 24 | #include 25 | 26 | 27 | /* *********************************** DECLARATION *********************************** */ 28 | 29 | /** 30 | * Singleton (concrete) 31 | */ 32 | class Singleton 33 | { 34 | Singleton() = default; 35 | ~Singleton() = default; 36 | 37 | Singleton(const Singleton &) = delete; 38 | Singleton(Singleton&&) = delete; 39 | Singleton& operator=(const Singleton &) = delete; 40 | Singleton& operator=(Singleton &&) = delete; 41 | 42 | public: 43 | static Singleton& getInstance() 44 | { 45 | static Singleton instance; 46 | return instance; 47 | } 48 | }; 49 | 50 | /* *********************************** USAGE *********************************** */ 51 | 52 | int main(int argc, char* argv[]) 53 | { 54 | /* Instansiasi awal akan menciptakan objek baru (Singleton&) */ 55 | auto& inst1 = Singleton::getInstance(); 56 | 57 | /* 58 | Instansiasi selanjutnya akan mengambil instance 59 | yang telah diciptakan sebelumnya. 60 | */ 61 | auto& inst2 = Singleton::getInstance(); 62 | 63 | return 0; 64 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Singleton/c++/singleton-3.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Singleton 3 | Archive of Reversing.ID 4 | Design Pattern (Creational) 5 | 6 | Membuat instance di heap tanpa pengelolaan. 7 | 8 | Compile: 9 | [clang] 10 | $ clang++ singleton.cpp -o singleton 11 | 12 | [gcc] 13 | $ g++ singleton.cpp -o singleton 14 | 15 | [msvc] 16 | $ cl singleton.cpp 17 | 18 | Run: 19 | $ singleton 20 | */ 21 | 22 | /* *********************************** DECLARATION *********************************** */ 23 | 24 | /** 25 | * Singleton (concrete) 26 | */ 27 | class Singleton 28 | { 29 | // Instance didefinisikan sebagai static 30 | static Singleton * _instance; 31 | 32 | public: 33 | static Singleton * getInstance() 34 | { 35 | if (nullptr == _instance) 36 | _instance = new Singleton(); 37 | 38 | return _instance; 39 | } 40 | }; 41 | 42 | // Instansiasi komponen statis 43 | Singleton* Singleton::_instance = nullptr; 44 | 45 | /* *********************************** USAGE *********************************** */ 46 | 47 | int main(int argc, char* argv[]) 48 | { 49 | // Instansiasi awal akan menciptakan objek baru 50 | Singleton * inst1 = Singleton::getInstance(); 51 | 52 | // Instansiasi selanjutnya akan mengambil instance 53 | // yang telah diciptakan sebelumnya. 54 | Singleton * inst2 = Singleton::getInstance(); 55 | 56 | return 0; 57 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Creational/Singleton/c++/singleton-4.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Singleton 3 | Archive of Reversing.ID 4 | Design Pattern (Creational) 5 | 6 | Modern C++ 7 | 8 | Singleton template 9 | 10 | Compile: 11 | [clang] 12 | $ clang++ singleton.cpp -o singleton 13 | 14 | [gcc] 15 | $ g++ singleton.cpp -o singleton 16 | 17 | [msvc] 18 | $ cl singleton.cpp 19 | 20 | Run: 21 | $ singleton 22 | */ 23 | #include 24 | #include 25 | 26 | /* *********************************** DECLARATION *********************************** */ 27 | /** 28 | * Singleton (template) 29 | * 30 | */ 31 | template 32 | class Singleton 33 | { 34 | Singleton(const Singleton &) = delete; 35 | Singleton& operator=(const Singleton &) = delete; 36 | 37 | static Type* _instance; 38 | 39 | protected: 40 | Singleton() = default; 41 | ~Singleton() = default; 42 | 43 | public: 44 | template 45 | static Type& getInstance(Args... args) 46 | { 47 | if (!_instance) 48 | _instance = new Type(std::forward(args)...); 49 | 50 | return *_instance; 51 | } 52 | }; 53 | 54 | template Type* Singleton::_instance = nullptr; 55 | 56 | // ====================================================================================== 57 | 58 | /** 59 | * Service (concrete) 60 | * 61 | * object yang dibungkus sebagai singleton. 62 | */ 63 | class Service 64 | { 65 | int _data; 66 | public: 67 | Service(int a, int b) 68 | { 69 | _data = a * b; 70 | } 71 | 72 | int provideService() 73 | { 74 | return _data; 75 | } 76 | }; 77 | 78 | typedef Singleton ServiceSingleton; 79 | 80 | /* *********************************** USAGE *********************************** */ 81 | 82 | int main(int argc, char* argv[]) 83 | { 84 | // Pemanggilan Service dengan parameter 85 | ServiceSingleton::getInstance(9, 15).provideService(); 86 | 87 | return 0; 88 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Structural/Facade/c++/facade-1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Facade 3 | Archive of Reversing.ID 4 | Design Pattern (Structural) 5 | 6 | 7 | Compile: 8 | [clang] 9 | $ clang++ facade.cpp -o facade 10 | 11 | [gcc] 12 | $ g++ facade.cpp -o facade 13 | 14 | [msvc] 15 | $ cl facade.cpp 16 | 17 | Run: 18 | $ facade 19 | */ 20 | #include 21 | #include 22 | 23 | 24 | /* *********************************** DECLARATION *********************************** */ 25 | /** 26 | * SubSystem1 (concrete) 27 | * 28 | * 29 | */ 30 | class SubSystem1 31 | { 32 | public: 33 | void operation () 34 | { 35 | std::cout << "SubSystem-1 :: operation ... " << std::endl; 36 | } 37 | }; 38 | 39 | 40 | // ====================================================================================== 41 | /** 42 | * SubSystem2 (concrete) 43 | * 44 | * 45 | */ 46 | class SubSystem2 47 | { 48 | public: 49 | void operation () 50 | { 51 | std::cout << "SubSystem-2 :: operation ... " << std::endl; 52 | } 53 | }; 54 | 55 | // ====================================================================================== 56 | 57 | /** 58 | * Facade (concrete) 59 | * 60 | * High-level interface untuk mengoperasikan subsystem. 61 | */ 62 | class Facade 63 | { 64 | std::unique_ptr _sub1; 65 | std::unique_ptr _sub2; 66 | 67 | public: 68 | Facade () 69 | { 70 | _sub1 = std::make_unique(); 71 | _sub2 = std::make_unique(); 72 | } 73 | 74 | /* 75 | Operasi ini membungkus dua proses yang ada sehingga dianggap sebagai 76 | 1 operasi tunggal. 77 | */ 78 | void operation() 79 | { 80 | _sub1->operation(); 81 | _sub2->operation(); 82 | } 83 | }; 84 | 85 | 86 | /* *********************************** USAGE *********************************** */ 87 | 88 | int main(int argc, char* argv[]) 89 | { 90 | // Mendeklarasikan facade yang akan menangani 2 subsystem di belakang. 91 | auto facade = std::make_unique(); 92 | facade->operation(); 93 | 94 | return 0; 95 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Structural/Proxy/c++/proxy-1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Proxy 3 | Archive of Reversing.ID 4 | Design Pattern (Structural) 5 | 6 | 7 | Compile: 8 | [clang] 9 | $ clang++ flyweight.cpp -o flyweight 10 | 11 | [gcc] 12 | $ g++ proxy.cpp -o proxy 13 | 14 | [msvc] 15 | $ cl proxy.cpp 16 | 17 | Run: 18 | $ proxy 19 | */ 20 | #include 21 | #include 22 | 23 | 24 | /* *********************************** DECLARATION *********************************** */ 25 | 26 | /** 27 | * Subject (abstract) 28 | */ 29 | class Subject 30 | { 31 | public: 32 | /* Virtual destructor */ 33 | virtual ~Subject() { } 34 | 35 | /** 36 | * Contoh operasi kelas yang akan diimplementasikan oleh setiap kelas turunan 37 | */ 38 | virtual void request() = 0; 39 | }; 40 | 41 | // ====================================================================================== 42 | 43 | /** 44 | * ConcreteSubject (concrete) 45 | */ 46 | class ConcreteSubject : public Subject 47 | { 48 | public: 49 | virtual ~ConcreteSubject() { } 50 | 51 | void request() override 52 | { 53 | std::cout << "[ConcreteSubject] :: request" << std::endl; 54 | } 55 | }; 56 | 57 | // ====================================================================================== 58 | 59 | /** 60 | * Proxy (concrete) 61 | * 62 | * Class yang meneruskan request menuju subject. 63 | */ 64 | class Proxy : public Subject 65 | { 66 | std::shared_ptr _sub; 67 | 68 | public: 69 | Proxy () { } 70 | Proxy (std::shared_ptr subject) : _sub{subject} 71 | { } 72 | 73 | void request() 74 | { 75 | std::cout << "Proxy request ..." << std::endl; 76 | _sub->request(); 77 | } 78 | }; 79 | 80 | 81 | /* *********************************** USAGE *********************************** */ 82 | 83 | int main(int argc, char* argv[]) 84 | { 85 | auto sub = std::shared_ptr{new ConcreteSubject}; 86 | auto proxy = std::make_unique(sub); 87 | 88 | proxy->request(); 89 | 90 | return 0; 91 | } -------------------------------------------------------------------------------- /Codes/Design-Pattern/Structural/README.md: -------------------------------------------------------------------------------- 1 | # Design Pattern 2 | 3 | ## Structural Pattern 4 | 5 | - Adapter 6 | - Bridge 7 | - Composite 8 | - Decorator 9 | - Facade 10 | - Flyweight 11 | - Proxy -------------------------------------------------------------------------------- /Codes/Language/c++/basic/0.skeleton.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | C/C++ Code Template 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | */ 6 | 7 | /* 8 | Deklarasikan header file (module) yang ingin disertakan. 9 | Header file umumnya berisi deklarasi konstanta, struct / class, serta prototipe fungsi. 10 | */ 11 | #include 12 | 13 | /* 14 | Definisikan fungsi main(). 15 | Fungsi main() adalah entry point atau fungsi pertama (user-code) yang akan dijalankan 16 | ketika aplikasi dijalankan. 17 | */ 18 | int main(int argc, char* argv[]) 19 | { 20 | // letakkan kode di sini 21 | 22 | 23 | // return value, status yang dikembalikan oleh program ke OS ketika eksekusi berakhir. 24 | return 0; 25 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/1.declare.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Declaration 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Deklarasi berbagai tipe data dasar 7 | */ 8 | 9 | int main(int argc, char* argv[]) 10 | { 11 | // deklarasi variabel dan konstanta 12 | // tipe data: integral = char, int, long 13 | // float = float, double 14 | 15 | // -- definisi bilangan bulat 16 | short s; 17 | int i; 18 | long l; 19 | 20 | // -- definisi bilangan pecahan (floating-point) 21 | float f; 22 | double d; 23 | 24 | // variabel vs konstanta 25 | int i_var; 26 | int i_var2, i_var3; 27 | const int X = 10; 28 | const int Y = 15, Z = 20; 29 | 30 | // memungkinkan untuk assign ulang ke variable tapi tidak ke konstanta 31 | i_var = 1; 32 | i_var3 = i_var2 = i_var; 33 | 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/10.switch.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Switch 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Statement Switch untuk pencocokan majemuk. 7 | */ 8 | 9 | #include 10 | 11 | int main(int argc, char* argv[]) 12 | { 13 | // definisi variabel lokal 14 | int grade = 'B'; 15 | 16 | switch (grade) 17 | { 18 | case 'A': 19 | std::cout << "Excellent" << std:: endl; 20 | break; 21 | case 'B': 22 | case 'C': 23 | std::cout << "Well done" << std:: endl; 24 | break; 25 | case 'D': 26 | std::cout << "You passed" << std:: endl; 27 | break; 28 | case 'F': 29 | std::cout << "Better try again" << std:: endl; 30 | break; 31 | default: 32 | std::cout << "Invalid grade" << std:: endl; 33 | } 34 | 35 | std::cout << "Your grade is : " << grade << std::endl; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/11.for.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Foor 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Statement For untuk perulangan. 7 | */ 8 | 9 | #include 10 | 11 | int main(int argc, char* argv[]) 12 | { 13 | int a; 14 | 15 | // perulangan dengan pencacahan 16 | for (a = 10; a < 20; a = a + 1) 17 | { 18 | std::cout << "Value of a: " << a << std::endl; 19 | } 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/12.while.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | While 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Statement While untuk perulangan. 7 | */ 8 | #include 9 | 10 | int main(int argc, char* argv[]) 11 | { 12 | int a = 10; 13 | 14 | while (a < 20) 15 | { 16 | std::cout << "Value of a: " << a std::endl; 17 | 18 | // increment a, perubahan nilai sehingga mendekati kondisi henti 19 | a++; 20 | } 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/13.do-while.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Do-While 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Statement Do-While untuk perulangan. 7 | */ 8 | #include 9 | 10 | int main(int argc, char* argv[]) 11 | { 12 | int a = 10; 13 | 14 | do 15 | { 16 | std::cout << "Value of a: " << a << std::endl; 17 | 18 | // increment a, perubahan nilai sehingga mendekati kondisi henti 19 | a++; 20 | } while (a < 20); 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/14.function.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Function 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Fungsi sebagai potongan kode. 7 | */ 8 | #include 9 | 10 | int max(int num1, int num2) 11 | { 12 | // deklarasi variabel lokal yang dibutuhkan 13 | int result; 14 | 15 | // operasi sebuah fungsi 16 | if (num1 > num2) 17 | result = num1; 18 | else 19 | result = num2; 20 | 21 | // kembalikan nilai yang sesuai 22 | return result; 23 | } 24 | 25 | int main(int argc, char* argv[]) 26 | { 27 | // deklarasi variabel dan isi dengan nilai dari kembalian fungsi 28 | int a = max(3, 5); 29 | int b = max(7, 10); 30 | 31 | std::cout << "max(3, 5) = " << a << std::endl; 32 | std::cout << "max(7,10) = " << b << std::endl; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/15.string.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | String 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Representasi String 7 | */ 8 | 9 | #include 10 | 11 | /* 12 | Terdapat dua tipe string di C++: 13 | - C-Style 14 | - C++ String class 15 | 16 | Pada C-Style, string diimplementasikan sebagai array of character dengan 17 | 0 atau \0 sebagai batas akhir string. 18 | 19 | Pada C++ String class, terdapat sebuah class yang merepresentasikan string 20 | dengan operasinya (akan dibahas pada class). 21 | */ 22 | 23 | int main(int argc, char* argv[]) 24 | { 25 | // C-Style string, deklarasi array dengan karakter tiap elemennya 26 | char str1[] = {'R', 'e', 'v', 'e', 'r', 's', 'i', 'n', 'g', '.', 'I', 'D', 0}; 27 | char str2[] = "Programming"; 28 | char str3[32]; 29 | 30 | // C++ String class 31 | std::string str4 = "Reversing.ID"; 32 | std::string str5 = "Programming"; 33 | std::string str6; 34 | 35 | // -- Operasi C-Style string 36 | // copy 37 | strcpy(str3, str1); 38 | 39 | // concatenation 40 | strcat(str3, str1); 41 | 42 | 43 | // -- Operasi C++ String class 44 | // copy 45 | str6 = str4; 46 | 47 | // concatenation 48 | str6 += str5; 49 | 50 | return 0; 51 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/2.array.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Array 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Sifat dan penggunaan array. 7 | */ 8 | 9 | #include 10 | 11 | int main(int argc, char* argv[]) 12 | { 13 | int plain [10]; 14 | double assigned [10] = { 100.0, 2.0, 3.4, 7.0, 50.0 } ; 15 | 16 | // assign value ke index 6 dari array "plain" 17 | plain [6] = 10; 18 | 19 | std::cout << "plain[0] = " << plain[0] << std::endl; 20 | std::cout << "plain[6] = " << plain[6] << std::endl; 21 | std::cout << "assigned[0] = " << assigned[0] << std::endl; 22 | std::cout << "assigned[6] = " << assigned[6] << std::endl; 23 | 24 | // assign value ke index 6 dari arrai "assigned" 25 | assigned[6] = 3.14; 26 | 27 | std::cout << "assigned[6] = " << assigned[6] << std::endl; 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/3.struct.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Struct 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Struct dan penggunaannya. 7 | */ 8 | 9 | #include 10 | #include 11 | 12 | 13 | struct book_t 14 | { 15 | char title[50]; 16 | char author[50]; 17 | char subject[100]; 18 | int book_id; 19 | }; 20 | 21 | 22 | int main( ) 23 | { 24 | book_t Book1; // Deklarasi Book1 dengan tipe Book 25 | book_t Book2; // Deklarasi Book2 dengan tipe Book 26 | 27 | // spesifikasi book 1 28 | strcpy( Book1.title, "C/C++ Programming"); 29 | strcpy( Book1.author, "Rakai Ady Wikradinata"); 30 | strcpy( Book1.subject, "C Programming Tutorial"); 31 | Book1.book_id = 6495407; 32 | 33 | // spesifikasi book 2 34 | strcpy( Book2.title, "Little Playground of Reverse Engineering"); 35 | strcpy( Book2.author, "Satria Ady Pradana"); 36 | strcpy( Book2.subject, "Reverse Engineering Tutorial"); 37 | Book2.book_id = 6495700; 38 | 39 | // cetak informasi book 1 40 | std::cout << "Book 1 title : " << Book1.title << std::endl; 41 | std::cout << "Book 1 author : " << Book1.author << std::endl; 42 | std::cout << "Book 1 subject : " << Book1.subject << std::endl; 43 | std::cout << "Book 1 book_id : " << Book1.book_id << std::endl; 44 | 45 | // cetak informasi book 2 46 | std::cout << "Book 2 title : " << Book2.title << std::endl; 47 | std::cout << "Book 2 author : " << Book2.author << std::endl; 48 | std::cout << "Book 2 subject : " << Book2.subject << std::endl; 49 | std::cout << "Book 2 book_id : " << Book2.book_id << std::endl; 50 | 51 | return 0; 52 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/4.enum.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Enumeration 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Enumerasi dan penggunaannya. 7 | */ 8 | 9 | #include 10 | 11 | 12 | enum month_t 13 | { 14 | Jan, Feb, Mar, Apr, May, Jun, 15 | Jul, Aug, Sep, Oct, Nov, Dec 16 | }; 17 | 18 | 19 | int main(int argc, char* argv[]) 20 | { 21 | month_t month; 22 | 23 | month = Aug; // seharusnya bernilai 7 24 | 25 | std::cout << "Month: " << month << std::endl; 26 | 27 | // cetak semua bulan 28 | std::cout << "Month 'Jan' = " << Jan << std::endl; 29 | std::cout << "Month 'Feb' = " << Feb << std::endl; 30 | std::cout << "Month 'Mar' = " << Mar << std::endl; 31 | std::cout << "Month 'Apr' = " << Apr << std::endl; 32 | std::cout << "Month 'May' = " << May << std::endl; 33 | std::cout << "Month 'Jun' = " << Jun << std::endl; 34 | std::cout << "Month 'Jul' = " << Jul << std::endl; 35 | std::cout << "Month 'Aug' = " << Aug << std::endl; 36 | std::cout << "Month 'Sep' = " << Sep << std::endl; 37 | std::cout << "Month 'Oct' = " << Oct << std::endl; 38 | std::cout << "Month 'Nov' = " << Nov << std::endl; 39 | std::cout << "Month 'Dec' = " << Dec << std::endl; 40 | 41 | 42 | return 0; 43 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/5.ptr.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Pointer 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Sifat dan operasi pada Pointer dan Reference. 7 | */ 8 | 9 | #include 10 | 11 | 12 | int main(int argc, char* argv[]) 13 | { 14 | // deklarasi variabel normal 15 | int i_var = 0; 16 | int i_var2 = 10; 17 | 18 | // deklarasi sebuah pointer mengarah ke i_var 19 | int * i_ptr = &i_var; 20 | 21 | // deklarasi sebuah reference mengarah ke i_var 22 | int & i_ref = i_var; 23 | 24 | std::cout << "Nilai awal: " << std::endl; 25 | std::cout << " i_var = " << i_var << " (" << &i_var << ")" << std::endl; 26 | std::cout << " i_var2 = " << i_var2 << " (" << &i_var2 << ")" << std::endl; 27 | std::cout << " i_ptr = " << *i_ptr << " (" << i_ptr << ")" << std::endl; 28 | std::cout << " i_ref = " << i_ref << " (" << &i_ref << ")" << std::endl; 29 | 30 | *i_ptr = 135; 31 | 32 | std::cout << "* i_ptr = 135 " << std::endl; 33 | std::cout << " i_var = " << i_var << " (" << &i_var << ")" << std::endl; 34 | std::cout << " i_var2 = " << i_var2 << " (" << &i_var2 << ")" << std::endl; 35 | std::cout << " i_ptr = " << *i_ptr << " (" << i_ptr << ")" << std::endl; 36 | std::cout << " i_ref = " << i_ref << " (" << &i_ref << ")" << std::endl; 37 | 38 | i_ptr = &i_var2; 39 | i_var2 = 100; 40 | 41 | std::cout << "i_ptr = &i_var2 " << std::endl; 42 | std::cout << " i_var = " << i_var << " (" << &i_var << ")" << std::endl; 43 | std::cout << " i_var2 = " << i_var2 << " (" << &i_var2 << ")" << std::endl; 44 | std::cout << " i_ptr = " << *i_ptr << " (" << i_ptr << ")" << std::endl; 45 | std::cout << " i_ref = " << i_ref << " (" << &i_ref << ")" << std::endl; 46 | 47 | return 0; 48 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/7.if.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | IF 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Statement IF untuk pengujian kondisi. 7 | */ 8 | 9 | #include 10 | 11 | int main(int argc, char* argv[]) 12 | { 13 | // definisi variabel lokal 14 | int a = 10; 15 | 16 | // periksa ekspresi boolean dengan statement IF 17 | if (a < 20) 18 | { 19 | std::cout << "a is less than 20" << << std::endl; 20 | } 21 | 22 | std::cout << "Value of a is : " << a << std::endl; 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/8.if-else.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | IF-ELSE 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Statement IF untuk pengujian kondisi. 7 | */ 8 | 9 | #include 10 | 11 | int main(int argc, char* argv[]) 12 | { 13 | // definisi variabel lokal 14 | int a = 100; 15 | 16 | // periksa ekspresi boolean dengan statement IF 17 | if (a < 20) 18 | { // jika kondisi benar, maka cetak 19 | std::cout << "a is less than 20" << std::endl; 20 | } 21 | else 22 | { // jika kondisi salah, maka cetak 23 | std::cout << "a is not less than 20" << std::endl; 24 | } 25 | 26 | std::cout << "Value of a is : " a << std::endl; 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Codes/Language/c++/basic/9.if2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | IF 3 | Archive of Reversing.ID 4 | Programming Language (C++) 5 | 6 | Statement IF untuk pengujian kondisi. 7 | */ 8 | #include 9 | 10 | int main(int argc, char* argv[]) 11 | { 12 | // definisi variabel lokal 13 | int a = 0; 14 | 15 | // periksa ekspresi boolean dengan statement IF 16 | if (a > 0) 17 | { // jika kondisi benar, maka cetak 18 | std::cout << "a is positive" << std::endl; 19 | } 20 | else if (a < 0) 21 | { // jika kondisi benar, maka cetak 22 | std::cout << "a is negative" << std::endl; 23 | } 24 | 25 | std::cout << "Value of a is : " << a << std::endl; 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /References/Algorithm/backtrack.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Backtrack (Runut-Balik) 4 | 5 | ## Definisi 6 | 7 | Menyelesaikan masalah secara rekursif dengan cara membangun solusi bertahap, bagian demi bagian, menghapus solusi yang gagal memenuhi constraint. 8 | 9 | Backtrack merupakan implementasi Breadth-First Search. 10 | 11 | ## Struktur 12 | 13 | ## Penggunaan 14 | 15 | ## Catatan 16 | 17 | ## Karakteristik -------------------------------------------------------------------------------- /References/Algorithm/branch-and-bound.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Branch and Bound 4 | 5 | Umumnya digunakan untuk menyelesaikan masalah berkaitan dengan combinatorial-optimization. 6 | 7 | ## Definisi 8 | 9 | ## Struktur 10 | 11 | ## Penggunaan 12 | 13 | ## Catatan 14 | 15 | ## Karakteristik -------------------------------------------------------------------------------- /References/Algorithm/breadth-first-search.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Breadth-First Search (BFS) 4 | 5 | ## Definisi 6 | 7 | Pencarian melebar. Mengunjungi simpul-simpul pada graf dengan cara mengunjungi semua simpul tetangga / sibling terlebih sebelum mengunjungi simpul anak. 8 | 9 | ## Struktur 10 | 11 | Komponen algoritma: 12 | 13 | - Node Queue (Q) 14 | 15 | Sebuah antrean untuk menyimpan simpul yang telah dikunjungi. Simpul yang telah dikunjungi suatu saat diperlukan sebagai acuan untuk mengunjungi simpul-simpul yang bertetangga dengannya. Tiap simpul yang telah dikunjungi masuk ke dalam antrean hanya sekali. 16 | 17 | - Visited Array (V) 18 | 19 | Sebuah larik beertipe boolean untuk menyimpan informasi simpul-simpul yang telah dikunjungi sehingga dapat ditelusuri bahwa tidak ada simpul yang dikunjungi lebih dari sekali. 20 | 21 | Langkah umum: 22 | 23 | - inisialisasi `Q` sebagai antrean kosong. 24 | - masukkan simpul mula (start node) ke dalam antrean `Q`. 25 | - ambil sebuah node `n` dari antrean `Q` 26 | - untuk setiap node yang terhubung dengan `n`, periksa apakah node telah dikunjungi. Jika belum, masukkan node tersebut ke antrean `Q`. 27 | - proses node `n` dan tandai bahwa `n` telah dikunjungi. 28 | - jika antrean belum kosong, ulangi dari langkahstep 3. 29 | 30 | ## Penggunaan 31 | 32 | Strategi ini digunakan apabila: 33 | 34 | - 35 | 36 | ## Catatan 37 | 38 | ## Karakteristik 39 | 40 | - semua simpul pada aras (level) `d` akan dibangkitkan terlebih dahulu sebelum menelusuri simpul pada aras `d + 1`. -------------------------------------------------------------------------------- /References/Algorithm/brute-force.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Brute Force 4 | 5 | "When in doubt, use brute force" -- Ken Thompson 6 | 7 | ## Definisi 8 | 9 | Pendekatan lempang (straightforward) untuk memecahkan masalah, biasanya didasarkan kepada pernyataan masalah (problem statement) dan definisi konsep yang dilibatkan. 10 | 11 | Pemecahan masalah dengan sangat sederhana dan jelas (obvious-way solution). 12 | 13 | ## Penggunaan 14 | 15 | Sebaiknya strategi ini hanya digunakan sebagai alternatif terakhir. 16 | 17 | ## Catatan 18 | 19 | * sebagian besar permasalahan dapat dipecahkan dengan brute-force dengan pendekatan yang mudah dimengerti. 20 | * seringkali algoritma bertipe brute-force tidak mangkus (efisien). 21 | 22 | ## Karakteristik 23 | 24 | tidak ada pola karakteristik khusus. -------------------------------------------------------------------------------- /References/Algorithm/depth-first-search.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Depth-First Search (DFS) 4 | 5 | ## Definisi 6 | 7 | Pencarian mendalam. Mengunjungi simpul-simpul pada graf dengan cara mengunjungi seluruh path dari suatu node hingga akhir sebelum akhirnya mengunjungi node tetangga. 8 | 9 | ## Struktur 10 | 11 | Komponen algoritma: 12 | 13 | - Visited Array (`V`) 14 | 15 | Sebuah larik beertipe boolean untuk menyimpan informasi simpul-simpul yang telah dikunjungi sehingga dapat ditelusuri bahwa tidak ada simpul yang dikunjungi lebih dari sekali. 16 | 17 | Langkah umum: 18 | 19 | - proses node `n` dan tandai bahwa `n` telah dikunjungi. 20 | - untuk setiap node yang terhubung dengan `n`, periksa apakah node telah dikunjungi. Jika belum, lakukan `DFS()` ke node tersebut. 21 | 22 | ## Penggunaan 23 | 24 | Strategi ini digunakan apabila: 25 | 26 | ## Catatan 27 | 28 | ## Karakteristik -------------------------------------------------------------------------------- /References/Algorithm/divide-and-conquer.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Divide and Conquer. 4 | 5 | ## Definisi 6 | 7 | Menyelesaikan masalah dengan membagi masalah menjadi bagian kecil. 8 | 9 | ## Struktur 10 | 11 | Terdiri dari tiga langkah: 12 | 13 | * divide: memecah permasalahan menjadi beberapa subproblem yang memiliki kemiripan dengan masalah semula namun berukuran lebih kecil. 14 | * conquer: menyelesaikan subproblem secara independen (rekursif / iteratif). 15 | * combine: menggabungkan solusi tiap subproblem sehingga terbentuk solusi masalah semula. 16 | 17 | ## Penggunaan 18 | 19 | Strategi ini digunakan apabila: 20 | 21 | * subproblem tidak dievaluasi berkali-kali. Jika perlu evaluasi berkali-kali, gunakan Dynamic Programming. 22 | 23 | ## Catatan 24 | 25 | * Divide and Conquer serta [Dynamic Programming](dynamic-programming.md) membagi problem menjadi subproblem dan menyelesaikannya. 26 | * apabila subproblem yang dihasilkan hanya satu, maka disebut Decrease and Conquer. 27 | 28 | ## Karakteristik 29 | 30 | * umumnya problem dibagi menjadi dua bagian relatif sama besar. 31 | * terdapat batas ambang (treshold) ukuran masukan sehingga subproblem tidak perlu dipecah lagi. -------------------------------------------------------------------------------- /References/Algorithm/dynamic-programming.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Dynamic Programming. 4 | 5 | ## Definisi 6 | 7 | Menyelesaikan masalah dengan memecah masalah kompleks menjadi beberapa subproblem dan menyimpan hasil dari subproblem untuk menghindari perhitungan ulang pemanggilan yang sama. 8 | 9 | ## Struktur 10 | 11 | Terdapat dua pendekatan Dynamic Programming: 12 | 13 | * `memoization` (top-down) 14 | * `tabulation` (bottom-up) 15 | 16 | Keduanya menyimpan solusi dari subproblem. 17 | 18 | ## Penggunaan 19 | 20 | Strategi ini digunakan apabila: 21 | 22 | * masalah memiliki `overlapping subproblem`: tumpang tindih, subproblem yang lebih kecil dievaluasi berkali-kali ketika mengevaluasi problem yang lebih besar. 23 | * masalah memiliki `optimal substructure`: solusi optimal untuk keseluruhan masalah mengandung solusi optimal untuk subproblem. 24 | 25 | ## Catatan 26 | 27 | * [Divide and Conquer](divide-and-conquer.md) serta Dynamic Programming membagi problem menjadi subproblem dan menyelesaikannya. 28 | 29 | ## Karakteristik 30 | 31 | * umumnya memecahkan masalah optimisasi. 32 | * pendekatan memoization umumnya bersifat rekursif dengan lookup table. 33 | * pendekatan tabulation bersifat akumulatif dengan implementasi sebagai iterasi. -------------------------------------------------------------------------------- /References/Architecture/CQRS.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Command and Query Responsibility Segregation (CQRS) 4 | 5 | ## Definisi 6 | 7 | Memisahkan operasi `read` dan `write` aplikasi. 8 | 9 | Hal ini berarti model yang digunakan untuk operasi write (`command`) akan berbeda dengan model read (`query`). Lebih jauh lagi, data dapat pula disimpan ke lokasi berbeda. Pola ini juga sering dikombinasikan dengan [event sourcing](event-sourcing.md). 10 | 11 | ## Struktur 12 | 13 | Ketika aksi dilakukan aplikasi mengirim perintah ke command-service. Command service mengambil data yang dibutuhkan dari command database, melakukan beberapa manipulasi yang diperlukan dan menyimpan kembali ke database. Service kemudian mengabarkan ke read-service sehingga read-model dapat diperbarui. 14 | 15 | ![cqrs-command](_imgs_/cqrs-command.png) 16 | 17 | Ketika diperlukan untuk menampilkan data ke user, aplikasi akan menghubungi read-service. 18 | 19 | ![cqrs-query](_imgs_/cqrs-query.png) 20 | 21 | ## Penggunaan 22 | 23 | Arsitektur ini ideal digunakan untuk: 24 | 25 | * aplikasi yang membutuhkan banyak operasi read. 26 | * aplikasi dengan domain yang rumit. 27 | 28 | ## Karakteristik 29 | 30 | Keuntungan: 31 | 32 | * masing-masing model dapat fokus ke tanggung jawab masing-masing. 33 | 34 | - command model dapat fokus ke business logic dan validasi. 35 | - read model dapat disesuaikan untuk skenario spesifik 36 | 37 | * dapat menghindari query yang kompleks (misal: joins di SQL) yang meningkatkan performansi operasi read. 38 | 39 | Kekurangan: 40 | 41 | * membuat command dan read tersinkronisasi dapat menjadi sangat kompleks. -------------------------------------------------------------------------------- /References/Architecture/_imgs_/cqrs-command.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Architecture/_imgs_/cqrs-command.png -------------------------------------------------------------------------------- /References/Architecture/_imgs_/cqrs-query.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Architecture/_imgs_/cqrs-query.png -------------------------------------------------------------------------------- /References/Architecture/_imgs_/hexagonal-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Architecture/_imgs_/hexagonal-2.png -------------------------------------------------------------------------------- /References/Architecture/_imgs_/hexagonal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Architecture/_imgs_/hexagonal.png -------------------------------------------------------------------------------- /References/Architecture/_imgs_/microkernel.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Architecture/_imgs_/microkernel.png -------------------------------------------------------------------------------- /References/Architecture/_imgs_/microservice.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Architecture/_imgs_/microservice.png -------------------------------------------------------------------------------- /References/Architecture/_imgs_/onion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Architecture/_imgs_/onion.png -------------------------------------------------------------------------------- /References/Architecture/event-sourcing.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Event Sourcing 4 | 5 | ## Definisi 6 | 7 | Menyimpan event yang terjadi ke model, alih-alih menyimpan kondisi terkini model ke database. Ketika dibutuhkan informasi tentang model, maka seluruh event yang tersimpan (terkait model tersebut) akan diambil dan diterapkan kembali ke objek baru. Hal ini disebut sebagai `rehydrating`. 8 | 9 | ## Struktur 10 | 11 | ## Penggunaan 12 | 13 | Arsitektur ini ideal digunakan untuk: 14 | 15 | * sistem yang perlu memublikasi event ke sistem eksternal. 16 | * aaplikasi yang kan dibangun dengan CQRS. 17 | * aplikasi yang memiliki domain kompleks. 18 | * memerlukan audit-log terhadap perubahan data. 19 | 20 | ## Karakteristik 21 | 22 | Keuntungan: 23 | 24 | * dapat menyediakan audit-log dimana setiap event merepresentasikan manipulasi data pada suatu saat. 25 | 26 | Kekurangan: 27 | 28 | * membutuhkan penelusuran terhadap keseluruhan data ketika akan terjadi perubahan di database. 29 | * perlu memiliki penanganan data tertentu jika terjadi perubahan struktur di database. -------------------------------------------------------------------------------- /References/Architecture/hexagonal.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Hexagonal (Ports & Adapters) 4 | 5 | ## Definisi 6 | 7 | Membagi aplikasi berdasarkan tanggung jawab menjadi tiga bagian: aplikasi (UI), domain (business-logic), dan infrastruktur dengan domain menjadi inti dari sistem. 8 | 9 | ## Struktur 10 | 11 | Secara prinsip, arsitektur Hexagonal berdasarkan tiga prinsip dan teknik: 12 | 13 | * secara eksplisit memisahkan Aplikasi, Domain, dan Infrastruktur 14 | * dependensi mengalir dari Aplikasi dan Intrastruktur menuju DOmain 15 | * isolasi Boundary (batas) dengan Ports dan Adapter. 16 | 17 | ![Hexagonal](_imgs_/hexagonal.png) 18 | 19 | Sisi Aplikasi adalah sisi dimana interaksi dengan user akan terjadi. Di sisi ini terdapat kode yang menangani interaksi, sebagai contoh: user interface, HTTP routes untuk API, JSON serialization, dsb. Sisi ini adalah sisi dimana kita dapat mencari actor yang memacu Domain. 20 | 21 | Sisi Domain adalah bagian yang diisolasi dari sisi kiri (Aplikasi) dan kanan (Infrastruktur). Di sisi ini terdapat kode yang berkaitan dengan implementasi business logic, bagian yang secara konkret menyelesaikan masalah. 22 | 23 | Sisi Infrastruktur adalah bagian yang dibutuhkan oleh aplikasi untuk dapat berjalan. Di sisi ini terdapat kode seperti interaksi dengan database, operasi file system, kode yang menangani HTTP calls ke aplikasi lain, dsb. 24 | 25 | ![Hexagonal](_imgs_/hexagonal-2.png) 26 | 27 | Komunikasi menuju sisi yang berbeda dilakukan melalui interface yang didefinisikan. Pada arsitektur ini, Domain merupakan bagian dalam (`inside`) sistem dan Aplikasi maupun Infrastruktur disebut sebagai bagian luar (`outside`) 28 | 29 | ## Penggunaan 30 | 31 | Arsitektur ini ideal digunakan untuk: 32 | 33 | ## Karakteristik 34 | 35 | * terdapat tiga bagian aplikasi: aplikasi, domain, infrastruktur. 36 | * interface digunakan sebagai komunikasi. -------------------------------------------------------------------------------- /References/Architecture/layered.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Layered Architecture 4 | 5 | ## Definisi 6 | 7 | Membagi sistem ke dalam lapisan-lapisan dimana setiap lapisan memiliki tanggung jawab tertentu dan memberikan layanan ke service di lapisan lebih tinggi. 8 | 9 | ## Struktur 10 | 11 | Tidak ada batasan lapisan, namun terdapat beberapa lapisan yang umum ada: 12 | 13 | * Presentation (UI): menampilkan desain grafis aplikasi dan mengandung kode untuk menangani interaksi dari user. 14 | * Application: memberi abstraksi dan melakukan koordinasi antara `presentation` dan `application`. 15 | * Business (Domain): mendefinisikan model dan logic terkait dari problem bisnis yang ingin dipecahkan. 16 | * Persistence (data access): memberi abstraksi akses terhadap media penyimpanan (database) untuk dapat membaca dan memanipulasi data tanpa tergantung kepada teknologi. 17 | * Database: mendefinisikan teknologi penyimpanan yang digunakan untuk menyimpan dan mengolah data. 18 | 19 | Mungkin terdapat variasi tergantung kepada kompleksitas aplikasi. 20 | 21 | Tidak menutup kemungkinan dua layer dapat dikombinasikan menjadi satu, misal `ActiveRecord` yang mengombinasikan lapisan `business` dan `persistence`. 22 | 23 | ## Penggunaan 24 | 25 | Arsitektur ini ideal digunakan untuk: 26 | 27 | * aplikasi standard line-of-business yang melakukan proses lebih dari sekedar operasi CRUD. 28 | 29 | ## Karakteristik 30 | 31 | Keuntungan: 32 | 33 | * sederhana dan familiar. 34 | * memberi kemudahan dalam menulis aplikasi yang terorganisir. 35 | 36 | Kekurangan: 37 | 38 | * cenderung mengarah ke aplikasi monolitik dan susah untuk dipisah di kemudian hari. 39 | * terkadang diperlukan kode untuk mengakses hal yang ada di layer berbeda 40 | -------------------------------------------------------------------------------- /References/Architecture/microkernel.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Microkernel 4 | 5 | ## Definisi 6 | 7 | Disebut pula dengan Plug-in. 8 | 9 | Membagi aplikasi menjadi bagian inti dan sekelompok modul yang dapat dipasang dan dilepas tanpa mengganggu sistem secera keseluruhan. Microkernel menyediakan entrypoint dan flow aplikasi secara umum tanpa perlu mengetahui apa yang dilakukan oleh plugin. 10 | 11 | ## Struktur 12 | 13 | Microkernel terdiri dari bagian inti dan plugin. 14 | 15 | ![Microkernel](_imgs_/mikrokernel.png) 16 | 17 | ## Penggunaan 18 | 19 | Arsitektur ini ideal digunakan untuk: 20 | 21 | * aplikasi yang mengambil data dari beragam sumber, mentransformasikan data tersebut, dan menuliskan data ke beberapa tujuan berbeda. 22 | * aplikasi workflow. 23 | * aplikasi penjadwalan task atau job. 24 | 25 | ## Karakteristik 26 | 27 | Keuntungan 28 | 29 | * menawarkan fleksibilitas tinggi serta kemudahan untuk perluasan aplikasi. 30 | * microkernel dan plugin dapat dikembangkan secara terpisah. 31 | 32 | Kekurangan 33 | 34 | * susah untuk menentukan bagian mana yang termasuk ke dalam bagian microkernel dan tidak. 35 | * API yang predefined (terdefinisi di awal) bukan merupakan hal yang cocok untuk plugin. -------------------------------------------------------------------------------- /References/Architecture/microservice.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Micro Service 4 | 5 | ## Definisi 6 | 7 | Memecah sistem menjadi beberapa service kecil yang mandiri dan hanya menjalankan tugas yang spesifik. 8 | 9 | ## Struktur 10 | 11 | Aplikasi memanggil sebuah gateway (API central) kemudian request akan diteruskan ke microservice yang sesuai. Apabila service memiliki ketergantungan (dependensi) terhadap service lain, maka komunikasi dilakukan antar service dengan request yang dipertukarkan harus dipastikan backward-compatible. 12 | 13 | ![microservice](_imgs_/microservice.png) 14 | 15 | Tidak ada aturan jelas batasan seberapa besar sebuah microservice maupun kompleksitasnya. 16 | 17 | ## Penggunaan 18 | 19 | Arsitektur ini ideal digunakan untuk: 20 | 21 | * aplikasi yang memiliki beberapa bagian yang digunakan secara intensif dan memerlukan scaling. 22 | * service yang menyediakan fungsionalitas untuk beberapa aplikasi. 23 | * aplikasi akan menjadi semakin kompleks jika dikombinasikan sebagai aplikasi monolitik 24 | * aplikasi yang mendefinisikan `bounded-context` secara jelas. 25 | 26 | ## Karakteristik 27 | 28 | Tidak terlalu susah untuk membagi aplikasi yang monolitik ke microservice. 29 | 30 | Keuntungan: 31 | 32 | * dapat menulis, memelihara, dan deploy setiap microservice secara terpisah. 33 | * mudah untuk melakukan scaling dimana hanya perlu melakukan scale up terhadap microservice yang membutuhkan. 34 | * mudah untuk memodifikasi potongan kode dari aplikasi karena setiap service diharapkan berukuran kecil dan tidak tight-couple dengan bagian lain. 35 | 36 | Kekurangan: 37 | 38 | * membutuhkan banyak perhatian agar microservice dapat bekerja sama dengan baik: 39 | 40 | - communication 41 | - coordination 42 | - backward compatibility 43 | 44 | * satu aksi dari user dapat dilewatkan ke beberapa microservice yang artinya menjadi multiple points of failure. -------------------------------------------------------------------------------- /References/Architecture/serverless.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Serverless 4 | 5 | ## Definisi 6 | 7 | Menggunakan infrastruktur pihak ketiga (Function as a Service / FaaS) dengan fasilitas untuk menjalankan custom-code di lingkungan terkontrol sehingga fungsi-fungsi inti berjalan di pihak ketiga. 8 | 9 | ## Struktur 10 | 11 | ## Penggunaan 12 | 13 | Arsitektur ini ideal digunakan untuk: 14 | 15 | * aplikasi yang hanya terdiri dari business logic yang simple. 16 | 17 | ## Karakteristik 18 | 19 | Sifat umum: 20 | 21 | * stateless 22 | * berorientasi fungsi minimalistik, fungsi dengan ukuran kecil dan dapat bekerja cepat di setiap pemanggilan dengan minimnya dependensi terhadap fungsi lain. 23 | 24 | Keuntungan: 25 | 26 | * menghilangkan kebutuhan untuk alokasi dan pemeliharaan lingkungan pemroses (processing environment) seperti server. 27 | 28 | Kekurangan: 29 | 30 | * aplikasi yang kompleks butuh dipecah menjadi fungsi-fungsi kecil agar dapat secara efektif digunakan di layanan Function as a Service. 31 | * kehilangan kemungkinan untuk melakukan optimisasi server. 32 | * kurang efektif mengelola local-state. -------------------------------------------------------------------------------- /References/Data-Structure/List/_imgs_/component.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Data-Structure/List/_imgs_/component.png -------------------------------------------------------------------------------- /References/Data-Structure/List/_imgs_/list-append.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Data-Structure/List/_imgs_/list-append.png -------------------------------------------------------------------------------- /References/Data-Structure/List/_imgs_/list-delete.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Data-Structure/List/_imgs_/list-delete.png -------------------------------------------------------------------------------- /References/Data-Structure/List/_imgs_/list-insert.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Data-Structure/List/_imgs_/list-insert.png -------------------------------------------------------------------------------- /References/Data-Structure/List/_imgs_/list-prepend.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Data-Structure/List/_imgs_/list-prepend.png -------------------------------------------------------------------------------- /References/Data-Structure/List/_imgs_/list.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Data-Structure/List/_imgs_/list.png -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/chain-of-responsibility.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Chain of Responsibility (Behavioral pattern). 4 | 5 | Cara melewatkan request antara objek berantai. Ketika menerima request, setiap handler akan memutuskan untuk memproses request atau meneruskan ke handler lain. 6 | 7 | ## Tujuan 8 | 9 | * menghindari coupling antara pengirim dan penerima request ketika terdapat lebih dari satu handler alternatif. 10 | * memberikan kesempatan pada setiap handler untuk menangani request. 11 | * membentuk single processing pipeline yang berisi banyak kemungkinan handler. 12 | 13 | ## Struktur 14 | 15 | Class yang terlibat: 16 | 17 | * Handler: 18 | * ConcreteHandler: 19 | 20 | ## Penggunaan 21 | 22 | Desain ini digunakan ketika: 23 | 24 | * lebih dari satu objek dapat menangani sebuah request dan handler harus ditentukan secara otomatis. 25 | * perlu membuat request ke satu dari beberapa objek tanpa perlu menyebutkan penerima secara eksplisit. 26 | * sekelompok objek dapat menangani request secara dinamis. 27 | 28 | ## Catatan 29 | 30 | * Chain of Responsibility, [Command](command.md), [Mediator](mediator.md), dan [Observer](observer.md) menangani masalah decouple sender dan receiver dengan trade-off berbeda. 31 | 32 | - Chain of Responsibility melewatkan request ke receiver yang disusun berantai. 33 | - Command umumnya merinci hubungan sender-receiver dengan subclass. 34 | - Mediator memiliki reference ke setiap sender dan receiver secara tak langsung. 35 | - Observer mendefinisikan interface yang sangat decouple sehingga membuat beberapa receiver dapat dikonfigurasi saat runtime. 36 | 37 | * Chain of Responsibility dapat menggunakan Command untuk merepresentasikan request sebagai objek. 38 | * Chain of Responsibility umumnya diterapkan bersama dengan [Composite](../Structural/composite.md). 39 | 40 | ## Karakteristik 41 | 42 | * terdapat objek yang disusun secara berantai dengan pointer menuju objek berikutnya. 43 | * terdapat sebuah fungsi umum yang digunakan untuk melakukan penanganan event. 44 | * mungkin terdapat sebuah fungsi yang digunakan untuk melakukan pemeriksaan kondisi. -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/command.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Command (Behavioral pattern). 4 | 5 | Mengenkapsulasi request berupa command sebagai objek yang berisi segala informasi terkait request. 6 | 7 | ## Tujuan 8 | 9 | * enkapsulasi request sebagai objek. 10 | * mendefinisikan object-oriented callback. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: 15 | 16 | * Invoker/Sender: bertanggung jawab untuk menginisiasi request. 17 | * Command: mendeklarasikan method untuk eksekusi command. 18 | * ConcreteCommand: implementasikan beragam request. 19 | * Receiver: implementasi business logic. 20 | 21 | ## Penggunaan 22 | 23 | Desain ini digunakan ketika: 24 | 25 | * ingin parameterize objek dengan action yang akan dilakukan. 26 | * ingin specify, queue, dan execute request di waktu berbeda. 27 | * mendukung mekanisme undo. 28 | * mendukung logging perubahan sehingga operasi yang sama dapat diterapkan saat system crash. 29 | 30 | ## Catatan 31 | 32 | * [Chain of Responsibility](chain-of-responsibility.md), Command, [Mediator](mediator.md), dan [Observer](observer.md) menangani masalah decouple sender dan receiver dengan trade-off berbeda. 33 | 34 | - Chain of Responsibility melewatkan request ke receiver yang disusun berantai. 35 | - Command umumnya merinci hubungan sender-receiver dengan subclass. 36 | - Mediator memiliki reference ke setiap sender dan receiver secara tak langsung. 37 | - Observer mendefinisikan interface yang sangat decouple sehingga membuat beberapa receiver dapat dikonfigurasi saat runtime. 38 | 39 | * Chain of Responsibility dapat menggunakan Command untuk merepresentasikan request sebagai objek. 40 | * Command dapat menggunakan [Memento](memento.md) untuk memelihara state yang dibutuhkan untuk operasi undo. 41 | * MacroCommand dapat diimplementasikan dengan [Composite](../../Structural/composite.md). 42 | * Command yang harus disalin sebelum dimasukkan ke dalam history dapat diimplementasikan sebagai [Prototype](../../Structural/prototype.md). 43 | 44 | ## Karakteristik 45 | 46 | * command akan meneruskan request dengan memanggil receiver yang sesuai. 47 | * setiap command hanya memiliki satu receiver sebagai handler. -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/interpreter.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Interpreter (Behavioral pattern). 4 | 5 | Menyertakan elemen bahasa ke dalam program. 6 | 7 | ## Tujuan 8 | 9 | * mendefinisikan representasi sebuah grammar dan interpreter untuk sebuah language. 10 | * memetakan domain ke language, language ke grammar, dan grammar ke hierarchical object-oriented design. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: 15 | 16 | * Context: merangkum informasi spesifik terkait sebuah interpretasi. 17 | * Expression: representasi sebuah ekspresi bahasa. 18 | * TerminalExpression: node yang merepresentasikan sebuah nilai. 19 | * CompoundExpression: node yang merepresentasikan sebuah expression majemuk. 20 | * Evaluator: mengevaluasi sebuah ekspresi sehingga menghasilkan nilai. (opsional). 21 | 22 | ## Penggunaan 23 | 24 | Desain ini digunakan ketika: 25 | 26 | * grammar sederhana (untuk grammar yang complex, ada pendekatan lain yang lebih baik). 27 | * efisiensi bukanlah 28 | 29 | ## Catatan 30 | 31 | * Interpreter dapat menggunakan [State](state.md) untuk mendefinisikan parsing context. 32 | * Abstract Syntax Tree (AST) pada Interpreter merupakan [Composite](../Structural/composite.md) sehingga [Iterator](iterator.md) dan [Visitor](visitor.md) dapat berlaku. 33 | * simbol terminal (TerminalExpression) dapat dibagi sebagai Flyweight. 34 | 35 | ## Karakteristik 36 | 37 | -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/iterator.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Iterator (Behavioral pattern). 4 | 5 | Akses elemen sebuah koleksi secara sekuensial / berurutan tanpa mengekspos representasi di belakang. 6 | 7 | ## Tujuan 8 | 9 | * memberikan akses ke element dari kumpulan objek tanpa mengekspos representasi. 10 | * polymorphic traversal. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: 15 | 16 | * Collection/Aggregate: kumpulan objek dengan mekanisme penyimpanan tertentu. 17 | * Iterator: interface untuk objek yang dapat melakukan akses elemen secara sekuensial tanpa mengekspos mekanisme penyimpanan Collection. 18 | * ConcreteCollection: 19 | * ConcreteIterator: 20 | 21 | 22 | ## Penggunaan 23 | 24 | Desain ini digunakan ketika: 25 | 26 | ## Catatan 27 | 28 | * Abstract Syntax Tree (AST) pada [Interpreter](interpreter.md) merupakan [Composite](../Structural/composite.md) sehingga Iterator dan [Visitor](visitor.md) dapat berlaku. 29 | * Iterator dapat menjelajahi Composite. Visitor dapat menerapkan operasi ke Composite. 30 | * [Memento](memento.md) umumnya digunakan bersamaan dengan Iterator. Iterator menggunakan Memento untuk menangkap state dari iterasi dan disimpan secara internal. 31 | 32 | ## Karakteristik 33 | 34 | * traversal dilakukan searah, dimulai dari elemen pertama (first) dan dilanjutkan dengan elemen berikutnya (next). 35 | -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/memento.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Memento (Behavioral pattern). 4 | 5 | Save dan restore state dari object tanpa mengekspos detail implementasi. 6 | 7 | ## Tujuan 8 | 9 | * Menyimpan internal state sebuah objek secara eksternal tanpa menyalahi enkapsulasi. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat: 14 | 15 | * Originator: menghasilkan snapshot state dan mengembalikan dari state yang diinginkan. 16 | * Memento: value object yang bertindak sebagai snapshot dari Originator. Umumnya merupakan objek immutable. 17 | * Caretaker: menyimpan history dari memento dan dapat mengunjungi history untuk melakukan restorasi. 18 | 19 | ## Penggunaan 20 | 21 | Desain ini digunakan ketika: 22 | 23 | * snapshot keadaan objek harus disimpan (save) dan dapat dikembalikan (restore) suatu saat. 24 | * direct interface untuk mendapatkan state berpotensi mengekspos detail implementasi dan merusak enkapsulasi objek. 25 | 26 | ## Catatan 27 | 28 | * [Command](command.md) dan Memento bertindak sebagai magic-token yang dipertukarkan dan pada akhirnya akan dieksekusi. Pada Command, token merepresentasikan sebuah request; sementara pada Memento, token merepresentasikan internal state dari suatu objek pada saat tertentu. 29 | * [Command](command.md) dapat menggunakan Memento untuk memelihara state yang dibutuhkan untuk operasi undo. 30 | * Memento umumnya digunakan bersamaan dengan [Iterator](iterator.md). Iterator menggunakan Memento untuk menangkap state dari iterasi dan disimpan secara internal. 31 | 32 | ## Karakteristik 33 | 34 | * state yang disimpan oleh Memento dapat berupa sebagian maupun keseluruhan informasi / field. -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/observer.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Observer (Behavioral pattern). 4 | 5 | Cara untuk memberikan notifikasi setiap ada perubahan kepada beberapa class. 6 | 7 | ## Tujuan 8 | 9 | * Mendefinisikan dependensi one-to-many sehingga apabila terjadi perubahan pada suatu objek maka semua objek yang dependen terhadapnya akan menerima notifikasi update secara otomatis. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat: 14 | 15 | - Publisher/Subject: class yang bertindak sebagai generator suatu informasi atau event. 16 | - Subscriber/Observer: class yang menunggu adanya event melalui sebuah callback. 17 | 18 | ## Penggunaan 19 | 20 | Desain ini digunakan ketika: 21 | 22 | * terdapat objek yang bergantung kepada objek lain. 23 | * perubahan di satu objek membutuhkan perubahan di objek lain secara segera tapi tidak tau berapa banyak objek yang perlu diubah. 24 | 25 | ## Catatan 26 | 27 | * [Chain of Responsibility](chain-of-responsibility.md), [Command](command.md), [Mediator](mediator.md), dan Observer menangani masalah decouple sender dan receiver dengan trade-off berbeda. 28 | 29 | - Chain of Responsibility melewatkan request ke receiver yang disusun berantai. 30 | - Command umumnya merinci hubungan sender-receiver dengan subclass. 31 | - Mediator memiliki reference ke setiap sender dan receiver secara tak langsung. 32 | - Observer mendefinisikan interface yang sangat decouple sehingga membuat beberapa receiver dapat dikonfigurasi saat runtime. 33 | 34 | * Mediator dan Observer saling bersaing. Perbedaan antara keduanya adalah Observer menyebar (distribusi) komunikasi dengan mengenalkan konsep publisher dan subscriber sementara Mediator mengenkapsulasi komunikasi antar objek. Observer lebih mudah untuk di-reuse. 35 | * Mediator dapat menggunakan pola Observer untuk secara dinamis mendaftarkan Colleague dan berkomunikasi dengan mereka. 36 | 37 | ## Karakteristik 38 | 39 | * umumnya observer akan definisikan sebuah callback yang akan dipanggil oleh subject ketika ada event. 40 | * subject bersifat independen sementara observer bersifat dependan terhadap subject. 41 | * observer register diri sendiri ke subject. 42 | * subject dapat push informasi ke observer, atau observer pull informasi dari subject. -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/state.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | State (Behavioral pattern). 4 | 5 | Suatu atribut yang dapat digunakan untuk mengubah perilaku objek. 6 | 7 | ## Tujuan 8 | 9 | * Memberi kemampuan objek untuk mengubah perilaku ketika internal-state berubah. 10 | * object-oriented state machine. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: 15 | 16 | * Context: menyimpan reference ke salah satu objek state dan mendelegasikan semua tugas berkaitan dengan state. Berkomunikasi dengan state objek melalui interface state. 17 | * State: mendeklarasikan method untuk melakukan tugas spesifik state. 18 | * ConcreteState: 19 | 20 | ## Penggunaan 21 | 22 | Desain ini digunakan ketika: 23 | 24 | * perilaku objek bergantung kepada state dan harus memberikan reaksi yang tepat sesuai dengan state saat ini. 25 | * operasi memiliki conditional statement yang sangat besar dan bergantung kepada state objek. 26 | 27 | ## Catatan 28 | 29 | * State umumnya [Singleton](../Creational/singleton.md) 30 | * [Flyweight](../Structural/flyweight.md) menjelaskan kapan dan bagaimana objek State dapat dibagi. 31 | * [Interpreter](interpreter.md) dapat menggunakan State untuk mendefinisikan parsing-context. 32 | * [Strategy](strategy.md) memiliki 2 implementasi berbeda salah satunya mirip dengan State. Perbedaannya adalah Strategy bersifat statis (bind-once). 33 | 34 | ## Karakteristik 35 | 36 | * context menyimpan reference ke state terkini. -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/strategy.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Strategy (Behavioral pattern). 4 | 5 | Mengenkapsulasi algoritma ke dalam class. 6 | 7 | ## Tujuan 8 | 9 | * Mendefinisikan sekelompok algoritma, enkapsulasi sebagai class, dan membuat masing-masing dapat digunakan secara bergantian. 10 | * Mengubur detail algoritma di class turunan. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: 15 | 16 | * Context: menyimpan reference ke salah satu strategy kemudian mendelegasikan tugas ke strategy, alih-alih dieksekusi secara langsung. 17 | * Strategy: interface yang berlaku umum bagi semua strategy. 18 | * ConcreteStrategy: implementasi beragam algoritma yang dapat digunakan. 19 | 20 | ## Penggunaan 21 | 22 | Desain ini digunakan ketika: 23 | 24 | * banyak class berkaitan namun berbeda di perilaku. 25 | * hanya perlu sedikit variasi di algoritma. 26 | * algoritma memerlukan data yang tidak perlu diketahui client. 27 | 28 | ## Catatan 29 | 30 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/template-method.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Template Method (Behavioral pattern). 4 | 5 | Menangguhkan langkah-langkah algoritma ke dalam subclass. 6 | 7 | ## Tujuan 8 | 9 | * mendefinisikan kerangka algoritma di superclass namun menangguhkan langkah-langkah algoritma ke subclass tanpa mengganti struktur. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat: 14 | 15 | * AbstractClass: mendeklarasikan method sebagai langkah-langkah algoritma. 16 | * ConcreteClass: override semua langkah di template method. 17 | 18 | ## Penggunaan 19 | 20 | Desain ini digunakan ketika: 21 | 22 | * perilaku umum di kalangan subclass harus difaktorkan dan dilokalisasikan ke dalam class umum untuk menghindari duplikasi. 23 | * mengendalikan ekstensi subclass. 24 | 25 | ## Catatan 26 | 27 | * mengubah algoritma menjadi template-method perlu untuk menentukan langkah mana yang umum dan langkah mana yang spesifik terhadap suatu class. 28 | * Template Method menggunakan inheritance untuk membedakan bagian-bagian algoritma. [Strategy](strategy.md) menggunakan delegasi untuk membuat variasi algoritma. 29 | * Strategy memodifikasi logic dari objek secara individual. Template Method memodifikasi logic dari keseluruhan class. 30 | * [Factory Method](../Creational/factory-method.md) adalah spesialisasi dari Template Method. 31 | 32 | ## Karakteristik 33 | 34 | -------------------------------------------------------------------------------- /References/Design-Pattern/Behavioral/visitor.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Visitor (Behavioral pattern). 4 | 5 | Mendefinisikan operasi baru terhadap class tanpa melakukan perubahan. 6 | 7 | ## Tujuan 8 | 9 | * Memisahkan algoritma dari objek yang dioperasikan. 10 | * Merepresentasikan operasi yang akan dilakukan ke elemen struktur data. 11 | * Mendefinisikan operasi baru tanpa mengubah class yang dioperasikan. 12 | * Double dispatch. 13 | 14 | ## Struktur 15 | 16 | Class yang terlibat: 17 | 18 | * Visitor: interface yang mendeklarasikan sekelompok method dan menerima elemen konkret. 19 | * ConcreteVisitor: implementasi beberapa versi yang disesuaikan dengan kasus pada concrete element. 20 | * Element: interface yang mendeklarasikan method untuk menerima visitor. 21 | * ConcreteElement: implementasi penerima visitor dan mengarahkan call ke method di visitor. 22 | 23 | ## Penggunaan 24 | 25 | Desain ini digunakan ketika: 26 | 27 | * struktur objek memiliki banyak tipe objek dengan interfaceberbeda dan perlu dilakukan operasi terhadap objek tersebut tanpa bergantung kepada concrete class. 28 | * banyak operasi berbeda dan tak berkaitan yang perlu dilakukan terhadap objek di struktur dan perlu untuk menghindari "mencemari" class dengan operasi tersebut. 29 | * class jarang berubah namun operasi baru terhadap struktur akan sering mengalami perubahan. 30 | 31 | ## Catatan 32 | 33 | * Abstract Syntax Tree (AST) pada [Interpreter](interpreter.md) merupakan [Composite](../Structural/composite.md) sehingga [Iterator](iterator.md) dan Visitor dapat berlaku. 34 | * Iterator dapat menjelajahi Composite. Visitor dapat menerapkan operasi ke Composite. 35 | * Visitor mirip [Command](command.md) namun lebih powerful karena dapat menginisiasi apapun yang sesuai dengan objek yang ditemui. 36 | 37 | ## Karakteristik 38 | 39 | * terdapat method visit() sebagai callback yang akan dipanggil oleh tiap elemen. 40 | * terdapat method accept() pada elemen (di setiap hirarki) yang akan memanggil visit() di visitor. 41 | * method-overload pada fungsi visit() dengan parameter tiap tipe element. -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/abstract-factory.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Abstract Factory (Creational pattern) 4 | 5 | ## Tujuan 6 | 7 | * menawarkan interface untuk menciptakan sekelompok objek yang berhubungan atau memiliki keterkaitan dependensi tanpa memberikan detail kelas konkret. 8 | * sebuah hirarki yang mengenkapsulasi berbagai kemungkinan produk dan konstruksi sekelompok produk. 9 | 10 | ## Struktur 11 | 12 | Abstract Factory mendefinisikan sebuah Factory Method untuk setiap produk. Setiap Factory Method mengenkapsulasi pembentukan dan konstruksi objek yang konkret dan spesifik. 13 | 14 | Class yang terlibat: 15 | 16 | * AbstractProduct: kelas dasar yang mendefinisikan sekelompok produk bertipe sejenis. 17 | * Product: produk yang termasuk dalam kategori jenis yang sama. 18 | * AbstractFactory: interface untuk operasi yang menciptakan factory (untuk keluarga objek tertentu). 19 | * Factory: kelas yang menciptakan bertanggung jawab menciptakan objek-objek. 20 | 21 | ## Penggunaan 22 | 23 | Desain ini digunakan ketika: 24 | 25 | * system harus bersikap independen terhadap bagaimana produk dapat tercipta, dikomposisi, dan direpresentasikan. 26 | * system harus dapat dikonfigurasi untuk satu dari sekian keluarga / kelompok produk. 27 | * sekelompok produk yang saling berkaitan didesain untuk dapat bekerja bersama. 28 | 29 | ## Catatan 30 | 31 | ## Karakteristik 32 | 33 | * hasil akhir merupakan sebuah factory yang dapat membentuk beberapa produk dalam kelompok tertentu. -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/builder.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Builder (Creational pattern) 4 | 5 | Mengonstruksi objek yang kompleks secara bertahap. 6 | 7 | ## Tujuan 8 | 9 | * Memisahkan konstruksi sebuah objek yang kompleks dari representasinya sehingga proses konstruksi yang sama dapat menciptakan representasi yang berbeda. 10 | * Mendekomposisi proses menjadi serangkaian aksi-aksi kecil. 11 | 12 | ## Struktur 13 | 14 | Builder mendefinisikan satu atau lebih method yang mewakili fase pembentukan sebuah produk. Fase-fase ini kemudian akan di-invoke oleh sebuah Directory. Semua proses pembentukan akan ditangani oleh Director. 15 | 16 | Class yang terlibat: 17 | 18 | * Director: kelas yang melakukan pembangunan produk. Proses pembuatan produk yang terdiri dari fase-fase berbeda diabstraksi menjadi satu method yang seragam. 19 | * Builder: kelas yang bertanggung jawab membentuk komponen-komponen dari produk. 20 | * Produk: kelas yang diinstansiasi oleh Builder. 21 | 22 | ## Penggunaan 23 | 24 | Desain ini digunakan ketika: 25 | 26 | ## Catatan 27 | 28 | * Terkadang creational patterns bersifat komplementer: Builder dapat menggunakan satu atau lebih pattern lain untuk mengimplementasikan komponen yang akan dibangun. 29 | * Builder berfokus kepada konstruksi objek yang kompleks secara langkah demi langkah. AbstractFactory menekankan sekelompok objek produk (bisa produk sederhana maupun kompleks). Builder mengembalikan produk pada langkah akhir, sementara AbstractFactory langsung memberikan product yang diminta. 30 | * Builder seringkali membangun sebuah Composite. 31 | 32 | ## Karakteristik 33 | 34 | - Pola Builder mengorganisir konstruksi objek menjadi beberapa langkah. 35 | - Pembuatan objek dilakukan dengan mengeksekusi beberapa method untuk melakukan konstumisasi terhadap objek yang akan dihasilkan di akhir. 36 | 37 | ## References 38 | 39 | - [Refactoring.Guru](https://refactoring.guru/design-patterns/builder) 40 | - [SourceMaking](https://sourcemaking.com/design_patterns/builder) -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/factory-method.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Factory Method (Creational pattern). 4 | 5 | Factory Method adalah pola dimana terdapat sebuah method yang bertugas / bertanggung jawab untuk menciptakan object. 6 | 7 | Method atau function apapun yang mengembalikan instance dari class atau class turunan. 8 | 9 | ## Tujuan 10 | 11 | * Mendefinisikan interface untuk menciptakan objek, namun instansiasi diserahkan kepada subclass. 12 | * Mengganti konstruksi objek secara langsung dengan pemanggilan terhadap method di factory sehingga objek-objek yang beragam (namun dalam satu kelompok sama) dapat diciptakan dengan fleksibel. 13 | * Instantiasi class dari hirarki tanpa perlu melakukan hardcode nama class dan implementasinya. 14 | 15 | ## Struktur 16 | 17 | Class yang terlibat: 18 | 19 | * Product: mendefinisikan interface untuk tipe-tipe objek yang diciptakan oleh factory method. 20 | * ConcreteProduct: mengimplementasikan interface Product. 21 | * Creator: mendelarasikan factory method, yang mengembalikan objek bertipe AbstractProduct. 22 | * ConcreteCreator: override factory method untuk mengembalikan instance dari Product konkret. 23 | 24 | ## Penggunaan 25 | 26 | Desain ini digunakan ketika: 27 | 28 | ## Karakteristik 29 | 30 | 31 | ## References 32 | 33 | - [Refactoring.Guru](https://refactoring.guru/design-patterns/factory-method) 34 | - [SourceMaking](https://sourcemaking.com/design_patterns/factory_method) -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/multiton.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Multiton (Creational pattern). 4 | 5 | Multiton adalah pola generalisasi terhadap [Singleton](singleton.md). Jika Singleton memperbolehkan hanya satu instance dari sebuah kelas, Multiton memperbolehkan adanya beberapa instance yang dikelola dalam sebuah map. 6 | 7 | ## Tujuan 8 | 9 | 10 | ## Struktur 11 | 12 | Class yang terlibat: 13 | 14 | - Multiton: objek yang akan diinstansiasi. 15 | 16 | ## Penggunaan 17 | 18 | Desain ini digunakan ketika: 19 | -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/named-constructor.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Named Constructor (Creational pattern). 4 | 5 | Menggunakan static function sebagai factory untuk membangun instance, alih-alih menggunakan constructor. 6 | 7 | ## Tujuan 8 | 9 | * Menciptakan objek dari sumber data yang berbeda dengan konstruktor yang sama. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat: N/A 14 | 15 | 16 | ## Penggunaan 17 | 18 | Desain ini digunakan ketika: -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/object-pool.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Object Pool (Creational pattern). 4 | 5 | Membuat sebuah cache berupa kumpulan objek (resource) yang dapat dipakai ulang sehingga meminimalisir proses penciptaan (dan inisiasi) objek. 6 | 7 | ## Tujuan 8 | 9 | * Mengurangi waktu dalam penciptaan objek dengan menciptakan kumpulan objek yang dapat dipakai ulang. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat 14 | 15 | ## Penggunaan 16 | 17 | Desain ini digunakan ketika: 18 | 19 | * Inisialisasi objek membutuhkan biaya tinggi dan menciptakan objek dari awal sebisa mungkin dihindari. -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/prototype.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Prototype (Creational pattern). 4 | 5 | Membuat objek baru berdasarkan sebuah objek yang ada sebagai purwarupa (prototype) dan melakukan cloning terhadapnya. 6 | 7 | ## Tujuan 8 | 9 | * Menetapkan jenis objek yang diciptakan menggunakan instance purwarupa (prototype). Penciptaan objek dilakukan dengan menyalin prototype tersebut. 10 | * Menjadikan sebuah instance sebagai basis untuk instance berikutnya. 11 | 12 | ## Struktur 13 | 14 | Pola prototype mendelegasikan penciptaan objek kepada objek tersebut melalui mekanisme clone. Pola ini mendeklarasikan interface untuk semua objek agar mendukung fungsi clone. 15 | 16 | Class yang terlibat: 17 | 18 | * Prototype: interface yang mendefinisikan fungsi clone() 19 | * ConcretePrototype: class yang mengimplementasikan clone() sebagai cara untuk menyalin data dari objek original ke objek baru. 20 | 21 | Terdapat varian dimana didefinisikan sebuah Registry. 22 | 23 | * Registry: menyimpan beberapa objek purwarupa yang telah siap disalin. 24 | 25 | ## Penggunaan 26 | 27 | Desain ini digunakan ketika: 28 | 29 | * inisialisasi objek membutuhkan biaya tinggi dan menciptakan objek dari awal sebisa mungkin dihindari. 30 | 31 | ## Catatan 32 | 33 | * Factory Method menciptakan instance dengan inheritance, prototype dengan delegation. 34 | * Abstract Factory umumnya diimplementasikan dengan Factory method, namun bisa juga dengan Prototype. 35 | 36 | ## Karakteristik 37 | 38 | * Terdapat method clone() pada product. 39 | * Registry mengelola cache dari objek purwarupa. Registry dapat dienkapsulasi sebagai Factory baru. 40 | -------------------------------------------------------------------------------- /References/Design-Pattern/Creational/singleton.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Singleton (Creational pattern). 4 | 5 | Singleton adalah pola dimana hanya terdapat satu instance dari sebuah class dan tidak diperbolehkan adanya instansiasi tambahan. 6 | 7 | ## Tujuan 8 | 9 | - Memastikan class hanya memiliki (maksimal) satu instance selama runtime. 10 | - Menyediakan mekanisme global untuk mengakses objek. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: N/A 15 | 16 | ## Penggunaan 17 | 18 | Desain ini digunakan ketika: 19 | 20 | - Aplikasi membutuhkan satu, dan hanya satu, instance objek. 21 | 22 | ## Karakteristik 23 | 24 | - Tidak ada cara secara eksplisit untuk menciptakan instance baru. 25 | - Konstruktor didefinisikan sebagai private method. 26 | - Terdapat sebuah method untuk mendapatkan instance. 27 | - Instance serta method untuk mengakses instance didefinisikan sebagai static. 28 | - Lazy initialization diberlakukan (penciptaan objek dilakukan ketika instance diakses pertama kali). 29 | 30 | ## Catatan 31 | 32 | - [Abstract Factory](abstract-factory.md), [Builder](builder.md), dan [Prototype](prototype.md) dapat menggunakan Singleton dalam implementasinya. 33 | - [Facade](../Structural/facade.md) seringkali diimplementasikan sebagai Singleton karena hanya ada satu objek Facade yang dibutuhkan. 34 | - Object sejenis State umumnya Singleton. 35 | - Seringkali Singleton disalahartikan sebagai pengganti global variable. 36 | - Seringkali Singleton tidak diperlukan. -------------------------------------------------------------------------------- /References/Design-Pattern/Structural/adapter.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Adapter (Structural pattern). 4 | 5 | Mencocokkan interface dari class berbeda. 6 | 7 | ## Tujuan 8 | 9 | * Konversi (mengubah bentuk) interface sebuah class menjadi interface lain yang diharapkan oleh client. 10 | * Wrap class yang telah ada dengan interface baru. 11 | * Membuat class menjadi kompatibel dengan standard interface baru. 12 | 13 | ## Struktur 14 | 15 | Class yang terlibat: 16 | 17 | * Target: mendeskripsikan protokol, sebuah interface yang diharapkan diakses. 18 | * Adapter: mengonversikan pemanggilan ke Target akan dilayani oleh Adaptee/Service 19 | * Adaptee/Service: kelas yang menyediakan layanan. 20 | 21 | ## Penggunaan 22 | 23 | Desain ini digunakan ketika: 24 | 25 | ## Catatan 26 | 27 | 28 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/Structural/bridge.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Bridge (Structural pattern). 4 | 5 | Memisahkan antara interface suatu objek dengan implementasi. 6 | 7 | ## Tujuan 8 | 9 | * `Decouple` abstraksi dan implementasi. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat: 14 | 15 | ## Penggunaan 16 | 17 | Desain ini digunakan ketika: 18 | 19 | * Dibutuhkan run-time binding ke implementation. 20 | 21 | ## Catatan 22 | 23 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/Structural/composite.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Composite (Structural pattern). 4 | 5 | Mendeskripsikan sekelompok objek yang diperlakukan selayaknya sebuah objek yang padu. 6 | 7 | ## Tujuan 8 | 9 | * Mengomposisikan beberapa objek ke dalam struktur tree untuk merepresentasikan hirarki whole-part. 10 | * Recursive composition. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: 15 | 16 | * Component: interface mendeskripsikan operasi yang umum di elemen sederhana maupun kompleks di tree. 17 | * Composite: container yang berisi sub element. 18 | * Leaf: elemen dasar yang tak memiliki sub-elemen 19 | 20 | ## Penggunaan 21 | 22 | Desain ini digunakan ketika: 23 | 24 | ## Catatan 25 | 26 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/Structural/decorator.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Decorator (Structural pattern). 4 | 5 | Menambah behavior secara dinamis melalui wrapper. 6 | 7 | ## Tujuan 8 | 9 | * Menambahkan "responsibility" atau "behavior" ke objek secara dinamis melalui komponen yang dapat dirangkai dan dilepas. 10 | 11 | Disebut juga dengan "Wrapper". 12 | 13 | ## Struktur 14 | 15 | Class yang terlibat: 16 | 17 | ## Penggunaan 18 | 19 | Desain ini digunakan ketika: 20 | 21 | ## Catatan 22 | 23 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/Structural/facade.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Facade (Structural pattern). 4 | 5 | Satu class yang merepresentasikan keseluruhan subsystem (secara terpadu / unified). 6 | 7 | ## Tujuan 8 | 9 | * Memberikan interface yang disederhanakan untuk mengakses library, framework, atau kelompok class lain yang kompleks. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat: 14 | 15 | - Facade: memberikan akses ke sebagian fungsionalitas subsystem. 16 | 17 | ## Penggunaan 18 | 19 | Desain ini digunakan ketika: 20 | 21 | ## Catatan 22 | 23 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/Structural/flyweight.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Flyweight (Structural pattern). 4 | 5 | Meminimalisir penggunaan memory dengan cara berbagi data sebanyak mungkin pada objek serupa. 6 | 7 | ## Tujuan 8 | 9 | * Memperbanyak sumber data yang dimiliki bersama oleh beberapa objek. 10 | 11 | ## Struktur 12 | 13 | Class yang terlibat: 14 | 15 | * FlyweightFactory: mengelola object pool berisi flyweight. 16 | * Flyweight: class berisi sebagian dari objek asal (yang di-refactor) 17 | 18 | ## Penggunaan 19 | 20 | Desain ini digunakan ketika: 21 | 22 | ## Catatan 23 | 24 | Karena objek flyweight dapat digunakan di beragam konteks, perlu dipastikan bahwa state tidak mengalami perubahan. Flyweight hanya dapat menginisialisasi sekali melalui parameter konstruktor. Tidak boleh ada data yang terekspos ke objek lain. 25 | 26 | Untuk memudahkan akses ke beragam flyweight, factory method dapat digunakan untuk mengelola object pool dari flyweight. Method menerima state yang diinginkan dari client dan kemudian objek flyweight yang sesuai akan diberikan jika ada. 27 | 28 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/Structural/proxy.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Proxy (Structural pattern). 4 | 5 | Objek yang merepresentasikan objek lain. 6 | 7 | ## Tujuan 8 | 9 | * Menyediakan perantara/placeholder bagi objek lain. 10 | * Melakukan sesuatu sebelum atau sesudah request tanpa mengganggu subjek asli. 11 | 12 | ## Struktur 13 | 14 | Class yang terlibat: 15 | 16 | * Subject/Service: 17 | * Proxy: 18 | 19 | ## Penggunaan 20 | 21 | Desain ini digunakan ketika: 22 | 23 | ## Catatan 24 | 25 | ## Karakteristik -------------------------------------------------------------------------------- /References/Design-Pattern/_imgs_/periodic_table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ReversingID/Programming-Reference/0b2365b676b43da7a122889d079862c4ec0655a1/References/Design-Pattern/_imgs_/periodic_table.png -------------------------------------------------------------------------------- /References/Design-Pattern/general-techniques.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | General techniques / mechanism for code reuse. 4 | 5 | ## Inheritance 6 | 7 | Dynamic / runtime polymorphism. 8 | 9 | Keuntungan: 10 | 11 | - Dapat mengganti implementasi saat runtime. 12 | - Menyimpan objek berbeda (pointer, smart pointer, atau reference) dalam kontainer yang sama. 13 | - Menunda method call ke implementasi spesifik dan memperbolehkan client-code bekerja dengan banyak implementasi berbeda saat runtime. 14 | 15 | Kerugian: 16 | 17 | - Class harus diturunkan dari base yang sama jika perlu dilakukan modifikasi. 18 | - Objek hanya dapat dikembalikan dari factory function sebagai pointer atau dibungkus smart pointer. 19 | - Lebih lambat daripada static polymorphism (template dan overload functions). 20 | 21 | ## Delegation 22 | 23 | Menggunakan objek lain untuk mengimplementasikan beberapa fungsionalitas dan meneruskan method call alih-alih mewariskan object class. 24 | 25 | ## Static Polymorphism 26 | 27 | Template dan overload functions atau overload methods. 28 | 29 | Template dapat menghilangkan overhead akibat virtual method call dengan melakukan method-resolving saat compile (alih-alih saat runtime). 30 | 31 | ## Type Erasure 32 | 33 | ## Free Functions 34 | 35 | C++ adalah bahasa multiparadigma dan tidak semua kebutuhan perlu direpresentasikan sebagai class. Function dapat digunakan untuk memperluas kemampuan class tanpa perlu melakukan modifikasi. 36 | 37 | ## Higher Order Functions / Higher Order Methods / Lambda 38 | 39 | Lambda function dapat digunakan untuk: 40 | - menambah perilaku ke objek saat runtime. 41 | - membuat algoritma generik 42 | - fungsi 43 | - menyederhanakan event handling 44 | - callback -------------------------------------------------------------------------------- /References/README.md: -------------------------------------------------------------------------------- 1 | # Programming Reference 2 | 3 | Open repository of programming topic for reverse engineering purpose. 4 | 5 | ## Algorithm 6 | 7 | Strategi penyelesaian suatu masalah dengan membangun langkah-langkah pasti. 8 | 9 | ## Data Structure 10 | 11 | Membangun sebuah struktur pengelolaan data agar dapat melakukan penyimpanan, penghapusan, dan pencarian kembali data secara efisien. 12 | 13 | ## Design Pattern 14 | 15 | Membangun hubungan antar objek dan komunikasi di antaranya untuk memecahkan masalah berulang dengan pola-pola tertentu. 16 | 17 | ## Architecture 18 | 19 | Membangun struktur dasar dari sistem software berdasarkan modul-modul dan relasi antar elemen. --------------------------------------------------------------------------------