បង្កើតដោយ: @John Washam
បកប្រែជាភាសារខ្មែរដោយ: @Vortana Say
ពីដំបូងខ្ញុំបង្កើតនេះជាបញ្ជីប្រធានបទត្រូវធ្វើខ្លីដើម្បីក្លាយជាវិស្វករអភិវឌ្ឍន៍កម្មវិធី ប៉ុន្តែវាបានកើនឡើងដល់បញ្ជីធំដែលអ្នកបានឃើញសព្វថ្ងៃនេះ។ បន្ទាប់ពីឆ្លងកាត់គំរោងសិក្សានេះ ខ្ញុំបានក្លាយ ជាវិស្វករអភិវឌ្ឍន៍កម្មវិធីនៅអាមាហ្សូន (Amazon) អ្នកប្រហែលជាមិនចាំបាច់សិក្សាច្រេីនដូចខ្ញុំទេ។ ទោះយ៉ាងណាក៏ដោយអ្វីគ្រប់យ៉ាងដែលអ្នកត្រូវការគឺនៅទីនេះ។
ខ្ញុំបានសិក្សាប្រហែលជា ៨ ទៅ ១២ ម៉ោងក្នុងមួយថ្ងៃអស់រយៈពេលជាច្រើនខែ។ អ្នកអាចអានារឿងរបស់ខ្ញុំ៖ ហេតុអ្វីខ្ញុំសិក្សាពេញម៉ោងរយៈពេល ៨ ខែសំរាប់ការសំភាសន៍ហ្គូហ្គល
ចំណុចដែលបានរាយនៅទីនេះនឹងជួយអ្នករៀបចំការសំភាសន៍បច្ចេកទេសនៅក្រុមហ៊ុនកម្មវិធីណាមួយ។ រាប់បញ្ចូលទាំងក្រុមហ៊ុនធំៗដូចជា Amazon, Facebook, Google និង Microsoft ។
សូមសំណាងល្អដល់អ្នក!
ការបកប្រែ៖
ភាសារដែលកំពុងបកប្រែ:
Become a sponsor and support Coding Interview University!
Special thanks to:
exclusively on supporting early-stage COSS (commercial open source) startup founders.
Dev environments built for the cloud
- តើវាគឺជាអ្វី?
- ហេតុអ្វីប្រើវា?
- របៀបប្រើវា
- កុំមានអារម្មណ៍ថាអ្នកមិនឆ្លាតគ្រប់គ្រាន់
- ធនធានវីដេអូ
- ដំណើរការសម្ភាសន៍ និង ការត្រៀមសម្ភាសន៍ទូទៅ
- ជ្រើសរើសភាសាមួយសម្រាប់ការសម្ភាសន៍
- បញ្ជីសៀវភៅ
- មុនពេលអ្នកចាប់ផ្តើម
- អ្វីដែលអ្នកនឹងមិនឃើញ
- ចំណេះដឹងជាមុនដែលគួរមាន
- ផែនការប្រចាំថ្ងៃ
- ភាពស្មុគស្មាញនៃក្បួនដោះស្រាយ / Big-O / ការវិភាគ អាសុីមតុតិច (Asymptotic analysis)
- Data Structures
- ចំណេះដឹងបន្ថែម
- Trees
- Trees - កំណត់សំគាល់ និង ប្រវត្តិ
- Binary search trees: BSTs
- Heap / Priority Queue / Binary Heap
- balanced search trees (គំនិតទូទៅ តែពុំមែនព័ត៌មានលម្អិតទេ)
- traversals: preorder, inorder, postorder, BFS, DFS
- Sorting
- selection
- insertion
- heapsort
- quicksort
- merge sort
- Graphs
- directed
- undirected
- adjacency matrix
- adjacency list
- traversals: BFS, DFS
- ចំណេះដឹងបន្ថែមទៀត
- System Design, Scalability, Data Handling (if you have 4+ years experience)
- ពិនិត្យចុងក្រោយ
- អនុវត្តសំណួរសរសេរកូដ
- លំហាត់សរសេរកូដ / បញ្ហា
- នៅពេលអ្នកជិតដល់ការសំភាសន៍
- ប្រវត្តិរូបសង្ខេបរបស់អ្នក
- ត្រូវគិតអំពីពេលសម្ភាសន៍មកដល់
- មានសំណួរសម្រាប់អ្នកសម្ភាសន៍យេីង
- នៅពេលដែលទទួលបានការងារធ្វើ
នេះគឺជាគំរោងសិក្សារបស់ខ្ញុំដែលមានរយៈពេលជាច្រើនខែសំរាប់ការរៀនក្លាយពីអ្នកបង្កើតគេហទំព័រ (បង្រៀនដោយខ្លួនឯង និង មិនមានសញ្ញាប័ត្រ វិទ្យាសាស្ត្រកុំព្យូទ័រ) រហូតដល់ក្លាយជាវិស្វករអភិវឌ្ឍន៍កម្មវិធីសំរាប់ក្រុមហ៊ុនធំ។!
នេះមានន័យថាសម្រាប់ "វិស្វករអភិវឌ្ឍន៍កម្មវិធីថ្មី" ឬអ្នកដែលប្តូរពី ការអភិវឌ្ឍន៍កម្មវិធី / អ្នកបង្កេីតវេបសាយ (ដែលត្រូវការចំណេះដឹងផ្នែកវិទ្យាសាស្ត្រកុំព្យូទ័រ) ។ ប្រសិនបើអ្នកមាន បទពិសោធជាច្រើនឆ្នាំក្នុងការអភិវឌ្ឍន៍កម្មវិធី នោះអ្នកអាចនឹងរំពឹងថាមានបទសម្ភាសន៍ពិបាក។
ប្រសិនបើអ្នកមានបទពិសោធន៍អភិវឌ្ឍន៍កម្មវិធី ឬ វេបសាយច្រើនឆ្នាំ សូមកត់សម្គាល់ថាក្រុមហ៊ុនធំ ៗ ដូចជាហ្គូហ្គោល(Google) អាម៉ាហ្សូន (Amazon) ហ្វេសប៊ុក (Facebook) និង ម៉ៃក្រូសូហ្វ (Microsoft) មានទស្សនៈថាវិស្វករអភិវឌ្ឍន៍កម្មវិធី ខុសគ្នាពីអ្នកបង្កេីតកម្មវិធី ឬ ការអភិវឌ្ឍន៍គេហទំព័រវេបសាយ ហើយពួកគេត្រូវការចំណេះដឹងផ្នែកវិទ្យាសាស្ត្រកុំព្យូទ័រ។
ប្រសិនបើអ្នកចង់ក្លាយជាវិស្វករដែលអាចទុកចិត្តបានឬវិស្វករប្រតិបត្តិការសូមសិក្សាបន្ថែមពីបញ្ជីជម្រើស (បណ្តាញ និង សុវត្ថិភាព) ។
នៅពេលដែលខ្ញុំចាប់ផ្តើមគំរោងនេះ ខ្ញុំមិនដឹងពី stack, heap, Big-O, trees និង មិនដឹងរបៀបឆ្លងកាត់ក្រាហ្វ។ ប្រសិនបើខ្ញុំត្រូវសរសេរកូដដោះស្រាយ Sort ខ្ញុំអាចប្រាប់អ្នកថាវានឹងមិនល្អទេ។
Data Structure ទាំងអស់ដែលខ្ញុំធ្លាប់បានប្រើត្រូវបានបង្កើតឡើងមកជាមួយភាសា ហើយខ្ញុំមិនដឹងពីរបៀប និង ដំណេីរការដែល Data Structure។ ខ្ញុំមិនដែលត្រូវគ្រប់គ្រង Programming Memory ទេលុះត្រាតែកម្មវិធីខ្ញុំសរសេរមានបញ្ហា "អស់ Memory" ហើយបន្ទាប់មកខ្ញុំត្រូវរកដំណោះស្រាយបណ្តោះអាសន្ន។ ខ្ញុំបានប្រើ Multidiemsional arrays ពីរបីនៅក្នុងជីវិតរបស់ខ្ញុំ និង រាប់ពាន់នៃ Associate arrays ប៉ុន្តែខ្ញុំមិនដែលបង្កើត Data Structure ពីដំបូងឡើយ។
វាជាផែនការវែង។ វាអាចចំណាយពេលច្រើនខែ។ ប្រសិនបើអ្នកធ្លាប់ស្គាល់រឿងនេះរួចហើយវានឹងនាំអ្នកចំណាយពេលតិចជាងមុន។
អ្វីគ្រប់យ៉ាងខាងក្រោមគឺជាគ្រោង អ្នកគួរតែដោះស្រាយតាមលំដាប់ពីលើចុះក្រោម។
ខ្ញុំកំពុងប្រើសញ្ញាសម្គាល់ពិសេសរបស់ GitHub រួមទាំងបញ្ជីភារកិច្ចដើម្បីពិនិត្យមើលវឌ្ឍនភាពការងារខ្ញុំ។
បង្កើតសាខាថ្មី ដូច្នេះអ្នកអាចពិនិត្យមើលដូចនេះគ្រាន់តែដាក់សញ្ញា x ក្នុងតង្កៀប៖ [x]
ដាក់សាខាមួយ ហើយធ្វើតាមពាក្យបញ្ជាខាងក្រោម
git checkout -b progress
git remote add jwasham https://github.com/jwasham/coding-interview-university
git fetch --all
គូសសញ្ញា X ក្នុងប្រអប់ទាំងអស់បន្ទាប់ពីអ្នកបានបញ្ចប់ការកែសម្រួល
git add .
git commit -m "Marked x"
git rebase jwasham/main
git push --force
[ព័ត៌មានបន្ថែមអំពីសញ្ញាសម្គាល់ Github]](https://guides.github.com/features/mastering-markdown/#GitHub-flavored-markdown)
- វិស្វករអភិវឌ្ឍន៍កម្មវិធីដែលទទួលបានជោគជ័យគឺឆ្លាត ប៉ុន្តែមនុស្សជាច្រើនមានអារម្មណ៍ដែលពួកគេមិនឆ្លាតគ្រប់គ្រាន់។
- រឿងរបស់អ្នកសរសេរកម្មវិធីដែលមានទេពកោសល្យ
- វាមានគ្រោះថ្នាក់ក្នុងការទៅតែម្នាក់ឯង: ការប្រយុទ្ធនឹងសត្វចម្លែកដែលចេះបំបាំងកាយនៅក្នុងបច្ចេកវិទ្យា
វីដេអូខ្លះអាចប្រើបានតែតាមរយៈការចុះឈ្មោះចូលរៀនវគ្គ Coursera ឬ EdX ប៉ុណ្ណោះ។ ទាំងនេះត្រូវបានគេហៅថា MOOCs ។ ពេលខ្លះថ្នាក់រៀនមិននៅក្នុងវគ្គដូច្នេះអ្នកត្រូវរង់ចាំពីរបីខែសិន។
ខ្ញុំសូមកោតសរសើរចំពោះជំនួយរបស់អ្នកក្នុងការបន្ថែមប្រភពសាធារណៈដែលអាចរកបានដោយឥតគិតថ្លៃជានិច្ចដូចជាវីដេអូយូធ្យូប (YouTube) ដើម្បីភ្ជាប់វីដេអូវគ្គសិក្សាតាមអ៊ីនធឺណិត។
ខ្ញុំចូលចិត្តប្រើការបង្រៀនសាកលវិទ្យាល័យ។
- ABC: តែងតែសរសេរកូដ
- ការប្រេីប្រាស់ក្តារខៀន
- ការប្រេីប្រាស់ក្តារខៀនមានប្រសិទ្ធិភាពក្នុងពេលសម្ភាសន៍កម្មវិធី
- ជ្រើសរើសបុគ្គលិកជំនាញបច្ចេកវិទ្យា
- វិធីរកការងារនៅក្រុមហ៊ុនធំ ៤៖
- [បំបែកការសម្ភាសន៍ការសរសេរកូដ ១៖
- បំបែកបទសម្ភាសន៍កូដហ្វេសប៊ុក
- វគ្គសិក្សាត្រៀម:
- សំភាសន៍វិស្វករអភិវឌ្ឍន៍កម្មវិធី (មិនបានបង់ប្រាក់)៖
- រៀនពីរបៀបដើម្បីត្រៀមខ្លួនសម្រាប់ការសម្ភាសន៍វិស្វករអភិវឌ្ឍន៍កម្មវិធីពីអ្នកសំភាសន៍របស់ហ្គូហ្គោល (Google) ។
- Python សម្រាប់រចនាសម្ព័ន្ធទិន្នន័យក្បួនដោះស្រាយនិងសំភាសន៍ (វគ្គសិក្សាបង់លុយ)៖
- វគ្គសិក្សាសំភាសន៍ Python ដែលផ្តោតលើរចនាសម្ព័ន្ធទិន្នន័យក្បួនដោះស្រាយ ការសំភាសន៍សាកល្បងនិងច្រើនទៀត។
- ការណែនាំអំពីរចនាសម្ព័ន្ធទិន្នន័យនិងក្បួនដោះស្រាយដោយប្រើ Python (វគ្គសិក្សាឥតគិតថ្លៃរបស់ Udacity)៖
- រចនាសម្ព័នធ័រណេតនិងអ័រហ្គ្រែនដោយឥតគិតថ្លៃ។
- រចនាសម្ព័នទិន្នន័យនិងក្បួនដោះស្រាយ! (Udacity បង់ Nanodegree)៖
- ទទួលបានការអនុវត្តជាក់ស្តែងជាមួយនឹងរចនាសម្ព័ន្ធទិន្នន័យជាង ១០០ លំហាត់ និងការណែនាំពីអ្នកបងៀនដើម្បីជួយរៀបចំអ្នកសម្រាប់ការសម្ភាសន៍ និង ដាក់ការងារ។
- សំភាសន៍វិស្វករអភិវឌ្ឍន៍កម្មវិធី (មិនបានបង់ប្រាក់)៖
អ្នកអាចប្រើភាសាដែលអ្នកមានភាពងាយស្រួលក្នុងការសរសេរកូដសំភាសន៍ប៉ុន្តែសម្រាប់ក្រុមហ៊ុនធំ ៗ ទាំងនេះគឺជាជំរើសដ៏រឹងមាំ៖
- C ++
- Java
- Python
អ្នកក៏អាចប្រើរបស់ទាំងនេះដែរប៉ុន្តែត្រូវអានជាមុនសិន។ វាអាចមានការនិយាយតៗគ្នា៖
- JavaScript
- Ruby
នេះគឺជាអត្ថបទមួយដែលខ្ញុំបានសរសេរអំពីការជ្រើសរើសភាសាសម្រាប់ការសម្ភាសន៍៖ ជ្រើសរើសយកភាសាមួយសម្រាប់ការសម្ភាសន៍សរសេរកូដ
អ្នកគួររេីសភាសាដែលអ្នកទំលាប់ជាមួយ និង មានចំណេះដឹង។
សូមអានបន្ថែមអំពីជំរើស៖
- http://www.byte-by-byte.com/choose-the-right-language-for-your-coding-interview/
- http://blog.codingforinterviews.com/best-programming-language-jobs/
អ្នកនឹងឃើញការរៀន C, C ++ និង Python ខាងក្រោមព្រោះខ្ញុំកំពុងរៀន។ មានសៀវភៅពីរបីដែលពាក់ព័ន្ធសូមមើលនៅខាងក្រោម។
នេះគឺជាបញ្ជីខ្លីជាងអ្វីដែលខ្ញុំបានប្រើ។ នេះត្រូវបានសង្ខេបដើម្បីជួយសន្សំសំចៃពេលវេលារបស់អ្នក។
- សំភាសន៍ការសរសេរកម្មវិធីបង្ហាញ: ការសរសេរកូដវិធីរបស់អ្នកតាមរយៈការសំភាសន៍, បោះពុម្ពលើកទី ៤
- ចម្លើយសរសេរ C++ និង Java
- នេះគឺជាសមដ៏ល្អសម្រាប់ការបំបែកសំភាសន៍កូដ
- មិនពិបាកពេកទេ បញ្ហាភាគច្រើនប្រហែលជាងាយស្រួលជាងអ្វីដែលអ្នកបានឃើញក្នុងបទសម្ភាសន៍ (ពីអ្វីដែលខ្ញុំបានអាន)
- ការសំភាសន៍ការសរសេរកូដការបោះពុម្ពលើកទី ៦
- ចម្លើយនសរសេរជា Java
ជ្រើសរើសមួយ:
- ធាតុផ្សំនៃបទសម្ភាសន៍សរសេរកម្មវិធី (កំណែ C ++)
- ធាតុផ្សំនៃការសំភាសន៍សរសេរកម្មវិធីក្នុង Python
- ធាតុនៃការសំភាសន៍សរសេរកម្មវិធី (កំណែ Java)
អ្នកត្រូវជ្រើសរើសភាសាសំរាប់សំភាសន៍ (សូមមើលខាងលើ) ។
នេះជាអ្នីដែលខ្ញុំគិតថាអ្នកគួរមេីល។ ខ្ញុំមិនមានធនធានសម្រាប់ភាសាទាំងអស់ទេ។ ខ្ញុំស្វាគមន៍ការដាក់បន្ថែមពីអ្នក។
ប្រសិនបើអ្នកអានចំណុចមួយក្នុងចំណោមចំណុចទាំងនេះអ្នកគួរតែមានចំនេះដឹង Data Structure និងចំណេះដឹងអំពីក្បួនដោះស្រាយ (Algorithm) ដែលអ្នកត្រូវចាប់ផ្តើមធ្វើបញ្ហាសរសេរកូដ។
អ្នកអាចរំលងការបង្រៀនវីដេអូទាំងអស់នៅក្នុងគម្រោងនេះ លើកលែងតែអ្នកចង់ពិនិត្យឡើងវិញ។
ខ្ញុំមិនបានអានទាំងពីរនេះទេ ប៉ុន្តែវាត្រូវបានវាយតម្លៃនិងសរសេរយ៉ាងខ្ពស់ដោយ Sedgewick ។ គាត់អស្ចារ្យណាស់។
- វិធីដោះស្រាយក្នុង C++, ផ្នែក ១-៤៖ មូលដ្ឋានគ្រឹះរចនាសម្ព័ន្ធទិន្នន័យ (Data Structure) តម្រៀប (Sort) ស្វែងរក (Searching)
- វិធីដោះស្រាយក្នុង C++ ភាគ ៥៖ ក្បួនដោះស្រាយក្រាហ្វិច
ប្រសិនបើអ្នកមានអនុសាសន៍ល្អប្រសើរសម្រាប់ C++ សូមប្រាប់ខ្ញុំឱ្យដឹង។ រកមើលធនធានទូលំទូលាយ។
- វិធីដោះស្រាយ (Sedgewick និង Wayne)
- វីដេអូដែលមានមាតិកាសៀវភៅ (និង Sedgewick!) លើវគ្គសិក្សា៖
រឺ៖
- រចនាសម្ព័ន្ធទិន្នន័យ (Data Structure) និងក្បួនដោះស្រាយ Java
- ដោយហ្គ្រីដល (Goodrich), តាតសាសៀ (Tamassia), ហ្គោវីស (Goldwasser)
- អត្ថបទសម្រាប់វគ្គសិក្សាសំរាប់ថ្នាក់ដំបូងរបស់វិទ្យាសាស្ត្រកុំព្យូទ័រនៅឯ UC Berkeley
- សូមមើលរបាយការណ៍សៀវភៅរបស់ខ្ញុំស្តីពីកំណែ Python ខាងក្រោម។ សៀវភៅនេះមានប្រធានបទដូចគ្នា។
- រចនាសម្ព័ន្ធទិន្នន័យ (Data Structure) និងក្បួនដោះស្រាយ (Algorithm) ក្នុង Python
- ដោយហ្គ្រីដល (Goodrich), តាតសាសៀ (Tamassia), ហ្គោវីស (Goldwasser)
- ខ្ញុំចូលចិត្តសៀវភៅនេះ។ វាគ្របដណ្តប់អ្វីៗគ្រប់យ៉ាងនិងច្រើនទៀត។
- លេខកូដព្យញ្ជនៈ
- របាយការណ៍សៀវភៅរបស់ខ្ញុំ៖ https://startupnextdoor.com/book-report-data-structures-and-al algorithms-in-python/
បញ្ជីនេះបានកើនឡើងអស់រយៈពេលជាច្រើនខែហើយ ។
នេះគឺជាកំហុសមួយចំនួនដែលខ្ញុំបានធ្វើដូច្នេះអ្នកនឹងមានបទពិសោធប្រសើរជាងមុន។
ខ្ញុំបានមើលវីដេអូជាច្រើនម៉ោងនិងកត់ចំណាំគួរអោយចង់សើច ហើយប៉ុន្មានខែក្រោយមកមានរឿងជាច្រើនដែលខ្ញុំមិនចាំ។ ខ្ញុំចំណាយពេល ៣ ថ្ងៃទៀត តាមរយៈកំណត់ចំណាំរបស់ខ្ញុំនិងធ្វើប័ណ្ណបញ្ជាក់ដូច្នេះខ្ញុំអាចពិនិត្យមើលឡើងវិញ។
សូមមេត្តាអានដូច្នេះអ្នកនឹងមិនធ្វើឱ្យខ្ញុំខុសទេ។
រក្សាចំណេះដឹងវិទ្យាសាស្ត្រកុំព្យូទ័រ ។
វគ្គសិក្សាដែលបានណែនាំដល់ខ្ញុំ (មិនបានសិក្សាវាទេ)៖ ការរៀនពីរបៀបរៀន
ដើម្បីដោះស្រាយបញ្ហា ខ្ញុំបានបង្កើតវេបសាយកាតតូចមួយដែលខ្ញុំអាចបន្ថែមកាតចំនួន ២ ប្រភេទគឺទូទៅនិងលេខកូដ។ កាតនីមួយៗមានទ្រង់ទ្រាយខុសៗគ្នា។
ខ្ញុំបានបង្កើតវេបសាយសំរាប់ទូរស័ព្ទដំបូងមួយ ដូច្នេះខ្ញុំអាចពិនិត្យមើលឡើងវិញនៅលើទូរស័ព្ទ និង ថេប្លេតរបស់ខ្ញុំទោះបីខ្ញុំនៅទីណាក៏ដោយ។
អ្នកអាចបង្កេីតដោយឥតគិតថ្លៃ៖
- បណ្តាញឃ្លាំងផ្ទុកកាតឡើងវិញ
- មូលដ្ឋានទិន្នន័យកាតរបស់ខ្ញុំ (កាតចាស់ - ១២០០ កាត)៖
- ប្រព័ន្ធទិន្នន័យកាតរបស់ខ្ញុំ (កាតថ្មី - ១៨០០)៖
សូមចងចាំថាខ្ញុំបានឡើងលើក្តារហើយមានកាតគ្របដណ្តប់លើអ្វីៗទាំងអស់ចាប់ពីភាសាការជួបប្រជុំគ្នា និង សំនួរទាក់ទងនឹង Python រហូតដល់ការរៀនម៉ាស៊ីននិងស្ថិតិ។ វាជាវិធីច្រើនពេកសម្រាប់អ្វីដែលត្រូវការ។
កំណត់ចំណាំនៅលើបណ្ណបង្ហាញ៖ ជាលើកដំបូងដែលអ្នកទទួលស្គាល់អ្នកដឹងពីចម្លើយ សូមកុំសម្គាល់វាថាត្រូវបានគេស្គាល់។ អ្នកត្រូវតែមើល កាតដូចគ្នានិងឆ្លើយវាច្រើនដងឱ្យបានត្រឹមត្រូវមុនពេលដែលអ្នកពិតជាដឹង។ ពាក្យដដែលៗនឹងធ្វើឱ្យចំណេះដឹងនោះកាន់តែស៊ីជម្រៅ ខួរក្បាលរបស់អ្នក។
ជំរើសមួយផ្សេងទៀតក្នុងការប្រើប្រាស់បណ្តាញកាតរបស់ខ្ញុំគឺ Anki ដែលត្រូវបានណែនាំអោយខ្ញុំច្រើនដង។ វាប្រើប្រព័ន្ធពាក្យដដែលៗដើម្បីជួយអ្នកចងចាំ។ វាមានភាពងាយស្រួលសម្រាប់អ្នកប្រើដែលមាននៅលើគ្រប់វេទិកាទាំងអស់និងមានប្រព័ន្ធធ្វើសមកាលកម្មពពក។ វាមានតម្លៃ ២៥ ដុល្លារលើប្រព័ន្ធប្រតិបត្តិការ iOS ប៉ុន្តែមិនគិតថ្លៃនៅលើវេទិកាផ្សេងទៀតទេ។
មូលដ្ឋានទិន្នន័យបណ្ណបង្ហាញរបស់ខ្ញុំក្នុងទំរង់អាគី (Anki) ៖ https://ankiweb.net/shared/info/25173560 (សូមអរគុណ @xiewenya
៣. ចាប់ផ្តើមធ្វើសំណួរសម្ភាសន៍សរសេរកូដខណៈពេលដែលអ្នកកំពុងរៀនរចនាសម្ព័ន្ធទិន្នន័យ (Data Structure) និង ក្បួនដោះស្រាយ (Algorithm)
អ្នកត្រូវអនុវត្តអ្វីដែលអ្នកកំពុងរៀនដើម្បីដោះស្រាយបញ្ហាឬអ្នកនឹងភ្លេច។ ខ្ញុំបានធ្វើកំហុសនេះ។ នៅពេលដែលអ្នកបានរៀនប្រធានបទមួយ ហើយមានអារម្មណ៍ស្រួលជាមួយវាដូចជាបញ្ជីភ្ជាប់បើកសៀវភៅសម្ភាសន៍កូដសរសេរមួយហើយធ្វើសំណួរពីរបីទាក់ទងនឹង បញ្ជីដែលបានភ្ជាប់។ បន្ទាប់មកបន្តទៅប្រធានបទសិក្សាបន្ទាប់។ បន្ទាប់មកពេលក្រោយ ត្រលប់ក្រោយហើយធ្វើបញ្ហាបញ្ជីដែលបានភ្ជាប់ផ្សេងទៀត ឬបញ្ហាការហៅឡើងវិញឬអ្វីផ្សេងទៀត។ ប៉ុន្តែនៅតែធ្វើបញ្ហានៅពេលអ្នកកំពុងរៀន។ អ្នកមិនត្រូវបានគេជួលដើម្បីចំណេះដឹងទេ ប៉ុន្តែរបៀបដែលអ្នកអនុវត្តចំណេះដឹង។ មានសៀវភៅនិងគេហទំព័រជាច្រើនដែលខ្ញុំសូមណែនាំ។ សូមមើលនៅទីនេះសម្រាប់ព័ត៌មានបន្ថែម: ការអនុវត្តសំណួរសំណួរសរសេរកូដ
ខ្ញុំរក្សាទុកសន្លឹកបន្លំមួយសន្លឹកនៅលើ ASCII, OSI stack, សញ្ញាណសំគាល់ធំ ៗ (Big-O) និងច្រើនទៀត។ ខ្ញុំសិក្សាវានៅពេលខ្ញុំមានពេលទំនេរខ្លះ។
សម្រាកពីបញ្ហាសរសេរកម្មវិធីរយៈពេលកន្លះម៉ោង ហើយអានកាតរបស់អ្នក។
មានការរំខានជាច្រើនដែលអាចចំណាយពេលដ៏មានតម្លៃ។ ការផ្តោតអារម្មណ៍គឺពិបាក។ បើកតន្ត្រីមួយចំនួនដែលគ្មានទំនុកច្រៀងទេអ្នកនឹងអាចផ្តោតអារម្មណ៍បានល្អ។
ទាំងនេះជាបច្ចេកវិទ្យាដែលមានជាទូទៅប៉ុន្តែមិនមែនជាផ្នែកនៃផែនការសិក្សានេះទេ៖
- SQL
- Javascript
- HTML, CSS និងបច្ចេកវិទ្យាផ្នែក front-end
មុខវិជ្ជាខ្លះចំណាយពេលមួយថ្ងៃហើយ មុខវិជ្ជាខ្លះនឹងចំណាយពេលច្រើនថ្ងៃ។ អ្នកខ្លះរៀនតែគ្មានអ្វីអនុវត្ត។
ជារៀងរាល់ថ្ងៃខ្ញុំយកប្រធានបទមួយចេញពីបញ្ជីខាងក្រោមមើលវីដេអូអំពីប្រធានបទនោះហើយសរសេរកូតនៅក្នុង៖
- C - ប្រើរចនាសម្ព័ន្ធ និង មុខងារដែលយករចនាសម្ព័ន្ធ * និង អ្វីផ្សេងទៀតជា Arguments។
- C++ - ដោយមិនប្រើមុខងារដែលភ្ជាប់មកជាមួយនឹង ភាសា
- C++ - ប្រើប្រភេទដែលមានស្រាប់ដូចជា STL's::list សម្រាប់បញ្ជីភ្ជាប់ (Linked list)
- Python - ប្រើប្រភេទដែលមានស្រាប់ (ដើម្បីរំលឹក Python)
- និងសរសេរការធ្វើតេស្តដើម្បីធានាថាខ្ញុំធ្វើវាបានត្រឹមត្រូវពេលខ្លះគ្រាន់តែប្រើសេចក្តីថ្លែងអះអាងសាមញ្ញ assert()
- អ្នកអាចធ្វើ Jav ឬ អ្វីផ្សេងទៀតនេះគ្រាន់តែជារឿងរបស់ខ្ញុំប៉ុណ្ណោះ។
អ្នកមិនត្រូវការរបស់ទាំងអស់នេះទេ។ អ្នកត្រូវការតែ ភាសាមួយសម្រាប់ការសម្ភាសន៍ ។
ហេតុអ្វីត្រូវកូដទាំងអស់នេះ?
- អនុវត្ត អនុវត្ត អនុវត្តរហូតដល់ខ្ញុំច្បាស់ហើយអាចធ្វើវាដោយគ្មានបញ្ហា (អ្នកខ្លះមានករណីកំរច្រើន និង ព័ត៌មានលំអិតនៃការរក្សាទុកសៀវភៅដើម្បីចងចាំ)
- ធ្វើការនៅក្នុងឧបសគ្គ (បែងចែក / លុបចេញអង្គចងចាំ (Memory) ដោយគ្មានជំនួយពីការប្រមូលសំរាម (Gabage Collection) (លើកលែងតែ Python ឬ Java))
- ប្រើប្រភេទដែលមានស្រាប់ដូច្នេះខ្ញុំមានបទពិសោធន៍ប្រើឧបករណ៍ដែលមានស្រាប់សម្រាប់ការប្រើប្រាស់ដូចពេលធ្វេីការ (មិនមែនថាសរសេរការអនុវត្តន៍បញ្ជី (Linked List) របស់ខ្ញុំផ្ទាល់ក្នុងពេលធ្វេីការ)
ខ្ញុំប្រហែលជាមិនមានពេលវេលាដើម្បីធ្វើការទាំងអស់សម្រាប់មុខវិជ្ជាទាំងអស់នោះទេប៉ុន្តែខ្ញុំនឹងព្យាយាម។
អ្នកអាចឃើញកូដរបស់ខ្ញុំនៅទីនេះ៖
អ្នកមិនចាំបាច់ទន្ទេញចាំគ្រប់ក្បួនដោះស្រាយទាំងអស់។
សរសេរកូដនៅលើក្ដារខៀនឬក្រដាស មិនមែនកុំព្យូទ័រទេ។ សាកល្បងជាមួយធាតុចូលគំរូមួយចំនួន។ បន្ទាប់មកសាកល្បងវានៅលើកុំព្យូទ័រ។
-
រៀន C
-
C គឺនៅគ្រប់ទីកន្លែង។ អ្នកនឹងឃើញឧទាហរណ៍នៅក្នុងសៀវភៅការបង្រៀនវីដេអូ នៅគ្រប់ទីកន្លែង ពេលអ្នកកំពុងសិក្សា។
-
- នេះគឺជាសៀវភៅខ្លីមួយប៉ុន្តែវានឹងផ្តល់ឱ្យអ្នកនូវភាសា C យ៉ាងល្អហើយប្រសិនបើអ្នកអនុវត្តវាបន្តិច អ្នកនឹងឆាប់ស្ទាត់ជំនាញ។ ការយល់ដឹង C ជួយអ្នកឱ្យយល់ពីរបៀបដែលកម្មវិធីនិងការចងចាំដំណើរការ។
- ចម្លើយចំពោះសំណួរ
-
-
របៀបដែលកុំព្យូទ័រដំណើរការកម្មវិធី:
- គ្មានអ្វីត្រូវអនុវត្តទេ
- មានវីដេអូជាច្រើននៅទីនេះ។ គ្រាន់តែមើលឱ្យបានគ្រប់គ្រាន់រហូតដល់អ្នកយល់។ អ្នកអាចត្រលប់មកពិនិត្យឡើងវិញជានិច្ច។
- ប្រសិនបើការបង្រៀនមួយចំនួនមានភាពស្រងូតស្រងាត់អ្នកអាចរំលងដល់ក្រោមហើយមើលវីដេអូគណិតវិទ្យាដែលដាច់ពីគ្នាដើម្បីទទួលបានចំណេះដឹងជាមូលដ្ឋាន។
- Harvard CS50 - Asymptotic Notation (វីដេអូ)
- កំណត់ចំណាំ Big-O (ការបង្រៀនរហ័សទូទៅ) (វីដេអូ)
- Big O Notation (និង Omega និង Theta) - ការពន្យល់គណិតវិទ្យាល្អបំផុត (វីដេអូ)
- Skiena៖ - វីដេអូ - ស្លាយ
- ការណែនាំមួយចំពោះការវិភាគស្មុគស្មាញនៃគណិតវិទ្យា
- លំដាប់នៃការលូតលាស់ (វីដេអូ)
- ការវិភាគអាមីស្តូតូទិក (Amortized) (វីដេអូ)
- UC Berkeley Big O (មានវីដេអូ)
- UC Berkeley Big Omega (វីដេអូ)
- ការវិភាគរំលោះ (Amortized) (វីដេអូ)
- បង្ហាញរូបភាព "Big-O" (វីដេអូ)
- TopCoder (រួមបញ្ចូលទាំងទំនាក់ទំនងកើតឡើងវិញនិងទ្រឹស្តីបទមេ)៖
- សន្លឹកជំនួយ
-
- អនុវត្តវ៉ិចទ័រប្តូរទំហំដោយស្វ័យប្រវត្តិ។
- ការពិពណ៌នា៖
- អនុវត្តវ៉ិចទ័រ (បំលែង Arrays ដោយប្តូរទំហំស្វ័យប្រវត្តិ)៖
- អនុវត្តការសរសេរកូដដោយប្រើArrays និង ទ្រនិចចង្អុល និង គណិតទ្រនិចដើម្បីលោតទៅសន្ទស្សន៍មួយ។
- Arrays ទិន្នន័យថ្មីដែលមានអង្គចងចាំបម្រុងទុក
- អាចបែងចែកArraysនៅក្រោមក្រណាត់ដោយគ្រាន់តែមិនប្រើលក្ខណៈពិសេសរបស់វា
- ចាប់ផ្តើមជាមួយលេខ ១៦ ឬបើលេខចាប់ផ្តើមធំជាងប្រើថាមពល ២ - ១៦, ៣២, ៦៤, ១២៨
- size() - ចំនួនធាតុ
- capacity() - ចំនួនធាតុដែលវាអាចផ្ទុកបាន
- is_empty()
- at(index) - ត្រឡប់ធាតុនៅទីតាំងដែលបានផ្តល់ឱ្យ បេីទីតាំងនៅក្រៅព្រំដែន វានឹង មានកុំហស
- push(item)
- insert(index, item) - បញ្ចូលធាតុនៅទីតាំង ប្តូរតម្លៃទីតាំង និងធាតុនៅខាងក្រោមទៅខាងស្តាំ
- prepend (item) - អាចប្រើបញ្ចូលខាងលើនៅទីតាំង ០
- pop() - ដកចេញពីចុងបញ្ចប់តម្លៃត្រឡប់មកវិញ
- delete(index) - លុបធាតុនៅទីតាំងដែលអោយ ផ្លាស់ប្តូរធាតុនៅពីក្រោយទាំងអស់
- remove(item) - រកមើលតម្លៃនិងយកទីតាំងចេញដែលផ្ទុកវាចេញ (ទោះបីជានៅកន្លែងច្រើនក៏ដោយ)
- find(item) - រកមើលតម្លៃហើយត្រឡប់វិញនៅទីតាំងដំបូងជាមួយតម្លៃនោះ បើរកមិនឃើញត្រលប់វិញ -1
- resize(new_capacity) // មុខងារឯកជន
- ពេលទំហំ Array ដល់កំណត់, ផ្លាស់ប្តូរទំហំទ្វេដងទំហំ
- នៅពេលដែលចាប់យកវត្ថុមួយ ប្រសិនបើទំហំគឺ 1/4 នៃទំហំសរុប, ផ្លាស់ប្តូរទំហំដល់ពាក់កណ្តាល
- ពេលវេលា
- O(១) ត្រូវបន្ថែម / ដកចេញនៅចុងបញ្ចប់ (សងវិញសម្រាប់ការបែងចែកសម្រាប់ទំហំបន្ថែម) ទីតាំង
- O(n) ដើម្បីបញ្ចូល / ដកចេញនៅកន្លែងផ្សេងទៀត
- លំហ
- ជាប់ទាក់ទងនឹងការចងចាំដូច្នេះភាពជិតស្និទ្ធជួយដល់ការអនុវត្ត
- ទំហំត្រូវការ = (ទំហំ Array, ដែល >= n) * ទំហំនៃធាតុ, ប៉ុន្តែបើទោះបីជា 2n, នៅតែ O (n)
-
- ការពិពណ៌នា៖
- កូដ C (វីដេអូ)
- មិនមែនវីដេអូទាំងមូលទេគឺគ្រាន់តែជាផ្នែកអំពីរចនាសម្ព័ន្ធ (Data Structure) និងការបែងចែក Memory ។
- Linked List vs Arrays:
- ហេតុអ្វីអ្នកគួរចៀសវាង linked lists (វីដេអូ)
- Gotcha: you need pointer to pointer knowledge: (សម្រាប់ពេលអ្នកហុច pointer ទៅមុខងារមួយដែលអាចផ្លាស់ប្តូរអាស័យដ្ឋានដែលព្រួញចង្អុល) ទំព័រនេះគ្រាន់តែដើម្បីស្វែងយល់ពី pointer ទៅ pointer ។ ខ្ញុំមិនណែនាំបញ្ជីឈ្មោះបែបត្រាប់តាមនេះទេ។ ភាពងាយស្រួលក្នុងការអាននិងរក្សាបាននូវភាពលំបាកដោយសារតែភាពឆ្លាតវៃ។
- អនុវត្ត (ខ្ញុំបានធ្វើដោយប្រើទ្រនិចកន្ទុយនិងដោយគ្មាន)៖
- size() - ត្រឡប់ចំនួនធាតុទិន្នន័យក្នុងបញ្ជី
- empty() - bool ត្រឡប់ពិតបើទទេ
- value_at(index) - ត្រឡប់តម្លៃនៃធាតុទី (ចាប់ផ្តើមពីលេខ ០ ដំបូង)
- push_front(តម្លៃ) - បន្ថែមធាតុនៅខាងមុខបញ្ជី
- pop_front() - យកធាតុខាងមុខចេញហើយប្រគល់តម្លៃរបស់វាមកវិញ
- push_back(តម្លៃ) - បន្ថែមធាតុនៅចុងបញ្ចប់
- pop_back() - យកធាតុបញ្ចប់ហើយត្រឡប់តម្លៃរបស់វា
- front() - ទទួលបានតម្លៃនៃធាតុខាងមុខ
- back() - ទទួលបានតម្លៃនៃធាតុបញ្ចប់
- insert(index, តម្លៃ) - បញ្ចូលតម្លៃនៅindex ដូច្នេះធាតុបច្ចុប្បន្ននៅindexនោះត្រូវបានចង្អុលទៅធាតុថ្មីនៅindex។
- erase(index) - យក Node ចេញនៅ index ដែលបានផ្តល់ឱ្យ
- value_n_from_end(n) - ត្រឡប់តម្លៃ Node ទីពីខាងចុងបញ្ជី
- reverse() - បញ្ច្រាស់បញ្ជី
- remove_value(តម្លៃ) - លុបធាតុដំបូងក្នុងបញ្ជីជាមួយតម្លៃនេះ
- Doubly-linked List
- ការពិពណ៌នា (វីដេអូ)
- មិនចាំបាច់អនុវត្តទេ
-
- Stack (វីដេអូ)
- ការប្រើ Stack ចូលមុនចេញក្រោយ (វីដេអូ)
- នឹងមិនអនុវត្តទេ។ ការអនុវត្តជាមួយ Array គឺមិនសំខាន់។
-
- ការប្រើ Queue ចូលមុនចេញមុន(វីដេអូ)
- Queue (វីដេអូ)
- [ ] Circular buffer/FIFO
- [ ] Queue អាទិភាព (វីដេអូ)
- [ ] ប្រើ linked-list ដែលមានភ្ជាប់ជាមួយទ្រនិចនៅកន្ទុយ៖
- enqueue(តម្លៃ) - បន្ថែមតម្លៃនៅទីតាំងនៅកន្ទុយ
- dequeue() - ត្រឡប់តម្លៃនិងយកធាតុដែលបានបន្ថែមថ្មីៗចេញ (ផ្នែកខាងមុខ)
- empty() - [ ] អនុវត្តដោយប្រើអារេ Array ទំហំថេរ៖
- enqueue(តម្លៃ) - បន្ថែមធាតុនៅចុងបញ្ចប់នៃការផ្ទុកដែលមាន
- dequeue() - ត្រឡប់តម្លៃនិងយកធាតុដែលបានបន្ថែមថ្មីៗចេញ
- empty()
- full() - [ ] ថ្លៃ៖
- ការអនុវត្តមិនល្អដោយប្រើlinked listដែលអ្នករៀបជាជួរនៅនឹងក្បាលនិងដេស្កាយនៅកន្ទុយប្រហែលជា O(n) ដោយសារតែអ្នកត្រូវការនៅជាប់នឹងធាតុចុងក្រោយ, បណ្តាលឱ្យ dequeue គ្នាឆ្លងកាត់ពេញលេញ
- enqueue: O(1) (amortized, linked list and array [probing])
- dequeue: O(1) (linked list and array)
- empty: O(1) (linked list and array)
-
-
វីដេអូ៖
-
វគ្គសិក្សាអនឡាញ៖
- ស្វែងយល់អំពីមុខងារ Hash (វីដេអូ)
- ការប្រើតារាងHash (វីដេអូ)
- [គាំទ្រ Hash (វីដេអូ)](https://archive.org/details/0102WhatYouShouldKnow/06_04- ឧបត្ថម្ភគាំទ្រហាន់ឌ្រី)
- តារាងជំនួយភាសា Hash(វីដេអូ)
- Core Hash Tables (វីដេអូ)
- រចនាសម្ព័ន្ធទិន្នន័យ (វីដេអូ)
- បញ្ហាសៀវភៅទូរស័ព្ទ (វីដេអូ)
- [តារាងចែកចាយ]
-
អនុវត្តជាមួយអារេដោយប្រើការស៊ើបអង្កេតលីនេអ៊ែរ
- hash(k, m) - m គឺជាទំហំនៃតារាង hash
- add(key, value) - ប្រសិនបើមានកូនសោររួចហើយ, ធ្វើបច្ចុប្បន្នភាពតម្លៃ
- exists(key)
- get(key)
- remove(key)
-
-
- Binary search (វីដេអូ)
- Binary search (វីដេអូ)
- លម្អិត
- អនុវត្ត៖
- Binary search (នៅលើជួរអារេនៃចំនួនគត់)
- Binary search ដោយប្រើការហៅខ្លួនឯង
-
- សន្លឹកជំនួយ Bits
- អ្នកគួរតែស្គាល់ អំណាច ២ ពី (២ ^ ១ ដល់ ២ ^ ១៦ និង ២ ^ ៣២)
- ទទួលបានការយល់ដឹងដ៏ល្អអំពីការរៀបចំBitsជាមួយ៖ &, |, ^, ~, >>, <<
- ពាក្យ
- ការណែនាំល្អ៖ ការធ្វើចលនាBits (វីដេអូ)](https://www.youtube.com/watch?v=7jkIUgLC29I)
- C ការបង្រៀនសរសេរកម្មវិធី ២-១០: ប្រតិបត្តិការ Bitwise (វីដេអូ)
- ការរៀបចំBits - [ ] ប្រតិបតិ្តការ Bitwise
- Bithacks
- The Bit Twiddler
- The Bit Twiddler Interactive
- Bit Hacks (វីដេអូ)
- 2s និង 1s បំពេញបន្ថែម
- រាប់សំណុំ bits
- វិធី ៤ យ៉ាងដើម្បីរាប់ប៊ីតជាសាមសិបប៊ីត (វីដេអូ)
- រាប់ប៊ីត
- [របៀបរាប់ចំនួនសំណុំប៊ីតក្នុងចំនួនគត់ ៣២ ប៊ីត](http://stackoverflow.com/questions/109023/how-to-count-the-number-of-set-bits-in-a-32-bit- ចំនួនគត់)
- ប្តូរតម្លៃ
- តម្លៃដាច់ខាត:
- សន្លឹកជំនួយ Bits
-
- ស៊េរី៖ ចំនុចសំខាន់ Trees (វីដេអូ)
- ស៊េរី៖ Trees (វីដេអូ)
- ការសាងសង់ tree
- ការឆ្លងកាត់ tree
- ក្បួនដោះស្រាយ
- BFS(breadth-first search) និង DFS(depth-first search) (វីដេអូ)
- កំណត់សំគាល់របស់ BFS:
- level order (BFS, ដោយប្រេី queue)
- ភាពស្មុគស្មាញពេលវេលា: O(n)
- ភាពស្មុគស្មាញនៃលំហ: ល្អបំផុត៖ O(1), អាក្រក់បំផុត៖ O(n/2)=O(n)
- DFS notes:
- ភាពស្មុគស្មាញពេលវេលា: O(n)
- ភាពស្មុគស្មាញនៃលំហ: ល្អបំផុត៖ O(log n) - មធ្យមកម្ពស់ tree អាក្រក់បំផុត៖ O(n)
- inorder (DFS: ឆ្វេង, ខ្លួនឯង, ស្តាំ)
- postorder (DFS: ឆ្វេង, ស្តាំ, ខ្លួនឯង)
- preorder (DFS: self, left, right)
- កំណត់សំគាល់របស់ BFS:
-
- ការពិនិត្យឡើងវិញ Binary Search Tree (វីដេអូ)
- ស៊េរី (វីដេអូ)
- ចាប់ផ្តើមជាមួយតារាងនិមិត្តសញ្ញាហើយឆ្លងកាត់ការអនុវត្ត BST
- សេចក្តីផ្តើម (វីដេអូ)
- MIT (វីដេអូ)
- C/C++:
- Binary search tree - ការអនុវត្តក្នុង C/C++ (វីដេអូ)
- BST ការអនុវត្តក្នុង - ការបែងចែក memory ក្នុង stack និង heap (វីដេអូ)
- ស្វែងរកធាតុតូចបំផុត និង ធំបំផុតនៅក្នុង binary search tree (វីដេអូ)
- រកកំពស់ binary tree (វីដេអូ)
- Binary tree traversal - យុទ្ធសាស្ត្រ breadth-first និង depth-first (វីដេអូ)
- Binary tree: Level Order Traversal (វីដេអូ)
- Binary tree traversal: Preorder, Inorder, Postorder (វីដេអូ)
- ពិនិត្យមើលថាតើ binary tree គឺ binary search tree រឺទេ (វីដេអូ)
- លុបធាតុពី Binary Search Tree (វីដេអូ)
- Inorder Successor ក្នុង binary search tree មួយ (video)
- ការអនុវត្ត:
- insert // ដាក់ធាតុក្នុង tree
- get_node_count // ទទួលចំនួនធាតុដែលផ្ទុក
- print_values // បង្ហាញតម្លៃក្នុង tree, ពី តូច ទៅ ធំ
- delete_tree
- is_in_tree // ត្រឡប់វិញ ពិត ប្រសិនបេីតម្លៃក្នុង tree
- get_height // ត្រឡប់វិញ កំពស់ក្នុង nodes (កំពស់ single node គឺ 1)
- get_min // ត្រឡប់វិញ ធាតុតូចជាងគេ
- get_max // ត្រឡប់វិញ ធាតុធំជាងគេ
- is_binary_search_tree
- delete_value
- get_successor // ត្រឡប់តម្លៃខ្ពស់បំផុតបន្ទាប់នៅក្នុងtreeបន្ទាប់ពីតម្លៃដែលបានផ្ដល់ ៕ បើគ្មានត្រឡប់ -1
-
- visualized as a tree, but is usually linear in storage (array, linked list)
- Heap
- សេចក្តីផ្តើម (វីដេអូ)
- ការអនុវត្តដំបូង (វីដេអូ)
- Binary Trees (វីដេអូ)
- កំពស់ Tree (វីដេអូ)
- ប្រតិបត្តិការមូលដ្ឋាន (វីដេអូ)
- Binary Trees ពេញលេញ (វីដេអូ)
- Pseudocode (វីដេអូ)
- Heap Sort - លោតដើម្បីចាប់ផ្ដើម (វីដេអូ)
- Heap Sort (វីដេអូ)
- ការកសាង heap (វីដេអូ)
- MIT: Heaps និង Heap Sort (វីដេអូ)
- CS 61B មេរៀន 24: Priority Queues (វីដេអូ)
- Linear Time BuildHeap (max-heap)
- ការអនុវត្ត max-heap:
- insert
- sift_up - ត្រូវការសំរាប់បញ្ចូល
- get_max - ត្រឡប់ធាតុអតិបរិមាដោយមិនយកវាចេញ
- get_size() - ត្រឡប់ចំនួននៃធាតុដែលបានរក្សាទុក
- is_empty() - ត្រឡប់ពិតប្រសិនបើ heap មិនមានធាតុ
- extract_max - ត្រឡប់ធាតុអតិបរិមាយកវាចេញ
- sift_down - ត្រូវការសំរាប់ extract_max
- remove(i) - យកធាតុចេញនៅ index x
- heapify - បង្កើតheap ពីធាតុជាច្រើនដែលត្រូវការសម្រាប់ heap_sort
- heap_sort() - យកarray ដែលមិនបានតម្រៀបហើយប្រែក្លាយវាទៅជាកន្លែងដែលបានតម្រៀបតាមកន្លែងដោយប្រើheapអតិបរមា។ t
- ចំណាំ៖ ការប្រើ heap តូច ជំនួសនឹងជួយសន្សំប្រតិបត្តិការ ប៉ុន្តែត្រូវការទំហំទ្វេដង (មិនអាចធ្វើនៅនឹងកន្លែង) ។
-
កំណត់សំគាល់:
- អនុវត្ត sorts និងដឹងពីករណីដែលល្អ និង ដែលអាក្រក់, ភាពស្មុគស្មាញជាមធ្យមនីមួយៗ:
- កុំប្រេី bubble sort - វាមិនល្អ - O(n^2), លុះត្រាតែ n <= 16
- ស្ថេរភាពក្នុងក្បួនដោះស្រាយ sorting ("តើ Quicksort មានស្ថេរភាពឬ?")
- តើក្បួនដោះស្រាយអ្វីខ្លះអាចត្រូវបានប្រើ linked lists? អាចត្រូវបានប្រើ arrays? អាចត្រូវបានប្រើទាំងពីរ?
- ខ្ញុំនឹងមិនណែនាំឱ្យ Sort ជាមួយ linked list ប៉ុន្តែអាចប្រេី Merge Sort។
- Merge Sort សំរាប់ Linked List
- អនុវត្ត sorts និងដឹងពីករណីដែលល្អ និង ដែលអាក្រក់, ភាពស្មុគស្មាញជាមធ្យមនីមួយៗ:
-
សំរាប់ heapsort, សូមមេីល Heap data structure ខាងលេី. Heap sort គឺល្អ, ប៉ុន្តែមិនមានស្ថេរភាពទេ.
-
UC Berkeley:
-
កូដ Merge sort:
-
កូដ Quick sort:
-
អនុវត្ត:
- Mergesort: O(n log n) ករណីមធ្យម និង អាក្រក់បំផុត
- Quicksort O(n log n) ករណីមធ្យម
- Selection sort និង insertion sort ទាំងពីរគឺ O(n^2) សំរាប់ករណីមធ្យម និង អាក្រក់បំផុត
- ចំពោះ heapsort, សូមមេីល Heap data structure ខាងលេី.
-
មិនចាំបាច់ទេ ប៉ុន្តែខ្ញុំសូមណែនាំពួកគេ:
ជាការសង្ខេបនេះគឺជាការបង្ហាញជាក់ស្តែងនៃ ១៥ វិធីដោះស្រាយ Sorting ។ ប្រសិនបើអ្នកត្រូវការព័ត៌មានលម្អិតបន្ថែមលើប្រធានបទនេះសូមមើលផ្នែក "Sorting" នៅក្នុង ព័ត៌មានលំអិតលើប្រធានបទមួយចំនួន
Graphs អាចត្រូវបានប្រើដើម្បីបង្ហាញពីបញ្ហាជាច្រើននៅក្នុងវិទ្យាសាស្ត្រកុំព្យូទ័រ ដូចជា Trees និង Sorting។
-
កំណត់ចំណាំ:
- មានវិធីជាមូលដ្ឋានចំនួន ៤ ដើម្បីតំណាង graph ក្នុង memory:
- objects និង pointers
- adjacency matrix
- adjacency list
- adjacency map
- ស្គាល់ខ្លួនឯងជាមួយនឹង Graphs និង គុណសម្បត្តិនិងគុណវិបត្តិរបស់វា
- BFS និង DFS - ដឹងពីភាពស្មុគស្មាញក្នុងការគណនាការជួញដូររបស់ពួកគេ និង វិធីអនុវត្តកូដពិតប្រាកដ
- នៅពេលសួរសំណួរសូមស្វែងរកដំណោះស្រាយដែលមានមូលដ្ឋានលើ Graphs ជាមុនសិនបន្ទាប់មកបន្តទៅមុខទៀតប្រសិនបើគ្មាន។
- មានវិធីជាមូលដ្ឋានចំនួន ៤ ដើម្បីតំណាង graph ក្នុង memory:
-
MIT(វីដេអូ):
-
ការបង្រៀន Skiena - ការណែនាំ:
- CSE373 2012 - មេរៀនទី 11 - Graph Data Structures (វីដេអូ)
- CSE373 2012 - មេរៀនទី 12 - Breadth-First Search (វីដេអូ)
- CSE373 2012 - មេរៀនទី 13 - Graph Algorithms (វីដេអូ)
- CSE373 2012 - មេរៀនទី 14 - Graph Algorithms (បន្ត) (វីដេអូ)
- CSE373 2012 - មេរៀនទី 15 - Graph Algorithms (បន្ត 2) (វីដេអូ)
- CSE373 2012 - មេរៀនទី 16 - Graph Algorithms (បន្ត 3) (វីដេអូ)
-
Graphs (ពិនិត្យឡើងវិញ និង ច្រើនទៀត):
- 6.006 Single-Source Shortest Paths Problem (វីដេអូ)
- 6.006 Dijkstra (វីដេអូ)
- 6.006 Bellman-Ford (វីដេអូ)
- 6.006 Speeding Up Dijkstra (វីដេអូ)
- Aduni: Graph Algorithms I - Topological Sorting, Minimum Spanning Trees, Prim's Algorithm - មេរៀនទី 6 (វីដេអូ)
- Aduni: Graph Algorithms II - DFS, BFS, Kruskal's Algorithm, Union Find Data Structure - មេរៀនទី 7 (វីដេអូ)
- Aduni: Graph Algorithms III: Shortest Path - មេរៀនទី 8 (វីដេអូ)
- Aduni: Graph Alg. IV: Intro to geometric algorithms - មេរៀនទី 9 (វីដេអូ)
-
CS 61B 2014 (starting at 58:09) (វីដេអូ) - CS 61B 2014: Weighted graphs (វីដេអូ)
- Greedy Algorithms: Minimum Spanning Tree (វីដេអូ)
- Strongly Connected Components Kosaraju's Algorithm Graph Algorithm (វីដេអូ)
-
វគ្គសិក្សា Coursera:
-
ខ្ញុំនឹងអនុវត្ត:
- DFS ជាមួយ adjacency list (recursive)
- DFS ជាមួយ adjacency list (iterative with stack)
- DFS ជាមួយ adjacency matrix (recursive)
- DFS ជាមួយ adjacency matrix (iterative with stack)
- BFS ជាមួយ adjacency list
- BFS ជាមួយ adjacency matrix
- single-source shortest path (Dijkstra)
- minimum spanning tree
- DFS-based algorithms (សូមមេីល Aduni វីដេអូ ខាងលេី):
- ពិនិត្យ cycle (ត្រូវការសំរាប់ topological sort ព្រោះយើងនឹងពិនិត្យមើលវដ្តមុនពេលចាប់ផ្តើម)
- topological sort
- រាប់សមាសធាតុដែលបានភ្ជាប់នៅក្នុងក្រាហ្វ
- រាយសមាសធាតុដែលភ្ជាប់គ្នាយ៉ាងខ្លាំង
- ពិនិត្យក្រាហ្វិច bipartite
-
- ការបង្រៀនរបស់ Stanford លេី recursion និង backtracking:
- នៅពេលដែលសមរម្យដើម្បីប្រើវា
- តេី tail recursion ប្រសើរជាងអត់?
-
- អ្នកប្រហែលជាមិនឃើញមានបញ្ហានៃការសរសេរកម្មវិធី dynamic programming នៅក្នុងបទសម្ភាសន៍របស់អ្នកទេ ប៉ុន្តែវាសមនឹងទទួលបានការទទួលស្គាល់នូវបញ្ហាមួយក្នុងនាមជាបេក្ខជនសម្រាប់ការសរសេរកម្មវិធី dynamic programming។
- ប្រធានបទនេះអាចជាការពិបាកណាស់, ព្រោះថាបញ្ហារបស់ DP នីមួយៗត្រូវបានកំណត់ថាជាការទាក់ទងគ្នា
- ខ្ញុំស្នើឱ្យក្រឡេកមើលឧទាហរណ៍ជាច្រើននៃបញ្ហា DP រហូតទាល់តែអ្នកមានការយល់ដឹងច្បាស់អំពីគំរូដែលពាក់ព័ន្ធ។
- វីដេអូ:
- វីដេអូ Skiena អាចពិបាកធ្វើតាមព្រោះពេលខ្លះគាត់ប្រើក្តារខៀនដែលវាមើលមិនឃើញ
- Skiena: CSE373 2012 - មេរៀនទី 19 - ការណែនាំអំពី Dynamic Programming (វីដេអូ)
- Skiena: CSE373 2012 - មេរៀនទី 20 - Edit Distance (video)
- Skiena: CSE373 2012 - មេរៀនទី 21 - ឧទាហរណ៍ Dynamic Programming (វីដេអូ)
- Skiena: CSE373 2012 - មេរៀនទី 22 - ការអនុវត្តកម្មវិធី Dynamic Programming (វីដេអូ)
- Simonson: Dynamic Programming 0 (ចាប់ផ្តេីមពី 59:18) (វីដេអូ)
- Simonson: Dynamic Programming I - មេរៀនទី 11 (វីដេអូ)
- Simonson: Dynamic programming II - មេរៀនទី 12 (វីដេអូ)
- បញ្ជីបញ្ហារបស់ DP (នីមួយៗខ្លី): Dynamic Programming (វីដេអូ)
- Yale Lecture notes:
- Coursera:
-
- Optional: UML 2.0 Series (វីដេអូ)
- គោលការណ៍ SOLID OOP: គោលការណ៍ SOLID (វីដេអូ)
-
- ការពិនិត្យ Quick UML (វីដេអូ)
- រៀនគំរូទាំងនេះ:
- strategy
- singleton
- adapter
- prototype
- decorator
- visitor
- factory, abstract factory
- facade
- observer
- proxy
- delegate
- command
- state
- memento
- iterator
- composite
- flyweight
- ជំពូកទី ៦ (ភាគ ១) - Patterns (វីដេអូ)
- ជំពូកទី ៦ (ភាគ ២) - Abstraction-Occurrence, General Hierarchy, Player-Role, Singleton, Observer, Delegation (វីដេអូ)
- ជំពូកទី ៦ (ភាគ ៣) - Adapter, Facade, Immutable, Read-Only Interface, Proxy (video)
- ស៊េរីវីដេអូ (២៧ វីដេអូ)
- Head First Design Patterns
- ខ្ញុំដឹងថាសៀវភៅបទបញ្ញត្តិគឺ“ លំនាំរចនា៖ ធាតុផ្សំនៃកម្មវិធីដែលអាចប្រើឡើងវិញបាន” ប៉ុន្តែក្បាលទីមួយគឺល្អសម្រាប់អ្នកចាប់ផ្តើមដំបូង Object-Oriented ។
- Handy reference: 101 Design Patterns & Tips for Developers
- Design patterns សម្រាប់មនុស្ស
-
- ជំនាញគណិតវិទ្យា៖ វិធីស្វែងរក Factorial, Permutation និង Combination (ជ្រើសរើស) (វីដេអូ)
- Make School: Probability (វីដេអូ)
- Make School: បន្ថែមលេី Probability និង Markov Chains (វីដេអូ)
- Khan Academy:
- ប្លង់វគ្គសិក្សា:
- គ្រាន់តែវីដេអូ - ៤១ (វីដេអូនីមួយៗមានលក្ខណៈសាមញ្ញហើយវីដេអូនីមួយៗខ្លី)៖
-
- ដឹងពីបញ្ហាល្បីរបស់ NP-complete, ដូចជាអ្នកលក់ធ្វើដំណើរ និង បញ្ហា knapsack, ហើយអាចស្គាល់ពួកគេនៅពេលអ្នកសម្ភាសសួរអ្នកដោយក្លែងបន្លំ។.
- ដឹងថាអ្វីជា NP-complete.
- Computational Complexity (វីដេអូ)
- Simonson:
- Skiena:
- Complexity: P, NP, NP-completeness, Reductions (វីដេអូ)
- Complexity: Approximation Algorithms (វីដេអូ)
- Complexity: Fixed-Parameter Algorithms (វីដេអូ)
- Peter Norvig ពិភាក្សាអំពីដំណោះស្រាយដែលល្អប្រសើរបំផុតចំពោះបញ្ហាអ្នកលក់ធ្វើដំណើរ៖
- ទំព័រ 1048 - 1140 ក្នុង CLRS ប្រសិនបើអ្នកមានវា.
-
- Computer Science 162 - Operating Systems (25 វីដេអូ):
- សំរាប់ processes និង threads សូមមេីល វីដេអូ 1-11
- Operating Systems and System Programming (វីដេអូ)
- តេី Process និង Thread ខុសគ្នាដូចម្តេច?
- មាន:
- Processes, Threads, Concurrency issues
- តេី Process និង Thread ខុសគ្នាដូចម្តេច
- Processes
- Threads
- Locks
- Mutexes
- Semaphores
- Monitors
- តើពួកគេធ្វើការយ៉ាងដូចម្តេច?
- Deadlock
- Livelock
- CPU activity, interrupts, context switching
- Modern concurrency constructs with multicore processors
- Paging, segmentation and virtual memory (វីដេអូ)
- Interrupts (វីដេអូ)
- Process resource needs (memory: code, static storage, stack, heap, and also file descriptors, i/o)
- Thread resource needs (shares above (minus stack) with other threads in the same process but each has its own pc, stack counter, registers, and stack)
- Forking is really copy on write (read-only) until the new process writes to memory, then it does a full copy.
- Context switching
- How context switching is initiated by the operating system and underlying hardware?
- Processes, Threads, Concurrency issues
- threads in C++ (series - 10 វីដេអូ)
- concurrency ក្នុង Python (វីដេអូ):
- Computer Science 162 - Operating Systems (25 វីដេអូ):
-
- To cover:
- តេី unit testing ដំណេីរការយ៉ាងដូចម្តេច ?
- អ្វីជា mock objects ?
- អ្វីជា integration testing ?
- អ្វីជា dependency injection ?
- Agile Software Testing with James Bach (វីដេអូ)
- Open Lecture by James Bach on Software Testing (វីដេអូ)
- Steve Freeman - Test-Driven Development (that’s not what we meant) (វីដេអូ)
- Dependency injection:
- How to write tests
- To cover:
-
- នៅក្នុង OS, តេីវាដំណេីរការយ៉ាងដូចម្តេច ?
- អាចប្រមូលបាន Operating System videos
-
- Sedgewick - Suffix Arrays (វីដេអូ)
- Sedgewick - Substring Search (វីដេអូ)
- Search pattern in text (វីដេអូ)
ប្រសិនបើអ្នកត្រូវការព័ត៌មានលម្អិតបន្ថែមលើប្រធានបទនេះសូមមើលផ្នែក Additional Detail on Some Subjects.
-
- ចំណាំ មានការ Tries ផ្សេងៗគ្នា។ អ្នកខ្លះមានprefixes អ្នកខ្លះមិនមាន ហើយអ្នកខ្លះប្រើstring ជំនួសឱ្យbits ដើម្បីតាមដានផ្លូវ
- ខ្ញុំបានអានកូដប៉ុន្តែនឹងមិនអនុវត្តឡើយ
- Sedgewick - Tries (3 វីដេអូ)
- Notes on Data Structures and Programming Techniques
- វីដេអូខ្លីៗ:
- The Trie: A Neglected Data Structure
- TopCoder - Using Tries
- Stanford Lecture (real world use case) (វីដេអូ)
- MIT, Advanced Data Structures, Strings (can get pretty obscure about halfway through) (វីដេអូ)
-
- Big And Little Endian
- Big Endian Vs Little Endian (វីដេអូ)
- Big And Little Endian Inside/Out (វីដេអូ)
- និយាយបច្ចេកទេសខ្លាំងណាស់សម្រាប់ kernel devs. កុំបារម្ភប្រសិនបេីមិនយល់ទាំងស្រុង
- ពាក់កណ្តាលទីមួយគឺគ្រប់គ្រាន់ហើយ
-
- ** ប្រសិនបើអ្នកមានបទពិសោធបណ្តាញឬចង់ក្លាយជាវិស្វករដែលអាចជឿជាក់បានឬវិស្វករប្រតិបត្តិការរំពឹងថានឹងមានសំណួរ **
- បើមិនដូច្នោះទេនេះគ្រាន់តែជាការល្អដើម្បីដឹង
- Khan Academy
- UDP and TCP: Comparison of Transport Protocols (វីដេអូ)
- TCP/IP and the OSI Model Explained! (វីដេអូ)
- Packet Transmission across the Internet. Networking & TCP/IP tutorial. (វីដេអូ)
- HTTP (វីដេអូ)
- SSL and HTTPS (វីដេអូ)
- SSL/TLS (វីដេអូ)
- HTTP 2.0 (វីដេអូ)
- Video Series (21 វីដេអូ) (វីដេអូ)
- Subnetting Demystified - Part 5 CIDR Notation (វីដេអូ)
- Sockets:
** អ្នកអាចរំពឹងថានឹងមានសំណួររចនាប្រព័ន្ធប្រសិនបើអ្នកមានបទពិសោធ 4+ ឆ្នាំ។ **
- Scalability និង System Designគឺជាប្រធានបទដែលមានប្រធានបទជាច្រេីន និង ធនធានជាច្រើន ដោយសារវាត្រូវការគិតច្រេីនពេលបង្កេីតប្រព័ន្ធដែលល្អ រំពឹងថានឹងចំណាយពេលបន្តិចលើរឿងនេះ
- ការពិចារណា:
- Scalability
- Distill large data sets to single values
- Transform one data set to another
- Handling obscenely large amounts of data
- System design
- features sets
- interfaces
- class hierarchies
- designing a system under certain constraints
- simplicity and robustness
- tradeoffs
- performance analysis and optimization
- Scalability
- ចាប់ផ្តើមនៅទីនេះ: The System Design Primer
- System Design from HiredInTech
- How Do I Prepare To Answer Design Questions In A Technical Inverview?
- 8 Things You Need to Know Before a System Design Interview
- Algorithm design
- Database Normalization - 1NF, 2NF, 3NF and 4NF (វីដេអូ)
- System Design Interview - There are a lot of resources in this one. Look through the articles and examples. I put some of them below
- How to ace a systems design interview
- Numbers Everyone Should Know
- How long does it take to make a context switch?
- Transactions Across Datacenters (វីដេអូ)
- A plain English introduction to CAP Theorem
- Consensus Algorithms:
- Consistent Hashing
- NoSQL Patterns
- Scalability:
- អ្នកមិនត្រូវការរបស់ទាំងអស់នេះទេ។ គ្រាន់តែជ្រើសរើសយកចំណាប់អារម្មណ៍មួយចំនួនដែលអ្នកចាប់អារម្មណ៍។
- Great overview (វីដេអូ)
- ស៊េរីខ្លីៗ:
- Scalable Web Architecture and Distributed Systems
- Fallacies of Distributed Computing Explained
- Pragmatic Programming Techniques
- Jeff Dean - Building Software Systems At Google and Lessons Learned (វីដេអូ)
- Introduction to Architecting Systems for Scale
- Scaling mobile games to a global audience using App Engine and Cloud Datastore (វីដេអូ)
- How Google Does Planet-Scale Engineering for Planet-Scale Infra (វីដេអូ)
- The Importance of Algorithms
- Sharding
- Scale at Facebook (2012), "Building for a Billion Users" (វីដេអូ)
- Engineering for the Long Game - Astrid Atkinson Keynote(វីដេអូ)
- 7 Years Of YouTube Scalability Lessons In 30 Minutes
- How PayPal Scaled To Billions Of Transactions Daily Using Just 8VMs
- How to Remove Duplicates in Large Datasets
- A look inside Etsy's scale and engineering culture with Jon Cowie (វីដេអូ)
- What Led Amazon to its Own Microservices Architecture
- To Compress Or Not To Compress, That Was Uber's Question
- Asyncio Tarantool Queue, Get In The Queue
- When Should Approximate Query Processing Be Used?
- Google's Transition From Single Datacenter, To Failover, To A Native Multihomed Architecture
- Spanner
- Machine Learning Driven Programming: A New Programming For A New World
- The Image Optimization Technology That Serves Millions Of Requests Per Day
- A Patreon Architecture Short
- Tinder: How Does One Of The Largest Recommendation Engines Decide Who You'll See Next?
- Design Of A Modern Cache
- Live Video Streaming At Facebook Scale
- A Beginner's Guide To Scaling To 11 Million+ Users On Amazon's AWS
- How Does The Use Of Docker Effect Latency?
- A 360 Degree View Of The Entire Netflix Stack
- Latency Is Everywhere And It Costs You Sales - How To Crush It
- Serverless (very long, just need the gist)
- What Powers Instagram: Hundreds of Instances, Dozens of Technologies
- Cinchcast Architecture - Producing 1,500 Hours Of Audio Every Day
- Justin.Tv's Live Video Broadcasting Architecture
- Playfish's Social Gaming Architecture - 50 Million Monthly Users And Growing
- TripAdvisor Architecture - 40M Visitors, 200M Dynamic Page Views, 30TB Data
- PlentyOfFish Architecture
- Salesforce Architecture - How They Handle 1.3 Billion Transactions A Day
- ESPN's Architecture At Scale - Operating At 100,000 Duh Nuh Nuhs Per Second
- See "Messaging, Serialization, and Queueing Systems" way below for info on some of the technologies that can glue services together
- Twitter:
- មេីលបន្ធែម "Mining Massive Datasets" video series in the វីដេអូ section
- ការអនុវត្តដំណើរការរចនាប្រព័ន្ធ៖ នេះគឺជាគំនិតមួយចំនួនដើម្បីព្យាយាមធ្វើការលើក្រដាសនីមួយៗដោយមានឯកសារមួយចំនួនស្តីពីវិធីដែលត្រូវបានដោះស្រាយនៅក្នុងពិភពពិត៖
- ពិនិត្យឡើងវិញ: The System Design Primer
- System Design from HiredInTech
- cheat sheet
- flow:
- ស្វែងយល់ពីបញ្ហានិងវិសាលភាព
- កំណត់ករណីប្រើប្រាស់ដោយមានជំនួយពីអ្នកសម្ភាសន៍
- ស្នើលក្ខណៈបន្ថែម
- ដកចេញលក្ខណៈដែលអ្នកសម្ភាសន៍គិតថាលើស
- សន្មតថាភាពអាចរកបានខ្ពស់ត្រូវបានទាមទារបន្ថែមជាករណីប្រើប្រាស់
- គិតអំពីឧបសគ្គ៖
- សួរថាតើមានប៉ុន្មានសំណើរប៉ុន្មានក្នុងមួយខែ
- សួរថាតើមានសំណូមពរប៉ុន្មានក្នុងមួយវិនាទី (ពួកគេអាចស្ម័គ្រចិត្តឬធ្វើឱ្យអ្នកធ្វើគណនា)
- ប៉ាន់ស្មានអាននឹងសរសេរជាភាគរយ
- ចងចាំបទបញ្ជា ៨០/២០ ក្នុងពេលធ្វើការប៉ាន់ស្មាន
- តើទិន្នន័យប៉ុន្មានត្រូវបានសរសេរក្នុងមួយវិនាទី
- ការផ្ទុកសរុបត្រូវការក្នុងរយៈពេល ៥ ឆ្នាំ
- តើទិន្នន័យត្រូវអានប៉ុន្មានដងក្នុងមួយវិនាទី
- ការរចនាអរូបី៖
- ស្រទាប់ (សេវាកម្ម ទិន្នន័យ ឃ្លាំងសម្ងាត់ (cache) )
- ហេដ្ឋារចនាសម្ព័ន្ធ៖ ផ្ទុកតុល្យភាព(load balacing), សារ
- ទិដ្ឋភាពទូទៅរដុបនៃក្បួនដោះស្រាយគន្លឹះណាមួយដែលជំរុញសេវាកម្ម
- ពិចារណាការរាំងស្ទះនិងកំណត់ដំណោះស្រាយ
- ស្វែងយល់ពីបញ្ហានិងវិសាលភាព
- លំហាត់:
ផ្នែកនេះនឹងមានវីដេអូខ្លីៗដែលអ្នកអាចមើលបានយ៉ាងរហ័សដើម្បីពិនិត្យឡើងវិញនូវគោលគំនិតសំខាន់ៗ។ វាល្អណាស់ប្រសិនបើអ្នកចង់ធ្វើឱ្យស្រស់ជាងមុន។
- Series of 2-3 minutes short subject videos (23 វីដេអូ)
- Series of 2-5 minutes short subject videos - Michael Sambol (18 វីដេអូ):
- វីដេអូ Sedgewick - Algorithms I
- វីដេអូ Sedgewick - Algorithms II
ឥឡូវអ្នកដឹងពីប្រធានបទវិទ្យាសាស្ត្រកុំព្យូទ័រទាំងអស់ខាងលើ វាដល់ពេលត្រូវអនុវត្តការឆ្លើយសំនួរបញ្ហា។
ការអនុវត្តសំណួរសរសេរកូដមិនមែនអំពីការទន្ទេញចម្លើយចំពោះបញ្ហាសរសេរកម្មវិធីទេ។
មូលហេតុដែលអ្នកត្រូវអនុវត្តធ្វើបញ្ហាសរសេរកម្មវិធី៖
- ការទទួលស្គាល់បញ្ហានិងកន្លែងដែលរចនាសម្ព័ន្ធទិន្នន័យត្រឹមត្រូវនិងក្បួនដោះស្រាយត្រូវគ្នា
- ការប្រមូលផ្តុំតម្រូវការសម្រាប់បញ្ហា
- និយាយពីបញ្ហាដូចជាអ្នកនឹងជួបអ្នកសម្ភាសន៍ដែរ
- សរសេរកូដនៅលើក្តារខៀនឬក្រដាសមិនមែនកុំព្យូទ័រទេ
- មានពេលវេលានិងចន្លោះស្មុគស្មាញសម្រាប់ដំណោះស្រាយរបស់អ្នក
- សាកល្បងតេសដំណោះស្រាយរបស់អ្នក
មានការណែនាំដ៏ល្អសំរាប់វិធីសាស្រ្តដោះស្រាយបញ្ហាដែលមានលក្ខណៈជាបញ្ហាក្នុងការសំភាសន៍។ អ្នកនឹងទទួលបានពីកម្មវិធីសៀវភៅសំភាសន៍ផងដែរប៉ុន្តែខ្ញុំបានរកឃើញថាលេចធ្លោនេះ៖ Algorithm design canvas
គ្មានក្តារខៀននៅផ្ទះទេ? ខ្ញុំជាមនុស្សចំលែកនិងមានក្តារខៀនធំ។ ជំនួសឱ្យក្តារខៀន សូមរើសយកផ្ទាំងគំនូរធំ ៗ ពីហាងសិល្បៈ។ អ្នកអាចអង្គុយលើសាឡុងនិងអនុវត្តបាន។ នេះគឺជា "សាឡុងក្តារចុច" របស់ខ្ញុំ។ ខ្ញុំបានបន្ថែមប៊ិចនៅក្នុងរូបថតសម្រាប់ខ្នាត។ ប្រសិនបើអ្នកប្រើប៊ិចអ្នកនឹងចង់លុបចោល។ ឆាប់រញ៉េរញ៉ៃ។ ខ្ញុំប្រើខ្មៅដៃនិងជ័រលុប។
បន្ថែម:
- Mathematics for Topcoders
- Dynamic Programming – From Novice to Advanced
- MIT Interview Materials
- Exercises for getting better at a given language
អាននិងធ្វើបញ្ហាកម្មវិធី (តាមលំដាប់លំដោយ):
- Programming Interviews Exposed: Secrets to Landing Your Next Job, 2nd Edition
- ចម្លើយជា C, C++ និង Java
- Cracking the Coding Interview, 6th Edition
- ចម្លើយជា Java
មេីលសៀភៅ Book List above
នៅពេលដែលអ្នកបានរៀនខួរក្បាលរបស់អ្នកហើយ សូមដាក់ខួរក្បាលទាំងនោះឱ្យដំណើរការ។ យកបញ្ហាប្រឈមនៃការសរសេរកូដជារៀងរាល់ថ្ងៃតាមដែលអ្នកអាចធ្វើបាន។
វីឌីអូសំភាសន៍ការសរសេរកូដ:
- IDeserve (88 វីដេអូ)
- Tushar Roy (5 playlists)
- Super for walkthroughs of problem solutions
- Nick White - LeetCode Solutions (187 វីដេអូ)
- ការពន្យល់ល្អអំពីដំណោះស្រាយនិងលេខកូដ
- អ្នកអាចមើលបានច្រើនក្នុងរយៈពេលដ៏ខ្លី
- FisherCoder - LeetCode Solutions
គេហទំព័រប្រកួតប្រជែង:
- LeetCode
- គេហទំព័របញ្ហាសរសេរកូដដែលខ្ញុំចូលចិត្តបំផុត។ វាមានតម្លៃសម្រាប់ការជាវប្រាក់សម្រាប់រយៈពេល 1-2 ខែដែលអ្នកទំនងជានឹងរៀបចំ
- LeetCode solutions from FisherCoder
- សូមមើលវីដេអូស Nick ខាងលើសម្រាប់លេខកូដខ្លី
- HackerRank
- TopCoder
- InterviewCake
- Geeks for Geeks
- InterviewBit
- Project Euler (math-focused)
- Code Exercises
គេហទំព័រសិក្សាភាសាដែលមានបញ្ហាប្រឈម៖
Challenge repos:
Mock Interviews:
- Gainlo.co: Mock interviewers from big companies - I used this and it helped me relax for the phone screen and on-site interview
- Pramp: Mock interviews from/with peers - peer-to-peer model of practice interviews
- Refdash: Mock interviews and expedited interviews - also help candidates fast track by skipping multiple interviews with tech companies
- interviewing.io: Practice mock interview with senior engineers - anonymous algorithmic/systems design interviews with senior engineers from FAANG anonymously.
- Cracking The Coding Interview Set 2 (វីដេអូ):
- មើលបន្តការរៀបចំរបស់នៅក្នុង Cracking The Coding Interview និង back of Programming Interviews Exposed
គិតអំពីសំណួរសំភាសន៍ចំនួន 20 ដែលអ្នកនឹងទទួលបានរួមជាមួយធាតុខាងក្រោម។ មានចម្លើយ ២-៣ សម្រាប់ចម្លើយនីមួយៗ។ មានរឿងរ៉ាវមិនមែនគ្រាន់តែទិន្នន័យអំពីអ្វីដែលអ្នកបានសំរេចនោះទេ។
- ហេតុអ្វីបានជាអ្នកចង់បានការងារនេះ?
- តើអ្វីជាបញ្ហាដ៏លំបាកដែលអ្នកបានដោះស្រាយ?
- បញ្ហាធំ ៗ ដែលប្រឈមមុខ?
- ការរចនាម៉ូដណាដែលល្អបំផុត / អាក្រក់បំផុត?
- គំនិតសម្រាប់កែលម្អផលិតផលដែលមានស្រាប់
- តើអ្នកធ្វើការបានល្អបំផុតដោយរបៀបណាក្នុងនាមជាបុគ្គលនិងជាក្រុម?
- ជំនាញឬបទពិសោធន៍ណាមួយរបស់អ្នកដែលជាទ្រព្យសម្បត្តិនៅក្នុងតួនាទីហើយហេតុអ្វី?
- តើអ្វីដែលអ្នកពេញចិត្តបំផុតនៅ [ការងារ x / គម្រោង y]?
- តើអ្វីជាបញ្ហាប្រឈមដ៏ធំបំផុតដែលអ្នកបានប្រឈមនៅ [ការងារ x / គម្រោង y]?
- តើអ្វីទៅជាកំហុសដ៏លំបាកបំផុតដែលអ្នកបានជួបប្រទះនៅ [ការងារ x / គម្រោង y]?
- តើអ្នកបានរៀនអ្វីខ្លះនៅ [ការងារ x / គំរោង y]? តើអ្នកនឹងធ្វើអ្វីបានល្អជាងនៅ [ការងារ x / គំរោង y]?
សំនួរខ្លះរបស់ខ្ញុំ (ខ្ញុំប្រហែលជាដឹងចម្លើយរួចហើយប៉ុន្តែចង់បានយោបល់ឬទស្សនៈក្រុមរបស់ពួកគេ)
- តើក្រុមរបស់អ្នកមានទំហំប៉ុនណា?
- តើវដ្ដ dev របស់អ្នកមើលទៅដូចអ្វី? តើអ្នកធ្វើទឹកជ្រោះទឹកពន្លក / ឆាប់រហ័សទេ?
- តើប្រញាប់ប្រញាល់ដល់ពេលវេលាកំណត់ទេ? ឬមានភាពបត់បែន?
- តើការសម្រេចចិត្តត្រូវបានធ្វើឡើងនៅក្នុងក្រុមរបស់អ្នកយ៉ាងដូចម្តេច?
- តើអ្នកមានការប្រជុំប៉ុន្មានដងក្នុងមួយសប្តាហ៍?
- តើអ្នកមានអារម្មណ៍ថាបរិយាកាសការងាររបស់អ្នកជួយអ្នកក្នុងការផ្តោតអារម្មណ៍ទេ?
- តើអ្នកកំពុងធ្វើអ្វី?
- តើអ្នកចូលចិត្តអ្វី?
- ជីវិតការងារដូចជាអ្វី?
- តើការងារ / ជីវិតមានតុល្យភាពយ៉ាងដូចម្តេច?
សូមអបអរសាទរ!
បន្តរៀន។
រៀនមិនចេះចប់។
*****************************************************************************************************
*****************************************************************************************************
អ្វីគ្រប់យ៉ាងនៅខាងក្រោមចំណុចនេះគឺស្រេចចិត្តបេីចង់មេីល។
តាមរយៈការសិក្សាទាំងនេះ អ្នកនឹងទទួលបានការយល់ដឹងកាន់តែច្រើនពីគំនិតវិទ្យាសាស្ត្រកុំព្យូទ័រ ហើយអ្នកនឹងត្រូវបានរៀបចំខ្លួនឱ្យកាន់តែប្រសើរ
ការងារវិស្វកម្មផ្នែកទន់ណាមួយ។ អ្នកនឹងក្លាយជាវិស្វករផ្នែកទន់ដែលមានចំេនះពេញលេញ។
*****************************************************************************************************
*****************************************************************************************************
ទាំងនេះគឺនៅទីនេះដូច្នេះអ្នកអាចចូលទៅក្នុងប្រធានបទដែលអ្នកចាប់អារម្មណ៍។
-
The Unix Programming Environment
- ចាស់តែល្អ
-
The Linux Command Line: A Complete Introduction
- ជម្រើសទំនើប
-
- ការណែនាំ design patterns
-
Design Patterns: Elements of Reusable Object-Oriented Software
- AKA the "Gang Of Four" book, or GOF
- The canonical design patterns book
-
Algorithm Design Manual (Skiena)
- ជាការពិនិត្យឡើងវិញនិងការទទួលស្គាល់បញ្ហា
- ផ្នែកកាតាឡុកក្បួនដោះស្រាយគឺហួសពីវិសាលភាពនៃការពិបាកដែលអ្នកនឹងជួបសម្ភាសន៍
- សៀវភៅនេះមានពីរផ្នែក៖
- សៀវភៅសិក្សាថ្នាក់ស្តីពីរចនាសម្ព័ន្ធទិន្នន័យនិងក្បួនដោះស្រាយ
- គុណសម្បត្តិ:
- គឺជាការពិនិត្យឡើងវិញដ៏ល្អមួយដែលជាសៀវភៅក្បួនដោះស្រាយណាមួយ
- រឿងល្អ ៗ ពីបទពិសោធន៍របស់គាត់ដោះស្រាយបញ្ហានៅក្នុងឧស្សាហកម្មនិងបណ្ឌិតសភា
- ឧទាហរណ៍កូដនៅក្នុង C
- គុណវិបត្តិ:
- Can be as dense or impenetrable as CLRS, and in some cases, CLRS may be a better alternative for some subjects
- Chapters 7, 8, 9 can be painful to try to follow, as some items are not explained well or require more brain than I have
- Don't get me wrong: I like Skiena, his teaching style, and mannerisms, but I may not be Stony Brook material
- គុណសម្បត្តិ:
- Algorithm catalog:
- នេះជាហេតុផលពិតប្រាកដដែលអ្នកទិញសៀវភៅនេះ
- ហៀបនឹងចូលដល់ផ្នែកនេះ។ នឹងធ្វើបច្ចុប្បន្នភាពនៅទីនេះនៅពេលដែលខ្ញុំបានឆ្លងកាត់វា
- សៀវភៅសិក្សាថ្នាក់ស្តីពីរចនាសម្ព័ន្ធទិន្នន័យនិងក្បួនដោះស្រាយ
- អាចជួលវានៅលើ Kindle
- ចម្លើយ:
- Errata
-
Write Great Code: Volume 1: Understanding the Machine
- សៀវភៅនេះត្រូវបានបោះពុម្ពផ្សាយក្នុងឆ្នាំ ២០០៤ ហើយវាហួសសម័យបន្តិចប៉ុន្តែវាជាធនធានដ៏អស្ចារ្យសម្រាប់ការស្វែងយល់អំពីកុំព្យូទ័រដោយសង្ខេប
- The author invented HLA, so take mentions and examples in HLA with a grain of salt. Not widely used, but decent examples of what assembly looks like
- ជំពូកទាំងនេះពិតជាមានប្រយោជន៍ក្នុងការអានដើម្បីផ្តល់ឱ្យអ្នកនូវគ្រឹះដ៏ល្អមួយ:
- Chapter 2 - Numeric Representation
- Chapter 3 - Binary Arithmetic and Bit Operations
- Chapter 4 - Floating-Point Representation
- Chapter 5 - Character Representation
- Chapter 6 - Memory Organization and Access
- Chapter 7 - Composite Data Types and Memory Objects
- Chapter 9 - CPU Architecture
- Chapter 10 - Instruction Set Architecture
- Chapter 11 - Memory Architecture and Organization
-
- សំខាន់ៈ ការអានសៀវភៅនេះនឹងមានតម្លៃតែប៉ុណ្ណោះ។ សៀវភៅនេះគឺជាការពិនិត្យឡើងវិញដ៏អស្ចារ្យនៃក្បួនដោះស្រាយនិងរចនាសម្ព័ន្ធទិន្នន័យប៉ុន្តែនឹងមិនបង្រៀនអ្នកពីរបៀបសរសេរកូដល្អទេ។ អ្នកត្រូវតែចេះសរសេរកូដដំណោះស្រាយប្រកបដោយប្រសិទ្ធភាព
- AKA CLR, sometimes CLRS, because Stein was late to the game
-
Computer Architecture, Sixth Edition: A Quantitative Approach
- For a richer, more up-to-date (2017), but longer treatment
-
- ជំពូកដំបូង បង្ហាញនូវដំណោះស្រាយដ៏ឆ្លាតវៃចំពោះបញ្ហាសរសេរកម្មវិធី (ខ្លះចាស់ដោយប្រើខ្សែអាត់ទិន្នន័យ) ប៉ុន្តែនោះគ្រាន់តែជាការណែនាំប៉ុណ្ណោះ។ សៀវភៅណែនាំស្តីពីការរចនាកម្មវិធីនិងស្ថាបត្យកម្ម
ខ្ញុំបានបន្ថែមពួកគេដើម្បីជួយអ្នកឱ្យក្លាយជាវិស្វករផ្នែកទន់ដែលមានមានចំេណះពេញលេញហើយត្រូវដឹងច្បាស់បច្ចេកវិទ្យានិងក្បួនដោះស្រាយដូច្នេះអ្នកនឹងមានប្រអប់ឧបករណ៍ធំជាងមុន។
-
- រៀនពី unix-based code editor
- vi(m):
- emacs:
-
- Khan Academy
- បន្ថែមទៀតអំពី Markov processes:
- សូមមើលបន្ថែមនៅ MIT 6.050J Information និង Entropy series
-
- Intro
- Parity
- Hamming Code:
- Error Checking
-
- សូមមើលវីដេអូខាងក្រោមផង
- ត្រូវប្រាកដថាមើលវីដេអូទ្រឹស្តីព័ត៌មានជាមុន
- Information Theory, Claude Shannon, Entropy, Redundancy, Data Compression & Bits (វីដេអូ)
-
- សូមមើលវីដេអូខាងក្រោមផង
- ត្រូវប្រាកដថាមើលវីដេអូទ្រឹស្តីព័ត៌មានជាមុន
- Khan Academy Series
- Cryptography: Hash Functions
- Cryptography: Encryption
-
- ត្រូវប្រាកដថាមើលវីដេអូទ្រឹស្តីព័ត៌មានជាមុន
- Computerphile (វីដេអូ):
- វីដេអូ Compressor Head
- (optional) Google Developers Live: GZIP is not enough!
-
- ចំពោះBloom filterមួយដែលមាន m bits និង មុខងារhasing k, ទាំងការបញ្ចូលនិងការធ្វើតេស្តសមាជិកភាពគឺO(k)
- Bloom Filters (video)
- Bloom Filters | Mining of Massive Datasets | Stanford University (វីដេអូ)
- Tutorial
- How To Write A Bloom Filter App
-
- ប្រើដើម្បីកំណត់ភាពស្រដៀងគ្នានៃឯកសារ
- ការផ្ទុយមកពី MD5 ឬ SHA ដែលត្រូវបានប្រើដើម្បីកំណត់ថាតើឯកសារ ឬ ខ្សែអក្សរចំនួន ២ ពិតជាដូចគ្នា
- Simhashing (hopefully) made simple
-
-
ស្គាល់យ៉ាងហោចណាស់មែកធាងគោលពីរដែលមានតុល្យភាព (balanced binary tree) (និងដឹងពីរបៀបដែលវាត្រូវបានអនុវត្ត)៖
-
“ ក្នុងចំណោមដើមឈើស្វែងរកដែលមានតុល្យភាពដើម (balanced binary tree) AVL និងដើមឈើ ២/៣មិនពេញនិយមទេ៕ red-black trees ហាក់ដូចជាមានប្រជាប្រិយភាពជាង។ រចនាសម្ពន្ធ័ទិន្នន័យរៀបចំដោយខ្លួនឯងដែលគួរឱ្យចាប់អារម្មណ៍ជាពិសេសគឺមែកឈើsplay tree ដែលប្រើការបង្វិល ដើម្បីផ្លាស់ទីកូនសោណាដែលបានចូលទៅកាន់ឬស។ "- ស្គីណា (Skiena)
-
ក្នុងចំណោមទាំងនេះខ្ញុំបានជ្រើសរើសអនុវត្តមែកឈើ splay tree ។ ពីអ្វីដែលខ្ញុំបានអានអ្នកនឹងមិនអនុវត្តទេនៅមែកធាងស្វែងរកមានតុល្យភាពនៅក្នុងបទសម្ភាសន៍របស់អ្នក។ ប៉ុន្តែខ្ញុំចង់បង្ហាញលេខកូដ ហើយប្រឈមមុខនឹងវា ។ ខ្ញុំបានអានលេខកូដred-black treeច្រើន
- Splay tree: បញ្ចូល, ស្វែងរក, លុប ប្រសិនបើអ្នកអនុវត្តដើមឈើក្រហម / ខ្មៅសាកល្បងទាំងនេះ៖
- មុខងារស្វែងរក និង ការបញ្ចូល ការរំលងលុប
-
ខ្ញុំចង់រៀនបន្ថែមទៀតអំពី B-Tree ចាប់តាំងពីវាត្រូវបានគេប្រើយ៉ាងទូលំទូលាយជាមួយសំណុំទិន្នន័យធំ ៗ
-
AVL trees
-
ក្នុងការអនុវត្ត ៖ តាមអ្វីដែលខ្ញុំអាចប្រាប់បាន អ្វីៗទាំងនេះមិនត្រូវបានគេប្រើច្រើនទេនៅក្នុងការអនុវត្តប៉ុន្តែខ្ញុំអាចមើលឃើញកន្លែងដែលពួកគេប្រីវា៖ AVL Tree គឺជារចនាសម្ព័នមួយផ្សេងទៀតដែលគាំទ្រដល់ការស្វែងរក (បញ្ចូល n) ការបញ្ចូល និង ការដកយកចេញ។ វាកាន់តែម៉ឺងម៉ាត់ មានតុល្យភាពជាងដើមឈើខ្មៅក្រហម (red-black tree) ដែលមានការបញ្ចូលយឺត និង ដកចេញយឺត ប៉ុន្តែការទាញមកវិញលឿនជាងមុន។ នេះធ្វើឱ្យវា មានភាពទាក់ទាញសម្រាប់រចនាសម្ព័ន្ធទិន្នន័យដែលអាចត្រូវបានសាងសង់ម្តងហើយផ្ទុកដោយមិនមានការកសាងឡើងវិញដូចជាភាសា វចនានុក្រម (ឬវចនានុក្រមកម្មវិធីដូចជា opcodes របស់ assembler ឬ interpreter)
-
-
Splay trees
- ក្នុងការអនុវត្ត ៖ Splay trees ត្រូវបានប្រើជាធម្មតាក្នុងការអនុវត្ត caches, memory allocators, routers, garbage collectors, data compression, ropes (ការជំនួស string ដែលប្រើសម្រាប់ long text strings), ក្នុង Windows NT (ក្នុង virtual memory, networking និង file system code) ជាដេីម
- CS 61B: Splay Trees (វីដេអូ)
- MIT Lecture: Splay Trees:
- វាមានគណិតច្រេីន តែអាចមេីល១០ នាទីចុងក្រោយបាន
- វីដេអូ
-
Red/black trees
- នេះជាការពិពណ៌នាអំពីដេីមឈេី 2-3 (មើលខាងក្រោម).
- ក្នុងការអនុវត្ត ៖ Red–black trees ផ្តល់ជូនការធានាករណីអាក្រក់បំផុតសម្រាប់ពេលវេលាបញ្ចូល ពេលវេលាលុប និង ពេលវេលាស្វែងរក។ វាមិនត្រឹមតែធ្វើឱ្យពួកគេល្អនៅក្នុងកម្មវិធីដែលត្រូវការពេលវេលាប៉ុណ្ណោះទេ ដូចជាកម្មវិធីជាក់ស្តែង ប៉ុន្តែវាធ្វើឱ្យពួកគេប្លុកមានតម្លៃនៅក្នុងរចនាសម្ព័ន្ធទិន្នន័យផ្សេងទៀតដែលផ្តល់នូវការធានាករណីអាក្រក់បំផុត។ ឧទាហរណ៍រចនាសម្ព័ន្ធទិន្នន័យជាច្រើនដែលត្រូវបានប្រើក្នុងធរណីមាត្រគណនាអាចផ្អែកលើដើមឈើ red–black និង Completely Fair Scheduler ដែលប្រើនៅក្នុងខឺណែលលីនុចបច្ចុប្បន្នប្រើដើមឈើred–black ។ នៅក្នុងកំណែ ៨ នៃចាវ៉ា ការប្រមូលHashMapត្រូវបានកែប្រែហើយដើមឈើ Red-Black ត្រូវបានប្រើ ជំនួសឱ្យការប្រើLinkedListដើម្បីផ្ទុកធាតុដូចគ្នាបេះបិទទៅនឹងhashcodes មិនល្អ
- Aduni - Algorithms - Lecture 4 (តំណភ្ជាប់លោតទៅចំណុចចាប់ផ្តើម) (វីដេអូ)
- Aduni - Algorithms - Lecture 5 (វីដេអូ)
- Red-Black Tree
- An Introduction To Binary Search And Red Black Tree
-
2-3 search trees
- ក្នុងការអនុវត្ត ៖ 2-3 trees មានការបញ្ចូលលឿនជាងមុននៅក្នុងការចំណាយនៃការស្វែងរកយឺត (ដោយសារកំពស់ខ្ពស់ជាងបេីប្រៀបទៅ AVL trees).
- អ្នកអាចនឹងកំរប្រេី 2-3 tree ដោយសារតែការអនុវត្តរបស់វាទាក់ទងនឹងប្រភេទផ្សេងៗគ្នានៃថ្នាំង. ជំនួសវិញយេីងប្រេី Red Black trees.
- 23-Tree Intuition និង និយមន័យ (វីដេអូ)
- Binary View of 23-Tree
- 2-3 Trees (student recitation) (វីដេអូ)
-
2-3-4 Trees (aka 2-4 trees)
- ក្នុងការអនុវត្ត៖ សម្រាប់រាល់ 2-4 tree, វាមាន red–black trees ជាមួយ data elements ដែលមានលំដាប់ដូចគ្នា. ការបញ្ចូលនិងការលុប ប្រតិបត្ដិការនៅលើដើមឈើ 2-4 គឺស្មើទៅនឹងត្រឡប់ពណ៌និងការបង្វិលនៅក្នុងដើមឈើខ្មៅក្រហម. នេះធ្វើឱ្យដើមឈើ 2-4 ដើម ឧបករណ៍សំខាន់សម្រាប់ការស្វែងយល់ពីតក្កវិជ្ជានៅពីក្រោយដើមឈើក្រហម - ក្រហមហើយនេះជាមូលហេតុដែលអត្ថបទណែនាំជាច្រើននៃក្បួនដោះស្រាយណែនាំ ដើមឈើ ២-៤ ដើមមុនដើមឈើក្រហម - ក្រហមទោះបី ** ដើមឈើ ២-៤ ក៏មិនត្រូវបានប្រើក្នុងការអនុវត្តជាក់ស្តែងដែរ ** ។
- CS 61B មេរៀនទី 26: Balanced Search Trees (វីដេអូ)
- Bottom Up 234-Trees (វីដេអូ)
- Top Down 234-Trees (វីដេអូ)
-
N-ary (K-ary, M-ary) trees
- ចំណាំ: the N ឬ K ជា branching factor (max branches)
- binary trees គឺជា 2-ary tree មួយ, ដែលមាន branching factor = 2
- 2-3 trees គឺជា 3-ary
- K-Ary Tree
-
B-Trees
- ការពិត: វាជាអាថ៌កំបាំង, តែ B អាចជា Boeing, Balanced, ឬ Bayer (co-inventor).
- ក្នុងការអនុវត្ត: B-Trees ត្រូវបានប្រើយ៉ាងទូលំទូលាយនៅក្នុង databases. filesystems ទំនើបបំផុតភាគច្រេីនប្រេី B-trees (ឬ Variants). បន្ថែមពីលើ ការប្រើប្រាស់របស់វានៅក្នុង databases, B-tree ក៏ត្រូវបានប្រើនៅក្នុង filesystems ដើម្បីអនុញ្ញាតឱ្យចូលទៅកាន់ quick random access ទៅ arbitrary block មួយ ក្នុងឯកសារជាក់លាក់មួយ. បញ្ហាមូលដ្ឋានគឺការប្រែក្លាយបណ្តុំឯកសារអាយទៅជាប្លុកឌីស (ឬ ប្រហែលជាអាសយដ្ឋាន cylinder-head-sector)
- B-Tree
- B-Tree Datastructure
- សេចក្តីផ្តើមទៅ B-Trees (វីដេអូ)
- និយមន័យ B-Tree និង Insertion (វីដេអូ)
- ការលុប B-Tree (វីដេអូ)
- MIT 6.851 - Memory Hierarchy Models (វីដេអូ) - រៀនពី cache-oblivious B-Trees, data structures - ៣៧ នាទីដំបូងគឺបច្ចេកទេសហើយប្រហែលជាអាចរំលងចោល (B is block size, cache line size)
-
-
- ល្អសម្រាប់ការស្វែងរកចំនួនចំនុចក្នុងចតុកោណកែងឬវត្ថុវិមាត្រខ្ពស់
- ល្អសំរាប់ k-nearest neighbors
- Kd Trees (វីដេអូ)
- kNN K-d tree algorithm (វីដេអូ)
-
- "These are somewhat of a cult data structure" - Skiena
- Randomization: Skip Lists (វីដេអូ)
- សម្រាប់ចលនានិងលម្អិតបន្ថែមទៀត
-
- ការរួមបញ្ចូលគ្នានៃ binary search tree និង a heap
- Treap
- Data Structures: Treaps explained (វីដេអូ)
- Applications in set operations
-
- សូមមើលវីដេអូខាងក្រោម
-
- ហេតុអ្វី ML?
- Google's Cloud Machine learning tools (វីដេអូ)
- Google Developers' Machine Learning Recipes (Scikit Learn & Tensorflow) (វីដេអូ)
- Tensorflow (វីដេអូ)
- Tensorflow Tutorials
- Practical Guide to implementing Neural Networks in Python (using Theano)
- វគ្គសិក្សា:
- វគ្គចាប់ផ្តើមដ៏អស្ចារ្យ: Machine Learning - វីដេអូ - មេីលវីដេអូ 12-18 សំរាប់ linear algebra (14 និង 15 ដូចគ្នា)
- Neural Networks for Machine Learning
- Google's Deep Learning Nanodegree
- Google/Kaggle Machine Learning Engineer Nanodegree
- Self-Driving Car Engineer Nanodegree
- Metis Online Course ($99 សំរាប់ 2 ខែ)
- ធនធាន:
ខ្ញុំបានបន្ថែមគំនិតទាំងនេះដើម្បីពង្រឹងគំនិតមួយចំនួនដែលបានបង្ហាញខាងលើប៉ុន្តែខ្ញុំមិនចង់បញ្ចូលវាខាងលើព្រោះវាច្រើនពេក។ វាងាយស្រួលក្នុងការធ្វើឱ្យវាហួសប្រមាណលើប្រធានបទ។
អ្នកចង់ទទួលបានការងារនៅសតវត្សនេះមែនទេ?
-
SOLID
- Bob Martin SOLID Principles of Object Oriented and Agile Design (វីដេអូ)
- S - Single Responsibility Principle | Single responsibility to each Object
- O - Open/Closed Principal | On production level Objects are ready for extension but not for modification
- L - Liskov Substitution Principal | Base Class and Derived class follow ‘IS A’ principal
- I - Interface segregation principle | clients should not be forced to implement interfaces they don't use
- D -Dependency Inversion principle | Reduce the dependency In composition of objects.
-
Union-Find
-
More Dynamic Programming (វីដេអូ)
- 6.006: Dynamic Programming I: Fibonacci, Shortest Paths
- 6.006: Dynamic Programming II: Text Justification, Blackjack
- 6.006: DP III: Parenthesization, Edit Distance, Knapsack
- 6.006: DP IV: Guitar Fingering, Tetris, Super Mario Bros.
- 6.046: Dynamic Programming & Advanced DP
- 6.046: Dynamic Programming: All-Pairs Shortest Paths
- 6.046: Dynamic Programming (student recitation)
-
Advanced Graph Processing (វីដេអូ)
-
MIT Probability ប្រូបាប (គណិតវិទ្យា បងៀនយឹតល្អ) (វីដេអូ):
-
String Matching
- Rabin-Karp (វីដេអូ):
- Knuth-Morris-Pratt (KMP):
- Boyer–Moore string search algorithm
- Coursera: Algorithms អំពី Strings
- ចាប់ផ្តើមល្អ ប៉ុន្តែដល់ពេលហួស KMP វាកាន់តែស្មុគស្មាញ
- ការពន្យល់ដ៏ល្អនៃការព្យាយាម
- អាចរំលងបាន
-
Sorting
- Stanford lectures on sorting:
- Shai Simonson, Aduni.org:
- ការបង្រៀនរបស់ Steven Skiena អំពី sorting:
រីករាយជាមួយវិដេអូរខាងក្រោម
-
List of individual Dynamic Programming problems (each is short)
-
Excellent - MIT Calculus Revisited: Single Variable Calculus
-
Computer Science 70, 001 - Spring 2015 - Discrete Mathematics and Probability Theory
-
CSE373 - Analysis of Algorithms (25 វីដេអូ)
-
UC Berkeley CS 152: Computer Architecture and Engineering (20 videos) -
Carnegie Mellon - Computer Architecture Lectures (39 វីដេអូ)
-
MIT 6.042J: Mathematics for Computer Science, Fall 2010 (25 វីដេអូ)
-
MIT 6.050J: Information and Entropy, Spring 2008 (19 វីដេអូ)
- Love classic papers?
- 1978: Communicating Sequential Processes
- 2003: The Google File System
- ជំនួសដោយ Colossus ក្នុងឆ្នាំ 2012
- 2004: MapReduce: Simplified Data Processing on Large Clusters
- ជំនួសដោយ Cloud Dataflow?
- 2006: Bigtable: A Distributed Storage System for Structured Data
- 2006: The Chubby Lock Service for Loosely-Coupled Distributed Systems
- 2007: Dynamo: Amazon’s Highly Available Key-value Store
- អត្ថបទ Dynamo ចាប់ផ្តេីមអោយមាន NoSQL
- 2007: What Every Programmer Should Know About Memory (very long, and the author encourages skipping of some sections)
- 2010: Dapper, a Large-Scale Distributed Systems Tracing Infrastructure
- 2010: Dremel: Interactive Analysis of Web-Scale Datasets
- 2012: Google's Colossus
- មិនមាន អត្ថបទ
- 2012: AddressSanitizer: A Fast Address Sanity Checker:
- 2013: Spanner: Google’s Globally-Distributed Database:
- 2014: Machine Learning: The High-Interest Credit Card of Technical Debt
- 2015: Continuous Pipelines at Google
- 2015: High-Availability at Massive Scale: Building Google’s Data Infrastructure for Ads
- 2015: TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems
- 2015: How Developers Search for Code: A Case Study
- 2016: Borg, Omega, and Kubernetes