├── .clang_format ├── .clang_tidy ├── .gitattributes ├── .github ├── ISSUE_TEMPLATE │ └── bug_report.md ├── codeowners ├── funding.yml ├── pull_request_template.md └── workflows │ └── cpp.yml ├── .gitignore ├── .mergify.yml ├── .vscode └── .settings.json ├── CMakeLists.txt ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── algorithm ├── algoritma_greedy │ ├── CMakeLists.txt │ ├── huffman.cpp │ └── knapsack.cpp ├── bit_manipulation │ ├── CMakeLists.txt │ ├── count_of_set_bits.cpp │ ├── flip_count_bits.cpp │ └── hamming_distance.cpp ├── dynamic_programming │ ├── CMakeLists.txt │ ├── angka_armstrong.cpp │ ├── kadane.cpp │ ├── subset_sum.cpp │ └── word_break.cpp ├── hashing │ ├── CMakeLists.txt │ └── chaining.cpp ├── search_algorithm │ ├── CMakeLists.txt │ └── linear_search.cpp └── sorting │ ├── CMakeLists.txt │ ├── bead_sort.cpp │ ├── bubblesort.cpp │ ├── bubblesort_doubly_linkedlist.cpp │ ├── bucket_sort.cpp │ ├── insertion_sort.cpp │ ├── selection_sort.cpp │ └── snail_sort.cpp ├── artificial_intelligence ├── CMakeLists.txt ├── adaline_learning.cpp └── k_nearest_neighbour.cpp ├── backtracking ├── CMakeLists.txt ├── knight_tour.cpp ├── minimax.cpp ├── n_queens.cpp ├── rat_in_maze.cpp ├── subarray_sum.cpp ├── sudoku_solver.cpp └── wildcard_matching.cpp ├── basic ├── 01_introduction │ ├── hello_world.cpp │ └── readme.md ├── 02_variable_datatype │ ├── cmakelists.txt │ ├── readme.md │ └── variabel.cpp ├── 03_pointer_reference │ ├── pointer.cpp │ └── readme.md ├── 04_operator │ ├── operator_bitwise.cpp │ └── readme.md ├── 05_conditional │ ├── cmakelists.txt │ ├── conditional.cpp │ ├── readme.md │ └── ternary.cpp ├── 06_looping │ ├── break.cpp │ ├── continue.cpp │ ├── readme.md │ └── while.cpp ├── 07_array │ ├── array_cpp.cpp │ └── readme.md ├── 08_string │ ├── gaya_c.cpp │ ├── menggunakan_array.cpp │ └── readme.md ├── 09_multidimensional_array │ ├── multidimensional_array.cpp │ └── readme.md ├── 10_input_output │ ├── input_output.cpp │ └── readme.md ├── 11_constant_literal │ ├── constanta_const.cpp │ ├── constanta_define.cpp │ └── readme.md ├── 12_fungsi │ ├── fungsi.cpp │ ├── fungsi_return.cpp │ └── readme.md ├── 13_dynamic_array │ ├── dynamic_array.cpp │ └── readme.md ├── 14_class │ ├── kelas.cpp │ └── readme.md ├── 15_struct │ ├── contoh_struct.cpp │ └── readme.md ├── 16_vector_basic │ ├── readme.md │ └── vector_basic.cpp ├── 17_function_overload │ ├── function_overloading.cpp │ └── readme.md ├── CMakeLists.txt └── readme.md ├── design_patterns ├── readme.md └── singleton │ ├── CMakeLists.txt │ ├── readme.md │ ├── singleton_another_example.cpp │ ├── singleton_basic.cpp │ ├── static_class_scope.cpp │ └── static_file_scope │ ├── another.cpp │ ├── main.cpp │ └── readme.md ├── geometri ├── CMakeLists.txt ├── graham_scan.cpp └── include │ └── fungsi_graham.hpp ├── graf ├── CMakeLists.txt └── djikstra.cpp ├── license ├── math ├── CMakeLists.txt ├── Regula_falsi.cpp ├── bisection.cpp ├── cek_faktorial.cpp ├── cek_prima.cpp ├── cos.cpp ├── derivative.cpp ├── equation_linear.cpp ├── fast_power.cpp ├── fibonacci.cpp ├── ganjil_genap.cpp ├── least_square_method.cpp ├── linear_regression.cpp ├── mean_absolute_error.cpp ├── mean_absolute_percentage_error.cpp ├── mean_square_error.cpp ├── quadratic_formula.cpp ├── rabin_miller.cpp ├── radian.cpp ├── relu.cpp ├── sigmoid.cpp ├── statistik_deskritif.cpp ├── variance.cpp ├── volume.cpp └── z_score.cpp ├── object_oriented_programming ├── basic │ ├── 00_definisi_kelas │ │ ├── class_definition.cpp │ │ └── readme.md │ └── 01_metode_kelas │ │ ├── inner_class.cpp │ │ ├── outer_class.cpp │ │ └── readme.md ├── intermediate │ ├── 01_inheritance │ │ ├── inheritance.cpp │ │ └── readme.md │ ├── 02_abstract │ │ ├── abstract.cpp │ │ └── readme.md │ ├── 03_encapsulation │ │ ├── encapsulation.cpp │ │ └── readme.md │ └── 04_polymorphism │ │ ├── polimorfis.cpp │ │ └── readme.md └── readme.md ├── readme.md ├── renovate.json ├── strings ├── CMakeLists.txt └── boyer_moore.cpp └── struktur_data ├── binary_search_tree ├── binary_search_tree.cpp └── readme.md ├── hash_table ├── asset │ ├── hash_table_chaining.png │ ├── hash_table_collision.png │ ├── hash_table_visualisasi.png │ └── tabel_hash_kode_demo.png ├── hash_table.cpp └── readme.md ├── linked_list ├── linked ├── linked_list.cpp ├── linked_list_image.jpeg └── readme.md ├── readme.md └── struct_ds ├── readme.md ├── struktur_contoh1.cpp ├── struktur_contoh2.cpp └── struktur_contoh3.cpp /.clang_tidy: -------------------------------------------------------------------------------- 1 | --- 2 | Checks: '-*,google-*,clang-analyzer-*,-clang-analyzer-security.insecureAPI.*,cppcoreguidelines-*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-pro-bounds-*,openmp-*,performance-*,portability-*,modernize-*,-modernize-use-trailing-*' 3 | WarningsAsErrors: '*,-google-readability-*,-google-explicit-constructor,-modernize-*,modernize-avoid-c-arrays,-performance-move-const-arg,-performance-noexcept-move-constructor,-performance-unnecessary-value-param,-cppcoreguidelines-init-variables,-cppcoreguidelines-pro-*,-cppcoreguidelines-owning-memory,-clang-analyzer-cplusplus.Move' 4 | HeaderFilterRegex: '' 5 | AnalyzeTemporaryDtors: false 6 | FormatStyle: '{ BasedOnStyle: Google, UseTab: Never, IndentWidth: 4, TabWidth: 4, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 80, AccessModifierOffset: -3, AlignConsecutiveMacros: true }' -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto 2 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: buat report untuk membantu kita dalam menyelesaikan masalah pada repository 4 | title: BUG 5 | labels: bug 6 | assignees: slowy07 7 | 8 | --- 9 | 10 | ## Masalah 11 | 12 | 13 | ## Screenshots atau contoh error 14 | 15 | ``` 16 | pesan error 17 | ``` 18 | 19 | ## Desktop (please complete the following information): 20 | 21 | - OS: ``linux/windows/macOS`` 22 | - g++: ``g++ --version`` 23 | 24 | 25 | terima kasih ! 26 | -------------------------------------------------------------------------------- /.github/codeowners: -------------------------------------------------------------------------------- 1 | 2 | # This is a comment. 3 | # Each line is a file pattern followed by one or more owners. 4 | 5 | # These owners will be the default owners for everything in 6 | # the repo. Unless a later match takes precedence, 7 | # @global-owner1 and @global-owner2 will be requested for 8 | # review when someone opens a pull request. 9 | * @slowy07 10 | -------------------------------------------------------------------------------- /.github/funding.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2] 3 | patreon: # Replace with a single Patreon username 4 | open_collective: # Replace with a single Open Collective username 5 | ko_fi: # Replace with a single Ko-fi username 6 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel 7 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry 8 | liberapay: # Replace with a single Liberapay username 9 | issuehunt: # Replace with a single IssueHunt username 10 | otechie: # Replace with a single Otechie username 11 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] 12 | -------------------------------------------------------------------------------- /.github/pull_request_template.md: -------------------------------------------------------------------------------- 1 | # Deskripsi (Description) 2 | 3 | 4 | 5 | # Checklist: 6 | ##### Umum: 7 | - [ ] Saya menambah algoritma terbaru. 8 | - [ ] Saya memperbaiki algoritma yang sudah ada. 9 | - [ ] Saya memperbaiki dokumentasi. 10 | - [ ] Saya menambah dokumentasi. 11 | 12 | ##### Contributor Requirements (Syarat Kontributor) dan Lain-Lain: 13 | - [ ] Saya sudah membaca (I have read) [CONTRIBUTING](https://github.com/bellshade/CPP/blob/main/CONTRIBUTING.md) dan sudah menyetujui semua syarat. 14 | - [ ] Saya telah menambahkan komentar kode yang memberikan penjelasan maksud dari kode yang saya buat. 15 | - [ ] Saya menggunakan bahasa Indonesia untuk memberikan penjelasan dari kode yang saya buat. 16 | 17 | # Environment 18 | Saya menggunakan (I'm using): 19 | 20 | - ``OS`` = `Windows/Linux/Mac OS` 21 | - ``g++`` = 22 | 23 | 24 | 25 | # Link Issues 26 | 27 | Issues : # 28 | 29 | -------------------------------------------------------------------------------- /.github/workflows/cpp.yml: -------------------------------------------------------------------------------- 1 | # cpp testing menggunakan clang-tidy-10 dan clang-format 2 | # informasi dan dokumentasi clang-tidy 3 | # https://clang.llvm.org/extra/clang-tidy/ 4 | 5 | # informasi dan dokumentasi clang-format 6 | # https://clang.llvm.org/docs/ClangFormat.html 7 | 8 | 9 | name: Cpp Testing 10 | 11 | on: [push, pull_request] 12 | # push: 13 | # branches: [ main ] 14 | # pull_request: 15 | # branches: [ main ] 16 | permissions: 17 | contents: write 18 | 19 | jobs: 20 | TestingUtama: 21 | name: cpp test 22 | runs-on: ubuntu-latest 23 | steps: 24 | - uses: actions/checkout@v3 25 | with: 26 | fetch-depth: 0 27 | - uses: actions/setup-python@v4 28 | - name: install requirement 29 | run: | 30 | sudo apt-get -qq update 31 | sudo apt-get -qq install clang-tidy clang-format 32 | - name: git 33 | run: | 34 | git config --global user.name github-actions[bot] 35 | git config --global user.email 'github-actions@users.noreply.github.com' 36 | - name: format filename 37 | run: | 38 | wget https://raw.githubusercontent.com/bellshade/unitesting-script/main/filename_formatter.sh 39 | chmod +x filename_formatter.sh 40 | ./filename_formatter.sh .cpp, .hpp 41 | 42 | - name: mengambil file yang telah dirubah 43 | run: | 44 | git branch 45 | git diff --diff-filter=dr --name-only origin/main > git_diff.txt 46 | echo "file diubah-- `cat git_diff.txt`" 47 | 48 | - name: Konfigurasi statik lint cpp 49 | run: cmake -B build -S . -DCMAKE_EXPORT_COMPILE_COMMANDS=ON 50 | 51 | build: 52 | name: cek compile 53 | runs-on: ${{ matrix.os }} 54 | needs: [TestingUtama] 55 | permissions: 56 | pull-requests: write 57 | strategy: 58 | matrix: 59 | os: [ubuntu-latest, windows-latest, macOS-latest] 60 | steps: 61 | - uses: actions/checkout@v4 62 | with: 63 | submodules: true 64 | - name: build cpp 65 | run: | 66 | cmake -B ./build -S . 67 | cmake --build build --parallel 4 68 | - name: tambah label jika fail 69 | uses: actions/github-script@v6 70 | if: ${{ failure() && matrix.os == 'ubuntu-latest' && github.event_name == 'pull_request'}} 71 | with: 72 | script: | 73 | github.rest.issue.addLabels({ 74 | issue_number: context.issue.number, 75 | owner: context.repo.owner, 76 | repo: context.repo.repo, 77 | labels: ['testing fail!'] 78 | }) 79 | 80 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .cache 3 | .vscode 4 | *.d 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | *.gch 10 | *.pch 11 | *.so 12 | *.dylib 13 | *.dll 14 | *.mod 15 | *.smod 16 | *.lai 17 | *.la 18 | *.a 19 | *.lib 20 | *.exe 21 | a.out 22 | *.out 23 | *.app 24 | 25 | build/ 26 | -------------------------------------------------------------------------------- /.mergify.yml: -------------------------------------------------------------------------------- 1 | pull_request_rules: 2 | # membuat requirement dari automerge dengan sistem 3 | # ketika workflow build passed maka akan dicentang 4 | # ketika target pull request ke main maka akan dicentang 5 | # ketika dikasih label 'ready-to-merge' akan dicentang 6 | 7 | # ketika requirement telah terpenuhi maka bot akan bekerja 8 | # dan pull request secara otomatis akan merge 9 | - name: ci testing kalo sukses ke squash dengan label 10 | conditions: 11 | - base=main 12 | - label=ready-to-merge 13 | actions: 14 | # menambahkan komentar jika sudah di merge 15 | comment: 16 | message: terima kasih atas kontribusinya @{{author}}! 17 | # menambahkan label jika sudah di merge 18 | label: 19 | add: 20 | - sudah dirieview! 21 | # metode sistem dari automerge 22 | merge: 23 | method: squash 24 | commit_message_template: | 25 | {{ title }} 26 | 27 | {{ body }} 28 | 29 | This Commit License 30 | https://github.com/bellshade/CPP/blob/main/license 31 | 32 | Co-authored-by: bellshadebot 33 | 34 | - name: cpp labels 35 | conditions: 36 | - or: 37 | - body~=(?m)^\[X\] Saya menambah algoritma terbaru. 38 | - body~=(?m)^\[X\] Saya membperbaiki algoritma yang sudah ada. 39 | - files~=\.cpp$ 40 | actions: 41 | label: 42 | add: 43 | - cpp file 44 | -------------------------------------------------------------------------------- /.vscode/.settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "C_Cpp.clang_format_style": "{ BasedOnStyle: Google, UseTab: Never, IndentWidth: 4, TabWidth: 4, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 80, AccessModifierOffset: -3, AlignConsecutiveMacros: true }", 3 | "editor.formatOnSave": true, 4 | "editor.formatOnType": true, 5 | "editor.formatOnPaste": true, 6 | "files.associations": { 7 | "array": "cpp", 8 | "atomic": "cpp", 9 | "*.tcc": "cpp", 10 | "bitset": "cpp", 11 | "cctype": "cpp", 12 | "chrono": "cpp", 13 | "cinttypes": "cpp", 14 | "clocale": "cpp", 15 | "cmath": "cpp", 16 | "complex": "cpp", 17 | "cstdarg": "cpp", 18 | "cstddef": "cpp", 19 | "cstdint": "cpp", 20 | "cstdio": "cpp", 21 | "cstdlib": "cpp", 22 | "cstring": "cpp", 23 | "ctime": "cpp", 24 | "cwchar": "cpp", 25 | "cwctype": "cpp", 26 | "deque": "cpp", 27 | "list": "cpp", 28 | "unordered_map": "cpp", 29 | "unordered_set": "cpp", 30 | "vector": "cpp", 31 | "exception": "cpp", 32 | "algorithm": "cpp", 33 | "functional": "cpp", 34 | "iterator": "cpp", 35 | "map": "cpp", 36 | "memory": "cpp", 37 | "memory_resource": "cpp", 38 | "numeric": "cpp", 39 | "optional": "cpp", 40 | "random": "cpp", 41 | "ratio": "cpp", 42 | "set": "cpp", 43 | "string": "cpp", 44 | "string_view": "cpp", 45 | "system_error": "cpp", 46 | "tuple": "cpp", 47 | "type_traits": "cpp", 48 | "utility": "cpp", 49 | "fstream": "cpp", 50 | "initializer_list": "cpp", 51 | "iomanip": "cpp", 52 | "iosfwd": "cpp", 53 | "iostream": "cpp", 54 | "istream": "cpp", 55 | "limits": "cpp", 56 | "new": "cpp", 57 | "ostream": "cpp", 58 | "sstream": "cpp", 59 | "stdexcept": "cpp", 60 | "streambuf": "cpp", 61 | "typeinfo": "cpp", 62 | "valarray": "cpp" 63 | } 64 | } -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.22) 2 | project(Bellshade_cpp 3 | LANGUAGES CXX 4 | VERSION 1.0.0 5 | DESCRIPTION "kumpulan implementasi serta basic dari cpp" 6 | ) 7 | set(CMAKE_CXX_STANDARD 11) 8 | set(CMAKE_CXX_STANDARD_REQUIRED ON) 9 | 10 | if(MSVC) 11 | # set(CMAKE_CXX_STANDARD 14) 12 | add_compile_definitions(_CRT_SECURE_NO_WARNINGS) 13 | endif(MSVC) 14 | 15 | option(USE_OPENMP "flag to use OpenMP for multithreading" ON) 16 | if(USE_OPENMP) 17 | find_package(OpenMP 3.0 COMPONENTS CXX) 18 | if (OpenMP_CXX_FOUND) 19 | message(STATUS "Building with OpenMP Multithreading.") 20 | else() 21 | message(STATUS "No OpenMP found, no multithreading.") 22 | endif() 23 | endif() 24 | 25 | 26 | add_subdirectory(backtracking) 27 | add_subdirectory(algorithm/algoritma_greedy) 28 | add_subdirectory(algorithm/bit_manipulation) 29 | add_subdirectory(algorithm/dynamic_programming) 30 | add_subdirectory(algorithm/search_algorithm) 31 | add_subdirectory(algorithm/sorting) 32 | add_subdirectory(artificial_intelligence) 33 | add_subdirectory(strings) 34 | add_subdirectory(geometri) 35 | add_subdirectory(graf) 36 | add_subdirectory(design_patterns/singleton) 37 | 38 | # FIXME: ada beberapa fungsi header math terkhusus untuk 39 | # windows, oleh karena itu maka setting kompilasi 40 | # berjalan dari subdirektori `math` bekerja untuk 41 | # non windows 42 | # error tersebut ditemui pada pull request: 43 | # https://github.com/bellshade/CPP/pull/117 44 | if(NOT WIN32) 45 | add_subdirectory(math) 46 | endif() 47 | 48 | cmake_policy(SET CMP0054 NEW) 49 | cmake_policy(SET CMP0057 NEW) 50 | find_package(Doxygen OPTIONAL_COMPONENTS dot dia) 51 | if(DOXYGEN_FOUND) 52 | set(DOXYGEN_GENERATE_MAN NO) 53 | set(DOXYGEN_USE_MATHJAX YES) 54 | set(DOXYGEN_GENERATE_HTML YES) 55 | # set(DOXYGEN_HTML_TIMESTAMP YES) 56 | set(DOXYGEN_EXTRACT_STATIC YES) 57 | set(DOXYGEN_INLINE_SOURCES YES) 58 | set(DOXYGEN_CREATE_SUBDIRS YES) 59 | set(DOXYGEN_EXTRACT_PRIVATE YES) 60 | set(DOXYGEN_GENERATE_TREEVIEW YES) 61 | set(DOXYGEN_STRIP_CODE_COMMENTS NO) 62 | set(DOXYGEN_EXT_LINKS_IN_WINDOW YES) 63 | set(DOXYGEN_BUILTIN_STL_SUPPORT YES) 64 | set(DOXYGEN_EXCLUDE_PATTERNS */build/*) 65 | set(DOXYGEN_ENABLE_PREPROCESSING YES) 66 | set(DOXYGEN_CLANG_ASSISTED_PARSING YES) 67 | set(DOXYGEN_FILE_PATTERNS *.cpp *.h *.hpp *.md) 68 | set(DOXYGEN_MATHJAX_EXTENSIONS TeX/AMSmath TeX/AMSsymbols) 69 | set(DOXYGEN_TAGFILES "doc/cppreference-doxygen-web.tag.xml=http://en.cppreference.com/w/") 70 | if(MSVC) 71 | set(DOXYGEN_CPP_CLI_SUPPORT YES) 72 | endif() 73 | set(DOXYGEN_MATHJAX_RELPATH "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-MML-AM_CHTML") 74 | if(Doxygen_dot_FOUND) 75 | set(DOXYGEN_HAVE_DOT YES) 76 | set(DOXYGEN_CALL_GRAPH YES) 77 | set(DOXYGEN_INTERACTIVE_SVG YES) 78 | set(DOXYGEN_DOT_IMAGE_FORMAT "svg") 79 | endif() 80 | if(OPENMP_FOUND) 81 | set(DOXYGEN_PREDEFINED "_OPENMP=1") 82 | endif() 83 | if(GLUT_FOUND) 84 | set(DOXYGEN_PREDEFINED ${DOXYGEN_PREDEFINED} "GLUT_FOUND=1") 85 | endif() 86 | 87 | doxygen_add_docs( 88 | doc 89 | ${PROJECT_SOURCE_DIR} 90 | COMMENT "Generate documentation" 91 | ) 92 | endif() 93 | 94 | set(CPACK_PROJECT_NAME ${PROJECT_NAME}) 95 | set(CPACK_PROJECT_VERSION ${PROJECT_VERSION}) 96 | include(CPack) 97 | -------------------------------------------------------------------------------- /algorithm/algoritma_greedy/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | 3 | # FIXME: informasi error: 4 | # failure was caused by a read of a variable outside its lifetime 5 | # error C2131: expression did not evaluate to a constant 6 | # 7 | # error ditemukan pada: 8 | # https://github.com/bellshade/CPP/pull/117 9 | list(REMOVE_ITEM APP_SOURCES "knapsack.cpp") 10 | 11 | foreach( testsourcefile ${APP_SOURCES} ) 12 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 13 | add_executable( ${testname} ${testsourcefile} ) 14 | 15 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 16 | if(OpenMP_CXX_FOUND) 17 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 18 | endif() 19 | install(TARGETS ${testname} DESTINATION "bin/backtracking") 20 | 21 | endforeach( testsourcefile ${APP_SOURCES} ) 22 | -------------------------------------------------------------------------------- /algorithm/algoritma_greedy/huffman.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * huffman coding adalah sebuah tipe koding yang 3 | * optimal yang biasanya digunakan untuk lossless 4 | * data compression 5 | * kode huffman lebih cepat 45% dibandingkan 6 | * kode dari ASCII. 7 | */ 8 | #include 9 | #include 10 | 11 | // huffman pohon node 12 | struct MinHeapNode { 13 | // input karakter 14 | char data; 15 | // frekuensi dari karakter 16 | unsigned frekuensi; 17 | // kiri dan kanan node child 18 | MinHeapNode *kanan, *kiri; 19 | 20 | MinHeapNode(char data, unsigned frekuensi) { 21 | kiri = kanan = NULL; 22 | this->data = data; 23 | this->data = frekuensi; 24 | } 25 | }; 26 | 27 | // untuk membandingkan antara 28 | // heap node 29 | struct komparasi { 30 | bool operator()(MinHeapNode *kiri, MinHeapNode *kanan) { 31 | return (kiri->frekuensi > kanan->frekuensi); 32 | } 33 | }; 34 | 35 | // menampilkan kode huffman dari 36 | // root pohon huffman 37 | void printKode(struct MinHeapNode *root, std::string str) { 38 | if (!root) { 39 | return; 40 | } 41 | 42 | if (root->data != '$') 43 | std::cout << root->data << ":" << str << "\n"; 44 | 45 | printKode(root->kiri, str + "0"); 46 | printKode(root->kanan, str + "1"); 47 | } 48 | 49 | /** 50 | * bangun pohon huffman dan menampilkan kode dengan 51 | * melintasi pohon huffman yang dibagun 52 | */ 53 | void KodeHuffman(char data[], int frekuensi[], int ukuran) { 54 | struct MinHeapNode *kiri, *kanan, *atas; 55 | 56 | // membuat min heap dan memasukkan semua karakter ke dalam data[] 57 | std::priority_queue, komparasi> 58 | minHeap; 59 | for (int i = 0; i < ukuran; ++i) 60 | minHeap.push(new MinHeapNode(data[i], frekuensi[i])); 61 | 62 | // looping ketika ukuran heap tidak menjadi 1 63 | while (minHeap.size() != 1) { 64 | kiri = minHeap.top(); 65 | minHeap.pop(); 66 | 67 | kanan = minHeap.top(); 68 | minHeap.pop(); 69 | 70 | // buat simpul internal baru dengan frekuensi sama 71 | // dengn jumlah dua node. 72 | // buat juga dua simpil yang diekstrasi sebagai child kiri 73 | // dan kana dan node baru ini, maka ditambahkan simpul ini 74 | // ke min heap "$" adalah nilai khusus untuk kode internal 75 | atas = new MinHeapNode('$', kiri->frekuensi + kanan->frekuensi); 76 | atas->kiri = kiri; 77 | atas->kanan = kanan; 78 | minHeap.push(atas); 79 | } 80 | 81 | // tampilkan kode huffman 82 | // menggunakan pohon huffman 83 | // yang sebelumnya sudah dibuat 84 | printKode(minHeap.top(), ""); 85 | } 86 | 87 | // jalankan semua fungsi 88 | int main() { 89 | char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'}; 90 | int frekuensi[] = {5, 9, 12, 13, 16, 45}; 91 | 92 | int ukuran = sizeof(arr) / sizeof(arr[0]); 93 | 94 | KodeHuffman(arr, frekuensi, ukuran); 95 | return 0; 96 | } 97 | -------------------------------------------------------------------------------- /algorithm/algoritma_greedy/knapsack.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * knapsack adalah masalah yang mana seorang 3 | * berhadapan dengan persoalan optimasi pemilihan 4 | * benda mana yang bisa ditampung dalam wadah berkapasitas 5 | * terbatas. optimasi dimasukkan ke dalam suatu wadah yang 6 | * dimaksud diahasilkan keuntungan semaksimal mungkin. 7 | */ 8 | #include 9 | 10 | struct Item { 11 | int ukuran; 12 | int profit; 13 | }; 14 | 15 | float profitPerUnit(Item x) { return (float)x.profit / (float)x.ukuran; } 16 | 17 | /** 18 | * algoritma greedy yang merupakan teknik pemogramn yang kerap kali digunakan 19 | * dalam mengatasi permasalahan optimasi. cara kerja algoritma ini yaitu dengn 20 | * menggunakan heuristic dalam mencari solusi suboptium dengan harapan solusi 21 | * optimum. 22 | */ 23 | 24 | int partisi(Item arr[], int low, int high) { 25 | Item pivot = arr[high]; 26 | int i = (low - 1); 27 | 28 | for (int j = low; j < high; j++) { 29 | // jika element lebih kecil maka bisa 30 | // di dalam 31 | if (profitPerUnit(arr[j]) <= profitPerUnit(pivot)) { 32 | i++; 33 | Item temp = arr[i]; 34 | arr[i] = arr[j]; 35 | arr[j] = temp; 36 | } 37 | } 38 | Item temp = arr[i + 1]; 39 | arr[i + 1] = arr[high]; 40 | arr[high] = temp; 41 | return (i + 1); 42 | } 43 | 44 | void quickSort(Item arr[], int low, int high) { 45 | if (low < high) { 46 | int p = partisi(arr, low, high); 47 | quickSort(arr, low, p - 1); 48 | quickSort(arr, p + 1, high); 49 | } 50 | } 51 | 52 | int main() { 53 | int n; 54 | float kapasitas; 55 | std::cout << "\nmasukkan kapasitas dari wadah: "; 56 | std::cin >> kapasitas; 57 | std::cout << "\nmasukkan angka dari item: "; 58 | std::cin >> n; 59 | Item itemArray[n]; 60 | 61 | for (int i = 0; i < n; i++) { 62 | std::cout << "\nmasukkan ukuran dan profit dari item " << i + i 63 | << " : "; 64 | std::cin >> itemArray[i].ukuran; 65 | std::cin >> itemArray[i].profit; 66 | } 67 | 68 | quickSort(itemArray, 0, n - 1); 69 | 70 | float maxProfit = 0; 71 | int i = n; 72 | while (kapasitas > 0 && --i >= 0) { 73 | if (kapasitas >= itemArray[i].ukuran) { 74 | maxProfit += itemArray[i].profit; 75 | kapasitas -= itemArray[i].ukuran; 76 | std::cout << "\n\t" << itemArray[i].ukuran << "\t" 77 | << itemArray[i].profit; 78 | } else { 79 | maxProfit = profitPerUnit(itemArray[i]) * kapasitas; 80 | std::cout << "\n\t" << kapasitas << "\t" 81 | << profitPerUnit(itemArray[i]) * kapasitas; 82 | kapasitas = 0; 83 | break; 84 | } 85 | } 86 | std::cout << "\nmaks profit : " << maxProfit; 87 | return 0; 88 | } 89 | -------------------------------------------------------------------------------- /algorithm/bit_manipulation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/backtracking") 11 | 12 | endforeach( testsourcefile ${APP_SOURCES} ) -------------------------------------------------------------------------------- /algorithm/bit_manipulation/count_of_set_bits.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file count_of_set_bits.cpp 3 | * @details Count of set bits 4 | * diberikan angka integer. kemudian kalkulasi angka dari bits 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | namespace bit_manipulation{ 11 | namespace count_of_set_bits{ 12 | std::uint64_t countSetbits(std::int64_t n){ 13 | int count = 0; 14 | while (n != 0){ 15 | ++count; 16 | n = (n & (n - 1)); 17 | } 18 | return count; 19 | } 20 | } 21 | } 22 | 23 | static void test(){ 24 | assert(bit_manipulation::count_of_set_bits::countSetbits(4) == 1); 25 | } 26 | 27 | int main(){ 28 | test(); 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /algorithm/bit_manipulation/flip_count_bits.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * diberi dua angka A dan B, kemudian hitung jumlah 3 | * bit yang perlu dibalik untuk mengubah A menjadi B 4 | * 5 | * contoh 6 | * A = 01010 7 | * B = 10100 8 | * bit A yang perlu dibalik adalah 10100 9 | * jika dibalik maka mendapatkan 10100, yaitu B 10 | * 11 | * time kompleksitas terburuk: O(log n) 12 | * space kompleksitas: O(1) 13 | */ 14 | #include 15 | #include 16 | #include 17 | 18 | namespace bit_manipulation { 19 | 20 | namespace flip_count_bits { 21 | 22 | std::uint64_t countBitsFlip(std::int64_t A, std::int64_t B) { 23 | // variabel hitung untuk menghitung jumlah 24 | // flip bit 25 | // angka A danB dalam mempresentasikan biner dari 26 | // angka 'n' 27 | int hitung = 0; 28 | A = A ^ B; 29 | while (A) { 30 | A = A & (A - 1); 31 | hitung++; 32 | } 33 | return hitung; 34 | } 35 | } // namespace flip_count_bits 36 | } // namespace bit_manipulation 37 | 38 | /** 39 | * membuat fungsi untuk mengetes fungsi dari 40 | * flup_count_bits 41 | */ 42 | static void test() { 43 | // A = 10 B = 20 44 | // maka dengan ini mengembalikan 4 45 | assert(bit_manipulation::flip_count_bits::countBitsFlip(10, 20) == 4); 46 | // A= 11 B = 8 47 | // maka dengan ini mengembalikan 2 48 | assert(bit_manipulation::flip_count_bits::countBitsFlip(11, 8) == 2); 49 | } 50 | 51 | int main() { 52 | // memanggil fungsi test 53 | test(); 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /algorithm/bit_manipulation/hamming_distance.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @brief hamming distance 3 | * penjelasan lebih lanjut tentang hamming distance 4 | * https://en.wikipedia.org/wiki/Hamming_distance 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | namespace bit_manipulation { 12 | /** 13 | * @namespace hamming_distance 14 | * @brief fungsi utama dari implementasi 15 | * hamming distance 16 | * 17 | */ 18 | namespace hamming_distance { 19 | /** 20 | * @param nilai jumlah yang ingin dihitung 21 | * jumlah bit yang ditetapkan 22 | * @return jumlah bit yang ditetapkan dalam nomor 23 | * yang diberikan 24 | */ 25 | std::uint64_t bitCount(std::uint64_t value) { 26 | std::uint64_t count = 0; 27 | while (value) { 28 | // mengecek bit terendah 29 | if (value & 1) { 30 | count++; 31 | } 32 | // menghapus bit terendah 33 | value >>= 1; 34 | } 35 | return count; 36 | } 37 | 38 | /** 39 | * fungsi ini mengembalikan jarak hamming antara 40 | * dua bilangan bulat 41 | * @param a bilangan pertama 42 | * @param b bilangan kedua 43 | * @return jarak hamming antara a dan b 44 | */ 45 | uint64_t hamming_distance(uint64_t a, uint64_t b) { return bitCount(a ^ b); } 46 | 47 | /** 48 | * fungsi ini mengembalikan jarak hamming antara dua string 49 | * @param a string pertama 50 | * @param b string kedua 51 | * @return jarak hamming antara a dan b 52 | */ 53 | uint64_t hamming_distance(const std::string &a, const std::string &b) { 54 | assert(a.size() == b.size()); 55 | size_t n = a.size(); 56 | uint64_t count = 0; 57 | for (size_t i = 0; i < n; i++) { 58 | count += (b[i] != a[i]); 59 | } 60 | return count; 61 | } 62 | } // namespace hamming_distance 63 | 64 | } // namespace bit_manipulation 65 | 66 | static void test() { 67 | assert(bit_manipulation::hamming_distance::hamming_distance(11, 2) == 2); 68 | } 69 | 70 | int main() { 71 | test(); 72 | uint64_t a = 11; 73 | uint64_t b = 200; 74 | 75 | std::cout << bit_manipulation::hamming_distance::hamming_distance(a, b) 76 | << std::endl; 77 | 78 | return 0; 79 | } 80 | -------------------------------------------------------------------------------- /algorithm/dynamic_programming/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | 3 | # FIXME: informasi error: 4 | # failure was caused by a read of a variable outside its lifetime 5 | # error C2131: expression did not evaluate to a constant 6 | # 7 | # error ditemukan pada: 8 | # https://github.com/bellshade/CPP/pull/117 9 | list(REMOVE_ITEM APP_SOURCES "kadane.cpp") 10 | 11 | foreach( testsourcefile ${APP_SOURCES} ) 12 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 13 | add_executable( ${testname} ${testsourcefile} ) 14 | 15 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 16 | if(OpenMP_CXX_FOUND) 17 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 18 | endif() 19 | install(TARGETS ${testname} DESTINATION "bin/backtracking") 20 | 21 | endforeach( testsourcefile ${APP_SOURCES} ) 22 | -------------------------------------------------------------------------------- /algorithm/dynamic_programming/angka_armstrong.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | namespace dynamic_programming { 5 | 6 | /** 7 | * @brief cek apakah angka yang diberikan adalah angka armstrong 8 | * @param angka angka yang akan di cek 9 | * @return false jika angka yang diberikan bukan angka armstrong 10 | * @return true jika benar 11 | */ 12 | template bool cek_armstrong(const T &angka) { 13 | // inisialisasi variabel 14 | int jumlah_digit = 0, sementara = angka, hasil = 0; 15 | 16 | // hitung jumlah digit dari angka yang diberikan 17 | // contoh: 153 memiliki 3 digit 18 | while (sementara != 0) { 19 | // hapus digit terakhir 20 | sementara /= 10; 21 | // tambah jumlah digit 22 | jumlah_digit++; 23 | } 24 | 25 | // hitung untuk memeriksa apakah adalah angka armstrong 26 | // pada angka dengan n-digit, jumlah digit yang dipangkatkan dengan n 27 | // harus sama dengan aslinya 28 | sementara = angka; 29 | while (sementara != 0) { 30 | // ambil digit terakhir 31 | int sisa = sementara % 10; 32 | // pengkatkan dengan jumlah digit 33 | hasil += static_cast(std::pow(sisa, jumlah_digit)); 34 | // hapus digit terakhir 35 | sementara /= 10; 36 | } 37 | 38 | // jika hasil sama dengan angka asli, maka angka armstrong 39 | if (hasil == angka) { 40 | return true; 41 | } else { 42 | // jika tidak sama dengan parameter yang diberikan 43 | return false; 44 | } 45 | } 46 | } // namespace dynamic_programming 47 | 48 | /** 49 | * @brief implementasi testing 50 | * @return void 51 | */ 52 | static void testing() { 53 | // untuk testing angka armstrong 54 | assert(dynamic_programming::cek_armstrong(153) == true); 55 | assert(dynamic_programming::cek_armstrong(370) == true); 56 | 57 | // untuk testing angka bukan angka armstrong 58 | assert(dynamic_programming::cek_armstrong(15) == false); 59 | assert(dynamic_programming::cek_armstrong(103) == false); 60 | 61 | std::cout << "testing pass!" << std::endl; 62 | } 63 | 64 | int main() { 65 | testing(); 66 | return 0; 67 | } 68 | -------------------------------------------------------------------------------- /algorithm/dynamic_programming/kadane.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file kadane.cpp 3 | * @brief algoritma kadane untuk 4 | * mencari nilai maksimum dari sebuah array 5 | * informasi lebih lanjut mengenai algoritma kadane 6 | * https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d 7 | */ 8 | 9 | # include 10 | # include 11 | 12 | int maxSubArraySum(int a[], int size){ 13 | int max_so_far = INT_MIN, max_ending_here = 0; 14 | 15 | for (int i = 0; i < size; i++){ 16 | max_ending_here = max_ending_here + a[i]; 17 | if (max_so_far < max_ending_here) 18 | max_so_far = max_ending_here; 19 | 20 | if (max_ending_here < 0) 21 | max_ending_here = 0; 22 | } 23 | return max_so_far; 24 | } 25 | 26 | int main(){ 27 | int n, i; 28 | 29 | std::cout<<"masukkan jumlah elment\n"; 30 | std::cin>>n; 31 | 32 | int a[n]; 33 | for(i = 0; i < n; i++){ 34 | std::cin>>a[i]; 35 | } 36 | int max_sum = maxSubArraySum(a, n); 37 | std::cout<<"jumlah maksimum adalah"< 6 | #include 7 | #include 8 | #include 9 | namespace dynamic_programming { 10 | /** 11 | * @namespace subset_sum 12 | * @brief fungsi untuk algoritma subset 13 | */ 14 | namespace subset_sum { 15 | /** 16 | * @brief fungsi rekursif menggunakan dynamic programming untuk 17 | * menentukan apakah terdapat subset yang jumlahnya sesuai 18 | * dengan target atau tidak 19 | * @param arr array input 20 | * @param jumlahTarget jumlah target dari subset 21 | * @param dp peta yang menyimpan hasil perhitungan 22 | * @return true/false jika apakah suset dengan jumlah target 23 | * ada atau tidak 24 | */ 25 | bool rekursi_subset_sum(const std::vector &arr, int jumlahTarget, 26 | std::vector> *dp, 27 | int indeks = 0) { 28 | // ditemukan subset valid dengan jumlah yang sesuai 29 | if (jumlahTarget == 0) { 30 | return true; 31 | } 32 | // akhir dari array 33 | if (indeks == arr.size()) { 34 | return false; 35 | } 36 | 37 | // jika sudah di mapping 38 | if ((*dp)[indeks].count(jumlahTarget)) { 39 | return (*dp)[indeks][jumlahTarget]; 40 | } 41 | 42 | // cek jawaban 43 | bool jawaban = 44 | rekursi_subset_sum(arr, jumlahTarget - arr[indeks], dp, indeks + 1) || 45 | rekursi_subset_sum(arr, jumlahTarget, dp, indeks + 1); 46 | // save hasil bool ke di peta 47 | (*dp)[indeks][jumlahTarget] = jawaban; 48 | return jawaban; 49 | } 50 | 51 | /** 52 | * @brief fungsi yang implementasi algoritma subset sum menggunakan pendekatan 53 | * top-down 54 | * @param arr array input 55 | * @param jumlahTarget jumlah dari target subset 56 | * @return true/false jika subset dengan jumlah target ada atau tidak 57 | */ 58 | bool problem_subset_sum(const std::vector &arr, const int jumlahTarget) { 59 | // ukuran array 60 | size_t n = arr.size(); 61 | std::vector> dp(n); 62 | return rekursi_subset_sum(arr, jumlahTarget, &dp); 63 | } 64 | } // namespace subset_sum 65 | } // namespace dynamic_programming 66 | 67 | /** 68 | * @brief fungsi untuk menguji 69 | * @return void 70 | */ 71 | static void uji() { 72 | std::vector> input_kustom_arr(3); 73 | input_kustom_arr[0] = std::vector{1, -10, 2, 31, -6}; 74 | input_kustom_arr[1] = std::vector{2, 3, 4}; 75 | input_kustom_arr[2] = std::vector{0, 1, 0, 1, 0}; 76 | 77 | // jumlah target custom 78 | std::vector jumlah_target_kustom(3); 79 | jumlah_target_kustom[0] = -14; 80 | jumlah_target_kustom[1] = 10; 81 | jumlah_target_kustom[2] = 2; 82 | 83 | // output yang dihitung oleh fungsi problem_subset_sum 84 | std::vector output_dihitung(3); 85 | 86 | // loop dengan tujuan melakukan perhitungan untuk tiap 87 | // kasus uji 88 | for (int i = 0; i < 3; i++) { 89 | output_dihitung[i] = dynamic_programming::subset_sum::problem_subset_sum( 90 | input_kustom_arr[i], jumlah_target_kustom[i]); 91 | } 92 | 93 | // output yang diharapkan 94 | std::vector output_diharapkan{true, false, true}; 95 | 96 | for (int i = 0; i < 3; i++) { 97 | assert(output_diharapkan[i] == output_dihitung[i]); 98 | } 99 | 100 | std::cout << "semua testing pass!"; 101 | } 102 | 103 | int main() { 104 | uji(); 105 | return 0; 106 | } 107 | -------------------------------------------------------------------------------- /algorithm/hashing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/hashing") 11 | 12 | endforeach( testsourcefile ${APP_SOURCES} ) 13 | -------------------------------------------------------------------------------- /algorithm/search_algorithm/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/search_algorithm") 11 | 12 | endforeach( testsourcefile ${APP_SOURCES} ) 13 | -------------------------------------------------------------------------------- /algorithm/sorting/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.1) 2 | set (CMAKE_CXX_STANDARD 11) 3 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 4 | foreach( testsourcefile ${APP_SOURCES} ) 5 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 6 | add_executable( ${testname} ${testsourcefile} ) 7 | 8 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 9 | if(OpenMP_CXX_FOUND) 10 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 11 | endif() 12 | install(TARGETS ${testname} DESTINATION "bin/sorting") 13 | 14 | endforeach( testsourcefile ${APP_SOURCES} ) -------------------------------------------------------------------------------- /algorithm/sorting/bead_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define BEAD(i,j) beads[ i * max + j] 5 | 6 | // fungsi untuk perform algoritma 7 | 8 | void beadSort(int *a, int len){ 9 | // menemukan nilai maksimum dari elemen 10 | int max = a[0]; 11 | for(int i = 1; i < len; i++){ 12 | if(a[i] > max) 13 | max = a[i]; 14 | } 15 | 16 | // mengalokasikan memori 17 | unsigned char *beads = new unsigned char[max * len]; 18 | memset(beads, 0, static_cast(max) * len); 19 | 20 | // marking beadsnya 21 | for(int i = 0; i < len; i++) 22 | for(int j = 0; j < a[i]; j++) BEAD(i,j) = 1; 23 | 24 | for (int j = 0; j < max; j++){ 25 | // menghitung berapa banyak bead tiap elemen 26 | int sum = 0; 27 | for (int i = 0; i < len; i ++){ 28 | sum += BEAD(i,j); 29 | BEAD(i,j) = 0; 30 | } 31 | 32 | // menggeser bead kebawah 33 | for(int i = len - sum; i < len; i++) BEAD(i,j) = 1; 34 | } 35 | 36 | // maukkan value yang diorting ke array menggunakan bead 37 | for(int i = 0; i < len; i++){ 38 | int j; 39 | for(j = 0; j < max && BEAD(i,j); j++){ 40 | } 41 | a[i] = j; 42 | } 43 | delete[] beads; 44 | } 45 | 46 | // fungsi utama 47 | int main(){ 48 | int a[] = {5, 4, 2, 1,5, 7, 8}; 49 | int len = sizeof(a) / sizeof(a[0]); 50 | beadSort(a, len); 51 | 52 | for(int i = 0; i < len; i++) printf("%d", a[i]); 53 | 54 | return 0; 55 | } -------------------------------------------------------------------------------- /algorithm/sorting/bubblesort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Bubble Sort adalah Sorting algorithm yang cara kerjanya adalah dengan membandingkan 2 elemen array 3 | lalu menggeser kedua elemen tersebut sesuai dengan urutan terus-menerus sampai akhir array 4 | Berikut gambaran cara kerja dari Bubble Sort 5 | ============================================= 6 | Inisialisasi [5, 3, 8, 4, 6] Inisialisasi array acak 7 | Elemen 1 2 3 4 5 8 | Langkah 1 [5, 3, 8, 4, 6] Membandingkan elemen ke 1 dengan elemen ke 2. Dikarenakan nilai dari 9 | ^ ^ elemen ke 1 lebih besar maka posisi kedua elemen tersebut ditukar 10 | Langkah 2 [3, 5, 8, 4, 6] Membandingkan elemen ke 2 dengan elemen ke 3. Dikarenakan nilai dari 11 | ^ ^ elemen ke 2 lebih kecil maka posisi kedua elemen tidak ditukar 12 | Langkah 3 [3, 5, 8, 4, 6] Membandingkan elemen ke 3 dengan elemen ke 4. Dikarenakan nilai dari 13 | ^ ^ elemen ke 3 lebih besar maka posisi kedua elemen tersebut ditukar 14 | Langkah 4 [3, 5, 4, 8, 6] Membandingkan elemen ke 4 dengan elemen ke 5. Dikarenakan nilai dari 15 | ^ ^ elemen ke 4 lebih besar maka posisi kedua elemen tersebut ditukar 16 | Langkah 5 Mengulangi pengecekan dari awal sampai akhir array sampai tidak ada lagi yang dapat ditukar posisi 17 | Final [3, 4, 5, 6, 8] Array selesai diurutkan 18 | ============================================= 19 | */ 20 | 21 | #include 22 | #include 23 | #include 24 | 25 | namespace sorting 26 | { 27 | void bubbleSort(std::vector &numbers) 28 | { 29 | int n = numbers.size(); 30 | for (int i = 0; i < n; i++) 31 | { 32 | for (int x = 0; x < (n - i - 1); x++) 33 | { 34 | // jika current number yang direprsentasikan oleh numbers[x] lebih besar dari 35 | // nextNumber numbers[x+1] maka tukarkan posisi 2 angka tersebut 36 | if (numbers[x] > numbers[x + 1]) 37 | { 38 | // std::cout << "Menukar: " << numbers[x] << " Dengan " << numbers[x+1] << std::endl; 39 | auto temp = numbers[x]; 40 | numbers[x] = numbers[x + 1]; 41 | numbers[x + 1] = temp; 42 | } 43 | } 44 | } 45 | } 46 | void tampilkanUrutan(std::vector numbers) 47 | { 48 | for (auto &x : numbers) 49 | { 50 | std::cout << x; 51 | } 52 | std::cout << "\n"; 53 | } 54 | } // namespace sorting 55 | 56 | /** 57 | * @brief test 58 | * @return void 59 | */ 60 | static void test() 61 | { 62 | std::vector numbers = {5, 3, 8, 4, 6}; 63 | std::vector expectationSortResult = {3, 4, 5, 6, 8}; 64 | std::cout << "Sebelum diurut\n"; 65 | sorting::tampilkanUrutan(numbers); 66 | sorting::bubbleSort(numbers); 67 | std::cout << "Sesudah diurut\n"; 68 | sorting::tampilkanUrutan(numbers); 69 | assert(numbers == expectationSortResult); 70 | } 71 | int main() 72 | { 73 | test(); 74 | return 0; 75 | } 76 | -------------------------------------------------------------------------------- /algorithm/sorting/bubblesort_doubly_linkedlist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | struct Node { 6 | int number; 7 | 8 | Node* prev; 9 | Node* next; 10 | }; 11 | 12 | Node* NodeHead = NULL; 13 | Node* NodeTail = NULL; 14 | 15 | void CreateNodeBegin(int number); 16 | void BubbleSort(); 17 | void ReadData(); 18 | 19 | int main() { 20 | CreateNodeBegin(5); 21 | CreateNodeBegin(3); 22 | CreateNodeBegin(1); 23 | CreateNodeBegin(9); 24 | CreateNodeBegin(7); 25 | 26 | BubbleSort(); 27 | 28 | ReadData(); 29 | } 30 | 31 | /* Bubble sort */ 32 | void BubbleSort() 33 | { 34 | int swapped; 35 | struct Node *temp; 36 | 37 | // Cek apakah data kosong. Jika kosong, bubble sort berhenti. 38 | if (NodeHead == NULL) return; 39 | 40 | do { 41 | swapped = 0; 42 | temp = NodeHead; 43 | 44 | // Looping list hingga mencapai node terakhir 45 | while (temp->next != NodeTail) { 46 | /* 47 | Sorting data secara ascending. 48 | Jika ingin sorting secara descending, ubah operator '>' dibawah ini menjadi '<'. 49 | */ 50 | if (temp->number > temp->next->number) { 51 | // swap() : function penukaran nilai antar 2 variable 52 | swap(temp->number, temp->next->number); 53 | swapped = 1; 54 | } 55 | 56 | // Menggeser node temp ke node selanjutnya 57 | temp = temp->next; 58 | } 59 | 60 | // Assign nilai NodeTail berupa node temp 61 | NodeTail = temp; 62 | } while (swapped); 63 | } 64 | 65 | // Membuat node baru dibagian awal list 66 | void CreateNodeBegin(int number) { 67 | Node* newNode = new Node; 68 | 69 | newNode->number = number; 70 | 71 | newNode->next = NodeHead; 72 | NodeHead = newNode; 73 | NodeHead->prev = NULL; 74 | } 75 | 76 | // Membaca data list 77 | void ReadData() { 78 | Node* temp = NodeHead; 79 | 80 | while (temp != NULL) { 81 | cout << temp->number << endl; 82 | temp = temp->next; 83 | } 84 | } -------------------------------------------------------------------------------- /algorithm/sorting/bucket_sort.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * bucket sort atau bin sort adalah algoritma sorting yang bekerja dengan 3 | * mendistribusikan elemen dari array ke dalam ember. setiap ember diurutkan 4 | * secara satu per satu, baik menggunakan algoritma yang beda atu ecara rekursif 5 | */ 6 | #include 7 | #include 8 | #include 9 | 10 | void sortingBucket(float arr[], int n) { 11 | // membuat ember kosong 12 | std::vector *b = new std::vector[n]; 13 | 14 | // masukkan elemen array di dalam ember yang 15 | // berbeda beda 16 | for (int i = 0; i < n; i++) { 17 | // variable bi adalah indeks untuk di dalam 18 | // ember 19 | int bi = n * arr[i]; 20 | b[bi].push_back(arr[i]); 21 | } 22 | 23 | // sorting ember satu persatu 24 | for (int i = 0; i < n; i++) 25 | std::sort(b[i].begin(), b[i].end()); 26 | 27 | // masukkan semua ember ke dalam variabel arr[] 28 | int indeks = 0; 29 | for (int i = 0; i < n; i++) 30 | for (int j= 0; j < b[i].size(); j++) 31 | arr[indeks++] = b[i][j]; 32 | delete[] b; 33 | } 34 | 35 | int main() { 36 | float arr[] = {0.871, 0.761, 0.651, 0.7192, 0.8888, 0.712}; 37 | int n = sizeof(arr) / sizeof(arr[0]); 38 | sortingBucket(arr, n); 39 | 40 | std::cout<<"array yang sudah di sorting adalah\n"; 41 | for (int i = 0; i < n; i++) 42 | std::cout< 2 | #include 3 | using namespace std; 4 | //fungsi untuk menampilkan vector setelah sort secara Ascending(terkecil) 5 | void tampilkanAscending(vector& value){ 6 | for(int i = 0; i < value.size(); i++){ 7 | cout << value[i] << " "; 8 | } 9 | } 10 | //fungsi untuk menampilkan vector setelah sort secara Descending(terbesar) 11 | void tampilkanDescending(vector& value){ 12 | for(int i = 0; i < value.size(); i++){ 13 | cout << value[i] << " "; 14 | } 15 | } 16 | void InsertionSortAscending(vector& value, int &key){ //insertion sort menaik 17 | for(int i = 1;i < value.size(); i++){ 18 | key = value[i]; //inialisasi bilangan kedua merupakan key(kunci) 19 | int j = i - 1; //inialisasi j adalah bilangan pertama 20 | while(j >= 0 && value[j] > key){ //operator logika AND akan true jika kedua input true 21 | /*jka bilangan lebih besar dari 0 dan bilangan lebih besar dari key maka while akan berjalan*/ 22 | value[j + 1] = value[j]; // Geser elemen 23 | j = j - 1; //Pindah ke elemen berikutnya di kiri 24 | } 25 | value[j + 1] = key; // Masukkan key pada posisi yang benar 26 | } 27 | } 28 | void InsertionSortDescending(vector& value) { //insertion sort menurun 29 | for(int i = 1; i < value.size(); i++) { 30 | int key = value[i]; // key adalah elemen yang akan disisipkan 31 | int j = i - 1; 32 | // Geser elemen-elemen yang lebih kecil dari key ke kanan 33 | while(j >= 0 && value[j] < key) { 34 | value[j + 1] = value[j]; // Geser elemen 35 | j = j - 1; // Pindah ke elemen berikutnya di kiri 36 | } 37 | value[j + 1] = key; // Masukkan key pada posisi yang benar 38 | } 39 | } 40 | int main(){ 41 | int count,input,key; 42 | vector value; 43 | //meminta user untuk memasukkan panjang data(vector) 44 | cout << "Masukkan panjang data: "; 45 | cin >> count; 46 | for(int i = 0;i <= count - 1 ; i++){ 47 | cout << "Masukkan data ke " << i + 1 << ": "; 48 | cin >> input; 49 | value.push_back(input); 50 | } 51 | //menampilkan vector setelah sorting 52 | InsertionSortAscending(value,key); 53 | cout << "Data setelah di urut mulai dari terkecil "; 54 | tampilkanAscending(value); 55 | InsertionSortDescending(value); 56 | cout << "\ndata setelah di urut mulai terbesar "; 57 | tampilkanDescending(value); 58 | cin.get(); 59 | return 0; 60 | } -------------------------------------------------------------------------------- /algorithm/sorting/selection_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | // Fungsi untuk menukar posisi dua elemen 6 | void swap(int *a, int *b) { 7 | int temp = *a; 8 | *a = *b; 9 | *b = temp; 10 | } 11 | void PrintVec(vector& val){ //gunakan referencing 12 | for(int print = 0; print < val.size(); print++){ 13 | cout << val[print] << " "; 14 | } 15 | } 16 | void SelectionSort(vector& val){ //gunakan referencing untuk menghindari banyak penggunaan variabel 17 | /* 18 | Lakukan iterasi untuk setiap elemen vector dengan i sebagai indeks elemen pertama. 19 | Karena elemen terakhir secara otomatis sudah berada di posisi yang benar setelah semua iterasi, 20 | maka loop untuk i berhenti di val.size() - 1. 21 | */ 22 | for(int i = 0; i < val.size() - 1; i++){ 23 | //asumsikan elemen minimum adalah element index pertama atau i(karena index dimulai dari 0) 24 | int min = i; 25 | for(int j = i + 1; j val; 45 | // meminta user untuk memasukkan panjang data vector 46 | cout << "Masukkan panjang data: "; 47 | cin >> count; 48 | for(int i = 0; i <= count - 1 ; i++){ 49 | cout << "Masukkan data ke " << i + 1 << ": "; 50 | cin >> value; 51 | val.push_back(value); //memasukkan nilai yg dimasukkan(value) ke vector val 52 | } 53 | SelectionSort(val); 54 | cout << "sesudah sorting " << endl; 55 | PrintVec(val); 56 | cin.get(); 57 | return 0; 58 | } -------------------------------------------------------------------------------- /algorithm/sorting/snail_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using std::cout; 6 | using std::pair; 7 | using std::vector; 8 | 9 | // melakukan alias pada vector> menjadi Matrix 10 | using Matrix = vector>; 11 | 12 | vector snail_sort(const Matrix& mat) { 13 | // mengecek matrix mat 14 | // jika kosong maka return vector kosong 15 | if (mat.empty() || mat.at(0).empty()) return {}; 16 | 17 | // mengontrol arah pointer 18 | auto redirect = [](pair delta) -> pair { 19 | if (delta == pair{0, 1}) return {-1, 0}; // kanan ke bawah 20 | if (delta == pair{-1, 0}) return {0, -1}; // bawah ke kiri 21 | if (delta == pair{0, -1}) return {1, 0}; // kiri ke atas 22 | return {0, 1}; // atas ke kanan 23 | }; 24 | 25 | size_t n = mat.size(); 26 | 27 | Matrix marker(n, vector(n)); // matrix untuk mark 28 | vector snail = {mat.at(0).at(0)}; // hasil dari sorting 29 | 30 | pair pos = {0, 0}; // posisi saat ini (pointer) 31 | pair delta = {0, 1}; // arah pointer sekarang 32 | 33 | while (snail.size() < (n * n)) { 34 | // posisi pointer selanjutnya 35 | pair next_pos = {pos.first + delta.first, 36 | pos.second + delta.second}; 37 | 38 | // mengecek agar posisi (pointer) selanjut nya 39 | // tidak keluar dari index matrix 40 | auto left_right = (next_pos.first < 0 || next_pos.first >= n); 41 | auto up_down = (next_pos.second < 0 || next_pos.second >= n); 42 | 43 | // mengecek mark, jika 1 maka ubah arah pointer (delta) 44 | // jika 0 masukan posisi selanjut nya ke hasil sorting (snail), 45 | // mark posisi sekarang menjadi 1 dan ganti posisi sekarang (pos) 46 | if (left_right || up_down || 47 | marker.at(next_pos.first).at(next_pos.second)) { 48 | delta = redirect(delta); 49 | } else { 50 | snail.push_back(mat.at(next_pos.first).at(next_pos.second)); 51 | marker.at(pos.first).at(pos.second) = true; 52 | pos = next_pos; 53 | } 54 | } 55 | 56 | return snail; 57 | } 58 | 59 | // Mencetak vector 60 | void print_vec(const vector& vec) { 61 | cout << "{"; 62 | for (auto x : vec) { 63 | cout << x << ", "; 64 | } 65 | cout << "}\n"; 66 | } 67 | 68 | int main(void) { 69 | // membuat 2 matrix untuk di test 70 | Matrix matrix1 = { 71 | {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, 72 | {16, 17, 18, 19, 20}, {21, 22, 23, 24, 25}, 73 | }; 74 | 75 | Matrix matrix2 = { 76 | {1, 2, 3}, 77 | {4, 5, 6}, 78 | {7, 8, 9}, 79 | }; 80 | 81 | vector snail1 = snail_sort(matrix1); 82 | vector snail2 = snail_sort(matrix2); 83 | 84 | // cetak hasil sorting 85 | print_vec(snail1); 86 | print_vec(snail2); 87 | } -------------------------------------------------------------------------------- /artificial_intelligence/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp) 2 | foreach(testsourcefile ${APP_SOURCES}) 3 | string(REPLACE ".cpp" "" testname ${testsourcefile}) 4 | add_executable(${testname} ${testsourcefile}) 5 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 6 | if(OpenMP_CXX_FOUND) 7 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 8 | endif() 9 | install(TARGETS ${testname} DESTINATION "bin/artificial_intelligence") 10 | endforeach(testsourcefile ${APP_SOURCES}) 11 | -------------------------------------------------------------------------------- /backtracking/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/backtracking") 11 | 12 | endforeach( testsourcefile ${APP_SOURCES} ) -------------------------------------------------------------------------------- /backtracking/knight_tour.cpp: -------------------------------------------------------------------------------- 1 | // knight tour dlah urutn gerakan ksatria papan catur 2 | // sehingg ksatria mengunjungi setiap kotak hanya sekali. 3 | // jika ksatria berakhir pada kota yang merupakan langkah 4 | // satu ksatria dari awal persegi (gara bisa langsung 5 | // tur papan lgi, berikut jalur yang sama, tur ditutup; 6 | // jika tidak maka akan terbuka) 7 | 8 | #include 9 | #include 10 | 11 | namespace backtracking { 12 | namespace knight_tour { 13 | template 14 | bool issafe(int x, int y, const std::array, V> &sol) { 15 | return (x < V && x >= 0 && y < V && y >= 0 && sol[x][y] == -1); 16 | } 17 | 18 | template 19 | bool solve(int x, int y, int mov, std::array, V> &sol, const std::array &xmov, std::array &ymov) { 20 | int k = 0, xnext = 0, ynext = 0; 21 | 22 | if (mov == V * V) { 23 | return true; 24 | } 25 | 26 | for (k = 0; k < V; k++) { 27 | xnext = x + xmov[k]; 28 | ynext = y + ymov[k]; 29 | 30 | if (issafe(xnext, ynext, sol)) { 31 | sol[xnext][ynext] = mov; 32 | 33 | if (solve(xnext, ynext, mov + 1, sol, xmov, ymov) == true) { 34 | return true; 35 | } else { 36 | sol[xnext][ynext] = -1; 37 | } 38 | } 39 | } 40 | return false; 41 | } 42 | } // namespace knight_tour 43 | } // namespace backtracking 44 | 45 | int main() { 46 | const int n = 8; 47 | std::array, n> sol = {0}; 48 | 49 | int i = 0, j = 0; 50 | for (i = 0; i < n; i++) { 51 | for (j = 0; j < n; j++) { 52 | sol[i][j] = -1; 53 | } 54 | } 55 | 56 | std::array xmov = {2, 1, -1, -2, -2, -1, 1, 2}; 57 | std::array ymov = {1, 2, 2, 1, -1, -2, -2, -1}; 58 | 59 | sol[0][0] = 0; 60 | 61 | bool flag = backtracking::knight_tour::solve(0, 0, 1, sol, xmov, ymov); 62 | if (flag == false) { 63 | std::cout << "Error: solusi tidak ditemukan\n"; 64 | } else { 65 | for (i = 0; i < n; i++) { 66 | for (j = 0; j < n; j++) { 67 | std::cout << sol[i][j] << " "; 68 | } 69 | std::cout << "\n"; 70 | } 71 | } 72 | return 0; 73 | } 74 | -------------------------------------------------------------------------------- /backtracking/minimax.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file 3 | * @brief 4 | * mengembalikan nilai terpanjang / dan terpendek 5 | * algoritma minimax bisa dilihat disini 6 | * https://en.wikipedia.org/wiki/Minimax 7 | * @details 8 | * minimax adalah sebuah aturan keputusan 9 | * yang digunakan dalam kecerdasan buatan, teori permainan 10 | * statistik, dan teori keputusan dan 11 | * untuk meminimalisir (kemungkinan) kerugian untuk beberapa 12 | * skenario (kerugian maksimum) 13 | * ketika berhadapan dengan keuntungan, ini disebut dengan maximin 14 | * untuk memaksimalkan nilai keuntungan minimum 15 | * awalnya diformulasikan untuk teori permainan zero-sum dua pemain, 16 | * yang mencakup kasus di mana pemain mengambil gerakan alternatif dan mereka 17 | * juga melakukan gerakan simultan, itu juga telah diperluas ke permain yang lebih 18 | * kompleks dan pengambilan keputusan umum di hadapan ketidakpastian 19 | */ 20 | 21 | #include 22 | #include 23 | #include 24 | #include 25 | namespace backtracking { 26 | /** 27 | * periksa nomor mana yang maksimum / minimum dalam array 28 | * @param depth = kedalaman saat ini di dalam pohon permainan 29 | * lebih singkat tentang pohon permainan 30 | * https://en.wikipedia.org/wiki/Game_tree 31 | * @param nodex_index = indeks saat ini dalam array 32 | * @param is_max = jika index saat ini adalah angka terpanjang 33 | * @param score = menyimpan di dalam array 34 | * @param height = tinggi maksimum untuk pohon permainan 35 | * @return max atau min dari angka 36 | */ 37 | template 38 | int minimax(int depth, int node_index, bool is_max, 39 | const std::array &scores, double height) { 40 | if (depth == height) { 41 | return scores[node_index]; 42 | } 43 | 44 | int v1 = minimax(depth + 1, node_index * 2, !is_max, scores, height); 45 | int v2 = minimax(depth + 1, node_index * 2 + 1, !is_max, scores, height); 46 | 47 | return is_max ? std::max(v1, v2) : std::min(v1, v2); 48 | } 49 | } 50 | 51 | int main() { 52 | std::array scores = {90, 23, 6, 33, 21, 65, 123, 34423}; 53 | double height = log2(scores.size()); 54 | 55 | std::cout << "Optimasi value: " << backtracking::minimax(0, 0, true, scores, height) 56 | << std::endl; 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /backtracking/n_queens.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * teka-teki delapan ratu adalah masalah 3 | * menepatkan delapan ratu catur dengan papan catur 4 | * ukuran 8*8 sehigga tidak ada dua ratu yang saling 5 | * menyerang, demikian solusi mengharuskan tidak ada dua 6 | * ratu yang berbagi baris,kolom atau diagonal yan sama 7 | */ 8 | 9 | #include 10 | #include 11 | #include 12 | 13 | namespace backtracking { 14 | namespace n_queens { 15 | template 16 | void printSolusi(const std::array, n> board) { 17 | std::cout<<"\n"; 18 | for (int i = 0; i < n; i++) { 19 | for (int j = 0; j < n; j++) { 20 | std::cout<<""< 36 | bool isSafe(const std::array, n> &board, const int &row, const int &col) { 37 | int i = 0, j = 0; 38 | 39 | // periksa baris di sisi kiri 40 | for (i = 0; i < col; i++) { 41 | if (board[row][i]) { 42 | return false; 43 | } 44 | } 45 | 46 | // periksa diagonal atas di sisi kiri 47 | for (i = row, j = col; i >= 0 && j >= 0; i--, j--) { 48 | if (board[i][j]) { 49 | return false; 50 | } 51 | } 52 | 53 | // periksa diagonal bawah di sisi kiri 54 | for (i = row, j = col; j >= 0 && i < n; i++, j--) { 55 | if (board[i][j]) { 56 | return false; 57 | } 58 | } 59 | return true; 60 | } 61 | 62 | template 63 | void solveNQueen(std::array, n> board, const int &col) { 64 | if (col >= n) { 65 | printSolusi(board); 66 | return; 67 | } 68 | 69 | // pertimbangan kolom dan mencoba tempatkan 70 | // ratu di baris satu persatu 71 | for (int i = 0; i < n; i++) { 72 | // cek jika ratu bisa di tempatkan 73 | if (isSafe(board, i, col)) { 74 | board[i][col] = 1; 75 | solveNQueen(board, col + 1); 76 | board[i][col] = 0; 77 | } 78 | } 79 | } 80 | } 81 | } 82 | 83 | int main() { 84 | const int n = 4; 85 | std::array, n> board = { 86 | std::array({0, 0, 0, 0}), std::array({0, 0, 0, 0}), 87 | std::array({0, 0, 0, 0}), std::array({0, 0, 0, 0}) 88 | }; 89 | backtracking::n_queens::solveNQueen(board, 0); 90 | return 0; 91 | } -------------------------------------------------------------------------------- /backtracking/rat_in_maze.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | namespace backtracking 6 | { 7 | namespace rat_maze 8 | { 9 | template 10 | bool solveMaze(int currposrow, int currposcol, 11 | const std::array, size> &maze, 12 | std::array, size> soln) 13 | { 14 | if ((currposrow == size - 1) && (currposcol == size - 1)) 15 | { 16 | soln[currposrow][currposcol] = 1; 17 | for (int i = 0; i < size; ++i) 18 | { 19 | for (int j = 0; j < size; ++j) 20 | { 21 | std::cout << soln[i][j] << " "; 22 | } 23 | std::cout << std::endl; 24 | } 25 | return true; 26 | } 27 | else 28 | { 29 | soln[currposrow][currposcol] = 1; 30 | 31 | // jika ada solusi dengan bergerak satu langkah di depan dalam kolom 32 | if ((currposcol < size - 1) && maze[currposrow][currposcol + 1] == 1 && 33 | solveMaze(currposrow, currposcol + 1, maze, soln)) 34 | { 35 | return true; 36 | } 37 | 38 | // jika ada solusi dengan bergerak satu langkah ke depan berturut-turut 39 | if ((currposrow < size - 1) && maze[currposrow + 1][currposcol] == 1 && 40 | solveMaze(currposrow + 1, currposcol, maze, soln)) 41 | { 42 | return true; 43 | } 44 | 45 | // backtracking 46 | soln[currposrow][currposcol] = 0; 47 | return false; 48 | } 49 | } 50 | } // namespace rat_maze 51 | } // namespace backtracking 52 | 53 | /** 54 | * @brief Test 55 | * @returns void 56 | */ 57 | static void test() 58 | { 59 | const int size = 4; 60 | std::array, size> maze = { 61 | std::array{1, 0, 1, 0}, std::array{1, 0, 1, 1}, 62 | std::array{1, 0, 0, 1}, std::array{1, 1, 1, 1}}; 63 | 64 | std::array, size> soln{}; 65 | 66 | // Backtracking: atur solusi matriks ke nol 67 | for (int i = 0; i < size; ++i) 68 | { 69 | for (int j = 0; j < size; ++j) 70 | { 71 | soln[i][j] = 0; 72 | } 73 | } 74 | 75 | int currposrow = 0; // Posisi saat ini dalam baris 76 | int currposcol = 0; // Posisi saat ini dalam kolom 77 | 78 | assert(backtracking::rat_maze::solveMaze(currposrow, currposcol, maze, 79 | soln) == 1); 80 | } 81 | 82 | int main() 83 | { 84 | // jalankan test 85 | test(); 86 | return 0; 87 | } -------------------------------------------------------------------------------- /backtracking/subarray_sum.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file subarray_sum.cpp 3 | * @brief [subset-sum](https://en.wikipedia.org/wiki/Subset_sum_problem) 4 | * @date 2021-12-07 5 | * @details kita berikan array dan nilai jumlah. algoritma menemukan semua 6 | * sibarray dari array dengan jumlah yang sama dengan jumlah yang diberikan 7 | * dan mengembalikan jumlahnya. 8 | * catatan dalam masaslah ini hanya mengacu pada himpunan bagian kontinu sebagai 9 | * di mana.subarray dapat dibuat menggunakan operasi penghapusan di ujung depan 10 | * array saja. 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | /** 20 | * @brief algoritma backtracking 21 | * @namespace backtracking 22 | * 23 | */ 24 | namespace backtracking { 25 | namespace subarray_sum { 26 | /** 27 | * @brief fungsi utama untuk implementasi dari subarray sum 28 | * @param sum adalah yang diperlukan dari setiap subarray 29 | * @param in_arr adalh input dari array 30 | * @return jumlah dari angka set 31 | */ 32 | uint64_t subarray_sum(int64_t sum, const std::vector &in_arr) { 33 | int64_t nelement = in_arr.size(); 34 | int64_t count_of_subset = 0; 35 | int64_t current_sum = 0; 36 | std::unordered_map sumarray; 37 | 38 | for (int64_t i = 0; i < nelement; i++) { 39 | current_sum += in_arr[i]; 40 | if (current_sum == sum) { 41 | count_of_subset++; 42 | } 43 | 44 | // jika seandainya current_sum lebih besar 45 | // dari jumlah yang dibutuhkan 46 | if (sumarray.find(current_sum - sum) != sumarray.end()) { 47 | count_of_subset += (sumarray[current_sum - sum]); 48 | } 49 | sumarray[current_sum]++; 50 | } 51 | return count_of_subset; 52 | } 53 | } // namespace subarray_sum 54 | } // namespace backtracking 55 | 56 | static void testing() { 57 | std::cout << "test pertama "; 58 | std::vector array1 = {-7, -3, -2, 5, 8}; 59 | assert(backtracking::subarray_sum::subarray_sum(0, array1) == 1); 60 | 61 | std::cout << "berhasil!" << std::endl; 62 | } 63 | 64 | int main() { 65 | testing(); 66 | 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /backtracking/sudoku_solver.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file sudoku_solve.cpp 3 | * @author your name (you@domain.com) 4 | * sudoku disebut dengan number placement game. 5 | * informasi lebih lanjut tentang sudoku 6 | * https://en.wikipedia.org/wiki/Sudoku 7 | */ 8 | 9 | #include /// for assert 10 | #include /// for IO operations 11 | 12 | /** 13 | * @namespace backtracking 14 | * @brief Backtracking algorithms 15 | */ 16 | namespace backtracking { 17 | namespace sudoku_solver { 18 | template 19 | bool isPossible(const std::array, V> &mat, int i, int j, 20 | int no, int n) { 21 | for (int x = 0; x < n; x++) { 22 | if (mat[x][j] == no || mat[i][x] == no) { 23 | return false; 24 | } 25 | } 26 | 27 | int sx = (i / 3) * 3; 28 | int sy = (j / 3) * 3; 29 | 30 | for (int x = sx; x < sx + 3; x++) { 31 | for (int y = sy; y < sy + 3; y++) { 32 | if (mat[x][y] == no) { 33 | return false; 34 | } 35 | } 36 | } 37 | 38 | return true; 39 | } 40 | 41 | template 42 | void printMat(const std::array, V> &mat, 43 | const std::array, V> &starting_mat, int n) { 44 | for (int i = 0; i < n; i++) { 45 | for (int j = 0; j < n; j++) { 46 | if (starting_mat[i][j] != mat[i][j]) { 47 | std::cout << "\033[93m" << mat[i][j] << "\033[0m" 48 | << " "; 49 | } else { 50 | std::cout << mat[i][j] << " "; 51 | } 52 | if ((j + 1) % 3 == 0) { 53 | std::cout << '\t'; 54 | } 55 | } 56 | if ((i + 1) % 3 == 0) { 57 | std::cout << std::endl; 58 | } 59 | std::cout << std::endl; 60 | } 61 | } 62 | template 63 | bool solveSudoku(std::array, V> &mat, 64 | const std::array, V> &starting_mat, int i, 65 | int j) { 66 | if (i == 9) { 67 | printMat(mat, starting_mat, 9); 68 | return true; 69 | } 70 | if (j == 9) { 71 | return solveSudoku(mat, starting_mat, i + 1, 0); 72 | } 73 | if (mat[i][j] != 0) { 74 | return solveSudoku(mat, starting_mat, i, j + 1); 75 | } 76 | for (int no = 1; no <= 9; no++) { 77 | if (isPossible(mat, i, j, no, 9)) { 78 | mat[i][j] = no; 79 | bool solution_found = solveSudoku(mat, starting_mat, i, j + 1); 80 | if (solution_found) { 81 | return true; 82 | } 83 | } 84 | } 85 | mat[i][j] = 0; 86 | return false; 87 | } 88 | } // namespace sudoku_solver 89 | } // namespace backtracking 90 | 91 | int main() { 92 | const int V = 9; 93 | std::array, V> mat = { 94 | std::array{5, 3, 0, 0, 7, 0, 0, 0, 0}, 95 | std::array{6, 0, 0, 1, 9, 5, 0, 0, 0}, 96 | std::array{0, 9, 8, 0, 0, 0, 0, 6, 0}, 97 | std::array{8, 0, 0, 0, 6, 0, 0, 0, 3}, 98 | std::array{4, 0, 0, 8, 0, 3, 0, 0, 1}, 99 | std::array{7, 0, 0, 0, 2, 0, 0, 0, 6}, 100 | std::array{0, 6, 0, 0, 0, 0, 2, 8, 0}, 101 | std::array{0, 0, 0, 4, 1, 9, 0, 0, 5}, 102 | std::array{0, 0, 0, 0, 8, 0, 0, 7, 9}}; 103 | 104 | backtracking::sudoku_solver::printMat(mat, mat, 9); 105 | std::cout << "Solution " << std::endl; 106 | std::array, V> starting_mat = mat; 107 | backtracking::sudoku_solver::solveSudoku(mat, starting_mat, 0, 0); 108 | 109 | return 0; 110 | } -------------------------------------------------------------------------------- /backtracking/wildcard_matching.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | namespace backtracking { 7 | namespace wildcard_matching { 8 | std::vector> dpTable(1000, std::vector(1000, -1)); 9 | bool wildcard_matching(std::string s, std::string p, uint32_t pos1, 10 | std::uint32_t pos2) { 11 | uint32_t n = s.length(); 12 | uint32_t m = p.length(); 13 | if (pos1 == n && pos2 == m) { 14 | return true; 15 | } 16 | if (pos1 != n && pos2 == m) { 17 | return false; 18 | } 19 | if (pos1 == n && pos2 != m) { 20 | while (pos2 < m && p[pos2] == '*') { 21 | pos2++; 22 | } 23 | 24 | return pos2 == m; 25 | } 26 | if (dpTable[pos1][pos2] != -1) { 27 | return dpTable[pos1][pos2]; 28 | } 29 | if (s[pos1] == p[pos2]) { 30 | return dpTable[pos1][pos2] = wildcard_matching(s, p, pos1 + 1, pos2 + 1); 31 | } 32 | 33 | else { 34 | if (p[pos2] == '?') { 35 | return dpTable[pos1][pos2] = wildcard_matching(s, p, pos1 + 1, pos2 + 1); 36 | } else if (p[pos2] == '*') { 37 | return dpTable[pos1][pos2] = wildcard_matching(s, p, pos1, pos2 + 1) || 38 | wildcard_matching(s, p, pos1 + 1, pos2); 39 | } else { 40 | return dpTable[pos1][pos2] = 0; 41 | } 42 | } 43 | } 44 | 45 | } // namespace wildcard_matching 46 | } // namespace backtracking 47 | 48 | static void test() { 49 | std::cout << "1st test "; 50 | std::string matching1 = "baaabab"; 51 | std::string pattern1 = "*****ba*****ab"; 52 | assert(backtracking::wildcard_matching::wildcard_matching(matching1, pattern1, 53 | 0, 0) == 1); 54 | std::cout << "passed" << std::endl; 55 | 56 | std::cout << "2nd test "; 57 | std::string matching2 = "baaabab"; 58 | std::string pattern2 = "ba*****ab"; 59 | assert(backtracking::wildcard_matching::wildcard_matching(matching2, pattern2, 60 | 0, 0) == 1); 61 | std::cout << "passed" << std::endl; 62 | 63 | std::cout << "3rd test "; 64 | std::string matching3 = "baaabab"; 65 | std::string pattern3 = "ba*ab"; 66 | assert(backtracking::wildcard_matching::wildcard_matching(matching3, pattern3, 67 | 0, 0) == 1); 68 | std::cout << "passed" << std::endl; 69 | 70 | std::cout << "4th test "; 71 | std::string matching4 = "baaabab"; 72 | std::string pattern4 = "a*ab"; 73 | assert(backtracking::wildcard_matching::wildcard_matching(matching4, pattern4, 74 | 0, 0) == 1); 75 | std::cout << "passed" << std::endl; 76 | 77 | std::cout << "5th test "; 78 | std::string matching5 = "baaabab"; 79 | std::string pattern5 = "aa?ab"; 80 | assert(backtracking::wildcard_matching::wildcard_matching(matching5, pattern5, 81 | 0, 0) == 1); 82 | std::cout << "passed" << std::endl; 83 | } 84 | 85 | int main() { 86 | test(); 87 | return 0; 88 | } 89 | -------------------------------------------------------------------------------- /basic/01_introduction/hello_world.cpp: -------------------------------------------------------------------------------- 1 | // '#' adalah indikator perintah pre-prosesor 2 | // include adalah perintah untuk memasukan library ke source code 3 | // iostream adalah library standar bawaan C++ 4 | // yang berfungsi untuk input dan ouput data 5 | #include 6 | 7 | // fungsi main() di bawah adalah entry point yang 8 | // merupakan tempat dimana kode akan pertama kali 9 | // dieksekusi dan dijalankan oleh compiler 10 | // setiap statement pada c++ wajib diakhiri dengan ; (titik koma) 11 | int main(){ 12 | 13 | // std:: merupakan namespace yang digunakan untuk 14 | // seluruh standard library C++ termasuk iostream 15 | // cout yang merupakan salah satu objek dari library iostream, 16 | // singkatan dari "Character OUTput" digunakan sebagai 17 | // perintah output dengan menggunakan operator left shift (<<) 18 | // Pada contoh berikut, kita akan memasukkan kata "bellshade" 19 | std::cout<<"bellshade!"; 20 | 21 | // return 0 adalah perintah untuk mengeluarkan nilai integer 0 22 | // apabila program berhasil dijalankan tanpa error 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /basic/01_introduction/readme.md: -------------------------------------------------------------------------------- 1 | # Pengenalan C++ 2 | 3 | C++ adalah bahasa pemrograman yang dibuat pada tahun 1979. Seperti namanya, C++ adalah bahasa turunan dari bahasa C. C++ menyempurnakan konsep OOP yang tidak terdapat dalam bahasa C. 4 | 5 | Sama seperti bahasa pada umumnya, program C++ dijalankan baris per baris, dari atas ke bawah, dan dari kiri ke kanan. 6 | 7 | Struktur dari C++ adalah sebagai berikut: 8 | 9 | ```cpp 10 | #include 11 | 12 | int main() { 13 | // program kamu berada di sini 14 | } 15 | ``` 16 | 17 | - `#include ` adalah library yang digunakan 18 | - `int main()` adalah function yang menampung semua program kamu 19 | 20 | ## Menulis Program C++ Pertamamu 21 | 22 | Program C++ disimpan dengan ekstensi `.cpp`, yang berarti "C Plus Plus". Silakan buka code editor favorit kamu lalu tulis code di bawah ini dan simpan filenya dengan nama `hello_world.cpp`. 23 | 24 | ```cpp 25 | #include 26 | using namespace std; 27 | 28 | int main() { 29 | cout << "Hello World!"; 30 | return 0; 31 | } 32 | ``` 33 | 34 | Penjelasan tentang code ini dapat dilihat [di sini](hello_world.cpp). 35 | 36 | ## Namespace 37 | 38 | Namespace berguna untuk memperpendek kode jika kita menggunakan suatu library yang telah ada, 39 | jika kita bandingkan kode di atas dan dibawah maka akan ada perbedaan penggunaan `cout` dan `std::cout` (tanpa menggunakan `using namespace std;` ) 40 | 41 | ```cpp 42 | #include 43 | 44 | int main() { 45 | std::cout << "Hello World!"; 46 | return 0; 47 | } 48 | ``` 49 | 50 | ## Komentar 51 | 52 | Komentar pada kode sangat berguna dalam menerangkan/menginformasikan kode yang kita tulis, komentar yang ditulis pada kode tidak akan dieksekusi oleh mesin. 53 | Terdapat 2 cara dalam menulisan kode pada C++ yaitu komentar 1 baris menggunakan simbol `//`, dan komentar multiline yang diapit oleh simbol `/*` dan `*/` 54 | 55 | ```cpp 56 | #include 57 | 58 | int main() { 59 | // Komentar 1 baris, komentar ini tidak akan di eksekusi oleh mesin 60 | 61 | /* 62 | ini komentar multiline 63 | yang berisi lebih dari 1 baris 64 | */ 65 | } 66 | ``` 67 | 68 | **Catatan dalam penamaan file:** 69 | 70 | - Disarankan untuk memberi nama file tanpa spasi 71 | - Gunakan `_` atau `-` jika nama file lebih dari satu kata, misal `hello_world.cpp` atau `hello-world.cpp` 72 | 73 | Selamat! Kamu sudah berhasil menulis program pertamamu. 74 | 75 | contoh lebih lanjut [kelas terbuka - apa itu c++](https://www.youtube.com/watch?v=WtBF_-pLrjE&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=1) 76 | -------------------------------------------------------------------------------- /basic/02_variable_datatype/cmakelists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/variabel") 11 | 12 | endforeach( testsourcefile ${APP_SOURCES} ) -------------------------------------------------------------------------------- /basic/02_variable_datatype/readme.md: -------------------------------------------------------------------------------- 1 | # Variabel dan Tipe Data 2 | 3 | 4 | ## Variabel 5 | 6 | Variabel adalah sebuah kontainer yang berfungsi dalam penyimpanan value sehingga dapat digunakan secara berulang kali. Variabel memetakan sebuah nama ke suatu nilai. 7 | 8 | ### Aturan Penamaan Variabel 9 | 10 | Kamu bisa menamai variabel dengan nama apapun, tetapi ada beberapa aturan yang harus dipenuhi: 11 | 12 | - Hanya terdiri dari huruf, angka, dan underscore (`_`) 13 | - Tidak dimulai dengan angka 14 | - Tidak boleh sama dengan *reserved word*. Contoh: `int`, `if`, `string`. 15 | 16 | Contoh penamaan yang benar, seperti `hasil`, `jumlah_angka`, dan `namaSaya`. Perlu diperhatikan bahwa penggunaan huruf kapital akan berpengaruh (case sensitive). Variabel `angka` dan `Angka` akan dianggap berbeda. 17 | 18 | > Dalam standar penamaan variabel, C++ menggunakan camelCase untuk penamaan pada variabel. Contoh: `angkaSaya`. 19 | > 20 | 21 | ### Deklarasi Variabel 22 | 23 | Saat mendeklarasi sebuah variabel, kamu harus menyertakan tipe datanya. Tipe data dituliskan sebelum nama variabel, dipisahkan oleh spasi. Jika memiliki tipa data yang sama, kamu bisa mendeklarasikannya secara bersamaan 24 | 25 | ```cpp 26 | = ; 27 | ``` 28 | 29 | Variabel dapat dideklarasiikan dengan langsung memasukkan nilainya atau tanpa memberi nilai (nilai di-assign kemudian). 30 | 31 | ```cpp 32 | // langsung memasukkan nilai 33 | int angkaSaya = 15; 34 | 35 | // hanya deklarasi nama 36 | int angkaSaya; 37 | angkaSaya = 15; 38 | 39 | // deklarasi dengan tipe data sama 40 | int nilai, jumlah; 41 | double sisa = 1, hasil = 0; 42 | ``` 43 | 44 | ### Menampilkan Nilai Variabel 45 | 46 | Untuk menampilkan nilai variabel dalam C++, kamu bisa menggunakan perintah `cout` dengan menambahkan operator `<<`, seperti pada contoh di bawah ini. 47 | 48 | ```cpp 49 | int angkaSaya = 30; 50 | std::cout << "Angka Saya adalah " << angkaSaya; // 30 51 | ``` 52 | 53 | Kamu juga bisa mengganti nilai yang sebelumnya sudah terdapat pada variabel dengan cara 54 | 55 | ```cpp 56 | int angkaSaya = 1; 57 | angkaSaya = 30; 58 | std::cout << "Angka saya sekarang adalah " << angkaSaya; // 30 59 | ``` 60 | 61 | Selain dengan perintah `cout`, kamu juga bisa menggunakan fungsi `printf`. 62 | 63 | ```cpp 64 | int angkaSaya = 30; 65 | printf("Angka Saya adalah %d", angkaSaya); 66 | ``` 67 | 68 | Berikut ini simbol-simbol untuk setiap tipe data. Penjelasan untuk masing-masing tipe data akan dijelaskan di bagian selanjutnya. 69 | 70 | | Tipe data | Simbol | 71 | | - | - | 72 | | short | `%d` | 73 | | unsigned short | `%u` | 74 | | int | `%d` | 75 | | unsigned int | `%u` | 76 | | long long | `%lld` atau `%I64d` | 77 | | unsigned long long | `%llu` atau `%I64u` | 78 | | float | `%f` | 79 | | double | `%lf` | 80 | | char | `%c` | 81 | 82 | lanjutan tentang variabel [disini](https://www.youtube.com/watch?v=vnYWr7jFl5M&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=12) -------------------------------------------------------------------------------- /basic/02_variable_datatype/variabel.cpp: -------------------------------------------------------------------------------- 1 | // Contoh penggunan variabel dengan tipe data integer dan float 2 | #include 3 | 4 | int main() { 5 | // Metode 1 6 | // Melakukan deklarasi variabel dengan menetapkan nilainya pada baris terpisah 7 | // Deklasari tipe data integer pada variabel (a, b dan c) 8 | int a; 9 | int b; 10 | int c; 11 | 12 | // Inisialisai nilai untuk setiap variabel 13 | a = 2; 14 | b = 3; 15 | c = a + b; 16 | 17 | // Menampilkan hasil penjumlahan a + b 18 | std::cout << a << " + " << b << " = " << c << '\n'; 19 | 20 | // Metode 2 21 | // Melakukan deklarasi variabel dengan menetapkan nilainya pada baris yang sama 22 | // Deklarasi variabel (d, e dan f) dan menetapkan nilainya dengan tipe data float (bilangan pecahan) 23 | float d = 2.5f; 24 | float e = 3.14f; 25 | float f = d + e; 26 | 27 | // Menampilkan hasil penjumlahan d + e 28 | std::cout << d << " + " << e << " = " << f << '\n'; 29 | 30 | // Metode 3 31 | // Melakukan deklarasi beberapa variabel dalam 2 baris 32 | // Deklarasi tipe data integer pada variabel (x, y, dan z) 33 | int x, y, z; 34 | 35 | // Inisialisai nilai untuk setiap variabel 36 | x = 5; 37 | y = 3; 38 | z = x * y; 39 | 40 | // Menampilkan hasil perkalian x * z 41 | std::cout << x << " * " << y << " = " << z<< '\n'; 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /basic/03_pointer_reference/pointer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | // menampilkan address dari sebuah string 5 | std::string benda = "meja"; 6 | std::cout << &benda; // 0x7ffe137a25f0 7 | 8 | // menyimpan address kedalam pointer dan tampilkan 9 | std::string hewan = "kelinci"; 10 | std::string* ptr = &hewan; // ptr = 0x7ffe137a25f0 11 | std::cout << ptr; // 0x7ffe137a25f0 12 | 13 | // menampilkan value atau isi dari alamat yang ada dalam pointer 14 | std::string hewan2 = "gajah"; 15 | std::string* ptr2 = &hewan2; // ptr = 0x7ffe137a25f0 16 | std::cout << *ptr2; // "gajah" 17 | 18 | /* 19 | Penempatan operator * bebas seperti: 20 | string* ptr; (dianjurkan) 21 | string * ptr; 22 | string *ptr; 23 | 24 | Untuk dereferencing dianjurkan seperti: 25 | *ptr; 26 | */ 27 | return 0; 28 | } -------------------------------------------------------------------------------- /basic/03_pointer_reference/readme.md: -------------------------------------------------------------------------------- 1 | # CPP Pointer 2 | Address dan Pointer adalah fitur ekslusif bahasa pemrograman C dan C++. Address dan pointer memiliki tiga fungsi utama, yaitu melokasikan objek baru, _melemparkan/mengoper_ fungsi ke fungsi yang lainnya, dan melakukan perulangan atau _loop_ elemen yang terdapat dalam array atau data struktur lain. 3 | 4 | **References:** 5 | - [Apa itu pointer?](https://docs.microsoft.com/en-us/cpp/cpp/pointers-cpp?view=msvc-160) 6 | - [Mengapa menggunakan pointer?](https://www.geeksforgeeks.org/features-and-use-of-pointers-in-c-c/) 7 | 8 | ## Address 9 | **Apa itu address?** 10 | Dalam bahasa Inggris, address berarti alamat atau lokasi. Kali ini, kita akan mengambil lokasi dari sebuah variable dalam C++. Setiap variable pasti memiliki sebuah address di mana address itu adalah letak variable tersebut di dalam memori. 11 | 12 | 13 | **Cara menampilkan address** 14 | ```cpp 15 | std::string benda = "kursi"; // "kursi" 16 | std::cout << &benda; // output: 0x7ffe137a25f0 (value ini merupakan address untuk variable benda) 17 | ``` 18 | Operator `&` merupakan _kunci_ yang akan mengembalikan address dari sebuah variable, _perlu diingat_ bahwa address ini akan terus berganti. 19 | 20 | **Reference:** [Tentang address](https://mathbits.com/MathBits/CompSci/Pointers/Addresses.htm#:~:text=The%20location%20of%20an%20object,of%20an%20object%20in%20memory.) 21 | 22 | ## Pointer 23 | **Apa itu pointer dalam C++?** 24 | Pointer merupakan variable khusus untuk menyimpan address sebagai value-nya. 25 | 26 | **Cara mendeklarasikan Pointer** 27 | ```cpp 28 | std::string benda = "kursi"; 29 | std::string* ptr = &benda; // ptr = 0x7ffe137a25f0 30 | std::cout << ptr; // 0x7ffe137a25f0 31 | ``` 32 | Untuk pointer, operator `*` merupakan _kunci_ untuk mendeklarasikan sebuah variable bertipe pointer. Sama seperti variable yang lainnya, nama variable dari pointer ini tidak boleh sama. 33 | 34 | **Null Pointer** 35 | ```cpp 36 | std::string* ptr = nullptr; // ptr = 0x0 37 | ``` 38 | Null pointer merupakan metode untuk mengosongkan address dari sebuah variable pointer atau tidak beralamat. 39 | 40 | **Mengambil value melalui pointer (dereferencing)** 41 | ```cpp 42 | std::string benda = "kursi"; 43 | std::string* ptr = &benda; // ptr = 0x7ffe137a25f0 44 | std::cout << *ptr; // "kursi" 45 | ``` 46 | Untuk mengambil value dengan address, kita harus mendeklarasikan operator `*` sebelum memanggil pointer. 47 | 48 | **Pointer to Pointer** 49 | ```cpp 50 | std::string benda; 51 | std::string* ptr; 52 | sdt::string** pptr; 53 | 54 | benda = "kursi" 55 | 56 | ptr = &benda; // ptr menyimpan address benda 57 | 58 | pptr = &ptr; // pptr menyimpan address yang sama dengan ptr 59 | 60 | std::cout << "Value yang terdapat dalam benda: " << benda << std::endl; 61 | std::cout << "Value yang terdapat dalam *ptr: " << *ptr << std::endl; 62 | std::cout << "Value yang terdapat dalam **ptr: " << **ptr << std::endl; 63 | ``` 64 | ``` 65 | Output: 66 | Value yang terdapat dalam benda: kursi 67 | Value yang terdapat dalam *ptr: kursi 68 | Value yang terdapat dalam **ptr: kursi 69 | ``` 70 | Metode Pointer to Pointer ini mengharuskan kita untuk menambah `*` lagi seperti `**ptr`, Pointer to Pointer merupakan metode untuk mengakses address dari sebuah pointer sehingga membentuk seperti sebuah rantai pointer. 71 | 72 | **References:** 73 | - [Pointers](https://www.w3schools.com/cpp/cpp_pointers.asp) 74 | - [Null Pointer](https://www.tutorialspoint.com/cplusplus/cpp_null_pointers.htm) 75 | - [Dereference](https://www.w3schools.com/cpp/cpp_pointers_dereference.asp) 76 | - [Pointer to Pointer](https://www.tutorialspoint.com/cplusplus/cpp_pointer_to_pointer.htm) 77 | - [Macam-macam Pointer](https://www.tutorialspoint.com/cplusplus/cpp_pointers.htm) 78 | 79 | ## Contoh penggunaan: Mengganti nilai variable 80 | ```cpp 81 | #include 82 | int main(){ 83 | // deklarasikan angka yang akan diakses oleh pointer dan variable dari angka yang akan diganti 84 | int num = 20; 85 | int val; 86 | 87 | // deklarasikan pointer dan simpan address num ke dalamnya 88 | int* ptr; 89 | ptr = # 90 | 91 | // ganti nilai val dengan nilai num menggunakan ptr 92 | val = *ptr; 93 | std::cout << "Nilai dari val adalah " << val; // Output: Nilai dari val adalah 20 94 | } 95 | ``` 96 | 97 | topik lanjutan pada pointer bisa dilihat [disini](https://www.youtube.com/watch?v=O1kWNj5Ikro&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=43) 98 | -------------------------------------------------------------------------------- /basic/04_operator/operator_bitwise.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Hai teman-teman! Mari kita belajar tentang cara kerja operator bitwise dengan contoh sederhana! 3 | 4 | Sebelumnya, mari kita pahami dulu tipe data char. Char (character) adalah tipe data yang digunakan untuk menyimpan satu karakter seperti huruf, angka, atau simbol. 5 | Setiap karakter char sebenarnya disimpan dalam bentuk biner 8-bit berdasarkan kode ASCII. 6 | */ 7 | #include 8 | 9 | int main(){ 10 | char a = 'F'; 11 | char b = 'C'; 12 | char c = a & b; 13 | std::cout << c << std::endl; 14 | } 15 | 16 | /* 17 | Program di atas akan menghasilkan output: B 18 | 19 | Kenapa bisa begitu? Yuk kita pahami bersama-sama! 20 | 21 | Di sini kita membandingkan 2 variabel bertipe char: 22 | - Variabel a berisi huruf 'F' 23 | - Variabel b berisi huruf 'C' 24 | 25 | Dalam tabel ASCII, setiap karakter memiliki nilai biner masing-masing: 26 | 'F' = 01000110 27 | 'C' = 01000011 28 | 29 | Kemudian kita menggunakan operator bitwise AND ('&'). Operator ini akan membandingkan setiap digit biner dari kedua karakter tersebut. 30 | Jika kedua digit sama-sama bernilai 1, hasilnya 1. Jika tidak, hasilnya 0. 31 | 32 | Mari kita bandingkan: 33 | 01000110 (F) 34 | 01000011 (C) 35 | -------- AND 36 | 01000010 37 | 38 | Nah, hasil operasi bitwise AND tersebut adalah 01000010, yang dalam tabel ASCII merupakan representasi dari huruf 'B'! 39 | 40 | Bagaimana? Menarik kan cara kerjanya? 😊 41 | 42 | kalau penasaran, teman-teman bisa ber-eksperiment dengan melihat tabel ASCII ini sebagai referensi >> https://www.ascii-code.com/ 43 | */ 44 | -------------------------------------------------------------------------------- /basic/04_operator/readme.md: -------------------------------------------------------------------------------- 1 | # Operator 2 | 3 | Sebelum mempelajari tentang operator, kamu harus sudah mengenal tentang "Ekspresi". Ekspresi terdiri dari dua komponen, yaitu **operator** dan **operand.** 4 | 5 | - operator: simbol dari operasi yang akan dilakukan 6 | - operand: nilai yang akan dioperasikan 7 | 8 | **Contoh**: `a + b` 9 | a dan b adalah operand 10 | simbol `+` adalah operator 11 | 12 | 13 | Selanjutnya, kita akan mempelajari tentang operasi dan operatornya. 14 | 15 | ## 1. Operator Numerik 16 | 17 | Operasi numerik adalah operasi yang dilakukan pada bilangan. Operasi numerik juga dikenal dengan nama operasi aritmatika 18 | 19 | | Operator | Nama Operasi | 20 | | - | - | 21 | | `+` | Penambahan | 22 | | `-` | Pengurangan | 23 | | `*` | Perkalian | 24 | | `/` | Pembagian | 25 | | `%` | Modulo | 26 | 27 | **Hal-hal yang perlu diperhatikan:** 28 | 29 | - Jika operand merupakan bilangan bulat, akan selalu menghasilkan bilangan bulat juga. 30 | - Jika ada salah satu operand bertipe `float`, hasil akan berupa `float` juga. 31 | - Operasi pembagian pada `integer` akan dibulatkan ke bawah 32 | - Operasi modulo hanya bisa digunakan pada `integer` 33 | 34 | contoh lebih lanjut dari operator numerik bisa dilihat [disini](https://www.youtube.com/watch?v=bxNqTu4N-Is&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=15) 35 | 36 | ### Operator Unary 37 | 38 | Operasi unary dapat dilakukan dengan hanya satu operand. Operator yang sering digunakan adalah increment (++) dan decrement (—). 39 | 40 | | Operator | Nama Operasi | Contoh | 41 | | - | - | - | 42 | | `-` | Negatif | `-1` | 43 | | `++` | Penambahan | `i++`, `++i` | 44 | | `--` | Pengurangan | `i--`, `--i` | 45 | 46 | lebih lanjut dari operator unary bisa dilihat [disini](https://www.youtube.com/watch?v=cmKs-eEsHfY&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=23) 47 | 48 | ## 2. Operator Relasional 49 | 50 | Operasi relasional yaitu membandingkan dua operand dan mengembalikan `boolean` (`true` atau `false`). 51 | 52 | | Operator | Nama Operasi | 53 | | - | - | 54 | | `==` | Sama dengan | 55 | | `!=`| Tidak sama dengan | 56 | | `<` | Kurang dari | 57 | | `>` | Lebih dari | 58 | | `<=`| Kurang dari atau sama dengan | 59 | | `>=` | Lebih dari atau sama dengan | 60 | 61 | contoh lebih lanjut dari operator relasional bisa dilihat [disini](https://www.youtube.com/watch?v=rgdgn4yFg18&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=16) 62 | 63 | ## 3. Operator Logika 64 | 65 | Operator logika digunakan untuk menggabungkan dua—atau lebih—kondisi 66 | 67 | | Operator | Nama Operasi | 68 | | - | - | 69 | | `&&` | AND | 70 | | `\|\|` | OR | 71 | | `!` | NOT | 72 | 73 | lebih lanjut dari operator logika bisa dilihat [disini](https://www.youtube.com/watch?v=k9nBTzvba34&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=17) 74 | 75 | ## 4. Operator Bitwise 76 | 77 | Operator Bitwise adalah operator yang melakukan operasi pada level bit (biner) dari suatu nilai. 78 | Operator ini bekerja dengan mengoperasikan bit per bit dari dua operand. 79 | 80 | | Operator | Nama Operasi | Keterangan | 81 | | - | - | - | 82 | | `&` | AND | Menghasilkan 1 jika kedua bit bernilai 1 | 83 | | `\|` | OR | Menghasilkan 1 jika salah satu bit bernilai 1 | 84 | | `^` | XOR | Menghasilkan 1 jika kedua bit bernilai berbeda | 85 | | `~` | NOT | Membalikkan semua nilai bit | 86 | | `<<` | Left Shift | Menggeser bit ke kiri | 87 | | `>>` | Right Shift | Menggeser bit ke kanan | 88 | 89 | **Contoh penggunaan:** 90 | ```cpp 91 | int a = 5; // 00000101 dalam biner 92 | int b = 3; // 00000011 dalam biner 93 | 94 | int c = a & b; // 00000001 = 1 95 | int d = a | b; // 00000111 = 7 96 | int e = a ^ b; // 00000110 = 6 97 | int f = ~a; // 11111010 = -6 98 | int g = a << 1; // 00001010 = 10 99 | int h = a >> 1; // 00000010 = 2 100 | ``` 101 | 102 | Operator Bitwise sering digunakan dalam: 103 | - Pemrograman sistem 104 | - Optimasi kode 105 | - Manipulasi flag dan state 106 | - Enkripsi data sederhana 107 | -------------------------------------------------------------------------------- /basic/05_conditional/cmakelists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/kondisional") 11 | 12 | endforeach( testsourcefile ${APP_SOURCES} ) 13 | -------------------------------------------------------------------------------- /basic/05_conditional/conditional.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //Contoh perulangan menggunakan IF 4 | int if_only() { 5 | // Deklarasi variabel 6 | int a = 1; 7 | 8 | // Hanya jalankan program di bawah ini saat nilai a = 1 9 | if (a == 1) { 10 | std::cout << "Contoh percabangan IF, Bellshade!" << std::endl; 11 | } 12 | 13 | return 0; 14 | } 15 | 16 | // Contoh penggunaan if-else 17 | int if_else() { 18 | // Deklarasi Variabel a dengan nilai 7 (integer) 19 | int a = 7; 20 | 21 | if (a == 7) { // Jika a = 7 jalankan program di bawah ini 22 | std::cout << "Kondisi if terpenuhi, Bellshade!" << std::endl; 23 | // Jika nilai a tidak sama dengan kondisi di atas (!=) jalankan program di bawah ini 24 | } else { 25 | std::cout << "kondisi if tidak terpenuhi, Bellshade" << std::endl; 26 | } 27 | 28 | return 0; 29 | } 30 | 31 | // Contoh percabangan dengan if-else-if 32 | int if_else_if() { 33 | // Deklarasi variabel 34 | int a = 4; 35 | 36 | // Else if akan menjadi alternatif jika kondisi pada if sebelumnya tidak terpenuhi 37 | // Akan menjalankan program dibawahnya 38 | if (a == 1) { // Jika a = 1 jalankan program di bawah ini 39 | std::cout << "Nilai a = 1!" << std::endl; 40 | } else if (a == 2) { // Jika a = 2 jalankan program di bawah ini 41 | std::cout << "Nilai a = 2!" << std::endl; 42 | } else if (a == 3) { // Jika a = 3 jalankan program di bawah ini 43 | std::cout << "Nilai a = 3!" << std::endl; 44 | } else { 45 | // Baris di bawah ini akan dijalankan apabila semua kondisi di atas tidak terpenuhi 46 | std::cout << "Nilai a bukan 1, 2 ataupun 3!" << std::endl; 47 | } 48 | 49 | return 0; 50 | } 51 | 52 | // Contoh penggunaan switch case 53 | // Switch-case merupakan alternatif dari if-else, biasa digunakan pada kodisi yang sederhana 54 | // Pada switch-case setiap kali melakukan pengecekan harus diakhiri dengan "break" 55 | // Jika tidak menambahkan break pada akhir pengecekan, program tidak akan berhenti dan akan selalu melakukan pengecekan 56 | int switch_case() { 57 | int a = 7; 58 | 59 | // Memindahkan kondisi ke variabel a 60 | switch (a) { 61 | // Saat a = 1 jalankan program di bawah ini 62 | case 1: 63 | std::cout << "Saat case = 1!" << std::endl; 64 | break; 65 | 66 | // Saat a = 1 jalankan program di bawah ini 67 | case 2: 68 | std::cout << "Saat case = 2!" << std::endl; 69 | break; 70 | 71 | // Jalankan program dibawah ini saat semua kondisi di atas tidak terpenuhi 72 | default: 73 | std::cout << "Nilai default pada case!" << std::endl; 74 | } 75 | 76 | return 0; 77 | } 78 | 79 | int main() 80 | { 81 | // Menjalankan fungsi di atas 82 | if_only(); 83 | if_else(); 84 | if_else_if(); 85 | switch_case(); 86 | } -------------------------------------------------------------------------------- /basic/05_conditional/ternary.cpp: -------------------------------------------------------------------------------- 1 | // Contoh pengkondisian menggunakan ternaty 2 | // Alternatif dari penggunaan if-else dengan menuliskan program hanya 1 baris saja 3 | // digunakan pada perhitungan/logika sederhana 4 | 5 | // logika dituliskan sebelum simbol "?" 6 | // simbol ":" digunakan sebagai else. 7 | // value sebelum ":" untuk hasil "True", value setelah ":" untuk hasil "False" 8 | 9 | #include 10 | 11 | int main() { 12 | int a = 5; 13 | int b = 10; 14 | 15 | // Contok penggunaan ternary untuk menentukan nilai c 16 | // cek apakah "a > b" (hasilnya false) 17 | // jika hasilnya "True" nilai c = a. 18 | // Jika hasilnya "False" nilai c = b. 19 | int c = a > b ? a : b; 20 | 21 | // Tampilkan Hasilnya 22 | std::cout << "Nilai dari variabel c adalah: " << c << std::endl; 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /basic/06_looping/break.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | // membuat perulangan dengan value i 5 | // dari 0 sampai dengan 50 6 | for(int i = 0; i < 50; i++){ 7 | // jika i adalah 20 8 | if (i == 20){ 9 | // maka akan menghentikan perulangan 10 | break; 11 | } 12 | // menampilkan i 13 | // atau hasil perulangan 14 | std::cout< 2 | 3 | int main(){ 4 | // membuat perulangan dengan value i 5 | // dari 0 sampai dengan 50 6 | for(int i = 0; i < 50; i++){ 7 | // jika i adalah 20 8 | if (i == 20){ 9 | // maka akan melewati angka 20 10 | continue; 11 | } 12 | // menampilkan i 13 | // atau hasil perulangan 14 | std::cout< 2 | 3 | int main(){ 4 | // menginisialisasi variabel i 5 | int i = 1; //kondisi_awal 6 | 7 | while (i <= 5) { //kondisi_ulang 8 | // mencetak "Hello World" sebanyak 5 kali 9 | std::cout << "Hello World\n"; 10 | 11 | i++; //perubahan 12 | } 13 | } -------------------------------------------------------------------------------- /basic/07_array/array_cpp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | // mendeklarasikan array dengan panjang element 5 5 | int nilai_siswa[5] = {12, 100, 50, 90, 80}; 6 | 7 | // menampilkan nilai array 8 | std::cout << nilai_siswa[2] << std::endl; 9 | 10 | // menampilkan semua array 11 | // dengan menggunakan for loop 12 | for (int i = 0; i < 5; i++){ 13 | // menampilkan semua array 14 | std::cout << nilai_siswa[i] << std::endl; 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /basic/07_array/readme.md: -------------------------------------------------------------------------------- 1 | # CPP Array 2 | Array digunakan untuk menyimpan dan menghasilkan beberapa atau banyak value dalam satu variabel, untuk mendeklarasikan array, deklarasikan berupa tipe data dari array, nama variabel dari array, dan jumlah value yang diinginkan yang dimasukkan di dalam tutup kurung kotak ``[]``, contoh kode: 3 | 4 | ```cpp 5 | std::string nama_siswa[5]; 6 | ``` 7 | contoh deklarasi value dari array 8 | ```cpp 9 | std::string nama_siswa[3] = {"erik", "mark", "spencer"}; 10 | ``` 11 | kita bisa mengakses element pada array seperti pada contoh dibawah ini 12 | ```cpp 13 | std::string nama_siswa[3] = {"erik", "mark", "spencer"}; 14 | std::cout << nama_siswa[0]; 15 | ``` 16 | pada penjelasan diatas kita mengakses element pertama dari siswa yaitu ``erik``, array dimulai dari index 0 dan kemudian berlanjut ``0 1 2...n`` 17 | 18 | kita juga bisa mengubah value dari element tersebut dengan cara memilih element yang ingin kita ubah dan menggantinya dengan yang sesuai 19 | ```cpp 20 | std::string nama_siswa[3] = {"erik", "mark", "spencer"}; 21 | nama_siswa[1] = "james"; 22 | std::cout << nama_siswa[1]; 23 | ``` 24 | contoh pada value integer 25 | ```cpp 26 | int nilai_siswa[3] = {90, 50, 70}; 27 | std::cout << nilai_siswa[2]; 28 | ``` 29 | 30 | ## Memanggil Array 31 | Kita bisa memanggil semua value dari array dengan cara menggunakan looping sebagai contoh 32 | ```cpp 33 | std::string nama_siswa[3] = {"erik", "mark", "spencer"}; 34 | for (int i = 0; i < 3; i++){ 35 | std::cout << nama_siswa[i] << std::endl; 36 | } 37 | ``` 38 | pada penjelasan diatas, perulangan diulang sebanyak 3 kali dimana sesuai dengan jumlah element dari array, kemudian menampilkan output dari nama siswa pada perulangan tersebut sehingga mengeluarkan output 39 | ``` 40 | erik 41 | mark 42 | spencer 43 | ``` 44 | 45 | contoh lain 46 | ```cpp 47 | std::string nama_siswa[3] = {"erik", "mark", "spencer"}; 48 | for (int i = 0; i < 3; i++){ 49 | std::cout << i[nama_siswa] << std::endl; 50 | } 51 | ``` 52 | 53 | ## Reference 54 | - [Arrays in CPP](https://www.w3schools.com/cpp/cpp_arrays.asp) 55 | 56 | contoh lebih lanjut dari array 57 | 58 | - [pendahuluan array](https://www.youtube.com/watch?v=8WhUADLI4RQ&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=47) 59 | - [array || standard library](https://www.youtube.com/watch?v=o1DegduG140&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=48) 60 | - [latihan array](https://www.youtube.com/watch?v=PGV8VigBVcg&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=49) 61 | - [looping array](https://www.youtube.com/watch?v=5jTGrD55Ws4&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=50) 62 | - [multidimensional array](https://www.youtube.com/watch?v=-hsKUD4fVRE&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=51) 63 | - [sort array | std library](https://www.youtube.com/watch?v=G0cml-wvaBc&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=53) 64 | - [search array | std library](https://www.youtube.com/watch?v=QFC4DXvRu8o&list=PLZS-MHyEIRo4Ze0bbGB1WKBSNMPzi-eWI&index=54) 65 | -------------------------------------------------------------------------------- /basic/08_string/gaya_c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | char salam[6] = {'H', 'e', ​​'l', 'l', 'o', '\0'}; 5 | std::cout<<"pesan yang keluar adalah "; 6 | std::cout< 2 | 3 | int main(){ 4 | char salam[] = "Hello boys"; 5 | std::cout< 26 | 27 | int main(){ 28 | char salam[6] = {'H', 'e', ​​'l', 'l', 'o', '\0'}; 29 | std::cout<<"pesan yang keluar adalah "; 30 | std::cout< 39 | 40 | int maian(){ 41 | char salam[] = "Hello boys"; 42 | std::cout< 2 | 3 | int main(){ 4 | 5 | // arr[baris][kolom] 6 | int arr[3][2] = { 7 | {0,1}, 8 | {2,3}, 9 | {4,5} 10 | }; 11 | 12 | for(int baris = 0; baris < 3; baris++){ 13 | for(int kolom = 0; kolom < 2; kolom++){ 14 | std::cout << "arr[" << baris << "][" << kolom << "]: " << arr[baris][kolom] << std::endl; 15 | } 16 | } 17 | 18 | /* 19 | 20 | Expected Output: 21 | arr[0][0]: 0 22 | arr[0][1]: 1 23 | arr[1][0]: 2 24 | arr[1][1]: 3 25 | arr[2][0]: 4 26 | arr[2][1]: 5 27 | 28 | */ 29 | } -------------------------------------------------------------------------------- /basic/10_input_output/input_output.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | // deklarasi variabel 5 | char nama_hewan[20]; 6 | std::cout << "Nama hewan: "; 7 | 8 | // deklarasi input stream 9 | std::cin >> nama_hewan; 10 | // menampilkan output 11 | std::cout << "Nama hewan: " << nama_hewan << std::endl; 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /basic/10_input_output/readme.md: -------------------------------------------------------------------------------- 1 | # basic input output 2 | 3 | pustaka standar c++ menyediakan serangkaian kemampuan input / output yang luas.c++ I/O aterjadi dalam aliran, yang merupakan urutan byte. jika byte mnegalir dari perangkat seperti keyboard, disk drive, atau koneksi jaringan, dll. ke memori utama, ini disebut **operasi input** dan jika byte mengalir dari memori utama ke perangkat seperti layar tampilan, printer, drive, disk, atau koneksi jaringan, dll,. ini disebut dengan **operasi keluaran atau output** 4 | 5 | 1. **** 6 | file ini mendifinisikan objek cin, cout, cerr, dan clog, yang masing-masing sesuai dengan aliran input standar, aliran output standar, aliran error standar tanpa buffer, dan aliran error standar buffer 7 | 8 | 2. **** 9 | file ini meyatakan layan yang berguna untuk melakukan I/O yang diformat dengan apa yang disebut dengan manipulator aliran **berparameter**, seperti **setw** dan **setprecision** 10 | 11 | 3. **** 12 | file ini mendlakarasikan layanan untuk pemrosesan file yang dikontrol pengguna. 13 | 14 | 15 | ## aliran keluaran standar (cout) 16 | 17 | Objek ditentukan sebelumnya cout adalah turunan dari ostream kelas. Objek cout dikatakan "terhubung ke" perangkat output standar, yang biasanya adalah tampilan layar. The cout digunakan bersama dengan operator aliran penyisipan, yang ditulis sebagai << yang dua kurang dari tanda-tanda seperti yang ditunjukkan dalam contoh berikut. 18 | 19 | ```cpp 20 | #include 21 | 22 | int main(){ 23 | char str[] = "bellshade cpp"; 24 | std::cout<> yang dua lebih besar dari tanda-tanda seperti yang ditunjukkan dalam contoh berikut. 34 | 35 | ```cpp 36 | #include 37 | 38 | int main(){ 39 | char merek_mobil[50]; 40 | 41 | std::cout<<"masukkan nama merk mobil: "; 42 | std::cin>>merek_mobil; 43 | cout<<"wow "< 57 | 58 | int main(){ 59 | char str[] = "error pada aplikasi..!"; 60 | cerr<<"problem: "< 72 | 73 | int main(){ 74 | char str[] = "masalah pada aplikasi.."; 75 | 76 | clog<<"log: "< 2 | 3 | int main(){ 4 | // deklarasi variabel dengan const 5 | const int PANJANG = 20; 6 | const int LEBAR = 2; 7 | int hasil; 8 | // kalkulasi 9 | hasil = PANJANG * LEBAR; 10 | // menampilkan hasil 11 | std::cout << "Hasil perhitungan adalah " << hasil; 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /basic/11_constant_literal/constanta_define.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // deklarasi preprosesor dengan #define 4 | #define PANJANG 20 5 | #define LEBAR 2 6 | 7 | int main(){ 8 | // deklarasi variabel hasil 9 | int hasil; 10 | // kalkulasi 11 | hasil = PANJANG * LEBAR; 12 | // menampilkan hasil 13 | std::cout << "Hasil perhitungan adalah " << hasil; 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /basic/12_fungsi/fungsi.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // membuat fungsi tanpa return nilai 4 | void panggil() { 5 | std::cout << "Fungsi tanpa return" << std::endl; 6 | } 7 | 8 | int main(){ 9 | // memanggil fungsi panggil() 10 | panggil(); 11 | 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /basic/12_fungsi/fungsi_return.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // mendeklarasikan fungsi 4 | int tambah(int angka1, int angka2); 5 | 6 | int main(){ 7 | int a = 20; 8 | int b = 30; 9 | int hasil; 10 | 11 | hasil = tambah(a, b); 12 | std::cout<<"hasilnya adalah :"< 2 | 3 | int main(){ 4 | int x, n; 5 | 6 | std::cout<<"masukkan jumlah item: "; 7 | std::cin>>n; 8 | 9 | // membuat array dinammis 10 | int *arr = new int(n); 11 | 12 | // masukkan item pada array dinamis 13 | std::cout<>arr[x]; 16 | } 17 | 18 | // tampilkan hasil 19 | std::cout<<"kamu memasukkan: "; 20 | for (x = 0; x < n; x++){ 21 | std::cout< 22 | 23 | int main(){ 24 | int x, n; 25 | 26 | std::cout<<"masukkan jumlah item: "; 27 | std::cin>>n; 28 | 29 | // membuat array dinammis 30 | int *arr = new int(n); 31 | 32 | // masukkan item pada array dinamis 33 | std::cout<>arr[x]; 36 | } 37 | 38 | // tampilkan hasil 39 | std::cout<<"kamu memasukkan: "; 40 | for (x = 0; x < n; x++){ 41 | std::cout< 54 | 55 | int main(){ 56 | int x, n; 57 | 58 | std::cout<<"masukkan jumlah item"; 59 | std::cin>>n; 60 | 61 | int *arr = new int(n); 62 | 63 | // memasukkan value ke dalam array dinamis 64 | std::cout<<"masukkan "<>arr[x]; 67 | } 68 | 69 | // menampilkan value yang sebelumnya 70 | // sudah diinput ke dalam array dinamis 71 | std::cout<<"kamu memasukkan: "; 72 | for(x = 0; x < n; x++){ 73 | std::cout< 2 | 3 | // membuat kelas persegi 4 | class Persegi{ 5 | // membuat akses 6 | // berupa publik sehingga bisa diakses 7 | // diluar kelas 8 | public: 9 | double panjang; 10 | double lebar; 11 | }; 12 | 13 | int main(){ 14 | // deklarasi objek baru dari kelas 15 | Persegi persegi1; 16 | Persegi persegi2; 17 | 18 | // membuat variabel hasil 19 | double hasil = 0.0; 20 | 21 | // mengisi value dari variabel 22 | // persegi1 23 | persegi1.panjang = 20; 24 | persegi1.lebar = 3; 25 | 26 | // mengisi value dari variabel 27 | // persegi2 28 | persegi2.panjang = 30; 29 | persegi2.lebar = 3; 30 | 31 | // menghitung hasil dari persegi1 32 | // dan menampilkan hasil 33 | hasil = persegi1.panjang * persegi1.lebar; 34 | std::cout<<"hasil persegi1: "< 27 | 28 | class Persegi{ 29 | // membuat akses publik sehingga 30 | // bisa diakses diluar persegi 31 | public: 32 | double panjang; 33 | double lebar; 34 | }; 35 | 36 | int main(){ 37 | // memanggil kelas Persegi 38 | Persegi persegi1; 39 | // membuat variabel hasil 40 | double hasil; 41 | 42 | // akses ke objek variabel tertentu 43 | // dan memberi value 44 | persegi1.panjang = 12; 45 | persegi1.lebar = 13; 46 | 47 | // menghitung hasil dari kedua variabel 48 | volume = persegi1.panjang * persegi1.lebar; 49 | 50 | // menampilkan hasil persegi 51 | std::cout<<"hasil dari hitung persegi panjang"< 2 | 3 | struct Struct_saya{ 4 | int angka_saya = 10; 5 | int angka_saya2 = 20; 6 | }; 7 | 8 | int main(){ 9 | Struct_saya objek_saya; 10 | 11 | std::cout<<"angka pertama "< 7 | 8 | class Kelas_saya{ 9 | int angka = 10; 10 | }; 11 | 12 | int main(){ 13 | Kelas_saya objek_saya; 14 | std::cout< 20 | 21 | struct Struct_saya{ 22 | int angka_saya = 10; 23 | int angka_saya2 = 20; 24 | }; 25 | 26 | int main(){ 27 | Struct_saya objek_saya; 28 | 29 | std::cout<<"angka pertama "< 2 | #include 3 | 4 | void loop(std::vector parameter){ 5 | std::cout << "\nData Vector berisikan: "; 6 | for(int i = 0; i < parameter.size(); i++){ 7 | std::cout << "[" << parameter[i] << "] "; 8 | } 9 | } 10 | 11 | int main() 12 | { 13 | // Deklarasi Vector 14 | std::vector v; 15 | 16 | // 1. push_back 17 | // Menginisialisasikan Vector dengan angka = 1, 2, 3 18 | v.push_back(1); 19 | v.push_back(2); 20 | v.push_back(3); 21 | loop(v); 22 | 23 | // 2. pop_back 24 | v.pop_back(); 25 | loop(v); 26 | 27 | // 3. at 28 | std::cout << "\nNilai pencarian: [" << v.at(1) << "]"; 29 | 30 | v.at(1) = 3; 31 | loop(v); 32 | 33 | // 4. clear 34 | v.clear(); 35 | loop(v); 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /basic/17_function_overload/function_overloading.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // Fungsi pertama 4 | int dikali(int var1) { 5 | std::cout << var1 << " x " << var1 << " : "; 6 | return var1 * var1; 7 | } 8 | 9 | // Fungsi kedua 10 | int dikali(int var1, int var2) { 11 | std::cout << var1 << " x " << var2 << " : "; 12 | return var1 * var2; 13 | } 14 | 15 | // Fungsi ketiga 16 | int dikali(int var1, int var2, int var3) { 17 | std::cout << var1 << " x " << var2 << " x " << var3 << " : "; 18 | return var1 * var2 * var3; 19 | } 20 | 21 | 22 | int main(int argc, char const *argv[]) 23 | { 24 | std::cout << dikali(1,2,3) << std::endl; 25 | std::cout << dikali(1,2) << std::endl; 26 | std::cout << dikali(1) << std::endl; 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /basic/17_function_overload/readme.md: -------------------------------------------------------------------------------- 1 | # Function Overload 2 | ***Function Overloading adalah membuat beberapa function dengan nama yang sama, tapi dibedakan dari jumlah dan tipe data parameter. 3 | Walaupun Umumnya, kita tidak bisa membuat function dengan nama yang sama.*** 4 | 5 | Mirip seperti penamaan variabel, compiler C++ akan error jika menemukan terdapat 2 atau lebih function dengan nama yang sama. 6 | Akan tetapi jika jumlah argument atau tipe data argument berbeda, maka akan dianggap sebagai fungsi yang berbeda pula. 7 | 8 | **Contoh Kode** berikut merujuk pada kalimat: 9 | - *Umumnya, kita tidak bisa membuat function dengan nama yang sama* 10 | - *Akan tetapi jika jumlah argument atau tipe data argument berbeda, maka akan dianggap sebagai fungsi yang berbeda pula.* 11 | 12 | Berikut adalah demonstrasinya 13 | 14 | ```cpp 15 | #include 16 | 17 | // Fungsi pertama 18 | int dikali(int var1) { 19 | std::cout << var1 << " x " << var1 << " : "; 20 | return var1 * var1; 21 | } 22 | 23 | // Fungsi kedua 24 | int dikali(int var1, int var2) { 25 | std::cout << var1 << " x " << var2 << " : "; 26 | return var1 * var2; 27 | } 28 | 29 | 30 | int main(int argc, char const *argv[]) 31 | { 32 | std::cout << dikali(2) << std::endl; 33 | std::cout << dikali(5, 5) << std::endl; 34 | 35 | return 0; 36 | } 37 | ``` 38 | Kedua nama fungsi sama `dikali` dengan `dikali` namun berbeda `parameter`. 39 | 40 | - fungsi `dikali` yang pertama memiliki `1 parameter` 41 | - fungsi `dikali` yang kedua memiliki `2 parameter` 42 | 43 | > Pada function kita dimungkinkan untuk mendirikan function lebih dari satu dengan identitas yang sama, selama masing-masing function tersebut memiliki perbedaan pada function parameter. Hal tersebut disebut sebagai fitur Overloading. 44 | 45 | > Pembuatan function overloading wajib untuk membuat function tersebut benar-benar berbeda dalam segi function parameter. Jika diidentifikasi memiliki kesamaan, maka kompilator akan mengeluh mengenai “ambiguating”. 46 | 47 | > Kadang kompilator juga akan mengeluh saat dimana memang tidak ditemukan kecocokan function dengan argument pada pemanggilan function. 48 | 49 | ### Keuntungannya apa? 50 | Function yang memiliki fitur overloading, memberikan kemudahan dengan kemungkinkan untuk memberikan argument secara fleksibel sesuai keadaan dan kebutuhkan. 51 | 52 | **Contohnya** 53 | _Function_ 54 | ```cpp 55 | // Fungsi pertama 56 | int dikali(int var1) { 57 | std::cout << var1 << " x " << var1 << " : "; 58 | return var1 * var1; 59 | } 60 | 61 | // Fungsi kedua 62 | int dikali(int var1, int var2) { 63 | std::cout << var1 << " x " << var2 << " : "; 64 | return var1 * var2; 65 | } 66 | 67 | // Fungsi ketiga 68 | int dikali(int var1, int var2, int var3) { 69 | std::cout << var1 << " x " << var2 << " x " << var3 << " : "; 70 | return var1 * var2 * var3; 71 | } 72 | ``` 73 | _inputUser_ 74 | ```cpp 75 | std::cout << dikali(1,2,3) << std::endl; 76 | std::cout << dikali(1,2) << std::endl; 77 | std::cout << dikali(1) << std::endl; 78 | ``` 79 | Kita dapat dengan bebas menggunakan fungsi yang mana saja, mengikuti/menyesuaikan parameter dari setiap fungsinya. 80 | 81 | 1. Jika kita memiliki nilai (_inputUser_) = `1,2,3`. 82 | - Maka saat kita memanggil fungsi `dikali`, secara otomatis memanggil fungsi yang ketiga (`dikali`) 83 | - `Hasil` 1 x 2 x 3 : 6 84 | 2. Jika kita memiliki nilai (_inputUser_) = `1,2`. 85 | - Maka saat kita memanggil fungsi `dikali`, secara otomatis memanggil fungsi yang kedua (`dikali`) 86 | - `Hasil` 1 x 2 : 2 87 | 3. Jika kita memiliki nilai (_inputUser_) = `1`. 88 | - Maka saat kita memanggil fungsi `dikali`, secara otomatis memanggil fungsi yang pertama (`dikali`) 89 | - `Hasil` 1 x 1 : 1 90 | -------------------------------------------------------------------------------- /basic/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/basic") 11 | 12 | endforeach( testsourcefile ${APP_SOURCES} ) -------------------------------------------------------------------------------- /basic/readme.md: -------------------------------------------------------------------------------- 1 | # Dasar-Dasar C++ 2 | 3 | Apa yang ada dalam folder ini? 4 | 5 | 1. [Pengenalan](01_introduction/) 6 | 2. [Variabel dan Tipe Data](02_variable_datatype/) 7 | 3. [Pointer dan Reference](03_pointer_reference/) 8 | 4. [Operator](04_operator/) 9 | 5. [Percabangan](05_conditional/) 10 | 6. [Perulangan](06_looping/) 11 | 7. [Array](07_array/) 12 | 8. [String](08_string/) 13 | 9. [Mutidimensional Array](09_multidimensional_array/) 14 | 10. [Input Output](10_input_output/) 15 | 11. [Constant Literal](11_constant_literal/) 16 | 12. [Fungsi](12_fungsi/) 17 | 13. [Dynamic Array](13_dynamic_array/) 18 | 14. [Class](14_class/) 19 | 15. [Struct](15_struct/) 20 | 16. [Vector Basic](16_vector_basic/) 21 | 17. [Function Overload](17_function_overload/) 22 | -------------------------------------------------------------------------------- /design_patterns/readme.md: -------------------------------------------------------------------------------- 1 | # Design patterns 2 | 3 | Seiring waktu yang terus berjalan, software pun akan terus mengalami 4 | pengembangan, agar komunikasi antar *objects*, pembuatan *objects*, 5 | dan struktur atau relasi antar *classes* dalam aplikasi tersebut 6 | berjalan lancar, *elegant*, dan mudah di-*track*, maka ada yang 7 | dinamakan **Design Patterns**. 8 | 9 | ## Apa itu Design patterns 10 | 11 | Adalah sebuah solusi agar saat kamu mengemmbangkan sebuah software, 12 | *code* software tersebut mudah dipahami, mudah dikelola, dan memiliki 13 | skalabilitas yang tinggi, bisa buat jaga-jaga jika kamu ingin serius 14 | dengan pengembangan software tersebut. **Design patterns** bukanlah 15 | sebuah *code* yang bisa kamu *plek-ketiplek* salin layaknya algoritma, 16 | melainkan sebuah *template* yang bisa kamu gunakan sebagai acuan saat 17 | mengembangkan software-mu. 18 | 19 | ## Kategori Design patterns 20 | 21 | Sebenarnya banyak sekali *patterns* yang digunakan saat proses pengembangan 22 | software, namun ada 23 jenis *patterns* yang umumnya digunakan sebagai pondasi 23 | dari *patterns* lainnya, 23 *patterns* itulah yang umum disebut dengan istilah 24 | **The Gang of Four (GoF)**, **GoF** memiliki 3 kategori, yaitu: 25 | 26 | - *Creational*, adalah bagaimana cara *objects* dibuat. 27 | - [Singleton](singleton/) 28 | - *... TODO* 29 | - *Structural*, adalah bagaimana cara menyusun dan hubungan dari *class-class* mu. 30 | - *... TODO* 31 | - *Behavioral*, adalah bagaimana cara komunikasi antar *objects*. 32 | - *... TODO* 33 | 34 | Bagus dan buruknya *patterns* bersifat *relative* terhadap sesuatu yang kamu 35 | ingin buat atau apa yang ingin kamu selesaikan. 36 | 37 | > [!NOTE] 38 | > disarankan lihat terlebih dahulu [OOP](../object_oriented_programming/) 39 | -------------------------------------------------------------------------------- /design_patterns/singleton/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.1) 2 | set (CMAKE_CXX_STANDARD 11) 3 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 4 | foreach( testsourcefile ${APP_SOURCES} ) 5 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 6 | add_executable( ${testname} ${testsourcefile} ) 7 | 8 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 9 | if(OpenMP_CXX_FOUND) 10 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 11 | endif() 12 | install(TARGETS ${testname} DESTINATION "bin/singleton") 13 | 14 | endforeach( testsourcefile ${APP_SOURCES} ) 15 | 16 | file( GLOB FILE_SCOPE_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/static_file_scope/*.cpp" ) 17 | add_executable( "static_file_scope" ${FILE_SCOPE_SOURCES} ) 18 | set_target_properties( "static_file_scope" PROPERTIES LINKER_LANGUAGE CXX ) 19 | if(OpenMP_CXX_FOUND) 20 | target_link_libraries( "static_file_scope" OpenMP::OpenMP_CXX ) 21 | endif() 22 | install( TARGETS "static_file_scope" DESTINATION "bin/singleton" ) 23 | -------------------------------------------------------------------------------- /design_patterns/singleton/readme.md: -------------------------------------------------------------------------------- 1 | # Singleton 2 | 3 | Adalah salah satu **Design Pattern** di kategori *Creational*. Sederhananya 4 | *pattern* ini hanya membolehkan sebuah *class* memiliki 5 | **hanya satu instance**, dan *instance* tesebut *Global Accessible* 6 | (artinya *instance* atau *object* tersebut dapat diakses oleh *unit* lain, 7 | atau katakanlah file `.cpp` lain dalam *project* yang sama). Terlepas 8 | dari baik dan buruknya *pattern* ini bisa dibilang banyak digunakan 9 | karena kesederhaannya dan kemudahannya dalam pengaplikasiannya. 10 | 11 | ## Kapan menggunakan Singleton ? 12 | 13 | Saat kamu ingin suatu *object* dapat diakses secara global, 14 | dan tidak ada duplikasi dari *object* tersebut. 15 | 16 | ## Cara kerja Singleton 17 | 18 | Singleton memiliki `contructor` yang bersifat `private` atau `protected`, 19 | hal ini mencegah *class* tersebut dapat di-insialisasi (dibuat object) secara biasa 20 | (`Class objek;`), lalu bagaimana cara mengakses *object* atau *instance* dari 21 | *class* tersebut ?. Umumnya setiap Singleton memiliki 1 *function* public `static` 22 | dengan return datatype class nya sendiri. [contoh code](singleton_basic.cpp) 23 | 24 | ### mengenai `static` keyword 25 | 26 | dalam CPP terdapat 3 kondisi `static` keyword, setiap kondisi dia bertingkah 27 | berbeda baik itu untuk variable ataupun untuk fingsi. 28 | 1. ketika digunakan di *file scope*, maka variable tersebut global namun 29 | hanya sebatas dalam file dimana ia di-deklarasikan. [contoh kode](static_file_scope/) 30 | 2. ketika digunakan di *function scope*, maka variable tersebut global, 31 | namun hanya bisa diakses oleh atau melalui fungsi tersebut saja. Contohnya 32 | seperti yang [awal-awal](singleton_basic.cpp) 33 | > [!NOTE] 34 | > - variable tersebut belum akan di inisialisasi sampai fungsi tersebut 35 | dipanggil pertama kali. (bagus untuk menghemat resources, namun eksekusi 36 | task kamu akan butuh extra waktu saat eksekusi pertama kali) 37 | > - tidak ada inisialisasi ulang, meskipun fungsi dipanggil beberapa kali 38 | 3. ketika digunakan di *struct* atau *class scope*, maka variable tersebut 39 | bukan sembarang member, melainkan member yang global, dapat diakses meskipun 40 | belum dibuat *object*-nya (tergantung level visibilitas), dan setiap *object* 41 | mendapatkan *share* akan variable tersebut (jika *object* kesatu mengubah 42 | nilai variable tersebut maka *object* kedua pun merasakan perubahannya). 43 | Sederhananya variable tersebut milik *class* dan bukan milik *object* 44 | [contoh code](static_class_scope.cpp) 45 | 46 | ## Catatan 47 | 48 | Hindari penggunaan Singleton secara berlebihan, contoh saat kamu 49 | ingin cek apakah *Plane* yang dibuat itu memiliki bentuk *square*: 50 | 51 | ```cpp 52 | class Plane { 53 | public: 54 | Plane (int x0, int y0, int x1, int y1) { 55 | this->x0 = x0; 56 | this->y0 = y0; 57 | this->x1 = x1; 58 | this->y1 = y1; 59 | } 60 | int x0, y0, x1, y1; 61 | }; 62 | 63 | class PlaneManager { 64 | private: 65 | PlaneManager () = default; 66 | public: 67 | static PlaneManager& getInstance () { 68 | static PlaneManager instance; 69 | return instance; 70 | } 71 | 72 | Plane* createPlane (int x0, int y0, int x1, int y1) { 73 | Plane* plane = new Plane(x0, y0, x1, y1); 74 | return plane; 75 | } 76 | bool isSquareShaped (Plane& plane) { 77 | return (plane.x1 - plane.x0) == (plane.y1 - plane.y0); 78 | } 79 | }; 80 | ``` 81 | 82 | bagaiman kalau begini 83 | 84 | ```cpp 85 | class Plane { 86 | public: 87 | Plane (int x0, int y0, int x1, int y1) { 88 | this->x0 = x0; 89 | this->y0 = y0; 90 | this->x1 = x1; 91 | this->y1 = y1; 92 | } 93 | int x0, y0, x1, y1; 94 | 95 | bool isSquareShaped() { 96 | return (x1 - x0) == (y1 - y0); 97 | } 98 | }; 99 | ``` 100 | 101 | lalu insialisasi objek dengan cara yang biasa, lebih simple 102 | dan masalah terselesaikan. 103 | 104 | ## Contoh kode 105 | 106 | - [basic singleton](singleton_basic.cpp) 107 | - [basic singleton 2](singleton_another_example.cpp) 108 | 109 | --- 110 | 111 | - static 112 | - [static di file scope](static_class_scope/) 113 | - [static di function scope](singleton_basic.cpp) 114 | - [static di class scope](static_class_scope.cpp) 115 | -------------------------------------------------------------------------------- /design_patterns/singleton/singleton_another_example.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // deklarasi class Logger, sebagai wrapper 4 | class Logger { 5 | protected: 6 | Logger (); 7 | 8 | public: 9 | static Logger& getInstance (); 10 | virtual std::string log (std::string message) = 0; 11 | }; 12 | 13 | // definisi class Logger untuk Windows 14 | class WindowLogger : public Logger { 15 | public: 16 | std::string log(std::string message) override { 17 | // lakukan Windows spesific task 18 | 19 | return "[WINDOWS] INFO: " + message; 20 | } 21 | }; 22 | 23 | // definisi class Logger untuk Unix 24 | class UnixLogger : public Logger { 25 | public: 26 | std::string log(std::string message) override { 27 | // lakukan Unix spesific task 28 | 29 | return "[UNIX] INFO: " + message; 30 | } 31 | }; 32 | 33 | // definisi class Logger 34 | Logger::Logger () = default; 35 | Logger& Logger::getInstance () { 36 | // lazy intialize (di inisialisasi saat fungsi dipanggil pertama kali) 37 | #ifdef _WIN32 38 | static WindowLogger* instance = new WindowLogger(); 39 | #else 40 | static UnixLogger* instance = new UnixLogger(); 41 | #endif // _WIN32 42 | return *instance; 43 | } 44 | 45 | int main () { 46 | std::cout << "Logging menggunakan `Logger` class: \n"; 47 | std::cout << "\t" << Logger::getInstance().log("Hello World") << std::endl; 48 | } 49 | -------------------------------------------------------------------------------- /design_patterns/singleton/singleton_basic.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class Singleton { 4 | private: 5 | Singleton () = default; 6 | 7 | public: 8 | static Singleton& getInstance () { 9 | static Singleton instance; // lazy intialize, memory belum dialokasikan sampai fungsi ini dipanggil pertama kali 10 | return instance; 11 | } 12 | 13 | Singleton (const Singleton& obj) = delete; // mencegah instance assignable 14 | 15 | // definisikan non-static fungsi-fungsi dan variable-variable 16 | // lalu akses seperti biasa. 17 | }; 18 | 19 | // nilai address dari instace Singleton pasti selalu sama, 20 | // yang berarti bahwa object yang dipanggil merupakan object yang sama. 21 | int main () { 22 | std::cout << "Pemanggilan instance pertama: \n"; 23 | std::cout << "\tInstance address: "; 24 | std::cout << &Singleton::getInstance() << '\n'; 25 | 26 | std::cout << "Pemanggilan instance kedua: \n"; 27 | std::cout << "\tInstance address: "; 28 | std::cout << &Singleton::getInstance() << '\n'; 29 | 30 | std::cout << "Pemanggilan instance ketiga: \n"; 31 | std::cout << "\tInstance address: "; 32 | std::cout << &Singleton::getInstance() << '\n'; 33 | } 34 | -------------------------------------------------------------------------------- /design_patterns/singleton/static_class_scope.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class ClassScope { 4 | public: 5 | ClassScope () = default; 6 | 7 | static int sharedVar; // definisi, memori dialokasikan 8 | }; 9 | 10 | int ClassScope::sharedVar = 5; // insialisasi 11 | 12 | int main () { 13 | ClassScope obj1; 14 | ClassScope obj2; 15 | 16 | std::cout << "Akses langsung nilai variable tanpa perantara object\n"; 17 | std::cout << "\tNilai: " << ClassScope::sharedVar << '\n'; 18 | std::cout << "Akses langsung nilai variable melalui object\n"; 19 | std::cout << "\tNilai: " << obj1.sharedVar << '\n'; 20 | 21 | obj1.sharedVar = 10; 22 | std::cout << "\nObject 1 mengubah nilai variable-nya, menjadi: "; 23 | std::cout << obj1.sharedVar << '\n'; 24 | 25 | std::cout << "Maka object 2 pun merasakan perubahannya\n"; 26 | std::cout << "\tNilai: " << obj2.sharedVar << '\n'; 27 | } 28 | -------------------------------------------------------------------------------- /design_patterns/singleton/static_file_scope/another.cpp: -------------------------------------------------------------------------------- 1 | static int var = 5; // untuk pembuktian lebih lanjut kamu bisa hilangkan `static` keyword-nya, 2 | // kemudian lakukan kompilasi ulang, 3 | // maka akan muncul error, karena tidah boleh ada 2 global variable (real) 4 | // yang bernama sama. 5 | 6 | // fungsi yang me-return nilai `var` di file ini 7 | int getVar () { 8 | return var; 9 | } 10 | -------------------------------------------------------------------------------- /design_patterns/singleton/static_file_scope/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | extern int getVar(); // deklarasi, memberitahu compiler bahwa fungsi ini di definisikan di file lain 4 | 5 | int var = 10; // intsialisasi global variable (real) 6 | 7 | int main () { 8 | std::cout << "Nilai variable dengan name 'var': "; 9 | std::cout << var << std::endl; 10 | std::cout << "Nilai variable dengan name 'var' di file lain: "; 11 | std::cout << getVar() << std::endl; // tidak bisa akses secara langsung variable `var` 12 | // di file lain karena ekslusif untuk file tersebut saja 13 | } 14 | -------------------------------------------------------------------------------- /design_patterns/singleton/static_file_scope/readme.md: -------------------------------------------------------------------------------- 1 | # Kompilasi 2 | 3 | Compile dengan menjalankan perintah 4 | 5 | ```shell 6 | g++ *.cpp -o nama_executable 7 | ./nama_executable 8 | ``` 9 | atau 10 | 11 | ```shell 12 | g++ *.cpp -o nama_executable.exe 13 | .\nama_executable.exe 14 | ``` 15 | -------------------------------------------------------------------------------- /geometri/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.1) 2 | set (CMAKE_CXX_STANDARD 11) 3 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 4 | foreach( testsourcefile ${APP_SOURCES} ) 5 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 6 | add_executable( ${testname} ${testsourcefile} ) 7 | 8 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 9 | if(OpenMP_CXX_FOUND) 10 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 11 | endif() 12 | install(TARGETS ${testname} DESTINATION "bin/geometri") 13 | 14 | endforeach( testsourcefile ${APP_SOURCES} ) 15 | -------------------------------------------------------------------------------- /geometri/graham_scan.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "include/fungsi_graham.hpp" 3 | #include 4 | #include 5 | #include 6 | 7 | /** 8 | * @brief fungsi testing dari graham scan 9 | * @return void 10 | */ 11 | static void testing() { 12 | // deklarasi vektor `titik_titik`yang menyimpan 13 | // beberapa titik dengan koordinat (x, y) 14 | std::vector titik_titik = { 15 | {0, 3}, {1, 1}, {2, 2}, {4, 4}, {0, 0}, {1, 2}, {3, 1}, {3, 3}}; 16 | 17 | // deklarasi vektor `hasil_ekspetasi` yang menyimpan hasil 18 | // yang diharapkan dari convex hull 19 | std::vector hasil_ekspetasi = { 20 | {0, 3}, {4, 4}, {3, 1}, {0, 0}}; 21 | 22 | // deklarasi vektor `hasil_terhitung` yang menyimpan hasil dari 23 | // perhitungan convex hull 24 | std::vector hasil_terhitung; 25 | 26 | // memanggil fungsi convex hull dengan argumen `titik_titik` dengan ukuran 27 | // vektor `titik_titik` 28 | hasil_terhitung = 29 | geometri::graham_scan::convexHull(titik_titik, titik_titik.size()); 30 | 31 | // menampilkan hasil uji yang pertama{0, 3}, {4, 4}, {3, 1}, {0, 0} 32 | std::cout << "testing pertama: "; 33 | 34 | // looping untuk memeriksa apakah hasil yang diharapkan sama dengan hasil yang 35 | // akan dihitung 36 | for (int i = 0; i < hasil_ekspetasi.size(); i++) { 37 | assert(hasil_terhitung[i].x == hasil_ekspetasi[i].x); 38 | assert(hasil_terhitung[i].y == hasil_ekspetasi[i].y); 39 | } 40 | 41 | std::cout << "testing pass !" << std::endl; 42 | } 43 | 44 | int main() { 45 | testing(); 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /graf/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.1) 2 | set (CMAKE_CXX_STANDARD 11) 3 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 4 | foreach( testsourcefile ${APP_SOURCES} ) 5 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 6 | add_executable( ${testname} ${testsourcefile} ) 7 | 8 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 9 | if(OpenMP_CXX_FOUND) 10 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 11 | endif() 12 | install(TARGETS ${testname} DESTINATION "bin/graf") 13 | 14 | endforeach( testsourcefile ${APP_SOURCES} ) 15 | -------------------------------------------------------------------------------- /license: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Bellshade 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /math/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/math") 11 | endforeach( testsourcefile ${APP_SOURCES} ) -------------------------------------------------------------------------------- /math/Regula_falsi.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #define ITERASI_MAX 1000000 6 | #define EPSILON 1e-6 //Epsilon dipakai untuk membatasi toleransi error 7 | //sumber 1 : https://www.geeksforgeeks.org/regula-falsi-method/ 8 | //sumber 2:https://byjus.com/maths/false-position-method/ 9 | 10 | /** 11 | * @brief Fungsi untuk menghitung nilai dari suatu polinomial 12 | * berdasarkan koefisien yang diberikan. 13 | * 14 | * @param x Nilai variabel independen dalam polinomial. 15 | * @param Koefisien Vektor yang berisi koefisien polinomial, 16 | * dimulai dari derajat tertinggi hingga 0. 17 | * @return Hasil evaluasi polinomial pada x. 18 | */ 19 | double FungsiPolynomial(double x, const std::vector& Koefisien){ 20 | double result = 0; 21 | int pangkat = Koefisien.size() - 1; 22 | for(int i = 0; i <= pangkat; i++){ 23 | result += Koefisien[i] * pow(x,pangkat - i); 24 | } 25 | return result; 26 | } 27 | 28 | /** 29 | * @brief Implementasi metode Regula Falsi untuk mencari akar fungsi. 30 | * 31 | * @param a Batas bawah interval pencarian akar. 32 | * @param b Batas atas interval pencarian akar. 33 | * @param Koefisien Vektor koefisien polinomial. 34 | */ 35 | void RegulaFalsi(double a, double b, const std::vector& Koefisien){ 36 | if(FungsiPolynomial(a,Koefisien) * FungsiPolynomial(b,Koefisien) >= 0){ 37 | std::cout << "Asumsi interval [a, b] salah, harus f(a) dan f(b) memiliki tanda berbeda.\n"; 38 | return; 39 | } 40 | std::cout << "Interval awal: [" << a << ", " << b << "]\n"; 41 | double c = a; 42 | for(int i = 0; i < ITERASI_MAX; i++){ 43 | double fa = FungsiPolynomial(a,Koefisien); 44 | double fb = FungsiPolynomial(b,Koefisien); 45 | // Temukan titik yang menyentuh sumbu x 46 | c = (a * fb - b * fa) / (fb - fa); 47 | // Periksa apakah titik yang ditemukan di atas adalah akar/root 48 | if(fabs(FungsiPolynomial(c,Koefisien)) < EPSILON){ 49 | break; 50 | }else if(FungsiPolynomial(c,Koefisien) * fa < 0){ 51 | /* 52 | Jika f(c) * f(a) < 0, berarti akar terletak di antara a dan c 53 | Maka kita perbarui batas atas b menjadi c 54 | */ 55 | b = c; 56 | }else{ 57 | /* 58 | Jika f(c) * f(a) >= 0, maka akar terletak di antara c dan b 59 | Maka kita perbarui batas bawah a menjadi c 60 | */ 61 | a = c; 62 | } 63 | } 64 | std::cout << "\n" << "Nilai akar adalah: " << c; 65 | } 66 | 67 | int main(){ 68 | std::vector Koefisien; 69 | double a = -2, b = 2; //nilai a dan b harus berbeda tanda 70 | int pilihan,koef; 71 | std::cout << "Pilihan " << "\n"; 72 | std::cout << "1. Fungsi derajat 3 " << "\n"; 73 | std::cout << "2. Fungsi Derajat 4 " << "\n"; 74 | std::cout << "Masukkan pilihan: "; 75 | std::cin >> pilihan; 76 | system("clear"); 77 | 78 | while(pilihan < 1 || pilihan > 2){ 79 | std::cout << "Anda memasukkan input yang salah! Masukkan kembali: "; 80 | std::cin >> pilihan; 81 | system("clear"); 82 | } 83 | 84 | int step = 3; 85 | if(pilihan == 1){ 86 | for(int i = 0; i < 4; i++){ 87 | std::cout << "Masukkan koefisien derajat " << step << ": "; 88 | std::cin >> koef; 89 | Koefisien.push_back(koef); 90 | step--; 91 | } 92 | }else if(pilihan == 2){ 93 | for(int i = 0; i < 5; i++){ 94 | std::cout << "Masukkan koefisien derajat " << step + 1 << ": "; 95 | std::cin >> koef; 96 | Koefisien.push_back(koef); 97 | step--; 98 | } 99 | }else{ 100 | std::cerr << "Pilihan tidak valid! Harap masukkan 1 atau 2.\n"; 101 | } 102 | 103 | RegulaFalsi(a, b, Koefisien); 104 | std::cin.get(); 105 | return 0; 106 | } 107 | -------------------------------------------------------------------------------- /math/bisection.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | float equation(float x) { 4 | /** 5 | * hasil dari pengurangan dan perkalian dari 6 | * nilai x 7 | * parameter: 8 | * x(float) 9 | * return: 10 | * hasil dari 10 - x * x 11 | */ 12 | return 10 - x * x; 13 | } 14 | 15 | float bisection(float a, float b) { 16 | /** 17 | * diberikan fungsi pada bilangan float f(x) dan dua bilangan 18 | * float 'a' dan 'b' sedimikian sehingga 19 | * f(a) * f(b) < 0 dan f(x) kontinu di [a, b] 20 | * disini f(x) memiliki persamaan aljabar atau transendental 21 | */ 22 | // menggunakan teori bolzano 23 | if (equation(a) * equation(b) >= 0) { 24 | std::cout << "0" << std::endl; 25 | } 26 | 27 | float c = a; 28 | while ((b - a) >= 0.01) { 29 | c = (a + b) / 2; 30 | if (equation(c) == 0.0) { 31 | break; 32 | } 33 | if (equation(c) * equation(a) < 0) { 34 | b = c; 35 | } else { 36 | a = c; 37 | } 38 | } 39 | return c; 40 | } 41 | 42 | int main() { 43 | // testing hasil code 44 | float hasil1 = bisection(-2, 5); 45 | float hasil2 = bisection(0, 6); 46 | std::cout << "hasil pengujian 1: " << hasil1 << std::endl; 47 | std::cout << "hasil pengujian 2: " << hasil2 << std::endl; 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /math/cek_faktorial.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | /** 6 | * Program sederhana untuk mengecek faktorial 7 | * Rumusnya adalah 8 | * n! = n *(n - 1) 9 | * Contoh sederhana 10 | * 5! = 5 x 4 x 3 x 2 x 1 = 120 11 | */ 12 | 13 | /** 14 | * Fungsi ``adalah_faktorial`` 15 | * @param n angka faktorial yang ingin di cek 16 | * @return jika faktorial maka kembali nilai true 17 | */ 18 | bool adalah_faktorial(std::uint64_t n) { 19 | if (n <= 0) { 20 | return false; 21 | } 22 | for (std::uint32_t i = 1;; i++) { 23 | if (n % i != 0) { 24 | break; 25 | } 26 | n = n / i; 27 | } 28 | if (n == 1) { 29 | return true; 30 | } else { 31 | return false; 32 | } 33 | } 34 | 35 | void test() { 36 | /** 37 | * Fungsi ini adalah untuk mengetes hasil dari 38 | * fungsi ``adalah_faktorial()`` 39 | */ 40 | std::cout<<"test, angka = 50\n"; 41 | assert(adalah_faktorial(50) == false); 42 | std::cout<<"pass\n"; 43 | 44 | std::cout<<"test, angka = 479001600\n"; 45 | assert(adalah_faktorial(479001600) == true); 46 | std::cout<<"pass\n"; 47 | } 48 | 49 | int main() { 50 | test(); 51 | return 0; 52 | } 53 | 54 | -------------------------------------------------------------------------------- /math/cek_prima.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * program sederhana mengecek bilangan prima pada suatu 3 | * input program 4 | */ 5 | #include 6 | #include 7 | 8 | template bool bilangan_prima(T angka) { 9 | bool hasil = true; 10 | 11 | if (angka <= 1) { 12 | return false; 13 | } else if (angka == 2 || angka == 3) { 14 | return true; 15 | } else if ((angka % 2) == 0 || angka % 3 == 0) { 16 | return false; 17 | } else { 18 | for (T i = 5; (i * i) <= (angka); i = (i + 6)) { 19 | if ((angka % 1) == 0 || (angka % (i + 2) == 0)) { 20 | hasil = false; 21 | break; 22 | } 23 | } 24 | } 25 | return (hasil); 26 | } 27 | 28 | int main() { 29 | assert(bilangan_prima(1) == false); 30 | assert(bilangan_prima(947) == true); 31 | assert(bilangan_prima(757) == true); 32 | 33 | int angka = 0; 34 | std::cout << "masukkan angka: "; 35 | std::cin >> angka; 36 | bool hasil = bilangan_prima(angka); 37 | if (hasil) { 38 | std::cout << angka << " adalah bilangan prima" << std::endl; 39 | } else { 40 | std::cout << angka << " bukan bilangan prima" << std::endl; 41 | } 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /math/cos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | /** 7 | * @file cos.cpp 8 | * @brief fungsi untuk mengetahui Cos nilai output dengan 9 | * menggunakan algoritma 10 | */ 11 | 12 | 13 | int factorial(int n){ 14 | if (n<0){ 15 | throw std::invalid_argument("Angka faktorial harus real"); 16 | } 17 | else if (n==0 or n==1){ 18 | return 1; 19 | } 20 | else{ 21 | return n * factorial(n-1); 22 | } 23 | } 24 | 25 | 26 | /** 27 | * @brief fungsi untuk mengetahui nilai cosinus pada titik 28 | * dengan menggunakan algoritma taylor series 29 | * @param sudut merupakan titik input untuk mengetahui 30 | * nilai cos dari titik tersebut 31 | * @param iterable merupakan jumlah perulangan perjumlah yang dilakukan 32 | * default 4 33 | * @return hasilnya berupa angka decimal 34 | */ 35 | 36 | 37 | template double cosinus(T sudut,int iterable=4){ 38 | double result = 0.0; 39 | for (int n = 0; n <= iterable; ++n){ 40 | double numerator = pow(-1,n) * pow(sudut,2*n); 41 | double denumerator = factorial(2*n); 42 | result =result + (numerator/denumerator); 43 | } 44 | return result; 45 | } 46 | 47 | 48 | int main(){ 49 | // testing 50 | std::vector list_sudut ={M_PI,M_PI/2,M_PI * 3/4}; 51 | for(int i =0;i 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | /** 14 | * @brief fungsi untuk menghitung mengetahui persamaan 15 | * persamaan linear dengan menentukan gradien dan interpreted 16 | * @param x merupakan input data bebas (independent) 17 | * @param y merupakan input data kaku (dependent) 18 | * @throw invalid_argument panjang data 19 | * @return berupa vector isinya interpreted dan coeffient 20 | */ 21 | 22 | template std::vector persamaan_garis(const std::vector&x,const std::vector&y){ 23 | if (x.size()!=y.size()){ 24 | throw std::invalid_argument("Ukurannya tidak pas"); 25 | } 26 | int n=x.size(); 27 | std::vectorresult; 28 | std::vectorx_2; 29 | std::vectory_2; 30 | std::vectorxy; 31 | // pangkat x 32 | for(int i=0;ix={1,3,4,5,8}; 59 | std::vectory={4,2,1,0,0}; 60 | std::vectorpersamaan=persamaan_garis(x,y); 61 | std::cout<<"vector values:"; 62 | for(const auto& value:persamaan){ 63 | std::cout< persamaan=persamaan_garis(x,y); 73 | for(const auto& value : persamaan){ 74 | std::cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | template 9 | double perpangkatan_rekursif(T a, T b){ 10 | if (b < 0) 11 | return 1.0 / perpangkatan_rekursif(a, -b); 12 | 13 | if (b == 0) 14 | return 1; 15 | 16 | T bwh = perpangkatan_rekursif(a, b >> 1); 17 | 18 | double hasil; 19 | if ((b & 1) == 0) 20 | hasil = bwh * bwh; 21 | else 22 | hasil = bwh * bwh * a; 23 | 24 | return hasil; 25 | } 26 | 27 | template 28 | double perpangkatan_linear(T a, T b){ 29 | if (b < 0) 30 | return 1.0 / perpangkatan_linear(a, -b); 31 | 32 | double hasil = 1; 33 | while(b){ 34 | if (b & 1) 35 | hasil = hasil * a; 36 | a = a * a; 37 | b = b >> 1; 38 | } 39 | 40 | return hasil; 41 | } 42 | 43 | int main(){ 44 | std::srand(std::time(nullptr)); 45 | std::ios_base::sync_with_stdio(false); 46 | 47 | std::cout<<"test perpangkatan .."<> n; 64 | assert(n >= 0); 65 | std::cout << "F(" << n << ") = " << fibonacci(n) << std::endl; 66 | } 67 | -------------------------------------------------------------------------------- /math/ganjil_genap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]){ 4 | std::string input; 5 | 6 | std::cout<<"Masukan angka: "; 7 | std::cin>>input; 8 | 9 | // Setiap karakter akan diperiksa untuk memastikan bahwa input harus berupa angka. 10 | for (const auto& itr : input){ 11 | if (!(itr >= '0' && itr <= '9')){ 12 | std::cout<<"Input harus angka!"; 13 | return 7; // Nilai 7 biasanya menunjukkan adanya kesalahan dalam program. 14 | } 15 | } 16 | 17 | int parseInt = stoi(input); // Konversi string input menjadi integer dan menyimpannya ke variabel parseInt. 18 | if (parseInt % 2 == 0){ 19 | std::cout<<"Ini adalah bilangan genap."; 20 | } else { 21 | std::cout<<"Ini adalah bilangan ganjil."; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /math/mean_absolute_error.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file mean_absoulte_eror.cpp 3 | * @brief Program ini merupakan untuk 4 | * menghitung Mean Absolute Error dari 5 | * 2 array dengan panjang yang sama 6 | */ 7 | #include 8 | #include 9 | #include 10 | #include 11 | /** 12 | * @brief Fungsi mae untuk menghitung mean Absolute Error 13 | * yang bertujuan mengetahui berapa akurasi error pada model 14 | * data yang kita latih 15 | * 16 | */ 17 | double mae(const std::vector &predict,const std::vector&actual){ 18 | if (predict.size() != actual.size()){ 19 | throw std::invalid_argument("panjang datanya tidak sama\ntolong check lagi"); 20 | } 21 | double abs_sum=0.0; 22 | for(int i=0;i predict; 33 | std::vector actual; 34 | 35 | predict={1.2,3.1,2.1,0.2,3.1}; 36 | actual={1,3.0,2.2,0.5,2.1}; 37 | std::cout<<"MAE :"< 2 | #include 3 | #include 4 | double mean_absolute_percentage_error(const std::vector&data_predict,const std::vector&data_actual){ 5 | // mengcheck panjang datanya 6 | if (data_predict.size() != data_actual.size()) 7 | { 8 | throw std::invalid_argument("ukuran datanya harus sama ya!!\n"); 9 | } 10 | double sum_abs=0.0; 11 | for (int i=0;i data_prediksi; 26 | std::vector data_asli={1.2,3.1,2.11,3.1}; 27 | data_prediksi={1.2,3.1,2.1,2.2}; 28 | data_asli={1.2,3.1,2.11,3.1}; 29 | // output 30 | std::cout<<"hasil MAPE adalah"<(arr1.size()); 42 | // hitung mean dari squared error sum dan return hasil nya 43 | double mean_squared_error = error_sum / n; 44 | return mean_squared_error; 45 | } 46 | 47 | int main() { 48 | std::vector predict{}; 49 | std::vector actual{}; 50 | 51 | predict = {1.5, 5.1, 7.3, 7.7, 8.0, 3.9}; 52 | actual = {2.5, 3.4, 7.0, 7.4, 7.8, 3.9}; 53 | std::cout << "MSE: " << mse(predict, actual) << '\n'; 54 | 55 | // test to throw an exception 56 | try { 57 | predict = {7.5, 4.5, 3.2}; 58 | actual = {7.1, 5.5}; 59 | 60 | std::cout << "MSE: " << mse(predict, actual) << '\n'; 61 | } catch (const std::exception& e) { 62 | std::cerr << e.what() << '\n'; 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /math/quadratic_formula.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file quadratic_formula.cpp 3 | */ 4 | 5 | #include 6 | #include 7 | 8 | /** 9 | * @brief program ini merupakan untuk check apakah 10 | * parameter a,b,c untuk mengatur equation tersebut 11 | * @param a equation a 12 | * @param b equation b 13 | * @param c equation c 14 | */ 15 | void quadratic_formula(int a,int b,int c){ 16 | if (a != 0){ 17 | float descriminant=(pow(b,b)-(4 * a *c)); 18 | if (descriminant>0){ 19 | float x1=(-b + sqrt(descriminant))/(2 * a); 20 | float x2=(-b - sqrt(descriminant))/(2 * a); 21 | std::cout<<"X1="< 2 | #include 3 | #include 4 | #include 5 | 6 | /** 7 | * algoritma yang menentukan apakah suatu 8 | * bilangan yang diberikan cenderung prima 9 | * mirip dengan model uji primalitas fermat 10 | * dan rumus solovay strassen 11 | */ 12 | template std::vector reverse_biner(T angka) { 13 | std::vector hasil; 14 | T temp = angka; 15 | while (temp > 0) { 16 | hasil.push_back(temp % 2); 17 | temp = temp / 2; 18 | } 19 | return hasil; 20 | } 21 | 22 | /** 23 | * fungsi eksponen modul 24 | * untuk memberikan hasil masalah 25 | * eksponensial modular dengan relatif cepat 26 | */ 27 | template 28 | T modular_eksponen(T base, const std::vector &eksponen_biner, T modulus) { 29 | if (modulus == 1) { 30 | return 0; 31 | } 32 | T b = 1; 33 | if (eksponen_biner.size() == 0) { 34 | return b; 35 | } 36 | T A = base; 37 | if (eksponen_biner[0] == 1) { 38 | b = base; 39 | } 40 | 41 | for (typename std::vector::const_iterator iterator = 42 | eksponen_biner.cbegin() + 1; 43 | iterator != eksponen_biner.cend(); ++iterator) { 44 | A = A * A % modulus; 45 | if (*iterator == 1) { 46 | b = A * b % modulus; 47 | } 48 | } 49 | return b; 50 | } 51 | 52 | /** 53 | * fungsi untuk mengetes fungsi diatas 54 | */ 55 | template bool testing(T d, T angka) { 56 | std::random_device rd_seed; 57 | std::mt19937 gen(rd_seed()); 58 | std::uniform_int_distribution<> distribution(2, angka - 2); 59 | T random = distribution(gen); 60 | std::vector pangkat = reverse_biner(d); 61 | T x = modular_eksponen(random, pangkat, angka); 62 | if (x == 1 || x == angka - 1) { 63 | return true; 64 | } 65 | 66 | while (d != angka - 1) { 67 | x = (x * x) % angka; 68 | d *= 2; 69 | if (x == 1) { 70 | return false; 71 | } 72 | if (x == angka - 1) { 73 | return true; 74 | } 75 | } 76 | return false; 77 | } 78 | 79 | template bool testing_rabin_miller(T angka, T perulangan) { 80 | if (angka <= 4) { 81 | if (angka == 2 || angka == 3) { 82 | return true; 83 | } else { 84 | return false; 85 | } 86 | } 87 | if (angka % 2 == 0) { 88 | return false; 89 | } 90 | 91 | T d = angka - 1, r = 0; 92 | while (d % 2 == 0) { 93 | d = d / 2; 94 | r++; 95 | } 96 | 97 | for (T i = 0; i < perulangan; ++i) { 98 | if (!testing(d, angka)) { 99 | return false; 100 | } 101 | } 102 | return true; 103 | } 104 | 105 | int main() { testing_rabin_miller(2, 1); } 106 | -------------------------------------------------------------------------------- /math/radian.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file radian.cpp 3 | * @brief program ini adalah untuk menghitung covert satuan 4 | * sudut seperti radian,degree dan gradian 5 | */ 6 | 7 | #include 8 | #include 9 | /** 10 | * @brief fungsi ini merupakan untuk mengubah dari 11 | * satuan radian kedalam bentuk satuan degree 12 | * @param radian parameter ini adalah nilai 13 | * input dalam bentuk satuan radian 14 | */ 15 | 16 | double radian_to_degree(float radian){ 17 | return radian *(180/M_PI); 18 | } 19 | /** 20 | * @brief fungsi ini merupakan untuk mengubah dari 21 | * satuan derajat ke dalam radian 22 | * @param degree parameter ini merupakan nilai 23 | * input dalam bentuk satuan degree 24 | */ 25 | 26 | double degree_to_radian(float degree){ 27 | return degree * (M_PI/180); 28 | } 29 | 30 | /** 31 | * @brief fungsi ini merupakan untuk mengubah dari 32 | * satuan radian kedalah bentuk gradian 33 | * @param radian merupakan input parameter dalam 34 | * satuan radian 35 | */ 36 | 37 | double radian_to_gradian(float radian){ 38 | return radian * (200/M_PI); 39 | } 40 | 41 | int main(){ 42 | // mari kita check 43 | std::cout<<"Convert dari radian ke degree"<< radian_to_degree(20.1)<<'\n'; 44 | std::cout<<"Convert dari degree ke radian"<< degree_to_radian(12.0)<<'\n'; 45 | std::cout<<"Convert dari radian ke gradian"<< radian_to_gradian(122.12)<<'\n'; 46 | return 0; 47 | } 48 | 49 | -------------------------------------------------------------------------------- /math/relu.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | /** 5 | * @file relu.cpp 6 | * @brief program ini untuk menghitung 7 | * Relu yang merupakan salah satu dari fungsi aktivasi 8 | * yang digunakan pada project Machine Learning dan Deep Learning 9 | * cara kerja ini mengambil nilai 0 apabila input nilai 10 | * kurang dari sama dengan 0 11 | */ 12 | float relu(float n){ 13 | /** 14 | * @brief Fungsi Relu untuk mengfilter inputnya 15 | * yang mana yang nilai lebih dari 0.0 dan mana yang 16 | * kurang dari 0.0 17 | * @param n ini merupakan variabel input nilai 18 | */ 19 | 20 | // ini kondisi untuk mengfilter inputnya 21 | if (n > 0.0){ 22 | return n; 23 | }else{ 24 | return 0.0; 25 | } 26 | } 27 | 28 | int main(){ 29 | // mari kita ujikan dengan lebih dari 0; 30 | std::cout< 2 | #include // Untuk fungsi exp() 3 | /** 4 | * @file sigmoid.cpp 5 | * @brief Program ini menghitung fungsi sigmoid yang digunakan 6 | * pada project Machine Learning dan Deep Learning. 7 | * Fungsi sigmoid akan menghasilkan nilai antara 0 hingga 1 8 | * berdasarkan input. 9 | */ 10 | double sigmoid(double x) { 11 | /** 12 | * @brief Fungsi Sigmoid untuk menghitung nilai aktivasi 13 | * yang berada di antara 0 hingga 1. 14 | * @param x ini merupakan variabel input nilai. 15 | * Nilai yang diberikan adalah tipe double dan hasilnya 16 | * berupa nilai sigmoid yang juga dalam tipe double. 17 | * @return Mengembalikan nilai sigmoid dari input x. 18 | */ 19 | return 1.0 / (1.0 + exp(-x)); // Rumus sigmoid 20 | } 21 | 22 | int main() { 23 | double x; 24 | std::cout << "Masukkan angka: "; 25 | std::cin >> x; 26 | 27 | // Memanggil fungsi sigmoid dan menampilkan hasilnya 28 | double result = sigmoid(x); 29 | std::cout << "Hasil Sigmoid: " << result << std::endl; 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /math/variance.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file variance.cpp 3 | * @brief Program untuk menghitung 4 | * Variance data (Var) dari banyaknya item 5 | * dengan panjang data 6 | */ 7 | 8 | #include 9 | #include 10 | /** 11 | * @brief Fungsi untuk menghitung Variansi data 12 | * dari sebuah data array biasa dan dibagi panjang 13 | * datanya sehingga bisa melihat karakteristik data 14 | * @param data adalah data berupa array biasa 15 | * @param n merupakan nama variabel dari panjang data 16 | * @return merupakan hasil dari perhitungan tersebut 17 | */ 18 | 19 | float variance(const std::vector&data,int n){ 20 | // kita buat variabel sum untuk 21 | // menampung hasil perjumlahan pada 22 | // data tersebut 23 | int sum=0; 24 | for(size_t i=0;i (sum) / n; 31 | // mari kita kalkulasi variance dengan 32 | // perulangan for loop 33 | 34 | // mari kita buat variabel variance 35 | // untuk menampung hasil kalkulasi 36 | // variance pada looping tersebut 37 | float variance=0.0; 38 | for(size_t i=0;i data; 51 | data={1,2,4}; 52 | int n=data.size(); 53 | std::cout<<"variasi"< 9 | #include 10 | 11 | double volume_kubus(float sisi){ 12 | /** 13 | * fungsi untuk menghitung volume kubus 14 | * @param sisi merupakan input sisi yang 15 | * bertipe data double dengan panjang datanya 16 | * lebih besar 17 | * @return hasil pangkat dari sisi pangkat 3 18 | */ 19 | return std::pow(sisi,3.0); 20 | } 21 | 22 | double volume_balok(double panjang,double lebar,double tinggi){ 23 | /** 24 | * fungsi ini menghitung volume balok 25 | * @param panjang merupakan input panjang sebuah balok 26 | * @param lebar merupakan input lebar sebuah balok 27 | * @param tinggi merupakan input tinggi sebuah balok 28 | * @return hasil dari perkalian panjang,lebar dan tinggi 29 | */ 30 | return panjang * lebar * tinggi; 31 | } 32 | 33 | double volume_kerucut(double area_dasar,double tinggi){ 34 | /** 35 | * fungsi ini menghitung volume kerucut 36 | * @see [cone](https://en.wikipedia.org/wiki/Cone) 37 | * @param area_dasar merupakan input area dasar sebuah kerucut 38 | * @param tinggi merupakan input lebar sebuah kerucut 39 | * @return hasil dari perkalian area dasar dan tinggi dibagi 3 40 | */ 41 | return area_dasar * tinggi /3.0; 42 | } 43 | double volume_tabung(double jari_jari,double tinggi){ 44 | /** 45 | * fungsi ini menghitung volume tabung 46 | * @see [cone](https://en.wikipedia.org/wiki/Cone) 47 | * @param jari merupakan input jari jari pada luas area 48 | * @param tinggi merupakan input panjangnya tinggi tersebut 49 | * @return hasil dari perkalian luas lingkaran dan tinggi 50 | */ 51 | return M_PI * pow(jari_jari,2.0) * tinggi; 52 | } 53 | double volume_bola(double jari){ 54 | /** 55 | * fungsi ini menghitung volume bola 56 | * @param jari merupakan input dari jari-jari yang dimiliki bola 57 | * return hasil dari perkalian dengan rumus V = \frac{4}{3}\pi r^3 58 | * */ 59 | return (4/3) * M_PI * pow(jari,3.0); 60 | } 61 | 62 | int main(){ 63 | std::cout<<"Volume Bola"< 2 | #include 3 | #include 4 | 5 | 6 | bool Verification(std::vector& data,int &x){ 7 | for(int i = 0;i <= data.size() - 1; i++){ 8 | if(x == data[i]){ 9 | return true; 10 | } 11 | } 12 | return false; 13 | } 14 | 15 | void Z_Score(std::vector& data,int &x){ 16 | //mean 17 | int resultMean; 18 | int Sum = 0; 19 | for(int i = 0; i <= data.size() - 1;i++){ 20 | Sum += data[i]; 21 | } 22 | resultMean = Sum / data.size(); 23 | std::cout << "Nilai rata-rata: " << resultMean << std::endl; 24 | 25 | //standart deviation 26 | int denominator = data.size() - 1; 27 | int numerator; 28 | float Standar_Dev; 29 | float sum_numerator = 0; 30 | for(int i = 0; i <= data.size() - 1;i++){ 31 | int numerator = sqrt((data[i] - resultMean) * (data[i] - resultMean)); //sqrt(pow((data[i] - mean))); 32 | sum_numerator += numerator; 33 | } 34 | 35 | Standar_Dev = static_cast(sum_numerator) / denominator; 36 | std::cout << "nilai Standar Deviation: " << Standar_Dev << std::endl; 37 | 38 | 39 | 40 | // Z score 41 | double score; 42 | score = (x - resultMean) / Standar_Dev; 43 | std::cout << "Nilai Z-Score: " << score << std::endl; 44 | } 45 | int main(){ 46 | int value,count,x; 47 | std::vector data; 48 | std::cout << "Masukkan panjang data: "; //masukkan panjang data 49 | std::cin >> count; 50 | 51 | for(int i = 0; i <= count - 1; i++){ // for untuk memasukkan data satu per satu 52 | std::cout << "Masukkan data ke " << i + 1 << ": "; 53 | std::cin >> value; 54 | 55 | data.push_back(value); //masukkan data yang di input di variabel value; 56 | } 57 | std::cout << "Masukkan nilai data(x): "; 58 | std::cin >> x; 59 | 60 | if(Verification(data,x)){ 61 | std::cout << "Nilai yang anda masukkan sudah benar! " << std::endl; 62 | }else{ 63 | std::cout << "data yang anda masukkan salah! \n"; 64 | std::cout << "Masukkan nilai kembali: "; 65 | std::cin >> x; 66 | } 67 | Z_Score(data,x); 68 | 69 | } -------------------------------------------------------------------------------- /object_oriented_programming/basic/00_definisi_kelas/class_definition.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class Pelajar{ 4 | // membuat akses ke atribut 5 | public: 6 | int id_mhs; 7 | void detail_mhs(){ 8 | // membuat fungsi yang akan menampilkan detail pelajar 9 | std::cout << "ID: " << id_mhs << std::endl; 10 | } 11 | }; 12 | 13 | int main(){ 14 | // memanggil kelas dan menjadikan sebagai objek 15 | Pelajar mhs1; 16 | Pelajar mhs2; 17 | 18 | // membuat akses ke atribut 19 | mhs1.id_mhs = 1; 20 | mhs2.id_mhs = 2; 21 | 22 | // memanggil fungsi 23 | mhs1.detail_mhs(); 24 | mhs2.detail_mhs(); 25 | } -------------------------------------------------------------------------------- /object_oriented_programming/basic/00_definisi_kelas/readme.md: -------------------------------------------------------------------------------- 1 | ## definisi kelas 2 | 3 | blok pembangun c++ yang mengarah ke pemograman berorientasi objek adalah kelas. ini adalh tipe data yang ditentukan pengguna yang menyimpan anggota data dan fungsi anggotanya sendiri, yang dapat diakses dan digunakan dengan membat turunan dari kelas itu. kelas seperti cetak biru untuk suatu objek 4 | 5 | - kelas adalah tipe data yang ditentukan pengguna yang memiliki anggota data dan fungsi anggota 6 | - anggota data adalah variabel data dan fungsi anggota adalah fungsi yang digunakan untuk memanipulasi variabel-variabel ini dan bersama-sama anggota data ini dan fungsi anggota mendifinisikan properti dan perilaku objek di kelas 7 | 8 | kita dapat mengatakan bahwa **kelas dalam c++** adalah etak biru ynag mewakii sekelompok objek yang berbagi beberapa properti dan perilaku umum 9 | 10 | **objek** 11 | 12 | objek adalah entitas yang dapat diidentfikasi dengan beberapa karaterisitik dan perilaku. objek adalh turunan dari kelas. ketika sebuah kelas didefinisikan, tidak ada memmori yang dialokasikan tetapi ketika itu dipakai (yaitu sebuah objek dibuat) memori dialokasikan. 13 | ```cpp 14 | class Pelajar{ 15 | char nama[20]; 16 | int nomo_mhs; 17 | public: 18 | void tentang_mhs(){ 19 | // blok kode dari fungsi yang 20 | // berisikan barisan kode yang memuat 21 | // detail tentang mhs 22 | } 23 | }; 24 | 25 | int main(){ 26 | Pelajar mhs1; // mhs1 adalah sebagai objek 27 | } 28 | ``` 29 | objek mengambil ruang di memori dan memiliki alamt terkait seperti catatan dalam pascal atau struktur atau gabungan dalam C. 30 | 31 | ketika sebuah program diekseskusi, objek beriteraksi dengan mengirim pesan satu sama lain.setiap objek berisi data dan kode untuk memanipulasi data. 32 | 33 | objek dapat berintraksi tanpa harus mengetahui detail data atau kode satu sama lain, cukup mengetahui jenis pesan yang diterima dan jenis respon yang dikembalikan oleh objek. -------------------------------------------------------------------------------- /object_oriented_programming/basic/01_metode_kelas/inner_class.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class KelasSaya { 4 | public: 5 | void metodeSaya() { 6 | std::cout<<"bellshade"; 7 | } 8 | }; 9 | 10 | int main() { 11 | // membuat object dari kelas 12 | KelasSaya objectSaya; 13 | 14 | // memanggil method 15 | objectSaya.metodeSaya(); 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /object_oriented_programming/basic/01_metode_kelas/outer_class.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class KelasSaya { 4 | public: 5 | void metodeSaya(); 6 | }; 7 | 8 | // membuat metode 9 | void KelasSaya::metodeSaya() { 10 | std::cout<<"bellshade"; 11 | } 12 | 13 | int main() { 14 | // membuat object dari kelas 15 | KelasSaya objectSaya; 16 | 17 | // memanggil method 18 | objectSaya.metodeSaya(); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /object_oriented_programming/basic/01_metode_kelas/readme.md: -------------------------------------------------------------------------------- 1 | ## class method 2 | 3 | Metode adalah fungsi yang dimiliki oleh kelas 4 | 5 | ada dua cara untuk mendifinisikan fungsi yang termasuk dalam kelas: 6 | - block di dalam kelas 7 | - block di luar kelas 8 | 9 | ## inner class 10 | 11 | ketika kita mengakses sebuah atribut yang terdapat dalam kelas, maka kita menggunakan fungsi titik ``.``: contoh 12 | 13 | ```cpp 14 | class KelasSaya { 15 | public: 16 | void methodSaya() { 17 | std::cout<<"bellshade"; 18 | } 19 | }; 20 | 21 | int main() { 22 | KelasSaya objectSaya; 23 | objectSaya.methodSaya(); 24 | 25 | return 0; 26 | } 27 | ``` 28 | 29 | ## outer class 30 | 31 | untuk mendifinisikan fungsi di luar kelas, kita harus mendklarasikannya di dalam kelas dan kemudian mendifinisikannya di luar kelas. ini dilakukan dengan menentukan nama kelas, diikuti operator ``::`` dan diikuti dengan nama fungsi 32 | 33 | ```cpp 34 | class KelasSaya { 35 | public: 36 | void methodSaya(); 37 | }; 38 | 39 | // mendklarasikan kembali 40 | void KelasSaya::methodSaya() { 41 | std::cout<<"bellshade"; 42 | } 43 | 44 | int main() { 45 | KelasSaya objectSaya; 46 | objectSaya.methodSaya(); 47 | 48 | return 0; 49 | } 50 | ``` -------------------------------------------------------------------------------- /object_oriented_programming/intermediate/01_inheritance/inheritance.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | class Kecepatan{ 3 | public: 4 | void setJarak(int j){ 5 | jarak = j; 6 | } 7 | void setWaktu(int w){ 8 | waktu = w; 9 | } 10 | protected: 11 | int jarak; 12 | int waktu; 13 | }; 14 | 15 | class Kalkulasi: public Kecepatan{ 16 | public: 17 | int getKecepatan(){ 18 | return (jarak / waktu); 19 | } 20 | }; 21 | 22 | int main(void){ 23 | Kalkulasi kalkulasi; 24 | kalkulasi.setJarak(17); 25 | kalkulasi.setWaktu(5); 26 | 27 | std::cout<<"total: "< 15 | 16 | class Kecepatan{ 17 | public: 18 | void setJarak(int j){ 19 | jarak = j 20 | } 21 | void setWaktu(int w){ 22 | waktu = w 23 | } 24 | protected: 25 | int jarak; 26 | int waktu; 27 | }; 28 | 29 | class Kalkulasi: public Kecepatan{ 30 | public: 31 | int getKecepatan(){ 32 | return (jarak / waktu) 33 | } 34 | }; 35 | 36 | int main(){ 37 | Kecepatan kecepatan; 38 | kecepatan.setJarak(17); 39 | kecepatan.setWaktu(5); 40 | 41 | std::cout<<"total: "< 2 | 3 | class Tambah{ 4 | public: 5 | // membuat konstruktor 6 | Tambah(int i = 0){ 7 | total = i; 8 | } 9 | 10 | // interface dari luar 11 | void tambahAngka(int angka){ 12 | total += angka; 13 | } 14 | 15 | int getTotal(){ 16 | return total; 17 | } 18 | 19 | private: 20 | // membuat data yang bersifat non publik 21 | int total; 22 | }; 23 | 24 | int main(){ 25 | // memanggil kelas 26 | // dan membuat objek baru 27 | Tambah a; 28 | 29 | // memanggil fungsi tambah angka 30 | a.tambahAngka(2); 31 | a.tambahAngka(3); 32 | a.tambahAngka(5); 33 | 34 | std::cout<<"total "< 15 | 16 | int main(){ 17 | std::cout<<"bellshade cpp"; 18 | 19 | return 0; 20 | } 21 | ``` 22 | 23 | ## manfaat dari abstraksi 24 | abstraksi data memberikan dua keuntungan penting 25 | - internalkelasdilindungi dari kesalahan tingkat pengguna yang tidakd isengaja yangmungkin merusak status objek. 26 | 27 | - implementasikelas dapat berkembangdari waktuke waktu sebagai tanggapan terhadap perubahan persyaratan atau laporan bug tanpa memerlukan perubahan kode tingkat pengguna 28 | 29 | dengan mendifinisikananggotadata hanya di bagian pribadi kelas, pembuat kelasbebas untuk membuat perubahan pada data. jika implementasi berubah hanya kode kelas yang perlu diperiksa untuk melihat apa yagn mempengaruhi perubahan tersebut. jika data bersifatpublik,maka fungsi apa pun yagn secara langsung mengakses anggota d ata dari representasi lama mungkin akan rusak. 30 | 31 | setiap program c++ di mana kita mengimplementasikan kelas dengan anggota publik dan pribadi adalah contoh dari abstraksi data 32 | 33 | ```cpp 34 | #include 35 | 36 | class Tambah{ 37 | public: 38 | // membuat konstruktor 39 | Tambah(int i = 0){ 40 | total = i; 41 | } 42 | 43 | // interface dari luar 44 | void tambahAngka(int angka){ 45 | total += angka; 46 | } 47 | 48 | int getTotal(){ 49 | return total; 50 | } 51 | 52 | private: 53 | // membuat data yang bersifat non publik 54 | int total; 55 | }; 56 | 57 | int main(){ 58 | // memanggil kelas 59 | // dan membuat objek baru 60 | Adder a; 61 | 62 | // memanggil fungsi tambah angka 63 | a.tambahAngka(2); 64 | a.tambahAngka(3); 65 | a.tambahAngka(5); 66 | 67 | std::cout<<"total "< 2 | 3 | class Tambah{ 4 | // akses kelas 5 | public: 6 | // konstruktor 7 | Tambah(int i = 0){ 8 | total = i; 9 | } 10 | 11 | // interface untuk diluar 12 | void tambahAngka(int angka){ 13 | total += angka; 14 | } 15 | 16 | // interface untuk diluar 17 | int getTotal(){ 18 | return total; 19 | }; 20 | 21 | // akses kelas 22 | private: 23 | // data yang tidak bisa 24 | // diakses 25 | int total; 26 | }; 27 | 28 | int main(){ 29 | Tambah a; 30 | 31 | a.tambahAngka(10); 32 | a.tambahAngka(12); 33 | 34 | std::cout<<"total "< 34 | 35 | class Tambah{ 36 | // akses kelas 37 | public: 38 | // konstruktor 39 | Tambah(int i = 0){ 40 | total = i; 41 | } 42 | 43 | // interface untuk diluar 44 | void tambahAngka(int angka){ 45 | total += angka; 46 | } 47 | 48 | // interface untuk diluar 49 | int getTotal(){ 50 | return total; 51 | }; 52 | 53 | // akses kelas 54 | private: 55 | // data yang tidak bisa 56 | // diakses 57 | int total; 58 | }; 59 | 60 | int main(){ 61 | Tambah a; 62 | 63 | a.tambahAngka(10); 64 | a.tambahAngka(12); 65 | 66 | std::cout<<"total "< 2 | 3 | // membuat kelas bentuk 4 | class Bentuk{ 5 | // akses modifikasi 6 | protected: 7 | // membuat atribut 8 | int lebar, tinggi; 9 | 10 | // akses modfikasi 11 | public: 12 | // membuat konstruktor 13 | Bentuk(int a = 0, int b = 0){ 14 | lebar = a; 15 | tinggi = b; 16 | } 17 | 18 | // membuat fungsi dinamis menggunakan kata kunci 19 | // virtual 20 | virtual int area(){ 21 | std::cout<<"parent class area :"<area(); 62 | 63 | // menyimpan address dari segitiga 64 | bentuk = &segitiga; 65 | 66 | //memanggil segitiga 67 | bentuk->area(); 68 | 69 | return 0; 70 | } -------------------------------------------------------------------------------- /object_oriented_programming/readme.md: -------------------------------------------------------------------------------- 1 | # object oriented programming 2 | bahasa pemograman muncul terus menerus, dan begitu pula metodologi yang berbebda.Pemograman berorientasi objek adalah salah satu metodologi yang telah menjadi sangat populer selamat beberapa tahun terakhir. 3 | 4 | di materi ini membahas tentang fitur-fitur bahasa pemograman python yang menjadikannya bahasa pemograman berorientasi objek. 5 | 6 | ## apa itu pemograman berorientasi objek 7 | **berorientasi objek** berarti diarahkan pada objek, dengan kata lain, itu berarti secara fungsional diarahkan pada pemodelan objek. ini adalh salah satu dari banyak teknik yang digunakan untuk memodelkan sistemyang komples dengan menggambarkan kumpulan objek yang berinteraksi melalui data dan perilakunya. 8 | 9 | ## prosedural vs pemograman berorientasi objek 10 | pemograman berbasis prosedural diturunkan dari pemograman struktural berdasarkan konsep fungsi / prosedur / rutin. sangat mudah untuk mengakses dan mengubah data dalam pemograman berorientasi prosedural. di sisi lain, objek oriented programming (OOP) memungkinkan penguraian masalah menjadi sejumlah unit yang disebut objek dan kemudian membangun data dan fungsi di sekitar objek-objek tersebut. ini lebih menekankan pada data daripada prosedur atau fungsi. juga di OOP, data disembunyikan dan tidak dapat diakses oleh prosedur eksternal. 11 | 12 | ## prinsip dasar pemograman berorientasi objek 13 | Pemrograman Berorientasi Objek (OOP) didasarkan pada konsep objek daripada tindakan, dan data daripada logika. Agar bahasa pemrograman berorientasi objek, ia harus memiliki mekanisme untuk memungkinkan bekerja dengan kelas dan objek serta penerapan dan penggunaan prinsip dan konsep dasar berorientasi objek yaitu pewarisan, abstraksi, enkapsulasi, dan polimorfisme. 14 | 15 | - **enkapsulasi (encapsulation)** 16 | 17 | Properti ini menyembunyikan detail yang tidak perlu dan membuatnya lebih mudah untuk mengelola struktur program. Setiap implementasi dan status objek tersembunyi di balik batasan yang ditentukan dengan baik dan menyediakan antarmuka yang bersih dan sederhana untuk bekerja dengannya. Salah satu cara untuk mencapai ini adalah dengan membuat data pribadi. 18 | 19 | - **warisan (inheritance)** 20 | 21 | Warisan, juga disebut generalisasi, memungkinkan kita untuk menangkap hubungan hierarkis antara kelas dan objek. Misalnya, 'buah' adalah generalisasi dari 'jeruk'. Warisan sangat berguna dari perspektif penggunaan kembali kode. 22 | 23 | - **absktraksi (abstaction)** 24 | 25 | Properti ini memungkinkan kita untuk menyembunyikan detail dan hanya mengekspos fitur penting dari sebuah konsep atau objek. Misalnya, seseorang yang mengendarai skuter tahu bahwa saat menekan klakson, suara akan keluar, tetapi dia tidak tahu bagaimana sebenarnya suara itu dihasilkan saat menekan klakson. 26 | 27 | - **polimofisme (polymorphism)** 28 | 29 | Polimorfisme berarti banyak bentuk. Artinya, suatu hal atau tindakan hadir dalam berbagai bentuk atau cara. Salah satu contoh polimorfisme yang baik adalah overloading konstruktor di kelas. 30 | 31 | ## cpp berorientasi objek 32 | inti dari pemograman python adalah objek dan OOP. namun kita tidak perlu membatasi diri untuk menggunakan OOP dengan mengatur kode anda ke dalam kelas. OOP menambah keseluruhan filosofi desain python dan mendorong cara pemograman yang bersih dan pragmatis. OOP juga memungkinkan dalam menulis program yang lebih besar dan kompleks. 33 | -------------------------------------------------------------------------------- /renovate.json: -------------------------------------------------------------------------------- 1 | { 2 | "extends": [ 3 | "config:base" 4 | ] 5 | } 6 | -------------------------------------------------------------------------------- /strings/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) 2 | foreach( testsourcefile ${APP_SOURCES} ) 3 | string( REPLACE ".cpp" "" testname ${testsourcefile} ) 4 | add_executable( ${testname} ${testsourcefile} ) 5 | 6 | set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) 7 | if(OpenMP_CXX_FOUND) 8 | target_link_libraries(${testname} OpenMP::OpenMP_CXX) 9 | endif() 10 | install(TARGETS ${testname} DESTINATION "bin/math") 11 | endforeach( testsourcefile ${APP_SOURCES} ) -------------------------------------------------------------------------------- /struktur_data/binary_search_tree/readme.md: -------------------------------------------------------------------------------- 1 | # binary search tree 2 | 3 | binary search tree (BST) adalah struktur data yagn mengadopsi konsep binary tree namun terdapat aturan bahwa setiap child node sebelah kiri selalu lebih kecil nilainya daripada root node. begitu pula sebaliknya setiap child node sebelah kanan selalu lebih besar nilainya daripada root node. 4 | 5 | tujuan untuk membedakan kiri dan kanan sesuai besaran nilainya, ialah untuk memberikan efisiensi terhadap proses searching. kalau struktur data tree sudah tersusun rapi sesuai dengan aturanya, maka proses search akan lebih cepat 6 | 7 | contoh dari binary search tree 8 | - setiap child node sebelah kiri harus lebih kecil nilainya daripada root nodenya. 9 | - setiap child node sebelah kanan harus lebih besar nilai daripada root nodenya 10 | 11 | **ada 3 jenis cara untuk melakukan penulusuran data pada bst** 12 | 13 | - preOrder: print data, telusur ke kiri, telusur ke kanan 14 | - inOrder: telusur ke kiri, print data telusur ke kanan 15 | - postOrder: telusur ke kiri, telusur ke kanan, print data 16 | -------------------------------------------------------------------------------- /struktur_data/hash_table/asset/hash_table_chaining.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bellshade/CPP/53659270c2dde663ffbc7e73ed0de2587614defd/struktur_data/hash_table/asset/hash_table_chaining.png -------------------------------------------------------------------------------- /struktur_data/hash_table/asset/hash_table_collision.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bellshade/CPP/53659270c2dde663ffbc7e73ed0de2587614defd/struktur_data/hash_table/asset/hash_table_collision.png -------------------------------------------------------------------------------- /struktur_data/hash_table/asset/hash_table_visualisasi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bellshade/CPP/53659270c2dde663ffbc7e73ed0de2587614defd/struktur_data/hash_table/asset/hash_table_visualisasi.png -------------------------------------------------------------------------------- /struktur_data/hash_table/asset/tabel_hash_kode_demo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bellshade/CPP/53659270c2dde663ffbc7e73ed0de2587614defd/struktur_data/hash_table/asset/tabel_hash_kode_demo.png -------------------------------------------------------------------------------- /struktur_data/hash_table/hash_table.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | // besar array tabel hash 7 | template 8 | class HashTable { 9 | private: 10 | // inisialisasi linked list untuk setiap index array 11 | list tableList[TABLE_SIZE]; 12 | // fungsi hash tabel hash 13 | int getHash(int value) { 14 | return value % TABLE_SIZE; 15 | } 16 | public: 17 | // fungsi untuk menyimpan nilai 18 | void insert(int value) { 19 | int hash = getHash(value); 20 | tableList[hash].push_back(value); 21 | } 22 | // fungsi untuk menghapus nilai 23 | void destroy(int value) { 24 | int hash = getHash(value); 25 | tableList[hash].erase(remove(tableList[hash].begin(), tableList[hash].end(), value), tableList[hash].end()); 26 | } 27 | // fungsi untuk mencari nilai 28 | void search(int value) { 29 | int hash = getHash(value); 30 | list::iterator result = find(tableList[hash].begin(), tableList[hash].end(), value); 31 | if(result != tableList[hash].end()) { 32 | printf("nilai %d ditemukan\n", value); 33 | } else { 34 | printf("nilai %d tidak ditemukan\n", value); 35 | } 36 | } 37 | // fungsi untuk meng-print tabel 38 | void printTable() { 39 | for(int i = 0; i < TABLE_SIZE; i++) { 40 | printf("%d --> ", i); 41 | for (auto const &value : tableList[i]) { 42 | cout << value << ' '; 43 | } 44 | printf("\n"); 45 | } 46 | } 47 | }; 48 | 49 | int main() { 50 | // inisialisasi tabel 51 | HashTable<5> tabelHash; 52 | 53 | // demo insert 54 | tabelHash.insert(21); 55 | tabelHash.insert(32); 56 | tabelHash.insert(19); 57 | printf("Tabel Hash Sebelum Kolisi\n"); 58 | tabelHash.printTable(); 59 | printf("\n"); 60 | 61 | // demo collision 62 | tabelHash.insert(37); 63 | printf("Tabel Hash Sesudah Kolisi\n"); 64 | tabelHash.printTable(); 65 | printf("\n"); 66 | 67 | // demo search 68 | printf("Hasil Pencarian Sebelum Penghapusan\n"); 69 | tabelHash.search(37); 70 | printf("\n"); 71 | 72 | // demo destroy 73 | tabelHash.destroy(37); 74 | printf("Hasil Pencarian Sesudah Penghapusan\n"); 75 | tabelHash.search(37); 76 | tabelHash.printTable(); 77 | printf("\n"); 78 | 79 | return 0; 80 | } -------------------------------------------------------------------------------- /struktur_data/linked_list/linked: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bellshade/CPP/53659270c2dde663ffbc7e73ed0de2587614defd/struktur_data/linked_list/linked -------------------------------------------------------------------------------- /struktur_data/linked_list/linked_list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | // membuat node 5 | class Node { 6 | public: 7 | int value; 8 | Node *next; 9 | }; 10 | 11 | int main() { 12 | Node *head; 13 | Node *pertama = NULL; 14 | Node *kedua = NULL; 15 | Node *ketiga = NULL; 16 | 17 | // alokasi 3 memori 18 | pertama = new Node(); 19 | kedua = new Node(); 20 | ketiga = new Node(); 21 | 22 | // menetapkan memori 23 | pertama -> value = 1; 24 | kedua -> value = 2; 25 | ketiga -> value = 3; 26 | 27 | // koneksi ketiga node 28 | pertama -> next = kedua; 29 | kedua -> next = ketiga; 30 | ketiga -> next = NULL; 31 | 32 | // print dari linked list 33 | head = pertama; 34 | while (head != NULL) { 35 | std::cout<<"node ke: "< value< next; 37 | } 38 | 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /struktur_data/linked_list/linked_list_image.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bellshade/CPP/53659270c2dde663ffbc7e73ed0de2587614defd/struktur_data/linked_list/linked_list_image.jpeg -------------------------------------------------------------------------------- /struktur_data/linked_list/readme.md: -------------------------------------------------------------------------------- 1 | # linked list 2 | 3 | linked list adalah adalah struktur data yang terdiri dari suatu node dan _referensi / pointer_ yang menghubungkan suatu node dengan yang lain. dimana node terakhir memiliki referensi ke _null_. setiap node memiliki data dan referensi ke node selanjutnya (_singly_) dan atau ke node sebelumnya (_doubly_). digunakan sebagai dasar implementasi _stack_ dan _queue_. tidak ada unser _random access_ via indeks seperti array dan setiap operasi hanya perlu operasi sekuensial dari node awal. 4 | 5 | ![linked_list_image](linked_list_image.jpeg) 6 | 7 | enaknya linked list bersifat dinamis secara ukuran, alokasi penggunaan _memory_ yang dibutuhkan pada _run-time_, mudah di implementasikan. akan tetapi kurangnya linked list lebih boros memory, pembacaan node hanya bisa melalui proses sekuensial dari awal. tidak layaknya via index di array. 8 | 9 | ## representasi dari linked list 10 | 11 | setiap simpul dari linked list terdiri dari 12 | 13 | - sebuah item data 14 | - alamat node lain 15 | 16 | kita membungkus item data dari refernsi node berikutnya dalam sebuah struct sebagai 17 | 18 | ```cpp 19 | struct node { 20 | int data; 21 | struct node *next; 22 | }; 23 | ``` 24 | 25 | memahami struktur node linked list adalah kunci untuk memahaminya.setiap node struct memiliki item data dan pointer ke node struct lain. kita buat linked list sederhana dengan tiga item untuk memahami cara kerjanya 26 | 27 | ```cpp 28 | // instalasi node 29 | 30 | struct node *head; 31 | struct node *pertama = NULL; 32 | struct node *kedua = NULL; 33 | struct node *ketiga = NULL; 34 | 35 | // alokasi memori 36 | 37 | pertama = malloc(sizeof(struct node)); 38 | kedua = malloc(sizeof(struct node)); 39 | ketiga = malloc(sizeof(struct node)); 40 | 41 | // menetapkan value data 42 | 43 | pertama -> data = 1; 44 | kedua -> data = 2; 45 | ketiga -> data = 3; 46 | 47 | // membuat koneksi antara node 48 | 49 | pertama -> next = kedua; 50 | kedua -> next = ketiga; 51 | ketiga -> next = NULL; 52 | 53 | // menyimpan alamat dari node pertama kedalam head 54 | 55 | head = pertama; 56 | ``` 57 | 58 | **contoh dari linked list** 59 | 60 | ```cpp 61 | #include 62 | 63 | class Node { 64 | public: 65 | int value; 66 | Node *next; 67 | }; 68 | 69 | int main() { 70 | Node *head; 71 | Node *pertama = NULL; 72 | Node *kedua = NULL; 73 | Node *ketiga = NULL; 74 | 75 | // alokasi 3 node 76 | pertama = new Node(); 77 | kedua = new Node(); 78 | ketiga = new Node(); 79 | 80 | // menetapkan value 81 | pertama -> value = 1; 82 | kedua -> value = 2; 83 | ketiga -> value = 3; 84 | 85 | // koneksi node 86 | pertama -> next = kedua; 87 | kedua -> next = ketiga; 88 | ketiga -> next = NULL; 89 | 90 | // print dari linked list 91 | head = pertama; 92 | 93 | while (head != NULL) { 94 | std::cout< value< next; 96 | } 97 | 98 | return 0; 99 | } 100 | ``` 101 | -------------------------------------------------------------------------------- /struktur_data/readme.md: -------------------------------------------------------------------------------- 1 | # Struktur Data 2 | Struktur data adalah format khusus untuk mengatur, memproses, mengambil, dan menyimpan data. Struktur data memudahkan programmer untuk menyimpan dan memproses data untuk sebuah aktivitas tertentu. Secara general, penggunaan struktur data yang tepat adalah kunci dari mendesain algoritma yang efisien. 3 | 4 | ## Implementasi Struktur Data 5 | Struktur data sering kali diimplementasi menggunakan tiga komponen, yaitu tipe data, pointer, dan sekumpulan operasi. 6 | 7 | - Tipe data: mendefinisikan tipe data atau nilai yang dapat disimpan dalam sebuah struktur data. 8 | - Pointer: membantu programmer dalam mendesain struktur data yang lebih kompleks dan terlepas dari heap memory seperti array. 9 | - Operasi: merupakan kumpulan operasi yang digunakan untuk berinteraksi dengan struktur data tersebut. Contohnya seperti `insert`, `delete`, `find`, dst. 10 | 11 | Kemudian, ketiga komponen ini dikemas dengan struktur [Struct](./struct_ds). 12 | 13 | ## Tipe Struktur Data 14 | Ada banyak struktur data yang dapat kita gunakan, masing-masing memiliki aturan pengaplikasian yang berbeda-beda. Berikut adalah contoh struktur data elementer yang sering dipelajari beserta deskripsinya: 15 | 16 | - Linked-list: adalah struktur data linear dimana data-data yang disimpan dihubungkan menggunakan pointer. 17 | - Stack: adalah linked-list yang memiliki aturan tertentu yakni `LIFO` (last-in fist-out), dimana elemen yang dihapus dari set adalah yang paling terakhir dimasukkan. 18 | - Queue: adalah linked-list yang memiliki aturan tertentu yakni `FIFO` (first-in fist-out), dimana elemen yang dihapus dari set adalah yang paling pertama dimasukkan. 19 | - Binary Search Tree: adalah struktur data yang menyerupai pohon dengan dua cabang, biasanya digunakan pada algoritma _searching_. 20 | 21 | Berikut adalah materi yang dapat anda baca lebih lanjut mengenai struktur data diatas: 22 | 23 | - [Linked-list](./linked_list) 24 | - [Binary-Search-Tree](./binary_search_tree) 25 | 26 | -------------------------------------------------------------------------------- /struktur_data/struct_ds/struktur_contoh1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct Kendaraan { 5 | char merk[40]; 6 | char pemilik[30]; 7 | int nomor_mesin; 8 | }; 9 | 10 | int main(){ 11 | // membuat struct baru untuk memanggil struct Kendaraan 12 | struct Kendaraan Kendaraan1; 13 | struct Kendaraan Kendaraan2; 14 | 15 | // menggunakan fungsi strcpy untuk mengisi value dari tiap 16 | // attribut pada stuktur 17 | strcpy(Kendaraan1.merk, "BMW"); 18 | strcpy(Kendaraan1.pemilik, "James arthur"); 19 | Kendaraan1.nomor_mesin = 7261; 20 | 21 | // mengisi value dari tiap attribut pada Kendaraan2 22 | strcpy(Kendaraan2.merk, "Jaguar"); 23 | strcpy(Kendaraan2.pemilik, "Bill foster"); 24 | Kendaraan2.nomor_mesin = 9281; 25 | 26 | // print dari kedua struktur yang sudah di deklarasikan 27 | std::cout<<"merk kendaraan 1 :"< 2 | #include 3 | 4 | void printKomputer(strcut Komputer komputer); 5 | 6 | struct Komputer { 7 | char pemilik[30]; 8 | char tujuan[30]; 9 | int jumlah; 10 | }; 11 | 12 | int main() { 13 | struct Komputer Komputer1; 14 | struct Komputer Komputer2; 15 | 16 | // menggunakan fungsi strcpy untuk mengisi value dari struct Kmomputer 17 | strcpy(Komputer1.pemilik, "James william"); 18 | strcpy(Komputer1.tujuan, "Berlin"); 19 | Komputer1.jumlah = 2; 20 | 21 | strcpy(Komputer2.pemilik, "Pace dean"); 22 | strcpy(Komputer2.tujuan, "indonesia"); 23 | Komputer2.jumlah = 4; 24 | 25 | // print struktur yang sudah dibuat 26 | printKomputer(Komputer1); 27 | 28 | printKomputer(Komputer2); 29 | 30 | return 0; 31 | 32 | } 33 | 34 | void printKomputer(struct Komputer komputer) { 35 | std::cout<<"pemilik :"< 2 | #include 3 | 4 | void printBuku(struct Buku *buku); 5 | 6 | struct Buku { 7 | char judul[30]; 8 | char penulis[20]; 9 | int id_buku; 10 | }; 11 | 12 | int main() { 13 | struct Buku Buku1; 14 | struct Buku Buku2; 15 | 16 | // menggunakan strcpy untuk mengisi value dari struktur 17 | strcpy(Buku1.judul, "habis gelap terbitlah terang"); 18 | strcpy(Buku1.penulis, "R.A Kartini"); 19 | Buku1.id_buku = 82910; 20 | 21 | strcpy(Buku2.judul, "Konsep Healing"); 22 | strcpy(Buku2.penulis, "levi ackerman"); 23 | Buku2.id_buku = 92817; 24 | 25 | // print 26 | printBuku(&Buku1); 27 | 28 | printBuku(&Buku2); 29 | 30 | return 0; 31 | 32 | } 33 | 34 | void printBuku(struct Buku *buku) { 35 | std::cout<<"judul :"< judul< penulis< id_buku<