Introduction To Algorithms is kind of the gold standard. It's heavily detailed, well written, and I'm pretty sure they put the word "Introduction" in there as a joke(it's 1292 pages).
PEOPLE TREAT THIS AS A JOKE BUT I SWEAR BY THIS. listen. as someone who went through college typing and have a job that's mostly typing with documents nearby, I've found documents or books to be unparalleled in wrist support. particularly Introduction to Algorithms, 3rd Edition puts my wrists at the perfect level for my keyboard. It provides rigidity that some wood wrist supports provide but also some give so that your wrists don't feel stiff as quickly.
While it isn’t necessary a book you flat out read but more of a very useful reference.
Introduction to Algorithms, 3rd Edition (The MIT Press) by Thomas H. Cormen
Introduction to Algorithms, 3rd Edition (The MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_api_glc_fabc_TkBbGbPB72YSB
It goes over just about every data structure, the pros and cons of each one, algorithm design, and analysis. Pretty much everything you need to be a software developer and to help prepare for any kind of dev interviews.
I will always and forever tell CS students here to take Algorithm Design with Alper Ungor. If you feel somewhat confident with data structures and discrete math, the class will level you up in terms of interview prep and give you an appreciation for the mathematical side of the major in general.
The class goes over a lot of the topics in the Introduction To Algorithms textbook, starting with sorting algorithms and getting into topics related to dynamic programming, graph traversal, computational geometry, P=NP, etc. Ungor seems to have relaxed with how strict he is with undergraduates, he expressed many times that he prefers teaching undergrads and wanted to make the class more appealing to a larger crowd. He also respected the class a ton and took feedback very seriously
Those are solutions to problems, I believe you can find a copy online for free but I’m not sure where. It’s definitely a nice book to have in your library though so I recommend buying it. Amazon
Comovente não é, mas um que me fez chorar sem dúvida foi Introduction to Algorithms do Thomas Cormen. Hoje em dia o choro começa quando vemos o preço.
this is the only thing you'll need for academic DS&A. the only good teacher for 146 (taylor) hasn't taught it in like 2 years i believe. There are a plethora of websites with DS&A practice (hacker rank, leetcode, lint code) that will help you train, but that book is the bible.
the stuff you learn in 146 (implementing basic data structures / algorithms and runtime analysis) are all critical in interviews later. that and some design specification questions
i would say 80% of my interviews had some algorithm solving so gl
oh yeah one more thing from my experience, interviewing for internships are the lower level sort of problems that you solve IN CLASS so make sure you know them in and out
for example off the top of my head the most popular questions are string reversals, linked list manipulation, stuff like atoi.
linked lists are the bread and butter of writing code that you know are extremely easy but hard to white board without talking out your thoughts, thus why books like CTCI (cracking the coding interview) recommends you know linked list implementation of all sorts right off the bat
I spent 5 years in college to not complete a 4 year degree. Best course/book I'd recommend is https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844. It was challenging, but that's the point. Started with internship at about $32k (a decade ago), which was still underpaid. Got an outside offer and moved on to better things.
You will tire when you reach your 30s+. Make sure to make your 20s count (whatever that means to you). Work on interesting problems, make a lot of money, start a side business. Something like that. Don't be lazy.
Knuth's books are dense, yes, but Wirth lays down some much-needed theory explaining the relationship between data structures and algorithms, which makes Knuth a lot more easily digestible IMO.
I strongly recommend Wirth first, and then as much as Knuth as you can comfortably handle.
If you hit a point where Knuth gets to be too much, then stop and pick up this textbook, which is more oriented towards students of algorithms (as is Wirth): https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
> De exemplu, pot spune ca stiu cand trebuie sa folosesc un set in favoarea unei liste, insa nu prea inteleg cum functioneaza in spate nici una dintre ele.
Orice programator trebuie sa parcurca cartea asta cel putin o data ca sa inteleaga ce se intampla "in spate".
> I følge Google
Hvilken søgning bruger du? Når jeg søger på "algorithm definition" så skriver den øverst "a process or set of rules to be followed in calculations or other problem-solving operations, especially by a computer."
> alle fagbøger jeg har læst
Hvilke bøger har du læst? Jeg er selv datalog fra DIKU med speciale i algoritme udvikling og high performance computing. Så jeg har også læst en del om algoritmer, f.eks. store dele af denne. Jeg hev den lige ud af skabet og slog op på side 5 hvor afsnittet starter: "Informally, an algorithm is any well-defined computational procedure that takes some value, or set of values, as input and produces some value, or set of values, as output."
> Men fortæl mig din, da jeg er nysgerrig.
Hvis jeg skulle beskrive det med mine egne ord, så ville jeg sige, at en algoritme er for software/datalogi/matematik det som en opskrift er for madlavning: Et sæt af instruktioner der, hvis fulgt, opnår en bestemt ting. F.eks. er det en algoritme man lærer som barn, når man skal dividere to tal. Det som du beskriver, lyder som et eksempel på en algoritme, der træner en form for machine learning model. Altså ikke definitionen for en algoritme.
If you're following the pseudocode style of CLRS, it might look like the following.
AVERAGE(A) sum = 0 for i = 1 to A.length sum = sum + A[i] return sum / A.length
You can find similar code on page 71 of Introduction to Algorithms 3rd Edition.
Take note that CLRS uses 1-based indexing.
Intro to Algorithms is what you want. And leetcode to put it into practice. The 3rd edition is cheap rn because 4th edition just released. Hth.
Introduction to Algorithms, 3rd Edition (The MIT Press) https://smile.amazon.com/dp/0262033844/ref=cm_sw_r_cp_api_i_N4CKDBV0HSHWAYH4V9RN
My school used Introduction to Computer Theory by Cohen for our Automata Theory course. For DS&A I've heard this one come well recommended.
Beyond that you'll need to get more specific about what you mean by computer science theory. Almost every subtopic in CS from Computer Architecture to Computer Graphics to Information Theory and all the rest has a theoretical and an applied side.
When I found myself deficient in data structures, I did a couple things. First, I dug up my old algorithms textbook, Introduction to Algorithms by Cormen et. al. This was the textbook in both undergrad and graduate algorithms classes, and each taught different parts of the book. It's got a pretty good sampling of the common and interesting data structures and algorithms for working with them.
You can start with the "Data Structures" section. If you know those and you can work with them, I'd be shocked if someone called you data structure ignorant at anything below distinguished engineer.
Once you know these data structures (and maybe some of the others), they'll become part of your lexicon, and you just might find an application for them in your career.
TAOCP is an interesting one. I mean sure, it has a lot of great stuff in it, but tbh- I have known people that have had it on their shelves, and have "acquired" a copy of it electronically and while if you really want to go down the rabbit hole, its all there for you, I don't know anyone that has actually found it useful and practical in their day to day work.
I am not saying not to read it, but in terms of time prioritization, I recommend you put it to the back of the list. This: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 is a little more concentrated and may be more useful- but neither of these seem to cover a hugely important topic these days- and that is cache awareness and data locality. With current architectures, Big O is actually dwarfed by data locality issues and keeping things in cache, as a fetch to RAM or disk may take thousands of cpu cycles and a "dumb" linear search where everything is cached may be much faster than a binary search that is constantly flushing its cache and loading from RAM.
Just something to keep in mind.
Do you know what book is going to be used for your class? The classic algorithms book is Introduction to Algorithms (https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844). I would read and then watch some videos on concepts I don’t understand. That way in the class you can ask better questions and you’ll be a bit ahead.
I didn't see anyone mention Introduction to Algorithms (MIT Press) yet. It's considered the standard must have book for algorithms and is language agnostic. I use it along side Grokking (for python specific/easy to follow examples). You probably want Introduction to Algorithms plus a language specific book for whatever you are working with.
Introduction to Algorithms:
I didn't take CSE31 since I was a transfer student, but I did take CSE100. Get real comfortable with the notation in this book. I don't have much to say that won't be covered in the syllabus, but my biggest take away for success is to become friends with the top performers in the class and hold yourself to the highest standard of integrity that you can.
If you can organize a study group and work together to solve problems and teach other this will get you very far and was one of my strategies for success. Also, under all circumstances avoid copying code off the internet unless you absolutely must.
If you make copying code off the internet a habit and can't think for yourself when developing code this will haunt you later on. I'm not saying don't use stackoverflow or read other people's repositories, but if you find yourself copying and pasting solutions without understanding what they're doing or why they work, then you are only hurting yourself. I've been reading many stories about students with BS in CS and master's in CS who can't code their way out of a paper bag or who can't solve fizzbuzz despite high GPA. So getting a high GPA or an A doesn't necessarily set you up for success.
There are a number of algorithm books for example: Introduction to Algorithms, 3rd Edition (The MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_api_glt_fabc_NYQPSQ3E0SFR1PFPKXB2
However, your post can potentially seem a little contradictory. Algorithms gives you the tools to solve problems but they aren’t the solutions to problems in the real world.
Random online programming challenges can be amazing if your problem is how to convert real world problems to programming tasks. They help you build those skills.
Implementing popular algorithms and data structures is definitely knowledge that will come in handy when working on apps and even in job interviews. I recommend this book, which also explains space and time complexity.
The algorithms are in pseudocode, so they are universal. They will force you to think how to implement them in Swift.
One of the best books written about this topic is still Introduction to algorithms by Cormen et. al.
It's time but I doubt Google would listen. People who work at Google are without doubt clever. They get the job EITHER by jumping through hoops better than thousands of applicants, OR being Joāo (i.e. a proven success). The hoops you jump through include being fluent in algorithms ... I once had the opportunity to work through a few chapters, and I realised how stupid I am.
Consequently, Google types see themselves as they indeed are - cleverer than you or me, and proven to be so by being Google employees. Let's be clear, were i so lucky, I'd be like them. They're still humans, to err is human, so we get the recent situation.
This may sound bitchy, but it's not meant to be, it's just my hypothesis about why they behave as they do.
That's a very broad question with no real concise answer. On the off-chance you're not trolling, I recommend getting in touch with a tutor, teaching assistant, or teacher/professor, and studying from a reference algorithms textbook like this one.
I usually recommend this book, which we used in university for the course on algorithms and data structure. It shows the most common algorithms in pseudo-code, which is independent of specific languages, and also covers their space and time complexity.
Introduction to Algorithms is an absolute must read. Pick a programming language you don’t know (I recommend C++ for industry) and go chapter by chapter implementing the algorithms.
This book is both introductory and advanced. It pretty much as everything in it. Its probably at least 3 semesters worth of content if it were used for a class.
> Show me where in your teamtreehouse tech degree you learned how to implement a custom AVL Tree and use it to optimize a large data set.
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 Here you go. They let me have a copy of this book without a degree (well honestly I find Sedgewick more approachable but he presents red-black trees and I don't recall if he goes into AVL trees at all)
This test seems bullshit lol. I got 60-80 percentile but I've studied and TAed this stuff in college and I've had a FAANG job for a few years. Don't take it too personally. The OS book does look like a great read though. If you want something simpler to understand systems at the user level instead of the kernel level, you can look at a book called "Computer Systems: A Programmer's Perspective". The intermediate systems classes at a lot of schools is based on this. Definitely do the shell and malloc labs in there (you will implement your own basic shell and your own malloc). CLRS is the bible for algorithms https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
If your systems and algorithms are solid, forget about whatever buzzword testing triplebyte does, you will be more capable than most junior engineers
I recommend this book, which I used in my CS degree to prepare for the Algorithms and Data Structures exam.
It covers algorithms in pseudocode, so it's IMO easier to understand and language independent. It also covers spatial and time complexity, and Big O notation.
Honestly, the CLRS book has been the most helpful thing for me doing my Analysis of Algorithms class. For each example in the book, watch a video or three so you get the gist of what's going on, then step through the pseudocode example so you more intuitively understand how it works. I also tend to skip a lot of the proofs, but they are there if you need them.
Tom Cormen co-authored it also. He's one of the authors of the famous textbook Introduction to Algorithms
First of all: algorithms and data structures are not advanced topics, they are the basics.
This book was used in the beginner lecture at my university and can be studied without any prior knowledge, it is pretty self contained. Just make sure to read all of the introduction.
pá eu se fosse a ti pegava em livros de algoritmos, um que já ouvi falar muito e até já folheei é este mas decerto ainda não sabes programar ou procuras algo mais simples. De qualquer forma podes dar sempre uma vista de olhos numa versão online sacada.
Man, this is book about algorithms with less than 750 pages. It is relatively thin.
For comparision Introduction to Algorithms, 3rd Edition (MIT Press) 3rd Edition I consider best of all time have over 1300 pages.
Time which is needed to study it is much more important than number of pages. Couple of weeks vs couple of months is crucial when you prepare to job interview. Skiena achieved this by skipping most of the math and focusing on real world examples
i'd caution you not to misjudge just how deep the C++ rabbit hole goes. the creator of C++ frequently talks about how no one understands all of C++.
learning a language is a pretty big difference from using it well. its the difference between learning your colors and being able to paint.
you should grab a copy of CLRS
do you have a github i can look at?
My schools curriculum had one UG class for data structures and algorithms as well and it covered most of the things I mentioned. We did stacks, queues, hash tables, b-trees, red-black trees, disjoint-set Forests, MSTs, Dijkstra's, some dynamic programming computing string edit-distances, and several other algorithms. We might have done heaps but I can't remember. The really basic stuff you will learn in CS1 and 2, most likely. Other than that I learned A* search in my AI course and graph min-cuts in Computer Vision (not that I needed either in any interviews).
That being said, professors can only devote so much time to each topic, so some of the coverage might have been cursory, and when you are interviewing 2 years after you took data structures you might have gotten rusty even if you were good when you took the class. You will definitely need to prepare prior to interviews somehow. Keep the book you get for your Data-Structures class (mine was this one); even if you don't cover everything you need for interviews in class the book will likely cover it somewhere. Cracking the Coding Interview is a great resource as well for getting a feel for solving interview style questions. Coding competition sites are great practice too (you don't need to know how to solve the really hard stuff).
Try /r/cscareerquestions (although read the sidebar first to see if the question is appropriate). For software engineering, you need to start building your project portfolio ASAP, ideally put it up on GitHub and put a link to your GitHub on your resume. Also, pick up a book on algorithms (CLRS is a popular choice), learn the algorithms, work through the problems, read up on how to approach interview algorithm questions, and then practice. The field is relatively open to people coming in with non-CS different degree, but you have to prove yourself.
Look at job listings and try to see what languages and tools they are using and learn that. Very often listed along the job description as "required skills" etc.
If you have a math background and want to jump in to the theory and skip the intro to programming stuff, you should get Algorithms by Cormen et al
something like this:
Probably much cheaper used.
Maybe this goes without saying, but it helps to code all the time.
The standard book used in hundreds of university courses is Introduction to Algorithms.
If you ever hear anyone refer to "CLRS", that is the book they are referring to (the acronym comes from the first letter of each of the four authors' last names).
Despite the title it is much more than an introduction. It goes deeply into all the major data structures and algorithms.
Your argument seems to be 'but I am a great programmer without algorithms'. Well I'm sorry, but I just don't think you can be a good programmer without knowing at least basic math and algorithms. Mediocre maybe, but not good. And if that hurts your feelings, then I can't help that.
One thing I'd like to say though, is that you have to realize that companies like Amazon, Facebook, Google, Microsoft etc. are huge and employ tens of thousands of devs, all of which pass these tests without problems, and all of whom give these interviews. There's literally tens of thousands of people working in IT right now who can solve these problems, and the only people who complain about it are people who can't. That seems to be a problem with you, not with the industry.
You also have to take into account that it's not HR or management that are making engineers ask you these questions. It's the engineers themselves who want to make sure that the new hire at least knows basic algorithms. Again, it's only people who don't know algorithms who argue that they don't need them. People who do know better. Just last week we didn't hire a guy because he didn't know basic shit. The manager wanted to hire, but the engineers said no.
So you have this idea, possibly born out of a hurt ego, that the industry is trying to shut you out. Look, every company out there wants to hire! Where I work, we can't hire people fast enough. But we do have a hiring bar, and we're sticking to it. Instead of trying to get the industry to change it standards to yours, perhaps you could try raising your own?
Should you be interested, basic algorithms and datastructure skills are not super hard to acquire, this book is a great starting point.
Again, sorry if I hurt your feelings.
Yep, I also printed that book and I am going through it as we speek (found it in some other reddit post). :) I was just asking about some good solid textbook that would take you from basics to advanced. Something like this book is for algorithms.
Text: Introduction to Algorithms. You'll use the same book in Foundations II.
Some of the Course Topics:
I had george green for 2421, He curved quite a bit but was one of the most boring teachers ever. uhm 2321 is kinda hard to prepare check out the MIT links for algorithms. And try finding this book online and start looking at it. http://www.amazon.com/Introduction-Algorithms-3rd-Edition-Press/dp/0262033844
I wouldn't jump head first into a paid program. spend 3-6 months taking free online courses. Once you've gone through them you'll have a better idea of what is the right fit for you. Bootcamps can be pricy, but if you pick the right one they'll teach you very specific skiils for a very specific target, and then match you up with potential companies. If you do go bootcamp route, do your homework first because there are a lot of duds out there just to take your money. If you decide getting a degree is the right route, you'll have a leg up with some programming experience under your belt. It's definitely possible to go 100% self taught, but it's not for everyone, and only you'll know if thats the right approach.
To start, code academy, khan academy and coursera all offer free online courses. I'd recommend starting with Java or Python and do a simple intro to programming first. After that feel free to branch out into an android course, or whatever else interests you at the time.
Once you have some basics down from the online courses, reading a standard algorithm and data structures book would be a good supplement. For algorithms, Introduction to Algorithms is pretty standard. I'm not sure what the data structures book du jour is, but there are a lot of good ones out there, try to find one that is language agnostic. At this point taking some MIT OpenCourseware might be a good idea, they have courses that will give you exercises for these books.
Best of luck!
Have him sign up for MIT's 6.001x Intro to Computation and Programming in Python.
Also, you might want to start him on Intro to Algorithms by Cormen. It's the best algorithms book on the market, and will definitely give your son a major advantage over his peers.
Unfortunately I don't lnow any good ones online, I know a decent textbook, PM me and I'll look it up later and edit it in here and respond to your PM.
in general though I'd say that if you want to learn more advanced programming you should go for computer science fundamentals. for example, do you own a copy of CLRS Intro to Algorithms? thats basically the gold standard text book for algorithms and data structures that is used in every Comp Sci curriculum in America. just working your way through some of the chapters of that book should be a very good way to improve your programming skills.
The 146 one is much harder, but in my opinion a very hard book to understand because they focus more on the mathematical side than the implementation/code side. This is the one we used: http://www.amazon.com/Introduction-Algorithms-3rd-Thomas-Cormen/dp/0262033844/ref=sr_1_3?ie=UTF8&qid=1450742857&sr=8-3&keywords=data+structures
Writing data structures have no "real world" practicality. No job/internship process is gonna ask you to implement a hash table from scratch. They'll just ask you to solve an algorithm and you have every tool at your disposal to do it. Space/time complexity should be something you know by heart coming out of this class, and every single 146 prof aside from Taylor sucks ass at actually doing what they're supposed to be doing. Just grab CLRS and comb through it and then you'll be fine with what 146 is SUPPOSED to do: You having a better grasp on the data structures itself, when to use X in Y scenario, etc etc
If you're planning on taking 149/158A/157A/166, just ask your advisor to let you yolo it, none of that shit needs 146 anyways
Don't recommend for 160 though
I actually just received this book today http://www.amazon.com/Introduction-Algorithms-3rd-Thomas-Cormen/dp/0262033844/ref=sr_1_1?s=books&ie=UTF8&qid=1447197695&sr=1-1&keywords=introduction+to+algorithms. It's been recommended to me several times here and in other programming subs. May be worth checking out.
Bust your ass at college, yes, but you really need to build a portfolio before graduating unless you want to spend a year+ doing so while working shit jobs to become employable.
Start making projects with well-commented code and following style guides and have them all on github. You're going to want to link your github on your resume.
Jump at any co-ops or paid internships you can, even if it extends your degree by a year.
Focus on mastering your data structures & algorithms classes. Buy Cormen's Introduction to Algorithms now and start going through it. You'll likely never, ever need some of the more advanced structures, but you never know what sort of 'extra credit' question might get tossed to you in an interview. Understand the pseudocode and how the Big O is arrived at.
Experience, your own projects, and data structures & algorithms are what's going to get you a job waiting for you as soon as you're done.
> acum mi se pare ca am ajuns la partea cea mai grea...algoritmica
Fă rost de cartea asta: http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?s=books&ie=UTF8&qid=1359218237&sr=1-1&keywords=cormen
You'll probably still understand the algorithms and the scenarios in which they are used and why. These things are explained in text and pseudocode and understandable without much knowledge of discrete math. However, you'll probably have trouble understanding a lot of the more detailed discussions of efficiency.
Maybe just have a look inside the amazon preview? It should give you a pretty good picture of what to expect. If you feel comfortable with the material there, you shouldn't have many problems with the whole book, it does not get much more complicated/math heavy. Especially if your goal isn't to live and breath all the material but just to build a solid toolset of algorithms.
The perennial Introduction to Algorithms http://www.amazon.com/Introduction-Algorithms-3rd-Thomas-Cormen/dp/0262033844 is 1300 pages of goodness according to stack overflow. I haven't read it because I don't have that kinda money to toss about. But from what I've heard from people who have read it, is that it is a fantastic introduction to algorithms and programming.
Are you using a textbook in your class? If so, which one?
It seems like you need to understand how these data structures actually work. Before trying to implement them, you should understand them on paper. If you aren't using a book, or if even after you have read your book you are struggling, I can point you to some online resources.
This is the book I used to teach myself algorithms. I was able to check it out from the library. Could this be an option for you?
Don't be discouraged by the downvotes, and let me know if you need more help.
You learn algorithms as you learn to program so don't worry about them too much now. Algorithms range in simplicity to quite theoretical so it's hard to say what you need to know, since some algorithms are rarely ever used in a job.
Junior developer algorithm questions are usually pretty easy, but of course if you end up interviewing with a larger software company they will end up asking much harder questions. Junior positions usually comprise of simple questions (languages, their nuances / differences) and simple "algorithms" (reverse an array/linked list, find the missing number, find unique element in a list, etc).
While far, far outside the scope of your current needs of understanding, CSLR is quite the awesome algorithms textbook: http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844
This thread, so far, includes only non-sequitur, off-topic, borderline defensive responses. Not that it's all bad advice; it's just mostly unrelated to your question.
There is value in learning how to analyze algorithms at a level beyond google-driven paging-in of topics when you need them. I'd propose that anybody telling you otherwise has never taken a proper algorithms course (or undertaken the self-study equivalent).
That said, I don't know what kind of shortcut you're looking for. You should probably try to work through a respected algorithms text, like this one:
The book Introduction to Algorithms is amazing. It's pretty much the only book I used as an undergrad that I still use today.
I don't think that is correct. Typically asymptotic equations are read left-to-right, meaning that the above equation simply means that Ο(n^2) ⊆ Θ(n) + Ο(n^2). Specifically, for any function f(n) ∈ O(n^2), there exist functions g(n) ∈ Θ(n) and h(n) ∈ O(n^2) such that f(n) = g(n) + h(n) for all n.
Taken from Cormen et al's Introduction to Algorithms: "We interpret such equations using the following rule: No matter how the anonymous functions are chosen on the left of the equal sign, there is a way to choose the anonymous functions on the right of the equal sign to make the equation valid. ... In other words, the right-hand side of an equation provides a coarser level of detail than the left-hand side."
Cormen’s intro to Algorithms. A classic https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
Get your man pants on and pick up a copy of CLRS.
"Introduction to Algorithms"by Cormen et.al. Is for me the most important one.
The "Dragon" book is maybe antoher one I would recommend, although it is a little bit more practical (it's about language and compiler design basically). It will also force you to do some coding, which is good.
Concrete Mathematics by Knuth and Graham (you should know these names) is good for mathematical basics.
Modern Operating Systems by Tennenbaum is a little dated, but I guess anyone should still read it.
SICP(although married to a language) teaches very very good fundamentals.
Be aware that the stuff in the books above is independent of the language you choose (or the book chooses) to outline the material.
I'll suggest you for the Stanford Algorithm Part 1 and Part 2 on Coursera and its free while doing you'll get some assignment also and after the completion ,it will provide you a certificate .Here is my list of Online Courses to learn data structures and algorithms. It is sorted according to quality (in my opinion) :
Most of these courses are language independent. So you're free to do assignments in whichever language you want.
I also recommend this book - Introduction to Algorithms, 3rd Edition: Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
There are many courses on the internet. Coursera, Udemy, etc.. I recommend you to read at least a book about it. It really helps you to understand the logic and complexity. For data structures, I also recommend you to implement them by your self.
This is a very good book: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
This is the full MIT course: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/
I strongly recommend you to follow the course and read the book.
Here's your bible: Introduction to Algorithms, 3rd Edition (The MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_apa_i_UbkDCb2H9VJ0B
I'm not self taught, I opted for University while working, so my resources were more professionally provided. That being said, I do have some resources I used where I straight up didn't understand the ones provided in class. I'll just go through the curriculum and assign a resource if any. I obviously don't remember all of them, and some of them happened to be found by chance. I remember reading a lot of documents from other universities. Hopefully that'll give some perspective on a university vs self taught route:
|Class||Resource||Notes||Some Takeaways||Difficulty (at the time of taking)|
|Introduction to Programming||https://www.learnpython.org/||Every student had to take this class, no matter what major. CS students had to get a B minimum to progress. Everyone else just needed a C. The Learn Python link is pretty much the entire class.||Understanding variable types, strings, arrays, and dictionaries.||4/10|
|Introduction to Object Oriented Programming||N/A||More or less a repeat of the previous class but in Java. Projects were pretty basic (now they are, back then I was so confused). They included stuff like making a Shape Class with various methods like getArea, getPerimeter, etc. Kind of funny now because this: https://gobyexample.com/interfaces, was essentially it (just written in Go).||OOP. Getters / Setters. Public / Private accessors.||5 / 10|
|Data Structures and Algorithms I||https://runestone.academy/ns/books/published/pythonds/index.html||Probably the first class I was considering dropping out. I was lucky in Intro to OOP but this class with 0 programming background was a nightmare. That link was probably the only reason I barely passed. I did also spend a ton of time in office hours here.||Literally leetcode but you're graded on it. LinkedLists, Graphs, Sorting Algorithms, all that good stuff.||7 /10|
|Programming Language Concepts||N/A||This is the class where it all clicked for me. Pretty late considering this is like 4th semester. We had a project called "Knights Tour", that given an NxN board, find and draw the sequence of steps where a Knight in Chess can access every single square touching it only once. That's the project where OOP actually made sense to me. Other stuff was basic lexicons. For every project in Java, you also had to figure out how to write it in C++.||Learned C++ without guidance. OOP finally clicked.||8 / 10|
|Intro to Networking||N/A - just Python websocket tutorials||The programming projects were pretty basic. Send data over a socket connection you established over TCP. I think there's a ton of tutorials on Youtube. This was more about learning how data flow works over a connection, basics of a Handshake, etc.||A lot of people didn't like this class. I liked it. You had the option of Python or C. Sockets were pretty cool and it was fun seeing data pass from terminal to terminal.||4/10|
|Discrete Math I||N/A||Lots of logic, and more algorithmy stuff. Describing sets and statements.||Logic gates, Djikstra's, and Heuristics.||4 / 10|
|Computer Systems||The C Programming Language 2nd Edition.||Low level stuff. C. Assembly. Bit manipulation. Binary. Overflow.||I thought it was super interesting, but takeaway is pretty much the same as notes. Mantissas. Kind of a tough class but fun and the only low level class.||7 / 10|
|Operating Systems||N/A||Honestly, this class was all memorization. If you knew the slides, you knew the material. Didn't program anything here.||Semaphores, deadlocks, pagination.||6 / 10|
|Database Management||https://www.sql-practice.com/||Honestly, this class was one of my favorites just because of the professors. Probably one of the nicest people I've ever met. Class was just learning SQL statements and queries, and setting up a relational database, drawing relational schemas, and learning relationships. Final project was exactly that based on set criteria.||SQL statements, queries, schema, and relationships.||2 / 10|
|Discrete Math II||N/A||A lot more interesting than the first one. Finite Automata, Turing Machines, Push Down Automata, Deterministic / Non-Deterministic automata. Projects were in Java or C++ only. Projects were pretty much drawing and implementing different automata that accepts a language provided by the professor. I pretty much had to Youtube every topic here. Lost of material to cover.||Automata, automata, automata.||8 /10|
|Data Structures and Algorithms II||https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844. Kind of expensive but from what I understand this is THE algorithm book||I hated this class with a passion. Programming assignments weren't bad and were mostly implementing and comparing the speed and size of various data structures when given data. The homework and tests though were a whole other beast. Generating mathematical functions given a sequence. Recursive relations. Really thought this was the end of my C.S career. Luckily the final was far easier than every other assignment and test combined.||Math functions to describe sequences. It was a nightmare.||10 / 10|
|Software Engineering||The documentation on Flask and React was good enough for this.||This class was literally 3 projects. You learned everything on your own and were graded on final result only. First project was 2 parts: 1 week to learn Flask and implement a Recipe App MVP and successfully deploy to Heroku. Week 2 was make the app look pretty (basic styling was sufficient, make it cohesive), and add a relevant Tweet using the Twitter api based on the shown dish. Can easily fail this if any API keys were public in your repo. Project 2 was a Chat App. You had 2 weeks for an MVP, having to learn React, PostgreSQL, and connecting it to Flask over websockets. Deploy to Heroku successfully. Week 3 was making it pretty, integrating CircleCI, and. adding in an API of your choice for custom commands. Final Project was a group project. Groups were chosen randomly. You had 1 week to come up an idea, ~10 story tasks per group member, and have it approved. Then 2 weeks for an MVP. The rest of the time was for implementing the story tasks, making it pretty, learning Unit Testing and having minimum 85% coverage, and documentation. You were graded as a group and individually based on your Github contributions. Last week was for final presentations.||Super time consuming, but proved we could learn really fast if we had to. Tech used was React, Flask, Sockets, PostgreSQL, Heroku, CircleCI, and something for python unit testing which I can't remember. Insanely fun class, and I loved every second of it despite some of it feeling impossible at times.||9 / 10|
My personal motto is to study for the interview, not for the job
Find practice interview problems online for the company that you want to join and find out what you need to learn in order to solve them. For example, leetcode.com has a way to filter questions by company, and there are many websites where people share their interview experiences such as teamblind.com but majority that I find are exclusively written in Chinese.
Cracking the Coding Interview is a good book for programming. If you are looking for Quant, look at wallstreetoasis. If you are looking for ML jobs, study calc, linear alg, and optimizations such as what a Hessian matrix is, and how you can reduce memory by using quasi-Newton methods.
And best way to get hiring managers to look at your resume would be to have personal projects. Personally, I am obsessed with using statistical models to help with language acquisition so I make WebApps to help myself and others learn Japanese using Bayesian statistics to emulate how we learn context clues.
For any position greater than new grad positions, you will also need to know System Design. Read the Palantir blog https://www.palantir.com/how-to-ace-a-systems-design-interview/ and then watch youtube videos and read blogs by the company on how they designed their system before the interview
Pretty sure this is the gold standard.
It's a difficult route, but it works. https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 .
E o chestie de noroc, peste cine dai si cat de ok sunt. Asa ca nu te lasa descurajat(a) daca una doua trei sau noua persoane ti-au zis nu.
Apoi urmeaza interviul in sine. Uita de proiecte si portofoliu ca nu esti graphical designer sau mai stiu eu ce.
Am amici care lucreaza la Google si altii care lucreaza pt Microsoft. Ce zic ei este: pune mana pe Cracking the Code Interview (https://www.crackingthecodinginterview.com/), rupe cartea aia in doua si n-ai sa ai probleme la nici un interviu de programare ever. Nu pentru ca ai sa primesti intrebari din cartea aia. Ci pentru ca daca intr-adevar studiezi materialul respectiv, orice intrebare ai primi nu ai cum sa gresesti.
Next, pentru interviul de algoritmica ai nevoie de Introduction-Algorithms de Thomas H. Cormen: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844. Pe asta nu trebiue sa o stii din scoarta in scoarta, dar trebuie sa ai habar despre ce-i acolo.
Partea cu experienta: S-ar putea ca firma x sa ceara experienta cu tehnologia y. Spune din prima ca nu ai experienta dar ca esti mai mult decat dispus sa inveti.
Ce contaeza foarte mult la un interviu pe langa cunistintele tehnice este atitudinea si entuziasmul. Fa foarte clar ca vrei sa inveti, studiaza un pic domeniul in care activeaza firma si arata interes si entuziasm pentru domeniul respectiv. Nu zic sa te transformi intr-un actor dar conteaza mult impresia pe care o faci.
Acestea fiind zise, bafta si spune-ne cand te-ai angajat!
If your biggest goal is to achieve those prestigious jobs, I'd suggest having a solid CS foundation knowledge like algorithm, data structure, etc. Pick up a book like Algorithm and follow the course, CLRS or the algorithm design manual by Skiena. Any of these are good and you only need one to have a general idea.
After that, just pick a language that you like/excel at and start solving algorithmic problems online. At the same time, try mastering all the features of the language too.
That's a short summary of how you get those jobs before graduating and as a new grad since every single internships and job interviews at these companies, you'll always be tested on these. This process is the same for everyone.
Learning is the easy part, the next part I want to tell you is: Don't be disillusioned about what is success in your life. I'm pretty sure if your parents love you, they'd have been already proud of you regardless if you get these jobs or not. There are never an absolute way to get these jobs and none of them guarantees your entrance. It's a combination of some intelligence, hard-work and luck. Just do the best of your ability.
This question is not really meant for this subreddit but CLRS should be a book worth looking at. For courses, you can try Coursera's Algorithms course but note this course is taught in Java.
How to manage memory is a bit of a generic statement.
It was a few years ago, but lots of entire series of lectures are online
e.g. Data Structures (YouTube)
You can also find series of lectures like the above on algorithms. Than do basic research on what the most common/industry standard textbooks for these topics are, like Introduction to Algorithms (Amazon link) and buy them or download PDFs or whatever.
The important thing is to actually do the work, suggested tasks/projects, etc. You won't be graded obviously but you don't need to be graded to learn this stuff.
Then there are one off books like Code: Hidden Language (Amazon link) that explore specific topics or walk you through certain ideas and concepts at a kind of introductory level. If you find the topic interesting or it is important for your work, it's a good starting point to learn about the lowest level stuff.
Hmmm, I might be completely wrong (it's been a long time since my first CS course), but you shouldn't worry so much about the language.
I mean, if it's your first one, yeah, it matters more. But most imperative, C-syntax languages are very similar, even more so from a CS 101 perspective. So you could try to learn some Java (C# is a better Java :-) ) if you find resources more easily.
If you want to see what a real :-p CS 101 course looks like, check this out: https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html (full text of the book available for free) and https://www.youtube.com/playlist?list=PLE18841CABEA24090 (videos from 1986 when this course was taught at HP IIRC and they recorded it). SICP is a really interesting and influential book, with a very interesting distribution of reviews on Amazon - mostly ones and fives, people seem to either love it or hate it. You might hate it, but you won't know unless you check it out ;-) I think it's best to try and watch one or two of the lectures to form a quick opinion.
Another language independent, important book is https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844.
My point is you shouldn't focus on a particular language or tech stack in college (you'll get to do that a lot on the job), but instead, try to study interesting stuff (which will help later as you'll be better equipped to recognize ideas, patterns and designs).
Make sure you cover the basics first as well, allow me to recommend this algorithms textbook, (Introduction to Algorithms by Thomas Cormen and others) https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 (I know it's a staple)
At large colleges, many "professors" are adjuncts, e.g. part time workers with no power, who can't even select what book they use for the courses they teach. For example, there are dozens of classic texts of computer science that can be used to teach programming, even ignoring free online resources (of which there are many).
Department and institutional administrators, however, often have sweetheart contracts with a particular publisher, or a "supervising professor" may get kickbacks for selecting a textbook that costs $160 and requires an online code (only $20 more, or $50 if you buy a used book!).
This was my college textbook, big focus on CS not so much just code. May be a little dense for going your own, depending on your math background.
It was pretty common textbook for college algorithms I & II courses in early 2000's, not sure if it's still as widely used.
Introduction to Algorithms - https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
CLRS is a classic. It's prety academic and you don't need to read all of it, but it's really really good.
I'm sure there's plenty of (free) resources online. But this book (I think) is kind of the gold standard. https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
Algorithm books? Introduction to Algorithms is a good one.
Let me suggest the data structure/algorithm bible for bachelor (and over) students
I don't know about the textbook for CSC316 (should be on the bookstore site) if you really want to get a deep understanding of algorithms I would suggest any edition of Introduction to Algorithms (https://www.amazon.com/dp/0262033844/ref=sspa_dk_detail_4?psc=1&pd_rd_i=0262033844&pd_rd_w=WZTEr&content-id=amzn1.sym.837c9c40-8722-4df3-9922-02a1f44f92b9&pf_rd_p=837c9c40-8722-4df3-9922-02a1f44f92b9&pf_rd_r=03944SBX3Z832G0V9BFH&pd_rd_wg=tDOVx&pd_rd_r=85c614a2-72cb-40c3-8376-154c474da70e)
This link is to the 3rd edition, (the 4th is available but much more expensive) but even the first or second edition will give you a lot of insight into the design and strategy of different families of algorithms. Combine that with a refresher on the Java code from 316 and you should be in great shape.
The CLRS Textbook is great and should be an eventual read. But it can be a bit dry and overwhelming. Within the same vein of academic textbooks Algorithms - Sedgewick & Wayne is easier to follow. A common sense guide to DS&A is also good.
If you want to learn DS&A in-depth (language agnostic) go with CLRS: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=nodl_?dplnkId=cb2b3eba-68b1-4bac-82f2-8e849e79ef9f
If you want to learn DS&A specifically with Java in mind, go with Robert Sedgwick: https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=mp_s_a_1_1?crid=3AKSJR39K177Q&keywords=robert+sedgewick+algorithms&qid=1654636204&sprefix=robert+sedg%2Caps%2C89&sr=8-1
Both are great books.
These are general topics not specific to Java at all so you can use any resource.
One of the best things you can do to learn comp sci is get yourself a text on data structures and algorithms. Here is one of the canonical texts:
This stuff is language agnostic. Every language is a little different, but we use hash maps, linked lists, trees, etc in all of them and this will teach you how to pick the right one for the task. This is where you learn to write code that performs because using the wrong data structure and/or algorithm is the difference between code that takes 10min or 100ms.
Another good thing to do is to learn how to drive a *nix style operating system (Linux, BSD, macOS, etc) from the command line (terminal). Using the various built in tools, writing scripts, etc. Being handy in a terminal is immeasurably useful for all stages of software development, particularly the build process.
There's a lot (!) to learn to be a good software developer, but this is where I would start.
That one, I'm not sure I would have gotten.
For me, it's 4 years of college, especially EECS 280 and 281 at the University of Michigan (TL/DAttend: Rebuild the entire C++ STL data structure set to STL Big-O standard with templates), then a lot of interviews and Leetcode and a couple of insights from fellow students.
Ex: All string problems use a read and write pointer. Also RIP Nate Binkert who explained *why* expanding a Hashmap was O(1) to a dumb newbie 3 months out of college.
Then 9 years of SWE experience including a solid 2 straight years of coding interviews (Carpal tunnel issues: https://www.reddit.com/r/cscareerquestions/comments/qwgr23/just_got_out_of_my_second_cubital_tunnel_surgery, 3rd surgery tomorrow) which I'd spend doing Leetcode and also getting a feeling for patterns. (I'm also targeting companies that don't ask LC Hards).
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=zg_bs_3870_6/131-5574128-8335639?pd_rd_i=0262033844&psc=1 was literally my textbook. Combine with Cracking the Coding Interview, which absolutely lives up to the hype and for $100, you can absolutely unlock $`100K/year.
There's also an interesting dynamic as you move past senior where they're not just trying to hire the best coders possible, they're also looking for project management which does seem to have taken the edge off the LC questions.
Pick this one as well, specially if you are targeting Linux: https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/
This is the book I used at university, it's pretty good, very detailed: https://www.amazon.com/gp/product/0262033844/
Seberapa penting pemahaman dsa? Well, the more complex the stuff you build, the more important it is. Untuk kebanyakan hal, biasanya udah ada premade solution nya. Nah tapi kalo kerjaan lu udah mulai rumit (dan biasanya akan berbanding lurus sama gaji), baru dsa bakal makin penting.
Contohnya: buat sistem rekomendasi kata pas user ngetik, misalnya user ngetik "red" harusnya keluar "reddit, reddoors, red, redirect"
Solusinya bisa aja kan kita iterasi seluruh bendahara kata yang kita punya, dan tiap kali ada kata yang awalannya "red" kita simpen terus di akhir kita keluarin. Kompleksitasnya bakal O(n) dimana n itu jumlah kata dalam kamus.
Nah bayangin sekarang jumlah katanya ada sebanyak kata dalam bahasa inggris, terus ada 10000 request rekomendasi per detik. Pas dicek performance kode sebelumnya, udah masuk ke unacceptable. Butuh 5 mesin yang standby cuma buat ngelengkapin kata.
Optimisasi selanjutnya kan kita bisa pake Trie (https://www.javatpoint.com/trie-data-structure) buat nurunin kompleksitas nyarinya ke O(log n)
For initial learning: This godsend playlist.
This free book.
A free online course in discrete mathematics which I can't seem to find anymore, but there are literally hundreds.
And most importantly, this awesome book, which I also got for free thanks to a website which I am pretty sure I can't name.
Project Euler, Leetcode, AdventofCode
Separate out two concerns.
Getting a 24 LPA job.
I taught this course 5 years ago. Many techniques
Discrete Math course may be a good place to start with writing and understanding proofs. Then you should be able to read and understand proofs contained in books like CRLS and Algorithm Design. Should be easy to find good online courses on these subjects (I don't have any specific recommendation, sorry).
Intro to algorithms has a pretty wide range.
Don't worry about languages. The book uses pseudo code anyways. I feel the exact opposite for learning concepts. Like, if you tried to make a six degrees of kevin bacon solver, you're writing a ton of code to read in 100k of records from a file, before you even get to start thinking about any algorithms. But, again, algorithms are pretty language independent, so, you can implement it in any language.
MIT has the opencourseware course available, too: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/lecture-videos/
Language used for data structures/algorithms does not matter nor should it. The underlying concepts behind each algorithm and data-structure is the most important aspect. Implementing said algorithm in your language of choice is simply an exercise.
I would suggest the following resources:
Here is some friendly advice from a Software Engineer who has had a very successful career so far, and was in your EXACT shoes just a few years ago.
Starting as a frontend developer is going to be the easiest way to get a professional programming job. I started as an FE dev, and then transitioned into a full-stack developer after 2 years of FE, and then transitioned into full backend after 2 more years of full-stack which is where I've been for the last year. I had to prove my worth as a FE and Full-Stack dev before getting a pure BE job. This isn't always the case, it was for me.
The long Version
You have to study a HELL of a lot more to get a pure backend role with no experience. These are the items you will need to become proficient in.
Typescript - If you're not already familiar with Typescript, it is time to learn! Most professional teams working daily in the JS ecosystem already utilize Typescript.
Data Structures & Algorithms - This is where I recommend doing old school things and buying a textbook. Here is my recommended TEXT. This will be lengthy and difficult, but it is imperative that you have adequate DS & Algo knowledge to be a backend developer.
Representational State Transfer (REST) - The easiest way to describe REST to someone is that it is a software development paradigm. This is an extremely popular design pattern for developing APIs, which is primarily what you'll be doing as a backend developer.
Networking - This is pretty straight forward, you will need to understand how computers talk to each other. How they send each other data. Etc.
Security - You will need to understand best practices for developing SAFE and SECURE software.
Databases - You will need to understand persistent data storage systems such as relational databases as well as non-relational databases. This includes understanding SQL and/or NoSQL.
There are more things to know, but this is the bulk. As you can see, there is a LOT here, and each of these bullet points is a rabbit hole of complexity. The reason most people start as a FE developer is because you gain a lot of baseline knowledge about the bullet points above while working in a much simpler environment. Once you feel conceptually comfortable with a lot of these topics, you could then start doing deep dives on each of them and building out your backend knowledge. After some studying and career experience, you could either internally transition to a backend role, or start applying externally for someone who will take you on as a true backend developer!
CLRS for algorithmic complexity, but also for all the (lot of) other topics in the book :)
Introduction to Algorithms, Thomas H. Cormen This
Você pode aprender sozinho sim, pega um livro como o do Cormen (https://www.amazon.com.br/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?dchild=1&keywords=cormen&qid=1635794876&s=books&sprefix=corme%2Cstripbooks%2C178&sr=1-1&ufe=app_do%3Aamzn1.fos.25548f35-0de7-44b3-b28e-0f56f3f96147) e estuda ele do começo ao fim que você fica craque em algoritmos
E para completar umas duas horas programando todo dia, tentando resolver problemas...
This is basically the standard university DS&A book, it is PACKED with theory and proofs.
Introduction to Algorithms, 3rd Edition
Another one which is similarly proof dense (but I liked this one better for the examples and applications)
If you want a very high level book, that is very approachable and even enjoyable, I'd suggest
> but it’s designing test systems (mechanical side of things of course)
I would wager that there's a lot of overlap in testing for mechanical things as there are for software. In theory, the same kind of things would be probably tested. Constraints, extreme cases, and "golden" cases (i.e. typical run). I also would imagine you would test things like environmental factors and functionality of your mechanical device/thingy.
> Any recommendations on books or websites that I can learn/review fundamentals?
This is sort of the "bible" among textbooks for algorithms/ds. However, it is a pretty difficult book and there's a lot of "extra" stuff you probably don't know how to learn.
I would recommend you do the following:
Find a book that teaches a language + DS&A (Data structures and algorithm). Pick a general purpose programming language (Python, Java, C/C++, etc.) and google "<language> data structure and algorithms book" (pick one that looks good and has decent reviews). Going through the entire book is not a bad idea since you often learn both some language and implementations based on that language. The language you choose doesn't matter, but statistically candidates who use Python as their interviewing language tends to fare better. Unfortunately though Python doesn't expose you as much to references/memory-management as much as C++/C does - so at least understand these concepts.
Get Cracking the Coding Interview. You should be able to solve most/all "easy"/"medium" level problems in that book.
Use the "bible" as a reference book and to supplement the most rigorous concepts you would see from (1) & (2).
You should also understand big-O notation (covered in the "bible" textbook).
Seems like some schools cover it better than others. There's plenty of places online to do some review.
You can see MIT's algorithms course here, free via OCW: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/
Berkeley's CS61B is here, which covers a lot: https://sp21.datastructur.es/
Berkeley's CS170 covers some of the more advanced topics, I can't find the video lectures from past semesters but the course site has the readings (and I suspect they'll be posting this semesters videos soon): https://cs170.org/
You can also look at books like:
Introduction to Algorithms. Haven't read this one but I think MIT uses it. https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
Algorithms. I actually kinda hate this book for being unnecessarily dense, mathy, and making poor formatting decisions, but it's certainly popular and covers the topics: https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
Cracking the Coding Interview. More of a cram sheet type book, but the explanatory sections do a good job reviewing common algorithm types with a focus on interviewing before throwing you into questions. https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/0984782850
Going of this, Robert Sedgwick also has a two part DS&A class on Coursera which may help:
As well, CLRS is one of the best textbooks for algorithms. Though it isn’t a light read.
obvious clrs plug.
if you want to learn you should start with this book https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
I learned from this book. It’s hard to master, I know, but it will make learning anything related to CS so much easier.
Introduction to Algorithms by Cormen, Leiserson, Rivest and Stein. Best algorithms and data structures book I have read as a beginner. https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
> but maybe it gives the benifit to also get more practice with the C# language
It can be a downside, since just having the code there means you don't have to go through the effort of implementing it yourself, so you don't really practice. Best bet may be to get one of the good text books like https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=pd_sbs_5?pd_rd_w=53M6A&pf_rd_p=651d64d1-3c73-45b6-ae09-e545600e3a22&pf_rd_r=2F0GHT2NQJA4GY3XQ2P5&pd_rd_r=0198ccd4-56a1-475a-a62e-7f3dc15367df&pd_rd_wg=ResP9&pd_rd_i=0262033844&psc=1 and practice by implementing things in C#
This is probably the introductory text for most people going through a computer science program in university.
This is a good book of this ilk, The Imposters Handbook: https://bigmachine.io/products/the-imposters-handbook/
Here are some algo books:
DPV algos: https://www.amazon.com/Algorithms-Sanjoy-Dasgupta/dp/0073523402
Algos Design: https://www.amazon.com/Algorithm-Design-Jon-Kleinberg/dp/0321295358
Ha. Is there something in particular making you feel like more discrete math knowledge is holding you back?
I read this book https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 but it's aimed more for college juniors. There is a lot math, but only for analyzing the algorithms. One can skip the math stuff altogether (especially on a first reading) and just understand how the data structures and work and the pros and cons of one versus another.
https://www.geeksforgeeks.org (under Tutorials) does a pretty good job going over everything one would need to start competing and they show hardly any math (because they state runtime complexities and omit the proofs).
I think it's more important to stare at the algos and data structures and see how they work. For example, one needs to visualize how a self-balanced tree provides the logarithmic time operations for a sorted set/map. One needs to visualize how a hash-based containers work, how they are implemented, and what happens when collisions occur. Seeing this stuff and applying to solving problems really doesn't need any math.
- 5 year degree in Computer Science
- 4 years of software engineering internships and co-ops
- If you get your foot in the door all you really need is the top two books for an entry level position (at least when I graduated in 2017)
There are a lot of excellent online reference guides.
I often use this one, all topics include programming examples in different languages such as Python:
One of the best books is this one, often used as university course material:
Probably not, but it depends on what you mean by "learn DS&A".
In 6 months, you can probably familiarize yourself with the various common families of algorithms and learn what the words mean.
However, if asked to solve the recurrence for... or given this algorithm prove that..., I would think that 6 months isn't sufficient time. The question of whether this level of analysis is relevant is left to your discretion.
As one datapoint, my algorithms courses were broken into a algo-I,II,II sequence and taught over the course of one academic year (academic quarters). This essentially covered CLRS cover to cover. Datastructures followed a ds-I,II,III sequence covering DSLAC cover to cover. The algo sequence involved almost no coding and was more a maths sequence. The datastructures sequence involved a small amount of coding (in scheme), but was still mostly a maths sequence.
If your math background is very strong (undergraduate degree+), you might be able to cram all your algo study into this timeframe.
You are working on real products that are used by real people. You are a real programmer, don't worry too much. I prefer someone who has experience in shipping products and writes beautiful code, than acing hacker rank problems and naming all his variables with single characters :P
But at the same time, products are based on data structures and algorithms. I don't expect you to know that the insertion complexity of a treemap is O(nlogn) or whatever the f it was, but that you have the ability to chose the data structure that solves your problem best.
freeCodeCamp released a video few days ago, you might want to check it out.
Dynamic Programming - Learn to Solve Algorithmic Problems & Coding Challenges
I do have this book which I "like": https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844, as reference book... (Well, I don't actually like it, doesn't really remind me of great times haha). You probably have already seen it somewhere in your office :P
And if you struggle with some of the hacker rank problems: Just ask. You know, people that have job interviews sometimes study for weeks (which is sad, personal note)... it's not like people like me that learned data structures and algorithms 15 years ago can remember everything...
Introduction to Algorithms, 3rd Edition (The MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_api_glc_fabc_h1qZFb0FAPN0K
Has both algorithms and data structures
He's not wrong.
I found a guide to becoming a web developer in 2020, and it looks pretty spot on for what you'd need to learn.
If you do FreeCodeCamp, finish FreeCodeCamp, including the projects, and then start at the beginning of the guide in this link, skip nothing, do every single course in order, read every book recommended and do the exercises at the end of each chapter, you'll have reached the end of the beginning, and you may be able to get a job afterward. It'll be very difficult without a degree, but people have done it. Do not skip anything.
This is toward the end of that guide, but ESPECIALLY do not skip this book:
This is the book we had back in school, and it's still one of the best books out there for learning these concepts.
This is an absurdly difficult career to break into as opposed to a trade or phlebotomy or something along those lines, the reason developers make bank is because the work is crazy complicated.
For classical complexity, any decent algorithms book should work. I've used this one.
I am afraid you will need a good enough background on discrete mathematics, and analysis of algorithms (beyond just knowing basic algorithms) to get through the books.
I own them. A friend of mine bought them for on the chip when he was in India (they, like all academic textbooks, are very expensive in the US.) It's been more than 20 years, and I still haven't gone through them all.
It is a good exercise to broaden your horizons, in particular, if you want to delve deep into CompSci.
But honestly, they are a bit dated in terms of the way the books were written. Do it if you want to enjoy the experience to go through these classics. But for a practical POV, I would suggest you check this textbook instead.
That book is a classic for me, and I've actually referred to it when doing actual work.
Iff that is too mathematical, you can start with this:
You can also try one of the algorithm classes in coursera. Good luck and enjoy your journey into CompSci. :)
Okay, I think I have a better understanding what you mean now.
This video will help a lot: https://m.youtube.com/watch?v=8aGhZQkoFbQ
You might also like Introduction to Algorithms. https://www.amazon.com.au/Introduction-Algorithms-Thomas-Dartmouth-College/dp/0262033844
In general, you don't NEED to know what these things are doing and so the information can be hard to find, but like you I have an insatiable need to know how it all works. The information is out there. You just have to dig for it.
A word of warning. Pursuing your curiosity can potentially slow down your progression to getting a dev job dramatically. I also believe however that it will pay off in the long run.
Not specific to C++, but this book is highly regarded - https://www.amazon.co.uk/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844
CLRS za algoritme, Biblija algoritama. Evo linka do knjige
Depends on the textbook. I would still consider this one, solving the exercises and coding the whole thing in the language of your choice as one of the best things total beginners can do.
For a good first (really only first) introduction, this classicis a good choice.
Depending on how much you are interested in theory and how much of a nerd you are, this book will pretty much sharpen your understanding of type systems and languages as a whole.
If you want to add math to the mix (which depending on what you mean with CS is an absolute requirement), give Donald some love.
Edit: sorry I added the german links, but the titles are valid
Not specific to C++, but this book is highly regarded - https://www.amazon.co.uk/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844
I graduated last year with a bachelors in applied math and now work for a large tech company as a software engineer. In undergraduate I took classes in a lot of traditional applied math fields like analysis, differential equations/dynamical systems, probability and statistics, optimization, numerical analysis/linear algebra, discrete math, etc. To be totally honest, a lot of these courses have relatively little value if you want to be a professional software developer in terms of practical knowledge. I didn't take that many CS courses (intro to cs, data structures, algorithms, and an elective theory course) but I TA'd data structures for a year and worked on some personal projects on the side.
In my opinion studying math absolutely gave me an edge in data structures and algorithms over the pure CS students. Every question that was primarily math (Big O notation, probability/probabilistic algorithms, amortization, recursion, graph theory, proof by induction/contradiction, etc.) was simpler/shallower versions of material that I had covered in math classes. Studying math gives you an intuition for how to exploit structure in a problem that makes you great at algorithm type puzzles, although most likely the lack of rigor will make it challenging to feel convinced by a lot of the proofs.
After that I basically just practiced data structures and algorithm style questions for a little while and worked on my personal projects and got an internship at a "top" tech company. i will say that my background didn't really prepare me at all for what I actually did day-to-day, but I think even most CS students won't be familiar with a lot of stuff like version control, testing, system design, documentation, etc. The reality is that I learned almost everything I needed to know on the job. As long as you have a good work ethic and willingness to learn I think it's not too hard to succeed in software engineering, however you will struggle for a long time before feeling comfortable.
My practical advice would be to take at least one beginning programming course and one intermediate programming class, as well as enough data structures and algorithms to cover 90%+ of the topics on leetcode/hackerrank. If you do that and have some minimal projects to list on your resume you should at least get interviews at enough companies that at that point your interview performance will be more important.
A few resources I also really like:
Just a warning though -- software engineering could be quite dull for someone who loves math. It's not as technically interesting or challenging as you might expect and if you're just in it to make a lot of money it might be disappointing.
Enrollment website says it's Introduction to Algorithms from MIT Press
Course Search and Enroll usually updates with needed textbooks, this is where I got the information
This one is really great https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
> I was told to have a solid foundation for that before getting into anything else.
Not sure what “anything else” is, but as long as you don’t completely fuck up the beginner’s stuff, you’re fine adding in formal data structures etc. whenever. You’ll be hard pressed not to implement some of that stuff on your own, and then you’ll have more of a feel for more complex or formal stuff. Having actual programming experience will motivate your learning.
Wrt online courses, for the mathier stuff it’s quite valuable to have an actual human being teaching as you scribble assiduously, and whom you can nag during office hours or whatever the post-plague setup will be. For the rest of it, you’d probably be fine wand’ring Wikipedia, but there are reasonably good college textbooks (AFAIK this and this are often used; stick to C-based or language-agnostic books so you don’t have to deal with OOPology) to give you a more formal intro. Some textbooks are outrageously expensive for a physical copy and once read you’re unlikely to reference them more than once per decade. For most stuff, there’s also the
filetype:pdf Google search or torrenting is a cheaper approach.
However, unless you’re headed for academia, you’re unlikely to need the more formal stuff ever. Mayybe you could whip it out at an interview. You’ll eyeball for big-Os. You’ll never use any of the other transforms Θ Ω o θ ω outside scratch or published paper. You’ll need maybe ten kinds of O expression, and those have basic ordering rules that are reasonably clear if you understand logs and pows. Unless you have more specific requirements (→Wikipedia), you’ll work primarily with pointers/links, arrays, hashing; via those, lists, trees, and maps. Implementations of things are all over Wikipedia, and those pages (or the source publication) will tell you exactly what the costs are and why. You’ll need to be able to compare costs formally for spitballing; everything else will usually be easier to deal with via graphs, and those are infinitely more useful for consumption in presentations, meetings, or hallway embolisms.
If you’re headed/aiming for a college degree, you’ll (=should) be taught most of the above in a (usually 200- or 300-level) class. You’ll(/ oughta) already be familiar with basic data structures by then, and there’s basically no need to get out ahead of the rest. If you do a course, prereqs are logs & pows, proof by induction, and familiarity with (plotted) graphs. I recommend some calc beforehand, since understanding of limits, derivatives, integrals, and series will be useful.
Alternately, Introduction to Algorithms, if I remember the cover art correctly.
I'm going to use this book (pdf is out there:) :
Introduction to Algorithms seems pretty popular.
This MIT course is by one of the authors of the book above.
It's a pretty big topic: Algorithms and data structures. Introduction to Algorithms is a pretty good book.
Start here and I'm not joking.
It's a game about programming essentially. The first few levels will seem fairly cakewalk and they are, but the later levels can get tricky. Then there are the size and speed challenges for each level.
And I know it's not C++, but python is a good place to start.
Also, pick up Introduction to Algorithms. I don't know your situation monetarily. I see that you're 15.
This book is great:
And MIT has a great online class:
There's a free class at Coursera: [email protected].
There are also some useful tutorials and fun coding challenges at hackerrank.com and leetcode.com. Many people use leetcode to prep their coding interviews.
If you want to go for the hard mode, read CLRS
But if you are only writing some small programs to do some math calculation, learning Big-O is good enough
Introduction to Algorithms, 3rd Edition (MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_api_i_G90gBb81DZFSS
MY MATH SUCKS, SO I'VE BEEN WORKING ON TEACHING MYSELF CALCULUS AND PROBABILITY/STATS.
ANYWAY, I'M GOING TO START TRYING TO FOCUS MORE ON JAVA OR C++ AND SIGN UP FOR LEETCODE AND CODERBYTE LIKE YOU SUGGEST.
Ovo su dve "standardne" knjige:
Introduction to Algorithms (Cormen, Leiserson, Rivest, Stein)
Lično, ja volim ovu (od drugog autora gore): Algorithms in C++
Dodatno, Knuth je pre neku godinu izašao u PDF-u i verujem da bi mogao da ga nađeš po Internetu, ali iskreno - danas je to nešto gde ćeš se najviše diviti tipografiji, i ako si baš baš baš jako matematički inkliniran dokazima (*). Za praktične potrebe 2017. godine bilo šta od ona dva gore navedena je bolje.
(*) Kome nije dosta matematike u Knuthu - Concrete Mathematics: A Foundation for Computer Science. Opet, možeš provesti udoban radni vek bez da znaš išta od toga, što ne znači da ne treba da čitaš ako nisi radoznao. Svakako ćeš biti u prednosti u odnosu na onog ko nije.
I studied those topics as part of a 4-year Computer Science degree, and speaking from my own experience I appreciated the rigor and structure of a traditional university (I just went to a state school though, nothing fancy). My Algorithms class used this book, which I think is pretty commonly assigned in undergrad CS courses.
If the cost or commitment of a university is too much for you right now though, the Khan Academy material on Computer Science is a great introduction
Citeste cartea asta in romana, sau in engleza. Se poate gasi online ca pdf, dar daca poti sa faci rost de ea de la o biblioteca sau daca iti permiti sa ti-o cumperi ar fi un pic mai bine.
Cand spun "citeste-o" spun viseaza tot ce e in cartea asta. Si intre timp apuca-te sa rezolvi probleme de pe infoarena.
Eu nu cred ca ti-ar fi util acum sa incepi sa inveti "tehnologii"(Python, CCNA, Node.js, etc). Daca ai ocazia sa te joci cu ceva, joaca-te, dar nu pierde prea mult timp cu ele. Pana termini liceul si facultatea o sa se schimbe multe tehnologii. Algorimii si structurile de date, pe de alta parte, sunt vechi de cel putin 50 de ani.
Comece pela "bíblia" Introduction to Algorithms: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_2?ie=UTF8&qid=1488450866&sr=8-2&keywords=algorithm
This has been my first semester of the program, so I can't speak in general, but from the 2 courses I have done: 1. CCA - the Udacity videos could be considered as a primer / introduction to the respective topics. In addition to the videos we studied corresponding parts of 2 classical textbooks (https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ and https://www.amazon.com/Introduction-Theory-Computation-Sipser). Have a look into the textbooks, especially the problems after each chapter to have a glimpse of difficulty of problems solved in class. The real meat of the class were the problem sets (1 PS each week) with several quite difficult problems to solve. A grade was based on 5 exams (every 2 weeks) - each of the exams having 3 problems of comparable difficulty to solve in 90 mins (more or less) - which should prove student's mastery of the subject. 2. CN - the Udacity lectures constitute a skeleton of the class, which is supplemented by a meat of more then dozen of scientific papers related to the studied topics and 8 projects (half of them programming, half of them reproducing some research, doing an experiment and writing a short paper with observations). Grade is based on 3 proctored exams covering Udacity lectures and mandatory reading material (the papers) and 8 projects. So far I can conclude that difficulty/rigor and time required are substantially higher than just watching the Udacity videos and clicking through somewhat banal in-lecture quizzes. You can get some idea by looking at www.omscentral.com - there are class reviews and time requirements estimates (based on the student's experiences). I spent in average at least 5-7 hrs/week by CCA (weeks before the exams were more intense, others more relaxed) and ca. 2-3 hrs/week by CN. However please note that time commitment vary according to previous experience, math and CS (I don't meen SW engineering) background. When comparing plain Udacity with real OMSCS program - access to profs, TAs and mutual discussions with classmates make a HUGE difference in learning value.
This is 351's bible.
For 330, just read last semester's slides.
You can rent it on Amazon for $26.53 for the semester, which is way better than Chegg ($73.49).
I've used The Algorithms and Data Structures book in a course and definitely provides a lot of insight into various algorithms and their perks but I haven't really used much of its information in actual programming.
I think a really good way to kind of look at these kinds of problems from a different perspective is to take an intro online course on some functional language. I mean look at this solution to merge sort in Scheme! https://stackoverflow.com/questions/14656435/mergesort-in-scheme
Exercises in this book.
Probably either of these two:
An actual CS degree is actually more of a math degree. You'd learn a lot of data structures and algorithms (learning how to store data and quickly access it). You'd learn some vector calculus, statistics, and combinatorics.
As far as programming goes, you'd learn Object Oriented Design (usually some kind of class about Software Design or Software Engineering). You'd learn how a processor works on the circuit level. You'd learn how compilers and interpreters work.
And your first year, you'd learn how to code. The first few classes are strictly designed so that you learn how to take your problems and break them down into manageable pieces that you know how to work with.
Most of what you need to know you could pick up from this book if you go through and implement the data structures yourself. I normally don't recommend textbooks, but man, the CLRS book is fantastic.
If you want intro, the professor I TA'd for actually posted all his lectures, homeworks, and tests online. If you just ignore stuff about the robots, you should pick up some alright skills.
Introduction to Algorithms is a bit dense, but gold.
A solid book I found quite useful: Introduction to Algorithms by Thomas Cormen
You could always pick up a book and try to read through it.. Though they can be pretty intense with theories.. I am in my data structures and algorithms class (second one of my degree) and we going through the book Introduction to Algorithms, but I have found that programming the algorithms and visualizing them helps more than you could possibly imagine... And you can always ask people to help explain anything that you don't understand..
This book is a standard in most computer science courses on algorithms.
You could get the first edition used or ^through ^^other ^^^means ^^^^/torrent
Not sure what you mean by advanced but you could check out a free online book called Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby and see if it covers what you're looking for.
Algorithms and Me covers a lot of algorithms applied to problems you'd find from interview questions. It shows multiple solutions done in C.
Problem Solving with Algorithms and Data Structures is Python oriented but covers a pretty good ground.
The book Introduction to Algorithms is an in-depth book on the subject and goes with the free MIT course online.
That's a decent way to learn the very basics of what I'll refer to as "structured programming". You'll learn the basic imperative control mechanisms as well as functional and later object decomposition.
> What are the potential backfires of using my methods and what could i add to make my learning experience more smooth ?
Your approach will focus very much on the "how", but not the "why". You'll (at some point) run afoul of not knowing what you don't know.
Put the code away for a while and go study the fundamentals and basic principles. At some point, you'll need to focus on a few different topics. Algorithms and computability are very important. To really understand some of the algorithmic and computational principles you'll also need to learn some basic math in the areas of: statistics/probability, calculus, limits/infinite series, and some linear algebra.
I suggest CRL and KNUTH. That should keep you busy for a few years. Good luck.
> Any help? Feel like I hit a mental road block in terms of applying my knowledge.
Start coding different algorithms in JS.
If you're not yet familiar with algorithms, check out the course at Khan Academy. All coding are done in JS and the course is co-authored by Thomas Cormen (the C in the famous CLRS book)
Pluralsight has a really nice one, in two parts. Personally, I picked up this: http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844/ref=pd_cp_14_4?ie=UTF8&refRID=1MFA91JZ3Z7XMF593S58
Computer Science is quite a big field, so it really depends on what part you are interested in. For the most part Computer Science is Mathematics and Engineering.
I would say one of the importaint fields you are probally interested in is Data Structures and Algorthims. For that I would recommend: "Introduction to Algorithms". If are interested in Theoretical Computer Science then I would recommend: "Theory of Computation" (2nd or 3rd) by Sipser. There are more books too, for example if you wanted to study AI then I would recommend "Artificial Intelligence: A Modern Approach".
For an online learning tool I think Coursea does a great job, in fact it was founded by a Computer Science Professor.
One note is that while Computer Science and Programming have a lot in common, they are not the same thing. Programming can be used to implement concepts from Computer Science, and in fact many Computer Science grads tend to become Software Engineers or Programmers. If you happen to dabble in Theoretical Computer Science it becomes very clear Programming != Computer Science.
CLRS refers to the four authors last names. It's probably a little heavy to get into before you actually take the class, so go slow.
ike /u/SidewaysGate says, Sipser is very approachable. Also CLRS (Intro to algorithms) is great.
Just did a quick search: http://www.theodinproject.com/ruby-programming/data-structures-and-algorithms
The Odin Project is building your own Ruby on Rails project, but I guess there's some stuff on data structures and algorithms. It seems a bit sparse to be honest. I'd probably look at a book like http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844 which is not language specific, and figure how to translate it (it is a bit pricey though).
There are courses like: http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/
Again, probably not specific to Ruby, so you'd have to figure out how to make the appropriate translations.
There are many branches in Computer Science to get into and there are many different types of programming you can do. Web development is pretty easy, or maybe try modding your favorite game? Mobile applications are pretty popular.
If you give me a general idea of something you would like to do, I can point you in the right direction of programming languages and skills you should learn.
Just a note: learning different languages is easy if you have a solid foundation in algorithms and data structures. I would recommend reading Introduction to Algorithms right off of the bat. It might be a little too advanced for you if you are coming in with absolutely no experience in programming or CS, but maybe after you get your feet wet a little, you can look into it. Or check out this free ebook on data structure and algorithms.
EDIT: changed the recommended ebook.
These are what I had. Different professors might use different books, obviously.
I didn't actually use or even buy the books for SoftEng and did fine. The other two classes relied heavily on problems from the book for homeworks.
If you're serious about going into computer science, I would strongly recommend taking a mathematics course, just to get you thinking logically. (You're going to end up taking 250, but still, it's incredibly helpful)
I'm not going to mention the coursework partly because /u/lordlicorice does a good job already and partly because I'm also a freshman like you, and I can't really advise anything from experience. I'd just suggest reading Introduction to Algorithms, which is a pretty well-known book to get started. I've also picked up Cracking the Coding Interview, just to help with some tech internships I want to get into. (My professor implied sometime back that you should have at least 330 before considering internships, but some of my friends have done some even before 216)
Not aware of any. Howeer, CLRS and Algorithm Design Manual are both great algo books I'd recommend.
Get this book, go here, sign up, and start solving problems.
Additionally, write a program with some friends - a good introductory one is a program that will schedule your classes for you (you can eventually upgrade it to build a database automatically).
Between the algorithm skills bestowed upon you by doing SPOJ problems and the knowledge of what issues you have to deal with in program design, within a year you will be orders of magnitude better at both programming and computer science compared to your peers.
Python je sranje. Sporo i odvratan syntax.Sad kad si vec poceo s pythonom nauci ga do kraja.
Proci kroz ovu knjigu bi ti bilo puno korisnije nego ucit novi jezik.
You need at least some basis in formal logic or mathematics to appreciate data structures and algorithms. Introduction to Algorithms is about as basic and comprehensive text as you can get. But you're not going to be able to get it without at least getting through the first few chapters of Discrete Mathematics.
Oh get out of here with your fancy pseudo from the algorithms book.
(That wasn't an insult. I just found it funny <em>the book</em> uses nil)
I'd just like to second this. This is an excellent "second-level" algorithms textbook, after you've done the basics.
For Data Structures, I have been using Intro to Algorithms to review DS & A.
This is one of those questions that could be as simple or as difficult to answer as you wanted it to be.
> While I learned about arrays, methods, strings, boolean, etc, etc, I didn't learn what they were, just what they do.
They're just computer representations of the vocabulary of problem solving that we humans use. We go through a sequence of steps with an algorithm (method, procedure, function), we connect things with maps (functions, graphs, arrays), we test truth or falsity with predicates (functions, boolean), we form sequences (strings, lists), ...
The list of things is pretty big and there's often more than one way to skin a cat. The best intro to this would be a good book on algorithms I guess. The book I was told to buy back in the early 1990s was this one:
Even at Microsoft we don't really care about your college degree as much as we care about your ability to code and understanding of computer science. You come to my interview like you've just swallowed a CLR (http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844), and I will hire you regardless of whether you went to school or not.
Companies hire on superficial characteristics in the absence of real ones; however, if you compare 4 years of college with 4 years of job experience - I don't know what will win.
It sounds like you need this book. http://www.amazon.com/dp/0262033844/ref=cm_sw_su_dp
I just got it yesterday and let me tell you it is a huge book. But literally everywhere I go or anyone I talk to says that it is THE data structures and algorithms book.
I would highly recommend reading CLRS & practice implementing the algorithms in Haskell via Learn You a Haskell. This will provide an extremely challenging but very thorough introduction to the fundamentals of computer science and functional programming. If you can work on that steadily for a year, I have no doubt you will have the motivation to be an excellent computer scientist.
Firstly, I wanna say sorry for your losses. You've had a rough life but good shit trudging through it 3Head, although you've arguably lost the best years of your life (Chester Bennington Who? Robin Williams Who?)
Now, I don't give a fuck if you were #1 or #777 in your programming class at your trashy school. You didn't get my point that however well you do in school doesn't matter, because regardless, you're bounded to solely that school, you're not nationally or internationally ranked (Being an analogy Andy, the #1 runner in my high school runs a 16:30 5K which is pretty good, but is no where near the international Olympiad level; the same is true with you and your trash-tier programming ability, you haven't accomplished anything in that field outside of school [and don't blame this on your illness, if you realized you were intelligent in high school, you would've been something back then, before your chronic disease emerged])
Also, those are the most fundamental basics of a multi-paradigm programming language, I learned Object-Oriented, exception-handling, recursion, generics, use of external libraries, methods, events, pointers, e.t.c. in 7th grade and there are hundreds of kids who'd done so at a much earlier age than me. Anyone with a somewhat quantifiable amount of intellect can understand that shit, that's the basics. You never truly got into programming, I can tell, as if you did, you would've instead listed the more complex theorems that actually require intellect to be able to derive and truly understand (algorithms and data structures) such as Computational Geometry and Shortest Path Algorithms(BFS, DFS, Dijkstra, Floyd Warshall, Prim, Kruskal), Computational Number Theory, Hashing, Trees, Data Structures(segment tree, fenwick tree, disjoint sets, Heavy-Light Decomposition). The list is endless; although you're 30 and pretty far behind, if you're at all interested in truly understanding these algorithms, their proofs and derivations (if you want to work at google, apple, e.t.c you need to learn), here's a link to an introductory book written in Pseudocode: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
(I may be immensely toxic, but just trying to help you out if you're still trynna stay on the CS path)
Also, you don't understand the problem-solving I was referring to. The questions you are referring to, given in school, require very basic problem-solving skills that don't truly captivate the beautiful art of problem-solving. True problem-solving is when you're faced with the most difficult and complex ad-hoc ~~(One subdivision of programming~~ ~~problem~~ ~~topics contains~~ ~~problems~~ ~~for which there exists no general technique or algorithm, i.e. no well-studied solution. These are known as~~ ~~ad~~*~~-~~~~hoc problems~~~~. Each~~* ~~ad~~*~~-~~*~~hoc problem~~ ~~is unique, and requires a specialized approach)~~ problem ever, where you have to manipulate it to devise an innately beautiful algorithm which beautifully merges a bunch of previous theorems that seem unrelated to creatively take a shortcut to the solution in a truly brilliant manner(this is easy to explain to others who understand problem-solving, but it's kind of hard to generalize it so sorry for the butchered explanation, here's a link that you can explore to learn more: https://artofproblemsolving.com/ )
Here's a programming question (from the final round of the USA Computing Olympiad for the brightest programmers across the nation, which I successfully solved). It may seem simple at first due to its short length, it's actually immensely complicated and requires immense critical thinking+IQ to come up with a unique algorithm which solves every possible test case; in my eyes, it truly captivates the art of problem-solving. If you're at all interested in seeing it here's a link: http://www.usaco.org/index.php?page=viewproblem2&cpid=950 (and don't lie and tell me you solved it, I know you can't because it requires knowledge of the complex Gauss-Bonnet theorem in topology/computational geometry taught far after Multivariable Calculus: https://en.wikipedia.org/wiki/Gauss%E2%80%93Bonnet_theorem )
TWITCH: And no, your remark about finding another way in was pretty retarded, of course, everyone would think of doing that, that's simple ban evasion. I'm obviously not gonna create a new twitch account to fucking chat, I already stream myself programming on my main twitch account so I'm not gonna go and make a whole new account to just chat, I'll donate someday and get unbanned from Felix's channel. Furthermore, I'd have to resub and build up my sub-streak all over again so not worth.
Also, I highly doubt I would've committed suicide if I were in your shoes because I would still have something going for me, the fact that I can and will make a meaningful contribution to society. And I know why you "weren't good enough for your interview," because you couldn't problem solve, most interviewers for companies such as Google and SpaceX ask questions that are slightly easier than those found in competitive programming competitions.
And bill gates and zuckerberg were dropouts because they were entrepreneurs, they could've easily finished college but it wasn't worth it because their companies started rapidly growing; they have skills that you don't, you're just a random dropout for no reason, most dropouts that make it big drop out because they see another vision for themselves. The main reason I want to go to a top university isn't for the education, I could learn all that I want from edX and Coursera, it's to meet others top students in hopes of creating our own successful business from our dorm.
If you're still interested in becoming a dev, hope that helped (although I'm half your age so I don't see why you'd listen to a zoomer like me regardless).
Edit (Didn't see your edit, I'm boutta go hard for disrespecting me): You're fucking retarded lmfao, your reddit is filled with gaming related shit (you're 30 and you game for a living, sad life) so I scrolled down to see the first post not in r/xqcow or r/letitidie and your age was there, I didn't see any sad shit you posted.
And yes, I do actually help others and inspire those invested in my field that I find in school and other communities, if I realize that they have recognizable talent and intellect to be something, but I'm not gonna be a soyboy cucklord who tells someone they can do it when they're realistically not smart enough to, I won't hold their hand and tell them they're worth something when they're really just an average andy that doesn't have the unique ability to ever do anything meaningful; I'll gladly shit on others who aren't smart and sit in a corner studying all day for the SAT because they can't naturally do well; I'll gladly tell them to kys, as talent outweighs hard work heavily.
I'm not privileged, I started at the fucking bottom (Kapp -> low middle-class) and reached the top myself, if you can't do it and are complaining, then natural selection retard.
(Also, Iostux is dogshit, I'd roll him in a 1v1 Kapp)
hot take: College textbooks aren't expensive
Unless you're gifted with coding and algorithms, don't expect to be able to land an interview and then land a job. Interviews will test you on algorithms, and coding.
If I were you, I'd just focus on learning Java syntax very well, then move on to OOP principles, and then move on to MVC principles.
Assuming you already have the required math background, you need to open this book, and starting going through the important parts in each chapter, and committing it to memory. You will be tested on things from this book during job interviews. You are expected to code them as well. Amazon specifically ask about Linear Programming whereas Google might ask about other stuff.
Not many make it without a CS degree. I have made a few bucks selling game apps, but there is always better things to do out there.
Algorithms book, considered to the holy bible in CS
Start using Java, and commit things to memory.
You will need at least 9 months of prep time.
Use this book to learn java https://www.amazon.com/Introduction-Programming-Structures-Comprehensive-Version/dp/0134670949/ref=sr_1_3?keywords=liang+java&qid=1564003011&s=books&sr=1-3
Use this other book as well:
I assume you already know how to study and memorize and take good notes.
To get started on making game apps, visit this, and download it, it may help to fund you https://www.scirra.com/