Reddit Reddit reviews Introduction to Algorithms, 3rd Edition (The MIT Press)

We found 326 Reddit comments about Introduction to Algorithms, 3rd Edition (The MIT Press). Here are the top ones, ranked by their Reddit score.

Computer Science
Computers & Technology
Books
Introduction to Algorithms, 3rd Edition (The MIT Press)
Hard Cover
Check price on Amazon

326 Reddit comments about Introduction to Algorithms, 3rd Edition (The MIT Press):

u/samort7 · 257 pointsr/learnprogramming

Here's my list of the classics:

General Computing

u/d4ntr0n · 72 pointsr/cscareerquestions

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).

u/jaimeandresb · 38 pointsr/compsci
u/flebron · 37 pointsr/compsci

Introduction to Algorithms (CLRS). I bought this book the year before I started university. I've now moved into my own place, and the first book I brought was that one. There's no technical other book I've read that many pages of. It's really filled with information, and presented in a rigorous, formal way.

Definitely my best purchase, books or otherwise.

u/d4m45t4 · 35 pointsr/programming
u/underwatr_cheestrain · 34 pointsr/javascript

Get your man pants on and pick up a copy of CLRS.

u/revertTS · 33 pointsr/compsci
u/DarkAnt · 26 pointsr/compsci

I don't know how to tell you how code well, because I don't know how to do it myself. I look at John Carmack, Bjarne Stroustrup, Guido van Rossum, Herb Sutter and co. and I realize how poorly I measure. That said, I do know of some things that will certainly help you. I believe to get good at something takes time and dedication. The following is in the order that I thought of it. I'm not sure how you should attempt to learn this material. Hopefully someone else can help you out with that.


Learning how to recognize potential solutions to classes of problems and of course having the basic tools to design a solution.

u/Lericsui · 26 pointsr/learnprogramming

"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.

u/CapableCounteroffer · 25 pointsr/learnprogramming

You can get a degree or you can teach yourself

The above resource is pretty good in outlining the major topics that all CS programs cover, but I would change some of their textbook and class recommendations.

I would replace the programming book/course with CS for all

Algorithms I would recommend sedgewick which is also available as a website or clrs for a more in depth review.

Those two topics will give you a very solid background. For what you want to do computer architecture, networking, operating systems, math, languages and compilers, and distributed systems aren't as important. If you wanted to expand your abilities as a programmer then you should explore those topics.

As for databases, for your purposes you may not need to learn so much how databases work as opposed to how to query databases. For this you need to learn SQL.

This should give you all the background you need in CS, now its time to start building applications. You'll probably hit roadblocks and need to research how to accomplish certain tasks, but with the above background that should be very doable.

u/bcguitar33 · 24 pointsr/compsci

Introduction to Algorithms is an absolute classic. It covers the vast majority of the algorithms that a good programmer "should" know (and goes over much of the math in the appendix in the back). Every school I've worked with has at least 1 course using this text, and typically each company doing anything interesting has at least 1 copy floating around somewhere.

I have a bunch more books that I could personally recommend if you have a specific thing you're trying to learn, but in terms of books that are 100% canon, that's the only one that comes to mind for me.

u/__LikesPi · 23 pointsr/learnprogramming

Algorithms are language agnostic but certain books are not. I recommend Introduction to Algorithms which is language agnostic and accompanied by lectures here. But there is also Algorithms by Robert Sedgewick which is in Java and accompanies these lectures and The Algorithm Design Manual which is language agnostic.

u/abstractifier · 22 pointsr/learnprogramming

I'm sort of in the same boat as you, except with an aero and physics background rather than EE. My approach has been pretty similar to yours--I found the textbooks used by my alma mater, compared to texts recommended by MIT OCW and some other universities, looked at a few lists of recommended texts, and looked through similar questions on Reddit. I found most areas have multiple good texts, and also spent some time deciding which ones looked more applicable to me. That said, I'm admittedly someone who rather enjoys and learns well from textbooks compared to lectures, and that's not the case for everyone.

Here's what I gathered. If any more knowledgeable CS guys have suggestions/corrections, please let me know.

u/DoISmellBurning · 19 pointsr/compsci

Cormen is your friend.

Core text for the algorithms course I did as an undergrad - I highly recommend it.

u/sallen35 · 18 pointsr/C_Programming

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) :

u/tenpairsofsocks · 18 pointsr/learnprogramming

Taking a course will definitely help and I have a few book suggestions.

Intro to Algorithm
This is pretty much the holy grail on algorithms, used in many college CS courses.

Skiena's Algorithm Design
My personal favorite. Combines his Ph.D experience with real world problems.

u/Cohesionless · 17 pointsr/cscareerquestions

The resource seems very extensive such that it should suffice you plenty to be a good software engineer. I hope you don't get exhausted from it. I understand that some people can "hack" the technical interview process by memorizing a plethora of computer science and software engineering knowledge, but I hope you pay great attention to the important theoretical topics.

If you want a list of books to read over the summer to build a strong computer science and software engineering foundation, then I recommend to read the following:

  • Introduction to Algorithms, 3rd Edition: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844. A lot of people do not like this classic book because it is very theoretical, very mathematical, and very abstract, but I think that is its greatest strength. I find a lot of algorithms books either focus too much about how to implement an algorithm in a certain language or it underplays the theoretical foundation of the algorithm such that their readers can only recite the algorithms to their interviewers. This book forced me to think algorithmically to be able to design my own algorithms from all the techniques and concepts learned to solve very diverse problems.

  • Design Patterns: Elements of Reusable Object-Oriented Software, 1st Edition: https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/. This is the original book on object-oriented design patterns. There are other more accessible books to read for this topic, but this is a classic. I don't mind if you replace this book with another.

  • Clean Code: A Handbook of Agile Software Craftsmanship, 1st Edition: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882. This book is the classic book that teaches software engineer how to write clean code. A lot of best practices in software engineering is derived from this book.

  • Java Concurrency in Practice, 1st Edition: https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601. As a software engineer, you need to understand concurrent programming. These days there are various great concurrency abstractions, but I believe everyone should know how to use low-level threads and locks.

  • The Architecture of Open Source Applications: http://aosabook.org/en/index.html. This website features 4 volumes of books available to purchase or to read online for free. It's content focuses on over 75 case studies of widely used open-source projects often written by the creators of said project about the design decisions and the like that went into creating their popular projects. It is inspired by this statement: "Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters."

  • Patterns of Enterprise Application Architecture, 1st Edition: https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/. This is a good read to start learning how to architect large applications.

    The general theme of this list of books is to teach a hierarchy of abstract solutions, techniques, patterns, heuristics, and advice which can be applied to all fields in software engineering to solve a wide variety of problems. I believe a great software engineer should never be blocked by the availability of tools. Tools come and go, so I hope software engineers have strong problem solving skills, trained in computer science theory, to be the person who can create the next big tools to solve their problems. Nonetheless, a software engineer should not reinvent the wheel by recreating solutions to well-solved problems, but I think a great software engineer can be the person to invent the wheel when problems are not well-solved by the industry.

    P.S. It's also a lot of fun being able to create the tools everyone uses; I had a lot of fun by implementing Promises and Futures for a programming language or writing my own implementation of Cassandra, a distributed database.
u/Lapompaelpompei · 17 pointsr/learnprogramming

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.

u/LunchNap · 16 pointsr/compsci


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

u/ethraax · 15 pointsr/programming

Introduction to Algorithms is an absolutely fantastic book. I've read it through a couple times. It's very well written and they have plenty of descriptive diagrams to help you intuitively grasp the different algorithms.

u/hell_onn_wheel · 13 pointsr/Python

Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.

Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.

To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above

What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)

How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.

What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.

All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.

Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!

u/roland23 · 13 pointsr/learnprogramming

The more significant differences between CS graduates and self taught programmers are algorithm design, important coding practices, and a lot of the mathematics.

Books on coding practices exist, but vary in various corporations or programming languages.

I highly recommend MITs book on algorithm design, to some it is considered the bible of all algorithm design.

As others have mentioned, Khan Academy is a great place to start for the mathematics. Particularly CALC I, II, Linear Algebra I, II, Discrete Math I, II.

It also couldn't hurt to look into some theory of computation topics (countability, turing machines, etc.)

u/wrelam · 12 pointsr/C_Programming

C Interfaces and Implementations has some decent advice for designing C programs. This is also a skill which you 'll develop with time (e.g. over your entire career) so don't worry too much about figuring it out immediately; it requires experience. As you work on various projects you'll get a sense for what works and what doesn't so that over time you'll have developed strategies for solving particular types of problems.

OOP concepts are still valid even though C may not have ways to necessarily implement them within the language proper. Object-Oriented Software Construction is a fantastic book for learning OOP concepts. As your C experience grows, you'll begin to see ways of implementing some of those design strategies with C, even though it's not an OO language.

Knowing when to use what type of data structure can also aid in simplifying your code base. The standard book for this is CLRS, but for C specific implementations and advice, see Algorithms in C.

u/v3nturetheworld · 12 pointsr/cscareerquestions

well depends on what you want to learn. Do you only want to do webdev stuff or learn a ton about CS concepts? I'm going to answer in terms of learning CS stuff, but first here's a page on how to go from knowing nothing to knowing a wide range and depth of CS topics: you do this, you'll be a grade A software engineer!

OK, moving on. First the basics which it sounds like you've got covered.

  1. understand basic programming concepts (conditions, loops, functions)
  2. learn a programming language pretty well, it doesn't matter what language. Being good at and Understanding CS concepts does not involve mastering a single language... once you get the concepts any language will be easy to learn... It sounds like you know some Javascript (not my personal recommendation for learning CS concepts), personally I'd recommend Python (easy syntax, great resources, wide use, etc..)

    OK, now where it sounds you stand. Learning the Advanced stuff.

  3. Algorithms: The bread and butter of programming. There are many resources out there, if you want to buy a book, the gold standard is "Intro to Algorithms, 3rd edition ". Other than that, I'd suggest just the relevant Wikipedia article for algorithms. Take the pseudocode and implement it yourself in your language of choice. Understand what the algorithm is doing. Compare it to similar algorithms, understand why/when it's better or worse.

  4. OK, now that you've got that done, you can start making more complicated stuff. Come up with some silly or interesting real world examples to practice with. I suggest at this point learning more about Object Oriented Programming... learn about Classes, class structure, generics (this all varies by language). Practice, practice, practice. 4 hours of coding a day if your not doing anything else, spend the rest researching/reading.

  5. Learn how to use Unix/Linux. it's good for you(tm)

  6. optional but cool: Learn about Computers structures and how operating systems work, bonus points if you want to build a basic OS from scratch (this requires learning a systems language like C/C++/Rust and some assembly).

    anywhoooo that's kind of an overview/recommendation... feel free to ask any more questions/clarifications/suggestions for resources.
u/frenchst · 12 pointsr/cscareerquestions

Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.

u/Prcrstntr · 12 pointsr/cscareerquestions
  1. Get the book Introduction to Algorithms. You can find a pdf online.

  2. Read it, and try to program and understand the simpler algorithms: Do the sorting algorithms first, and then go for the binary tree algorithms.
u/w3woody · 12 pointsr/computerscience

Read about the topic.

Practice.

Set yourself little challenges that you work on, or learn a new language/platform/environment. If you're just starting, try different easy programming challenges you find on the 'net. If you've been doing this a while, do something more sophisticated.

The challenges I've set for myself in the recent past include writing a LISP interpreter in C, building a recursive descent parser for a simple language, and implementing different algorithms I've encountered in books like Numerical Recipes and Introduction to Algorithms.

(Yes, I know; you can download libraries that do these things. But there is something to be gained by implementing quicksort in code from the description of the algorithm.)

The trick is to find interesting things and write code which implements them. Generally you won't become a great programmer just by working on the problems you find at work--most programming jobs nowadays consist of fixing code (a different skill from writing code) and involve implementing the same design patterns for the same kind of code over and over again.

----

When I have free time I cast about for interesting new things to learn. The last big task I set for myself was to learn how to write code for the new iPhone when it came out back in 2008. I had no idea that this would change the course of my career for the next 9 years.

u/fazzone · 11 pointsr/programming

Meh, these sort of definitional quibbles annoy me. What is the point of manufacturing a distinction such as this that pretty much exists solely as a "gotcha"? The fundamental idea at work is that you're re-using the answers to subproblems in order to computer the answer to the big problem. As long as you've got that idea down, what's the huge philosophical difference in the order that the subproblems are computed? I'm not saying that the distinction is invalid - there is an difference for sure - just not of great importance. In fact, if I were explaining it, I'd introduce DP as a particularly clean form of memoization -- one where you have spent effort to formulate an algorithm in a way that guarantees all subproblems are solved before their solutions are required in the next tier of problems.

I'm not 100% sure, but I think I remember Introduction to Algorithms explaining it this way. They may also have gone for taxonomy where memoization is the specific mechanism of storing results of previously-solved problems and dynamic programming is the application of such to algorithms (thus there would be top-down dynamic programming and bottom-up dynamic programming).

Edit: syntax (changed "computed in" to "computed")

u/Shadowsoal · 11 pointsr/compsci

In the theoretical field of complexity...

The 1979 version of Introduction to Automata Theory, Languages, and Computation by Hopcroft & Ullman is fantastic and used to be the canonical book on theoretical computer science. Unfortunately the newer versions are too dumbed down, but the old version is still worth it! These days Introduction to the Theory of Computation by Sipser is considered to be the canonical theoretical computer science text. It's also good, and a better "introduction" than H&U. That said, I prefer H&U and recommend it to anyone who's interested in more than getting through their complexity class and forgetting everything.

In the theoretical field of algorithms...

Introcution to Algorithms by Cormen, Leiserson, Rivest and Stein is dynamite, pretty much everything you need to know. Unfortunately it's a bit long winded and is not very instructive. For a more instructive take on algorithms take a look at Algorithms by Dasgupta, Papadimitriou and Vazirani.

u/lookatmetype · 11 pointsr/AdviceAnimals

Yea, understand this book cover to cover and you'll get any silicon valley job easily.

u/Gr8ingPresence · 10 pointsr/compsci

I don't think it's reasonable to speak about "canon" books in computer science - the field has become so broad that a handful of PhDs in the modern era could get to the very bleeding edge of their niche and not share any crucial books in common among their libraries.

That said, here are a few I think are fantastic:

u/bsmartt · 10 pointsr/compsci

I haven't heard of any of these. Unless you're pressed for time, read one of the classic DS&A books, and then read some c++ stuff. There are lots of ds&a books that are partially or fully language agnostic, they only have code blocks in pseudocode. This provides a very important opportunity for you to implement stuff in whatever language you like. Here's the one I used in college: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=zg_bs_132570011_2

u/cabbagerat · 10 pointsr/compsci

Start with a good algorithms book like Introduction to algorithms. You'll also want a good discrete math text. Concrete Mathematics is one that I like, but there are several great alternatives. If you are learning new math, pick up The Princeton Companion To Mathematics, which is a great reference to have around if you find yourself with a gap in your knowledge. Not a seminal text in theoretical CS, but certain to expand your mind, is Purely functional data structures.

On the practice side, pick up a copy of The C programming language. Not only is K&R a classic text, and a great read, it really set the tone for the way that programming has been taught and learned ever since. I also highly recommend Elements of Programming.

Also, since you mention Papadimitriou, take a look at Logicomix.

u/kqr · 10 pointsr/learnprogramming

If you are willing to sacrifice the "language" requirement, you could go for something like Introduction to Algorithms which will definitely make you a better programmer, regardless of your field. It contains, directly or indirectly, the solutions to 95% of the problems you'll encounter, and gives you the tools to deal with the last 5%.

u/TehLittleOne · 9 pointsr/learnprogramming

My suggestion is always to start with Python. It's a very high level language and it's very easy to learn. In fact, Python recently became the most popular language to teach beginners. I know you wanted to learn Java, but there are several things about it that make it not so great for beginners, as well as several things about Python that make it good for beginners (ask why if you're interested, but it may be a bit technical). As a programmer, you will likely learn a dozen or more languages (I've learned over a dozen in school), so saving Java for a bit later isn't really an issue. You'll find in programming that a lot of the important things apply to most languages, so learning these allow you to apply them to new languages quite easily. My university now uses this book in the first year computer science courses.

Get yourself situated with a free GitHub account. GitHub is my favourite version control. If you have a student email you can get a free private repository (so others can't see your stuff). If you don't have a student email to use to get one, you can still make a free account, but it will be public. What that means is that anyone who navigates to your account can see all your code. Since you're just starting out, it shouldn't matter if people browse your code, there's not much to see since it's just you going through the basics. GitHub has a tutorial for new users and also has a user-friendly client that makes it all really simple. You can save the more complex stuff for later until you're comfortable.

Once you've gone through Python and learned a bit, it's time to get into some of the language-independent things. Introduction to Algorithms is an amazing textbook. The authors are some of the most well respected people in the field and I've used it in school in more than one course. You can go through this at any time. I recommend you programming some of the things (they provide some code as well), and perhaps trying this stuff in Java might be a good segway from Python to Java.

u/Newt_Hoenikker · 9 pointsr/C_Programming

C and C++ are pretty different nowadays depending on your standard. "Game engine" is a pretty generic descriptor, because you can build game engines in a lot of different ways depending on your needs for the genre and how all-encompassing your engine needs to be, so I'm going to ask you a few questions about specifics in regards to your experience which might help to flesh out where you can start your search.

  • How are you with Data Structures? Algorithms? Which are you familiar with? How extensively have you used them? CLRS is a decent starting point with pretty broad coverage and good descriptions.

  • What about Design Patterns? Which ones? How much? They're not so much applicable in C, but C++ and other OOP languages are lousy with them. My university was way too into this book, but it wasn't bad; bonus all the examples are in C++.

  • How portable is your code, generally? What's your programming environment like? Windows? Mac? Linux? *BSD? Games are usually Windows oriented, but there's a lot that C/++ can do aside from that, and IMHO the best way to learn systems programming is with C and a Unix-like OS.

  • What is it exactly that you want to accomplish with your code? A broader engine? A more portable engine? Something not game related? In my experience learning for the sake of learning is great and all, but I lack drive without a concrete goal I'm working toward.

    Hope this helps.
u/DoUHearThePeopleSing · 9 pointsr/ethereum

Did you read any mathematical papers, are you familiar with university-level math, or with computer science?

What might help you get familiar with this style of writing is Concrete Mathematics ( https://notendur.hi.is/pgg/(ebook-pdf)%20-%20Mathematics%20-%20Concrete%20Mathematics.pdf ), or Introduction to Algorithms by Cormen ( http://www.amazon.com/dp/0262033844?tag=top-books-cs-20 ).

The first book is more about math, but it's a nice and fun read. And it will make you familiar with math notations. The other book is about algorithms and data structures - difficult to read, but once you get through the first chapters, reading things the Yellow Paper should be much easier. Protip with Cormen - skip the proofs at first :)

Most developers, even the ones familiar with architecture and design patterns, aren't familiar with the theoretical/mathematical groundwork behind all this.

In other words: the paper is written for computer scientists, not developers really. Many excellent developers are shit computer scientists and vice versa.

u/bonesingyre · 9 pointsr/compsci

Introduction to Algorithms, 3rd Edition

Surprised no one mentioned this one. This book goes into more depth on the topic, including theory and derivations of formulas.

Its definitely one of the best Algorithm books out there.

I would also look into Coursera, specifically Stanford's algorithm design class, it uses the above textbook and goes into more of the design of algorithms vs. here is how they work.

u/metahGVA · 9 pointsr/learnprogramming

Introduction to Algorithms is probably the best book if you want to go deep in algorithms eventually.

Cracking the coding interview book is also a great repository of "must-have" concepts for CS.

u/s32 · 9 pointsr/jobs

That being said, some websites simply aren't going to be enough. Codeacademy is awesome, but don't expect to learn algorithms from it; you probably would want to pick up a copy of CLRS and do the MIT course

u/gavlois1 · 9 pointsr/FreeCodeCamp

It depends on how much programming experience you have. If FreeCodeCamp is all you've done and have only worked with JavaScript, then I think that CS50 would be worth going through. For the first few lectures, he goes material which uses C and talks about low-level memory management and how many things work under the hood. While this isn't necessary to the daily work of a web developer, it is still good to write code while being conscious of what's happening under the hood through all those abstractions.

As /u/artotal said in his reply, learning the fundamentals of data structures and basic algorithms and complexity really go a long way. I don't think CS50 goes very in-depth with regards to this, but there's a few different sources you could learn from. You could go the hands-on route and hop straight onto sites like HackerRank and Kattis and start working your way up the problem ladders if you already have some basic familiarity. If learning from scratch, FreeCodeCamp has a nice set of videos on their YouTube channel talking about different data structures implemented in JS.

As for general progression after FreeCodeCamp, keep building projects. I'm not sure how far you're into the curriculum, but it's quite long and it's got many projects even in the curriculum if you do both front and back end curriculums. With your currently existing projects, go back and see if you can make improvements to any of them. Maybe try and move them off of Codepen (if you did them there) and to your own personal portfolio site. Refine your portfolio page and have links to your projects, your Github, resume, etc. You can have free hosting through Github Pages and you should be able to host all the front end projects there. For Node projects, you can try hosting them through Heroku, or see about free hosting through Google Cloud or get trial credits on AWS or Digital Ocean.

I hope this gave you a general idea of how to progress. Choose what you want to do depending on your immediate goal. Looking for a job? Polish that resume, get your portfolio site and projects up and running, maybe get a domain name for it. Go on HackerRank and LeetCode and practice some common interview problems. Have a bit of free learning time? Dive into the fundamentals of CS. Consider taking a look at some of the tried and true CS textbooks like this one (I'm sure that with some Googling you can find links to a pdf of it for free).

u/complich8 · 8 pointsr/AskComputerScience

I don't think you'll find just one -- computer science is too broad, even in the scope of what you're asking for.

You can probably find a reasonably readable algorithms book that'll introduce things like Big-O, Big-theta, Big-omega, graphs, trees, etc. Some of that bleeds into the "data structures" topic area (and vice-versa). This one is highly-regarded, but I couldn't say whether it's "for you" or not -- it's a bit textbooky.

u/Lord_Illidan · 8 pointsr/compsci

You will want this book sooner rather than later too.
CLRS - Introduction to Algorithms

u/jeykottalam · 8 pointsr/compsci

Introduction to Algorithms by CLRS

TAOCP is a waste of time and money; it's more for adorning your bookshelf than for actually reading. Pretty much anyone who suggests TAOCP and is less than 55 years old is just parroting Standard Wisdom™.

Godel, Escher, Bach is a nice book, but it's not as intellectually deep in today's world as it was when first published; a lot of the memes in GEB have been thoroughly absorbed into nerd culture at this point and the book should be enjoyed more as a work of art than expecting it to be particularly informative (IMO).

If you're interested in compilers, I recommend Engineering a Compiler by Cooper & Torczon. Same thing as TAOCP applies to people who suggest the Dragon Book. The Dragon Book is still good, but it focuses too much on parser generators and doesn't really cover enough of the other modern good stuff. (Yes, even the new edition.)

As far as real programming goes, K&R's The C Programming Language is still unmatched for its quality of exposition and brevity, but these days I'd strongly suggest picking up some Python or something before diving into C. And as a practical matter, I'd suggest learning some C++ from Koenig & Moo's Accelerated C++ before learning straight C.

Sipser's Introduction to the Theory of Computation is a good theory book, but I'd really suggest getting CLRS before Sipser. CLRS is way more interesting IMHO.

u/unacceptablePenguin · 8 pointsr/UniversityOfHouston

Introduction to Algorithms, 3rd Edition (MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_apa_89sSAbDN1RQ5V

That's probably the best book for data structures and algorithms out there. It's somewhat pricey but I use it all the time even for work things. You can probably find a free PDF with some digging. Look at the chapters in the Data Structures section particularly the elementary structure and hash map. The trees aren't covered in this course I believe.

u/sick_anon · 8 pointsr/algorithms

I suggest you to not waste too much time reading 15 different books on algorithms or spreading on 15 different resources (YT videos, online courses, forums, tutorials, etc.). Stick to 1 or 2 good books (try Introduction to Algorithms and, if you're completely new to algorithms, and have no idea what are they and what is their role in computer science and science in general, I recommend book by same author that could make a good preparation to previous book; it's called Algorithms Unlocked ) and start applying that knowledge in the run (solving problems). Remember: don't waste time on hundreds of resources; they may be great and offer some really high quality information about topic, but you just don't have time to go through all of them. Good luck!

u/leeeroyjenkins · 8 pointsr/cscareerquestions

http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

I won't directly link to a PDF version of it, but it's out there...

u/enzlbtyn · 8 pointsr/cpp

I'm a bit confused on your background with CS. You are you are aspiring to become a machine-learning researcher, yet evidently it doesn't seem like you have much of a background in CS which is why you're asking I assume. In any case, I'd recommend reading books on C++ and books on data structures/algorithms separately.

For algorithms/DS I recommend The Algorithm Design Manual and Introduction to Algorithms (commonly referred to as CLRS). Recommended books for C++ are on isocpp.org.

If you want to learn machine learning concepts and algorithms then I recommend some books on artificial intelligence and machine learning. To start with, Artificial Intelligence: A Modern Approach
then ISL. And/or potentially some associated MOOC courses, I recommend Learning from Data it's a really good course which teaches you fundamentals in machine learning such as learning theory and asks questions for why you can learn and etc.

In general, with all these books, you could possibly learn C++ by implementing their exercises or specific algorithms. Some examples would be basic CS related things binary search, sorting algorithms, heaps/priority queues and their associated implementations in the standard library. Then specific to Machine Learning you could implement decision trees and as an extension AdaBoost, a perceptron or a more generic neural network, and the list goes on.

u/CS_Student19 · 8 pointsr/computerscience

Tough call. I mean it sounds like you're setup pretty comfortably, so you don't really need any material goods. That's a great place to be.

Perhaps instead of some gift that can be purchased and wrapped in a box, you could do something else.

This might give you some ideas or perhaps they could find something unique, like an autographed copy of "Intro to Algorithms". I'm really just throwing stuff against the wall at this point, but maybe it might spark an idea.

u/rockinghigh · 8 pointsr/leetcode

You're essentially asking for a computer science class on algorithms. I would recommend:

u/lbkulinski · 8 pointsr/C_Programming

I am a big fan of Introduction to Algorithms. It covers a lot of content, and does it well!

u/phao · 8 pointsr/cscareerquestions

The best way I know how is by solving problems yourself and looking at good solutions of others.

You could consider going back to "fundamentals".

Most programming courses, IMO, don't have nearly as many exercises I think they should have. Some books are particularly good on their exercises list, for example K&R2, SICP, and TC++PL. Deitel's has long exercises lists, but I don't think they're particularly challenging.

There are some algorithms/DS books which focus on the sort of problem solving which is about finding solutions to problems in context (not always a "realistic" one). Like the "Programming Challenges" book. In a book like that, a problem won't be presented in a simple abstract form, like "write an algorithm to sort numbers". It'll be inside some context, like a word problem. And to solve that "word problem", you'll have to find out which traditional CS problems you could solve/combine to get the solution. Sometimes, you'll just have to roll something on your own. Like a new algorithm for the problem at hand. In general, this helps you work out your reduction skills, for once. It also helps you spotting applications to those classical CS problems, like graph traversal, finding shortest plath, and so forth.

Most algorithms/DS books though will present problems in a pretty abstract context. Like Cormen's.

I think, however, people don't give enough credit to the potential of doing the exercises on the books I've mentioned in the beginning.

Some books I think are worth reading which also have good exercises:

u/Bayequentist · 7 pointsr/algorithms

You should read CLRS from cover to cover.

u/lordnikkon · 7 pointsr/cscareerquestions

This is a great book for computer fundamentals that you should just read if you have any interest in computer science. But realistically you will not use much from this book in the real world. It is something to read to understand how things work.

You will get a lot more useful things out of a book like Intro to algorithms than SICP. The biggest thing i find self taught devs lack is an understanding of data structures. They know how to code and write solutions but dont know which data structure is efficient or why. They may learn by trial an error that one data structure is better for certain task but dont know why. If you are able to understand how the standard collections library for most major languages work you will be ahead of most devs

u/zman0900 · 7 pointsr/cscareerquestions

More than likely, your textbook will be Intro to Algorithms. Find yourself a copy and start reading. Even if the class uses something else, it's a great reference to have around.

u/megaicemage · 7 pointsr/learnprogramming

Someone else can probably point you to an actual resource, but here are my two cents.

Data Structures and Algorithms is a topic that you don't pick a specific language to learn in. All of the topics covered in algorithms are applicable to all languages, so it's usually a good idea to have a pretty good knowledge of the inner workings of your language of choice. Given this information, the textbook that my class used and it sounds like many other classes also use is Introduction to algorithms

u/williamfwm · 7 pointsr/technology

>The next generation of algorithms or smart application of the old ones could create even more upheaval

What, specifically, should we regulate, and how? An algorithm is just a set of steps that produces a correct answer to a problem. Which algorithms do you propose we regulate, and what should the regulations be? Should I go to jail if I implement a C++ solution of the map-coloring problem in a college classroom? Are there whole chapters of the classic CLRS textbook that should be banned from the curriculum?

A vague reference to "the next generation of algorithms" is hand-wavy, and suggests a fundamental misunderstanding of what algorithms are and how they apply to AI.

There is no algorithm that is going to just switch on one day and take over the world. That makes as much sense as worrying that the Pythagorean Theorem will wake up tomorrow and become SkyNet.

u/reddit_user_---_---_ · 7 pointsr/webdev

I'm assuming you are looking for generic algo and data struct taught in college:

Look up a university syllabus online, see the name of data structures, learn and implement them in whatever programming language. Same for algorithm, follow some syllebus, learn an algorithm, implement it. For more theory/math pick up a book, follow one of many mooc or find some university course's slides to work with.

I just did a quick search to make sure it is possible to find syllabuses, here's one of them I found for DS: http://bits.usc.edu/cs104/syllabus.html

Here's one for algo: http://www.people.iup.edu/sanwar/COSC%20310%20Syllabus.pdf

For book, my uni used this for DS: https://www.amazon.com/Data-Structures-Other-Objects-Using/dp/0132129485 (good)

For algo: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 (overrated, old and confusing, find something better if you can)

u/alphaglosined · 7 pointsr/csharp

I would recommend not looking for C# specific books. Language specific books tend to get out-dated very fast and won't be as high of quality.


For this reason you want books like https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 and https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043

​

I'm personally in the market for data structure books, sadly its a slippery slope when you already have a few.

u/Salyangoz · 7 pointsr/Turkey

ilk olarak kolay gelsin.

Stanford ve MIT'in online course'lari var itunes university'de ordan bakmaya basla istersen.

Internetten egitimini sevdigin okullarin syllabus'unu alip ordaki kitaplardan calismaya baslayabilirsin zaman kaybetmemek icin. Istersen sana sirali kendi transcriptimdeki dersleri PM olarak atabilirim.

Okulundan aldigin .edu emailini cogu programi bedava kullanmak icin kullanabilirsin. (github inanilmaz bi pack veriyor, %100 suistimal etmeni tavsiye ederim)

Kitap oku ve bol bol kod yaz. Boktan olsa, bozuk olsa bile yaz. Kagit kalemle de yazmaya cekinme (is basvurularinda seni beyaz tahtaya cikaracaklar malesef debugger/syntax checker olmicak)

aklima gelen standart kitaplardan en onde su geliyor:

  • Introduction to algorithms : facebook ve google direk bu kitap icinden soru soruyor ise alimlarda. Cogu ilk basta cok zor gelebilir, korkuya gerek yok, 2 sayfayi 3 gunde falan yapiyorsan cok iyi.


  • Bilgisayar temel bilgileri icin de Computer Organization

    Eger lise bilgilerinden korkuyorsan cok inanilmaz bi matematik yok (sektorune gore degisebilir tabi). Lineer Cebir (image processing/game-development vs.) ve Olasilik (AI, Machine learning, data analysis vs.) bilgilerini tazele. Eger machine learning falan yapmak istiyorsan ilerde olasilik bilginin guclu olmasi gerek.

    Cok net bi cizgi izlemene gerek yok. Gerektikce ogrenme politikasi benden yana cikti su ana kadar ama bu tartisilir.

    baska bisi olursa cevap vermeye calisirim.
u/Adenverd · 7 pointsr/programming

Preface: I'm not being condescending, I know a lot of incredible programmers who never attended a computer science class.

To be honest, this is the sort of stuff you learn about in a computer science degree program (though this would probably fit better in a graduate degree than an undergrad). If it really interests you, you should look into it.

If that's not a really viable option, I can't recommend this book on algorithms highly enough. It talks about runtime, scaling, data structures and graphs, etc. Truly fascinating stuff.

u/crwcomposer · 7 pointsr/compsci

His algorithms class probably used this textbook, but if they didn't, it's pretty much a standard:

http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

Don't be deceived by the title, it's more than just an introduction. As the description on Amazon states:

>Some books on algorithms are rigorous but incomplete; others cover masses of material but lack rigor. Introduction to Algorithms uniquely combines rigor and comprehensiveness.

u/DeadZombie9 · 7 pointsr/umanitoba

Books aren't required for first-year CS (they aren't needed for other years either).

Here is the online version of the book they use in COMP 1010. They will give you a link for the COMP 1020 book when you take the course but I'm not gonna look around for it.

General advice for any CS students: A good algorithms book is very handy. I recommend investing in this one. It's gonna be useful throughout your undergrad degree and probably afterward too.

u/webdevop · 7 pointsr/webdev
u/sorryateyourbagel · 7 pointsr/ECE

I have a EE undergrad degree and work as a software developer (mostly web development).

Best advice is to code as much as possible. I second @jewdai's recommendation to study data structures and algorithms -> learning these will give you a solid toolset for solving problems (w/ code) in the future. The bible for data structures and algorithms is:
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=zg_bs_132570011_2?_encoding=UTF8&psc=1&refRID=G4V554CGYNTY1J7NT6AZ

You should investigate what type of industry you're interested in. If you're interested in signal processing, check out companies that specialize in that area (I guarantee they need software developers).

Best chance for getting an entry level position would be one where you can leverage your EE expertise, but spend most of your time programming (it's the only way to get better). Working on an embedded system (e.g. firmware) might be a good fit because you need solid EE knowledge as well as software skills.

I would also leverage my alumni network; talk to your classmates fellow grads who are in software now. Get their advice and network; those connections can lead to jobs (or at least interviews at their companies).

Best of luck!

u/manbetrayedbyhismind · 6 pointsr/gamedev

Introduction to Algorithms. It's a great reference book for me now.

u/win7dev · 6 pointsr/IAmA

>What would be the best way to prepare for these types of interviews? What sources/books did you use to study data structures and algorithms?

Get a friend and have them run you through practice interviews. Lots of them. Get used to writing code on a whiteboard, because it's different from writing code in an IDE.

For algorithm practice, I bought Introduction to Algorithms and Programming Pearls. I also did a lot of research online to find out the kind of interview questions to expect. (Ignore the brainteaser questions; Microsoft doesn't do them any more.)

For the most part, just hit the books, study hard, and write lots of code on a whiteboard. This article by Steve Yegge really nails it, I think.

u/theootz · 6 pointsr/cscareerquestions

TL;DR Improve yourself, invest in your future, don't worry about the mistakes...read the books listed at bottom, and practice!

Few months ago I royally fucked up an interview at Microsoft. A really simple question. But I had no experience doing coding on paper instead of a computer.

I spent a lot of time studying various books and paper coding to make sure it wouldn't happen again.

I then had an interview for another (in my mind at the time) dream job. I did fine for all the phone interviews and they flew me over to the west coast for an in person interview for the day. I did well for the first bit until they started pulling out dynamic programming and integer programming questions on me and expecting me. Once again something I didn't prepare for, and f'd up. Didn't get this job either. For the longest time I was really hard on myself at fucking up on both these interviews one after another. Especially this second one since a lot more was riding on it than just the job (another story).

But then I decided I didn't want to have this sort of experience again and expected better of myself. I made myself further improve and brush up on all those concepts as well. Did a few mock interviews with friends, spent some time working on interview type questions on both the computer and on paper. A month or two later I started interviewing again. By this point I was an interviewing machine - and I'm now able to do just about anything thrown at me. I've had my choice of employers and until just recently, was in the situation where I had so many offers I didn't know which one I wanted most. I'll be heading to silicon valley soon at one of the top tech companies in the world with a fantastic offer considering I just graduated.

The point is - learn from the mistakes and improve yourself. I realize you don't want to be that guy spending heaps of time coding outside of work or whatever... but this is an investment in yourself and your career. Do it once, and then just brush up on your skills from time to time. Get into the interviewing mindset and just rock them so you can have your choice of job - and then you can go about your thing once you have the job locked. The up front investment will be worth it!

Things that helped me:

  • www.hackerrank.com - practiced a lot of questions on here
  • www.careercup.com - another great site for questions
  • Cracking the Coding Interview More help on questions, but also some great insights into the interview process for the larger tech companies and many hints and tips on how to go about solving the more complex problems
  • Code Complete A great book for helping you to refresh or learn about software design
  • Eternally Confuzzled Great resource to learn how to think about common data structures and algorithms

    Having trouble with Algorithm design/analysis? These are some of the go-to books for that:

  • The Algorithm Design Manual Probably the defacto for learning about algorithm design and analysis
  • Introduction to Algorithms A great book with many different algorithms and data structures to learn about
  • Algorithm Design A great book if you want to dive deeper into more complex subjects like graph theory, dynamic programming, search algorithms, etc.. etc..
u/hvidgaard · 6 pointsr/learnprogramming

I can't really point you to anything online, but this book is one of the best on the subject. If you work your way trough that book, you will know more than most CS undergrads do about algorithms and data structures.

It's also a must have if you're implementing your own data structures every now and then.

u/Gaff_Tape · 6 pointsr/ECE

Not sure about EE-related topics, but for CE you're almost guaranteed to use these textbooks:

u/ForeignStudentUS · 6 pointsr/greece

freelancer.com, upwork.com και παρες όσες περισσότερες δουλείες μπορείς. Βιβλια που μπορεις να διαβασεις:

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_2?ie=UTF8&qid=1482103739&sr=8-2&keywords=algorithms+and+data+structures

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_4?ie=UTF8&qid=1482103757&sr=8-4&keywords=software+engineering


Αν δεν ξέρεις κάτι google it. Η Ελλάδα έχει μεγάλες προοπτικές ανάπτυξης και πολύ καλό βιοτικό επίπεδο. Αν καταφέρεις και κάνεις κάτι μπορείς να βγάλεις καλά λεφτά κάνοντας εξαγωγές. Έχουμε υψηλό μορφωτικό επίπεδο σε συνδυασμό με το χαμηλό κόστος βιοτικού επιπέδου είναι θέμα χρόνου μέχρι να αρχίσουμε να εξάγουμε competitively priced τεχνολογία.

Αν εχεις ποιο συγκεκριμενη ερωτηση πες μου

u/salamanderoil · 6 pointsr/AskComputerScience

It depends on what you already know.

​

Do you have any prior programming experience? If not, start there. My no. 1 recommendation here would be Allen B. Downey's free Think Python book. Others might come along and recommend something like SICP, which is a good book, but perhaps a bit hard for an absolute beginner. Downey also has a version of his book that uses Java, so if you know for a fact that this is the language your introductory programming class will be using, then that could be a better option (Python is a simpler language, which makes it easier for you to focus on the actual concepts rather than the language itself, but if you know that you'll be using Java, you might as well kill two birds with one stone).

​

If you do have prior programming experience, you have all sorts of options:

  • You could learn a functional language, like a Lisp (Clojure, Racket, Scheme, LFE, ...) or something in the (extended) ML family (Standard ML, OCaml, F#, Haskell, Elm, ...).
  • Or, you could go the other way and learn something low-level, like C. You could even learn about C and Lisp at the same time by building your own.
  • Or learn a logic programming language, like Prolog.
  • Or, if you really want to understand object-oriented programming (and how languages like Java managed to stuff it up), you could learn Smalltalk.
  • If you don't know what a unit test is or how to write one, you should learn.
  • Learn about data structures and algorithms. As a CS student, you'll be learning about them at some stage anyway, so there's no harm in starting early. Some people might recommended CLRS for this, but for someone just starting out, I'd recommend something a bit friendlier, such as this series of videos from Princeton (presented by Robert Sedgewick, author of one of the most popular books on the subject). If you'd prefer a book, this free one from Allen B. Downey (who also wrote the introductory programming text I recommended earleir) looks quite good.
  • Work your way through NAND2Tetris. It will take way longer than a month, but it will definitely set you apart from the rest of the class. Even if you don't do this now, you should definitely plan to do it at some point.
  • Learn about databases. Again, you'll have to study them eventually, so why not start early? You could start by trying to build something that uses a database, like a simple todo utility.

    ​

    Regardless of whether or not you have programmed before, I would also recommend doing the following:

  • Learn some basic Unix skills. It doesn't have to be too much – just enough to be able to sit down at the command line and have a vague idea of what you're doing is fine for now. You'll learn more as you use it more. That said, if you really want to dive in and learn how everything works, then something like How Linux Works could be a good read.
  • Learn some discrete mathematics. As a CS student, you'll be required to learn it at some stage – it's the mathematical backbone of CS, much like calculus is to physics – so you might as well start early. This free, book-length set of notes from MIT is very well-regarded (but don't expect to get through it all in a month!). There is also a set of video lectures if you prefer. If you're keen on learning functional programming, another option could be to integrate that with your discrete maths studies by reading Thomas VanDrunen's Discrete Mathematics and Functional Programming (if the physical book is a bit expensive for you, there's also a cheaper ebook version available).
  • For bonus points: learn to use either Vim or Emacs. There probably isn't a massive practical advantage to using these this early in your career (although they could certainly come in handy later), but if other students see you writing code in one of them, you'll look like an absolute badass. Your teachers will probably be quietly impressed, too.

    ​

    if you have any questions about my above suggestions, let me know, and I'll see if I can point you in the right direction.

    ​

    Good luck!
u/JAPH · 6 pointsr/learnprogramming

Introduction to Algorithms by CLRS. Used in almost every algorithms class I've heard of, and a great reference book. It's about 1300 pages, so don't try to read straight through it.

C Programming Language by K&R. This is a C programmer's Bible.

Design Patterns by the Gang of Four

This is a little more of a topic book, but The Art of UNIX Programming by Raymond.

These are all either pretty common, or almost essential. You'll probably see these in your curriculum anyway, and you should. These are a good cornerstone.

u/WaxenDeMario · 6 pointsr/cscareerquestions

Yes! Also, quite honestly I don't know that many CS majors who took linear algebra at my school for whatever reason.

Where do you get started?

  • If you're the type of person who likes an organized class to learn concepts, consider checking out coursera or other similar websites which offer free online learning courses! Check out their CS offerings and start from the intro.

  • I must be known for spamming this SR with this, but check out CLRS, it pretty much contains most of the "CS math" you need to know for algorithms. As well as pretty much all you need to know about Algorithms and Data Structures for any basic job.

  • REALLY make sure you understand your Algorithms and Data Structures, nearly every interview for a basic position centers around these topics. As well as some others, depending on the company: Bit manipulation, multi-threading, TCP/IP, etc.

  • You want to learn some mainstream language as a lot of other people mentioned: C++, Java, C#, Python are a few that come to mind (though there are more like Ruby!). Side Note: Some people have differing opinions on whether C++ is good to learn as a first language. I don't know C# (but from its apparent similarity to Java) I would say C++ is probably the most difficult language to learn of the four I listed, but I feel that it also provides the most flexibility, because once you understand C++ it's easier to trainsition from C++ to Java, than say Java to C++ (similar for the other languages).

  • Practice! Start working on some Project Euler problems, or other practice problems. Bonus: Someone in another thread mentioned that they made a blog post for each problem they solved and explained every one of their design decisions. This seemed like a bit over the top, but it really is a good practice for an interview and a job! You can even put a link to this on your resume to share.

  • Find an Open Source to contribute to, come up with your own projects and post them on your github! This can show off your skills to a potential employer!

    Bonus for programming:

  • When coding alone it's easy to get lost and start "hashing" together code. When you get to big projects, you'll find that this causes a lot of problems (and when working with other people it can cause even more). Some things to keep in mind when coding:

  • Make sure your code is maintainable.

  • Make sure your code is scalable.

  • Test, test, test!

    Maintainable kinda means that your code is easy to test, easy to comprehend (by others) and easy to modify. Read up on different design patterns to learn more about this.

    Scalable is something you'll learn more about later, but basically it's kind of thinking about whether your code will be "good" enough to handle a lot of users (how fast is it how much memory will it take up)

    Testing is very important when coding. You want to try to write small pieces of code then test it (i.e.: make sure it works).

    All three of these things show up a lot in interviews, and if you can relate why you made your code the way you did to one of these three points (or something else) you should be pretty well off :D

    How do I land an interview?

  • In your resume make sure to list any CS projects you want to mention, a link to your website (if you have one) or to other work. As well as Operating Systems you're familiar with (Linux is a big plus, but not absolutely necessary), IDE's you're familiar with (things like Eclipse, Visual Studios), and Languages you know. If you can, make sure to relate those three bullets to your project and work somehow to reiterate your experience with each language.

  • A lot of recruiting is done on-campus, but there are other options, like applying online or even better...

  • Network your way in. This gets your resume through the massive HR screen

  • Edit, edit, edit (ask friends who are in the industry).

    How do I study for an Interview?

    Typcially, an interview will have you and the interviewer. The interviewer will first ask questions about you, what you're majoring in. And then maybe ask questions about your previous projects, and then he'll throw you a programming problem. Sometimes these can just be questions like "Which is faster: quicksort or mergsort?" or something like that, but other times they'll have you code something. If the interview is online, this will either mean you'll need to tell them the code you're writing or you'll code online on some collabarative envirionment (i.e.: you type the code online). If it's in-person they may have you write on a whiteboard. There are other formats of interviews as well, so make sure to research. Typically, for most larger companies, they won't care what language you code in (hopefully though it's mainstream!), but if you don't code in a language which they use, they may test you later for proficiency in one of their languages.

  • As I mentioned before, Algorithms and Data Structures are usually go-to's for interviews, but other topics may come up so check out the req's for each job specifically.

  • It may have been a while at this point since you studied your material, to brush up on interview questions, Cracking the Code Interview is a great book to brush up on your topics for an interview, it also has some resume advice, etc. if you choose to follow it.

  • Be sure to practice talking out loud while you're coding, as this can help you during interviews. If you're stuck but your thought process is good an interviewer can help push you in the right direction.

  • If you struggle with interviews, try having a friend who you know has experience and having him ask questions, better yet if you know a friend at the company, ask him to mock interview you.

  • If you have time ALWAYS make sure you run test cases through your code mentally, and mention the test you're running and what it's supposed to catch (expected behavior) to your interviewer! If you have time and choose to ignore these, it can give the interviewer a wrong impression :\ (it also makes you look really good if you come up with all the boundary cases)

    Sorry, not sure if this helps or not!
    Good luck!
u/nolsen01 · 6 pointsr/compsci

Here is my advice, take it with a grain of salt:

  • There are lots and lots of flamewar worthy disagreements in computer science, programming and technology in general. Linux vs Windows vs Mac, Gentoo vs Arch vs Ubuntu, Ruby vs Python vs Java, Object Oriented Programming vs Functional Programming. Even within languages, certain frameworks have their loyalists and will tell you their favorite framework is the only way to go. Do not get mixed up in this. Follow your interests and enjoy what you're doing.

  • Be patient. Do not try to learn too much too quickly. Since you have another year or so before you start taking computer science classes, you are not in a hurry. You can take this time to learn some practical skills rather than just theory (which is what /r/compsci is all about). You'll find that your classes will teach you really interesting theoretical stuff like how to measure the efficiency of your programs or how to organize your code to make it more maintainable, all of which is very helpful, but it probably won't teach you how to use Maven or how to use some of the things that the industry wants you to know how to use. This is what I mean by practical skills. Its one thing to know what a Binary Search Tree is, its another to know how to use a specific framework. Spend some time on the practical stuff now. That means actually creating stuff like websites or video games (or whatever interests you.)

  • "The perfect is the enemy of the good." Don't try to make your programs perfect. Make them work and try to form healthy habits but do not be the type that settles for nothing less than perfection. If you do, you'll find that you hardly get anything done.

  • Pick one language to specialize in. You will learn more this way in the beginning. A lot of people have stunted their own progress by spending their first couple of years learning different programming languages. Don't do that. You'll learn other programming languages eventually, it really isn't that hard, but you're better off specializing in a specific language (for now) than being crappy at a lot of languages. (I made this mistake.)

    If you want to get good at programming, I would recommend the book "How to design programs" combined together with The Racket Programming Language. If you're really up for it, mix in the content from Structure and Interpretation of Computer Programs (which is a great book by the way). If you finished those, you'll have a very good foundation for learning how to program. I would learn a new language (don't specialize in racket) and continue from there.

    The downside to learning racket is that it is not a common language, however as I said earlier, you'll find that learning new languages it very easy so this shouldn't be too much of a problem, especially if you're more concerned with forming a good foundation first.

    After learning all of that, I would say look into something on data structures and algorithms. There are a lot of great books on the subject. Introduction to Algorithms is considered the classic. If you can get through the whole thing on your own, then you are better then I am.
u/rowr · 6 pointsr/C_Programming
u/146throw213 · 5 pointsr/SJSU

doesnt matter, what you learn in that class @SJSU wont be enough

pick up http://www.amazon.com/Introduction-Algorithms-3rd-Thomas-Cormen/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1449290491&sr=8-1&keywords=CLRS

90% of your interview questions in the future for internships/jobs rely on this class

gl

u/gtani · 5 pointsr/algorithms

That book has reviewed excellent reviews http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693/. This is the standard text, CLR or CLRS http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/

What you're describing is probably what most people think of as machine learning, data science/mining, and has as much to do with computational efficiencies as it does algorithms' intrinsic behavior.

Also, What programming languages do you know?

Maybe if you look at a cheat sheet http://dlib.net/ml.html and some ML texts (Murphy, Bishop, Barber), those would help (also AIMA by Norvig/Russell)

http://www.amazon.com/review/R32N9EIEOMIPQU/ref=cm_cr_pr_perm?ie=UTF8&ASIN=0262018020&linkCode=&nodeID=&tag=

u/remotelyqueued · 5 pointsr/learnprogramming

I like this book on algorithms

u/maruahm · 5 pointsr/compsci

You're probably right.

For algorithms, the usual undergraduate text is Introduction to Algorithms by Cormen, et al. I do recommend it, too. It's comprehensive and good.

Besides Cormen, I've also made good use of Analysis of Algorithms and Analytic Combinatorics by Sedgewick and Flajolet. They're a bit more advanced, but I don't know algorithms analysis well enough as a field to know where they would usually be taught or how central their material is. They've been very worthwhile purchases for me, though, and I do recommend them as well.

Edit: It's also worth pointing out that, at my institution, the graduate intro algorithms course used Kozen's other textbook, The Design and Analysis of Algorithms. You might want to take a look.

u/sockmeistr · 5 pointsr/programming

Introduction to Algorithms by Cormen, Leiserson, Rivest and Stein

ISBN 978-0-262-03384-8

One of the few truely good Computer Science books.

http://www.amazon.co.uk/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1302640399&sr=8-1

u/videoj · 5 pointsr/learnprogramming

Data structures and Algorithms Write code to impleement every (or even most) and you'll be well preparped.

Design and Testing here.

Programming Languages here.

Also look for an open source project that needs help and provides you with experience in one or more of these areas (or start your own). Code is always a good way of showing you know something.

u/throwaway_veneto · 5 pointsr/italy

Per gli algoritmi, questo è un mattone ma dopo anni lo uso ancora all'occorrenza (tipo spiaccicare piccolo-medi roditori).

u/n2dasun · 4 pointsr/compsci

If you look in the sidebar, you'll notice a few other subreddits that might be better for this question, like /r/askcomputerscience and /r/cscareerquestions.

I'm learning, like you, and from my experience the answers you'll receive will generally be to learn one language intimately, and to learn data structures and algorithms to the point where you can explain them in an interview and be ready to cobble together an implementation in code (whiteboard or on a computer). Also, design patterns. You'll see recommendations for CLRS and Head First Design Patterns.

Don't forget to check the sidebars and FAQs for each of these subreddits. Your answers are likely to already be there.

u/jappacappa · 4 pointsr/cscareerquestions

Year one of ICT includes DFS, BFS, Dykstra, Bellman-ford, several tree-create and search algorithms, insertion sort for introduction etc... That's very basic stuff.. First year computer science we had red and black binary search trees and everything before that (everything about analysis about them, basically this whole book Introduction-Algorithms

That's basic first year ICT and CS curriculum.. Of course it's a hundred times more advanced after 3-4 years of study.

u/Bizkitgto · 4 pointsr/learnprogramming

One quick way would be to look up the algorithms courses offered by Stanford, MIT, etc and see what book the syllabus recommends. Some are offered as an MOOC as well (edX, Coursera, Khan, etc).

Also, you can check out these classic texts:

u/dustrider · 4 pointsr/programming

This is a tough one. It's been several years since I've used textbooks so there may be better ones out there, and I can't remember what they were in any case :).

CS is a pretty wide field, and does rely on a lot on mathematics. I don't believe you need the theory to be a business programmer, but I do believe that expanding your knowledge of computing, in any way, will make you more capable as a programmer.

There's a couple of free resources you can use to give you the back ground, MIT's opencoureware is excellent for this, and don't forget wikipedia, seriously don't laugh, but do follow up on the references in a wikipedia article.

from what you're saying it sounds like you're more interested in algorithms than computational theory. So I'll just focus on that:

The MIT course introduction to algorithms looks good, and This also has some videos of the lectures this is the textbook they used.

u/_INTER_ · 4 pointsr/java

If you want to get a head start at the college, I'd rather get more fundamental programming knowledge. Get a book about algorithms and datastructures (e.g. this or this, first few Google results pointed me to a PDF).

Well of course practical knowledge is also never bad.

u/GrowthMindset88 · 4 pointsr/learnprogramming

http://www.theodinproject.com/ was a great resource for learning web development. I really liked this book by David Herman for more advanced JS techniques: http://www.amazon.com/Effective-JavaScript-Specific-Software-Development/dp/0321812182. Also if your looking into Algorithms, this is probably THE book your looking for http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

u/CSMastermind · 4 pointsr/learnprogramming

I've posted this before but I'll repost it here:

Now in terms of the question that you ask in the title - this is what I recommend:

Job Interview Prep


  1. Cracking the Coding Interview: 189 Programming Questions and Solutions
  2. Programming Interviews Exposed: Coding Your Way Through the Interview
  3. Introduction to Algorithms
  4. The Algorithm Design Manual
  5. Effective Java
  6. Concurrent Programming in Java™: Design Principles and Pattern
  7. Modern Operating Systems
  8. Programming Pearls
  9. Discrete Mathematics for Computer Scientists

    Junior Software Engineer Reading List


    Read This First


  10. Pragmatic Thinking and Learning: Refactor Your Wetware

    Fundementals


  11. Code Complete: A Practical Handbook of Software Construction
  12. Software Estimation: Demystifying the Black Art
  13. Software Engineering: A Practitioner's Approach
  14. Refactoring: Improving the Design of Existing Code
  15. Coder to Developer: Tools and Strategies for Delivering Your Software
  16. Perfect Software: And Other Illusions about Testing
  17. Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application

    Understanding Professional Software Environments


  18. Agile Software Development: The Cooperative Game
  19. Software Project Survival Guide
  20. The Best Software Writing I: Selected and Introduced by Joel Spolsky
  21. Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams
  22. Rapid Development: Taming Wild Software Schedules
  23. Peopleware: Productive Projects and Teams

    Mentality


  24. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency
  25. Against Method
  26. The Passionate Programmer: Creating a Remarkable Career in Software Development

    History


  27. The Mythical Man-Month: Essays on Software Engineering
  28. Computing Calamities: Lessons Learned from Products, Projects, and Companies That Failed
  29. The Deadline: A Novel About Project Management

    Mid Level Software Engineer Reading List


    Read This First


  30. Personal Development for Smart People: The Conscious Pursuit of Personal Growth

    Fundementals


  31. The Clean Coder: A Code of Conduct for Professional Programmers
  32. Clean Code: A Handbook of Agile Software Craftsmanship
  33. Solid Code
  34. Code Craft: The Practice of Writing Excellent Code
  35. Software Craftsmanship: The New Imperative
  36. Writing Solid Code

    Software Design


  37. Head First Design Patterns: A Brain-Friendly Guide
  38. Design Patterns: Elements of Reusable Object-Oriented Software
  39. Domain-Driven Design: Tackling Complexity in the Heart of Software
  40. Domain-Driven Design Distilled
  41. Design Patterns Explained: A New Perspective on Object-Oriented Design
  42. Design Patterns in C# - Even though this is specific to C# the pattern can be used in any OO language.
  43. Refactoring to Patterns

    Software Engineering Skill Sets


  44. Building Microservices: Designing Fine-Grained Systems
  45. Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools
  46. NoEstimates: How To Measure Project Progress Without Estimating
  47. Object-Oriented Software Construction
  48. The Art of Software Testing
  49. Release It!: Design and Deploy Production-Ready Software
  50. Working Effectively with Legacy Code
  51. Test Driven Development: By Example

    Databases


  52. Database System Concepts
  53. Database Management Systems
  54. Foundation for Object / Relational Databases: The Third Manifesto
  55. Refactoring Databases: Evolutionary Database Design
  56. Data Access Patterns: Database Interactions in Object-Oriented Applications

    User Experience


  57. Don't Make Me Think: A Common Sense Approach to Web Usability
  58. The Design of Everyday Things
  59. Programming Collective Intelligence: Building Smart Web 2.0 Applications
  60. User Interface Design for Programmers
  61. GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos

    Mentality


  62. The Productive Programmer
  63. Extreme Programming Explained: Embrace Change
  64. Coders at Work: Reflections on the Craft of Programming
  65. Facts and Fallacies of Software Engineering

    History


  66. Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
  67. New Turning Omnibus: 66 Excursions in Computer Science
  68. Hacker's Delight
  69. The Alchemist
  70. Masterminds of Programming: Conversations with the Creators of Major Programming Languages
  71. The Information: A History, A Theory, A Flood

    Specialist Skills


    In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.

  72. Peter Norton's Assembly Language Book for the IBM PC
  73. Expert C Programming: Deep C Secrets
  74. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming
  75. The C++ Programming Language
  76. Effective C++: 55 Specific Ways to Improve Your Programs and Designs
  77. More Effective C++: 35 New Ways to Improve Your Programs and Designs
  78. More Effective C#: 50 Specific Ways to Improve Your C#
  79. CLR via C#
  80. Mr. Bunny's Big Cup o' Java
  81. Thinking in Java
  82. JUnit in Action
  83. Functional Programming in Scala
  84. The Art of Prolog: Advanced Programming Techniques
  85. The Craft of Prolog
  86. Programming Perl: Unmatched Power for Text Processing and Scripting
  87. Dive into Python 3
  88. why's (poignant) guide to Ruby
u/vitalijzad · 4 pointsr/computerscience

About Algorithms, a great book is Introduction to Algorithms by Cormen et al.

About programming I like PHP 5 Power Programming by Andi Gutmans, Stig Bakken, Derick Rethans. I know that it is old, but newer books aren't that good.

u/MITranger · 4 pointsr/learnprogramming

I really like /u/razeal113 's comment. That's a good algorithm for finding a good algorithm. Starting out with brute force isn't necessarily bad, as it at least gives you a jumping board to start optimizing. The only thing I would add is to increase your knowledge and toolbelt. You can gain a lot of inspiration and learn "how to think" by learning, analyzing, applying, and modifying all the awesome algorithms already out there. Here are some resources:

MOOCs.

u/e7hz3r0 · 4 pointsr/cscareerquestions

I haven't been in or done a junior dev interview in a long time so I can't speak to whether most companies ask algorithm questions these days.

What I can say is that many of the mid- and senior-level interviews I've been in do. This means, to me at least, that you should learn this stuff even if you don't get asked it in a junior dev interview.

As as self-taught developer, you have shown that you've got the drive and curiosity to learn a lot of stuff enough to do useful work. That says something. So bravo!

Practicing is a great idea. However, if you're constantly looking at the hints before coming up with your own answer, that's probably not as helpful. It sounds like you should learn more about algorithms as a whole topic.

To shore up your weaknesses with algorithms I'll suggest a few resources that I've come across over the years. Since I went the traditional CS degree route, I haven't used these personally but I know many people who recommend them:

u/blablahblah · 4 pointsr/cscareerquestions

This solution requires some knowledge of how C works. A pointer is a number referring to a point in memory (and memory is one continuous blob of data). A C string is just a pointer to a character- you start at the location given and keep reading until you hit a NUL (character 0). C doesn't have a boolean type, so you use 0 is false and anything else is true. Once you understand those things, it's a fairly straightforward answer- you start at the beginning of the string, increment the pointer (you can literally imagine a finger pointed at a specific spot in a container if it helps) until you reach the end of the string (marked by character 0), then swap the character from the front with the character from the back, moving each pointer towards the middle as you go.

Having enough knowledge of C to implement this solution is different than a general knowledge of algorithms. On the C side of things, you could read something like Learn C the Hard Way, or buy a copy of K&R if you just want something to refer to as you practice. On the algorithms side of things. For the algorithms side of things this is a pretty popular textbook on the subject.

u/Terr_ · 3 pointsr/PHP

Not PHP-specific, but I'd grab some used edition of the "CLRS book", nicknamed after the authors' initials.

Personally I just gloss over the "mathematically proving it's actually O(log(n))"-type bits in favor of the algorithm explanations.

u/mdf356 · 3 pointsr/cscareerquestions

It's about 40 years too late for any one person to have mastery of all the different parts of a computer.

For computer architecture, Hennessy and Patterson is the classic volume. For the software algorithms that are used everywhere, CLRS is the classic guide. For Operating Systems, The Design and Implementation of FreeBSD is a good book. I'm sure there's something similar for networking.

You could read the PCI spec, and some Intel data sheets, and the RFCs for networking protocols if you want to learn those things. For most parts of computers, I strongly suspect that most material is either too high level (yet another "Introduction to") or too low level (reading an RFC doesn't tell you whether it's used that way in practice or has been superseded).

The only way I've gotten to know things is to play with them. Change the code, make it do something else. Personal research like that is very educational but time consuming, and there's way too much out there to know everything, even for a single small piece of hardware and its associated software.

u/afraca · 3 pointsr/learnprogramming

There's the "bible" on algorithms, it's called Introduction to Algorithms by cormen et. al. , and it nicely covers Big O notation.

http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

u/zifyoip · 3 pointsr/learnprogramming

A widely recognized standard textbook for data structures and algorithms is Introduction to Algorithms by Cormen, Leiserson, Rivest, and Stein.

u/thethirdmoose · 3 pointsr/programming

That's the latest one.

Honestly, this book is amazing. It's called the "algorithms bible" for a good reason. It's called the "Introduction to Algorithms", but in reality it's a thorough reference book. It's 100% language-agnostic, as everything is in pseudocode. There are lots of practice problems in each chapter. It's also commonly referred to as CLRS (after the authors).

u/MrNetTek · 3 pointsr/computerscience

CS is almost pure math, especially beyond the freshman year. You can learn to code with almost no advanced math. So, what's up with that?

Numerous---everyday---apps are actually very simple coding, which do not require much math. This lures people who code into thinking math is not required in programming. That is a false assumption. This is the rub...anything advanced in technology requires equally advanced mathematics. AI, machine learning, data science, robotics, graph theory, geometric modeling, parallel architectures, electronics, telecom transmissions, cryptography, etc., etc., etc., all require advanced mathematics skills. The list goes on forever.

You'll never be a great programmer without at least a strong foundation in discrete mathematics (maybe you'll be a elementary app coder or maybe you'll be a low-level developer). Anyone saying you don't need math in CS is wrong. Anyone saying CS is easy is mistaken. For those that claim all you need is 3rd or 4th grade math, are 3rd or 4th grade coders. At least 1/3 of people drop out of computer science degrees---stating it was just too difficult.

I suggest to everyone to pick up The Art of Programming, by Knuth (and/or Introduction to Algorithms, from MIT Press). Come back and tell us if you think CS is hard, and...if math is required in programming. Find a quiet corner to cry in....the books are as intense, as they are inspirational.

My advice? Take a few discrete mathematics courses. You may have a job one day that requires you to know the cost of nodes in a tree, based upon the mathematics of recursion and exact powers: Example - That isn't 3rd grade math. Stare at this gem for a while: https://www.tug.org/texshowcase/cheat.pdf

The good news is...you live in the best possible era to learn CS. Millions of resources are at your disposal. You just need to be dedicated.

-MrNetTek

u/cshandle · 3 pointsr/math

It depends what sort of job you're applying for. If you are applying to Google-esque companies for a programmer position then be comfortable solving leetcode medium-hard problems on a whiteboard. This requires knowledge typically found in a data structures & algorithms course. Typically at a university those courses have pre-reqs of 1-2 programming courses + discrete mathematics. If you are already out of school, then you can find various books/MOOCs that cover this material. Familiarity with CLRS helps with algorithms knowledge. As a math major this sort of material (the rigorous study of algorithms) will be much easier for you to pick up than others. This is what I have found anyway.

If you are looking to work at a startup, then you may not even need a degree or DS&A knowledge. They may require you to simply know a certain tech stack really well. Some companies just give you various questions around a programming language. It depends on the company and interviewer(s). Check glassdoor for interview questions around a certain company to get an idea (if one exist for that company).

If you have follow up questions, then /r/cscareerquestions is an excellent place to post such questions.


u/IMovedYourCheese · 3 pointsr/cscareerquestions

Short answer - yes, self-taught coders can (and do) get great jobs in the industry. You can absolutely pursue a software career.

Long answer - first and foremost figure out if this is the right path for you. Do you genuinely enjoy coding? There's no way to answer that question other than to start learning and building things. There are ample resources available online for free, so all you need is a computer with internet and lots of free time.

Then figure out what areas you're interested in, whether it is front-end/UI development, back-end services, full stack, mobile apps, windows apps, databases, big data/analytics or anything else.

You can either build up a portfolio of personal projects or go to college. A 4-year CS degree will obviously be ideal, but is definitely not necessary. Do note that it is much harder for self-taught programmers to get noticed and get hired, so along with sharpening your resume and coding skills also attend job fairs and networking events and make connections.

Before you start applying for jobs, I would check each box on this list:

  • Know at least one mainstream programming language (C++, Java, C#, Python, Ruby etc.) really well.
  • Have an up-to-date resume with lots of relevant personal projects.
  • Try and get some part-time programming jobs (or internships) on the side to put on your resume.
  • Be familiar with common data structures and algorithms. I suggest reading Introduction to Algorithms.
  • Prepare for interviews by reading Cracking the Coding Interview or a similar book, and practice solving as many coding problems as you can in your language of choice.

    All of this is assuming that you want to be a programmer. There are a lot of other career options in the industry, like IT/operations, DBA, product management etc. so give those a thought as well.
u/zzzwwwdev · 3 pointsr/compsci
u/jb3689 · 3 pointsr/ruby

I came here to put this same book. This book is crazy, crazy good. It would help to have some knowledge of algorithms and data structures before going in as the examples aren't vast and the information are fairly heavy, but it's a fantastic reference.

I would encourage you to change your thinking from "learning algorithms in Ruby" to "learning algorithms" and then just implementing examples in Ruby. There are a few classic Algorithms book that I'd highly recommend. In addition to The Algorithm Design Manual, Data Structures in C is written in C but fairly generic and gives you the right tools for thinking about performance and algorithms, and Introduction to Algorithms, 3ed is more academic but also stupid inexpensive right now. It's a great learning book as the examples are very detailed. It's aimed at interviewing but Cracking the Coding Interview has a nice short survey of algorithms and data structures too

u/DisintegratedSystems · 3 pointsr/compsci

Introduction to Algorithms is, by far, the most important book during my time at college. If you ever pursue a career in computer science, most places will ask questions directly out of this book for interviews (examples for me: Google, Microsoft, several stock-trading companies, Dilliards, and Amazon).

http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

u/__thisismythrowaway · 3 pointsr/cscareerquestions

http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

http://online.stanford.edu/course/algorithms-design-and-analysis-part-1

http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-046j-introduction-to-algorithms-sma-5503-fall-2005/

http://www.geeksforgeeks.org

Those are 4 great resources if you're interested in closing that gap. I've heard good things about the Stanford one, maybe check that one out first. The geeksforgeeks site is decent as well if you like quick digestible articles.

u/Archibaldovich · 3 pointsr/cscareerquestions

The book my data structures and algorithms course used sucked, so I read this instead. It was helpful for me.

You can find a free pdf of it pretty easily if you search for: introduction to algorithms cormen leiserson rivest stein

edit: probably shouldn't link directly to a pdf of a textbook.

u/greyfade · 3 pointsr/learnprogramming

Keep working through your Python book. From what I've read, it seems to be a good book, and Python is worth being familiar with.

When you feel like you need a change of pace, watch Buckland's lectures. He doesn't dive into C right away, but instead talks about a very simplified low-level machine code. (It's simple enough, actually, that you could very easily implement a virtual machine for it in Python.) It'll help you build an understanding of how programs actually run, so that when you pick up a book on C, things will make more sense.

Then, when you feel confident in Python, go grab a book on C. I don't have any specific recommendations (there are a ton of good books) but it's nice to have a copy of K&R C on hand. Then you'll want a book on data structures. Maybe Introduction to Algorithms.

u/_rere · 3 pointsr/cscareerquestions

Hi there, fellow EE.

We should make a club :)

I believe you can do a crash course into software development and catch up later when it comes to be a better software developer, since you've already been in the market for 4 years I'm sure you know exactly what I'm talking about (job has nothing to do with education, and you can learn as you go), and I know its the same in CS, a lot of companies just want you to do specific thing, and they don't really care about your theoretical knowledge or your full knowledge with software development life cycle.


Since you are an EE graduate I think you can relatively easily land a c++ software development job, but the problem with c++ is that there is a lot of theoretical knowledge is expected from you.

Still I believe if you set aside 3 months of your lifetime and study the following:

Programming: Principles and Practice Using C++

Code Complete

introduction to algorithms

Optional:

Software Engineering

Java Heads first

C# in a nutshell

Note, half of these books will bore you to death, but you have to power through.
Also there will come times where you don't understand what you are reading, I find it best is just to keep going, eventually things will make sense.

I personally find books is the fastest way to learn, and give you the deepest knowledge and always access to awesome tips and tricks that you can't learn at class or from a video.

If you pick those books, you can read from them in parallel, make a habit of finishing a chapter per 24/48 hour and practice 1-2 hours of programming (of what you've learned) I'm sure by the end of the 3 months you will be better than a lot of CS graduates

u/ddoomus · 3 pointsr/gamedev

Unfortunately, there's no real fast-track.

That being said, focus on design patterns and algorithms. Understanding and putting design patterns into use is absolutely your best starting place. Knowing and learning new algorithms gets your brain thinking in the right way about any problem you're trying to solve. These two topics on their own can be really pretty dry and boring, but there's only two ways to learn them. The slow way, by trial and error, by experience (which you've been doing). And the boring way, that's slightly faster, study.
Introduction to algorithms is really good, but dry.

Head First: Design Patterns If you've never used a head first book, they're really well done IMO. Just commit yourself to a chapter a day once a week or something, force yourself through it, and you'll learn tons.

Another pro tip, re-write your existing code. When you realize you should've done something differently, fix it. Any time you find yourself copy pasting code, or thinking to yourself, damn, I should've made an abstract class, or a factory, or ... whatever it is, go through the process. In the end, it always comes down to doing. Learning this stuff only comes from doing.

u/dionyziz · 3 pointsr/cryptography

Hi,

You should already know most of the math you need to know from your math major. It helps to know number theory, group theory, and algebraic curves, depending on what you do. Important knowledge is also discrete mathematics: Discrete probability theory, Markov chains, graph theory, logic, proof methods, solving recurrences, etc. are all helpful tools.

In terms of computer science, it's imperative to know how to program. You can learn a programming language such as Python. Project Euler is a good place to start for a mathematician. Knowledge of algorithms is also important, and you must understand computability and complexity theory.

Stanford's Cryptography I is a good place to start learning cryptography. I think you can go ahead and start the course without attempting prerequisites and see where you get stuck to go and learn what is required of you.

u/pietremalvo1 · 3 pointsr/webdev

Best book: Introduction to Algorithms https://www.amazon.it/dp/0262033844/ref=cm_sw_r_cp_apa_i_PB1YCbFSV6BFK

It goes through data structures, algorithms and their cost (time, space etc..)

u/k4z · 3 pointsr/UCONN

probably is. don't have it handy.

since you're learning data structures and algorithms in python, any general data structures and algorithm course should work; just implement them in python.

it's hard to suggest [a good resource] off the top of the head, that isn't a mere udemy shill or incredibly dense like stanford's algo course. grokking algorithms was okay, while people might suggest introduction to algorithms (but there's a reason why it's 1k pages and pure madness to "refresh" your knowledge).

doing projects (crash course, automate) would help to refresh using python.

u/panicClark · 3 pointsr/ItalyInformatica

Io lavoro come sviluppatore ormai da diversi anni, anch'io non laureato (o meglio, laureato lo sarei, ma in un ambito piuttosto distante dall'informatica).

Le difficoltà maggiori all'inizio le ho incontrate quando si trattava di andare un pelino oltre al "giocare col lego" con linguaggi e framework (rigorosamente di alto livello): i fondamentali di come funzionano le reti e i protocolli, le strutture dati e gli algoritmi. Il primo ambito sto ancora cercando di approfondirlo bene, per strutture dati e algoritmi all'epoca mi consigliarono Introduction to Algorithms e devo dire che mi ci sono trovato abbastanza bene, seppure l'ho trovato noioso da seguire.

Mi è tornato relativamente più utile approfondire i linguaggi funzionali. Il classico in tal senso è Purely Functional Data Structures, ma a me è piaciuto di più Functional Programming in Scala.

u/therkleon · 3 pointsr/learnprogramming

I have Introduction to Algorithms (third edition) waiting on my shelf to be read after it was suggested to me by someone somewhere. It's supposed to be really good (and really long).

u/the_wwolf · 3 pointsr/Romania

Incepe cu asta: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

Aceasta carte este considerata un fel de biblie pentru progamatorii seriosi. Ea te invata sa gandesti corect si sa rezolvi algoritmi. Ai nevoie de asa ceva daca vrei sa fii programator de succes.

Totusi, majoritatea programatorilor nu exceleaza, si fac munca de calitate mediocra, dar castiga decent, deci se poate si fara cunostinte avansate.

  1. Alege un spatiu in care sa excelezi: Server sau Client (sunt si altele, dar astea-s cele mai populare)
  2. Fa o lista de proiecte care suna interesant si is cat de cat challenging
  3. Implementeaza-le
  4. Invata in fiecare zi
  5. Citeste blog-uri tehnice si proiecte celebre pe GitHub:
    1. Cum a ajuns instagram sa poata sustine milioane de useri
    2. Care este arhitectura Netflix ? Care sunt proiectele open source ale Netflix si ce fac
    3. Cum garanteaza Twitter generarea de ID-uri unice la scara mare ?
    4. etc

      Dupa 15 ani de programare si arhitectura software pot sa-ti spun ca nu ma opresc de invatat niciodata - invat zilnic ceva nou. Daca faci o pauza, pierzi trenul si trebuie sa recuperezi.

      Toate au un inceput. Poti sa incepi prin a cauta pe youtube channel-uri cu tutoriale de programare in limbaje care te intereseaza. Eu iti recomand Java(Server) si Swift(Mobile). Singurul mod prin care poti sa cresti repede: pune mana si implementeaza aplicatii. Fa tutoriale.

      Cel mai important: Fa ceea ce-ti place. Daca o faci doar pentru bani, ai sanse mari de esec.
u/drchlt · 3 pointsr/vzla

El de Cormen es uno de los que más se usan a nivel de postgrado.

Por mucho es lo más completo qué hay.

Edit: aquí está https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

u/desustorm · 3 pointsr/learnpython

CLRS is the classic for learning about different algorithms and concepts (e.g. sorting, graphs, data structures, etc. etc.). I didn't really like books when I was learning, but hacking my way through the K&R C book wasn't too painful

At university we learnt C, Java (and he marked us down if we used an IDE...), and then we had freedom to pick up whatever. So I would say having a look at C or C++ couldn't hurt and will definitely teach you fundamentals better than Python. But bear in mind there are some concepts in lower-level languages that you can (for the most part) ignore in Python, e.g. Garbage Collection, memory allocation, pointers.

u/Monfardini · 3 pointsr/brasil

URI é muito bom mesmo, OP. Tem uma porrada de exercícios, e como o amigo disse acima, a complexidade dos algoritmos aumentam só um pouco de problema pra problema, mas no final você já vai estar aplicando algoritmos bem avançados.
Pra aprender especificamente sobre algoritmos, recomendo o livro do Cormen, Introduction to algorithms!.

u/falafel_eater · 3 pointsr/AskComputerScience

Computer Science is a pretty big field, so "strong foundation" can mean different things to different people.
You will definitely want the following:

  1. Introduction to Algorithms and Data Structures
  2. Introduction to Computability
  3. Introduction to Operating Systems

    For algorithms and data structures, a very commonly used textbook is Cormen.
    For computability, Sipser.

    Operating Systems I don't remember off the top of my head.
    That said, you are probably much better off finding a high-quality university course that is based on these textbooks instead of trying to read them cover-to-cover yourself. Check out lecture series from places like MIT on youtube or whatever.

    After that, you can take an Intro to Artificial Intelligence, or Intro to Communication Networks, or any other intro-level course to a more specific sub-area. But if you lack basis in computability to the point where you don't know what an NP-Complete problem is, or have no idea what a Binary Search Tree is, or do not know what an Approximation Algorithm is, then it would be hard to say you have a strong foundation in CS.
u/CodeTamarin · 3 pointsr/computerscience

I think you're overstating it a bit. I think it really depends on what you do. I know a handful of grads who have learned from these books and they never use what they learned inside.

So, I'm mixed. Especially considering that Software Development is not the same as Computer Science.

Software Development is focused on bringing a product to production. These books while awesome (I own this one) don't prepare people for Software Development as a discipline. But, depending on your local market and what you want to do... I'm not convinced those books are as valuable as you say they are.

If you want to work for the Big 5, sure. But, there are more than 5 companies hiring people for development and there are more than the big 5 paying well for development and often, the use cases you're solving lean closer to the list I provided, rather than what algorithm books are.

I'm not saying there's no value. But I would wager if someone ONLY used an algorithm book to break into software, they would learn a lot of hard lessons. Because software is more than algorithms.

u/lavidaesbella · 3 pointsr/learnprogramming

Learn about C for OS programming: process control (fork() and friends) threading, networking, file management, API programming, etc.

I'm supposing you know about algorithms and data structures, like linked lists, trees, etc. If not that's right the way you need: Cormen

Pick any open source project you like and get involved. Do testing, read about bug reports, etc.

u/bo1024 · 3 pointsr/learnprogramming

A textbook might be a good idea. Like Introduction to Algorithms.

u/scriptsvcs · 3 pointsr/compsci

> Thanks for your time, my god this was longer than expected.

I suppose in the age of twitter that was a bit of a novel. For us old fogies, that's just a bit more than a post card :)

Introduction to Algorithms is the book for learning everything about algorithms. You'll learn all the standards; how to analyze them (space/time efficiency, Big-O, Big-Theta); and how to prove them; etc.

If you want to learn a great low-level language, the typical things to learn are assembly and C, but I would highly suggest learning Forth. There's tons on the web about it, but the seminal book was Starting Forth. You get all of the low-level detail of assembly, a bit of scaffolding, and you learn to build your higher level language structures as you need them. Great fun, and it's turned out to be very useful through the years, even though I never get to use it in production/release.

u/Dylnuge · 3 pointsr/AskComputerScience

Might be biased, but I'm a big fan of Jeff Erickson's Algorithm Notes, which I think are better than a lot of textbooks.

If you really want a book, CLR Algorithms and The Art of Computer Programming both get recommended a lot, with good reason.

If you're interested in computational theory, the New Turing Omnibus and Spiser's Theory of Computation are two good choices.

Finally, I'd check out Hacker's Delight. It's a lot more on the electrical/computer engineering side of things, which might interest you, and it's very detailed while still being quite excellent.

u/Neres28 · 3 pointsr/learnprogramming

Sounds like what you've done is real/serious programming, just on a smaller scale.

I wouldn't worry too much about not knowing various frameworks. We use Spring to inject dependencies into our client code, we use Glassfish as our application server, and we use JPA backed by EclipseLink as the glue to our data layer. However, when it comes down to it it's mostly about writing plain old Java objects.

For the rest:

  • I've heard that the Head First design patterns book is very good, but haven't read it myself. I've always gone to the GOF, but I do find it dry and hard to understand at times.

  • For algorithms I used Cormen et al in college and still refer back to it. But I don't really suggest it outside of a classroom.

    Rather than further enumerate my reading list, I'll point you to the Programming FAQ; an excellent resource for exactly the questions you're asking.
u/xibernetik · 3 pointsr/AskEngineers

Introduction to Algorithms, also fondly known as CLRS, is pretty much the gold standard when it comes to an overview of algos.

edit: Amazon link if you're into that sort of thing.

u/Wolfspaw · 3 pointsr/learnprogramming

There are some good books to help you in your quest, they discusses all programming techniques needed in competitions: greedy algorithms, dynamic programming, data structures... A lot of overlap
between them :

Competitive Programming 2 : Great book, a lot of
information packed

Art of Programming Contest : FREE book available from ACM site

Programming Challenges : From a famous
competition Professor (Skiena)

The Hitchker Guide to Programming Contests : Another FREE book,
Great Ideas

The Algorithm Design Manual : Another book from
skiena, talks about the practical applications of famous techniques and
algorithms used in competitions

Introduction to algorithms : THE book about
algorithms... In-depth explanations

Google code Jam contest analysis : Google Code Jam is a great
competition, with a lot of hard problems. And all of them have a
solution and analysis !

u/PennyPriddy · 3 pointsr/personalfinance

As someone in tech, I would say that the big things the coding camps don't cover is algorithms and data structures. A lot of the bigger company's tech interviews expect some degree of knowledge in those topics, so it'd be worth it to brush up on those on your own. There's a lot you can learn online, but this book is also incredibly good. I'm not sure if applies to machine learning, but the other book I wouldn't have wanted to be without when I was interviewing was "Cracking the Coding interview" and going from there to interviews on career cup.

The reason LaCita got downvoted is that it's not "guaranteed" you'll be making 100k+ in 1-2 years (I got very lucky and am making it after 3 years and a traditional four year education). There are still a lot of good and rewarding jobs in tech (and I'm glad you found a field in it you love), but there's sometimes an attitude that it's a high paying job anyone can get and anyone can do and you're guaranteed the kind of pay that is usually found at top companies and that's not always true.

Also, 100k+ is only great if you're not living in a high tech area that raised rents accordingly. I've had too much depressing fun playing "how much is my rent" since moving to Silicon Valley. No one ever guesses high enough.

u/the_omega99 · 3 pointsr/learnprogramming

I don't really think this is the place for looking for one on one tutors. There's several kinds of websites that focus on that (and likely some other subreddits, too).

For self learning, you may want to consider looking at Introduction to Algorithms, which is probably the best known algorithms and data structures book.

You could also check out this static course from Berkeley. It uses Java, though. The basics to algorithms are mostly language independent, but since examples are important, you'd still want to use Java there. For comparison, Introduction to Algorithms uses language-agnostic (but generally high level) pseudocode.

It is assumed for both that you're familiar with the basics of the language.

u/CandyCorns_ · 3 pointsr/compsci

I knew a colleague that did this exact thing. She was a PhD student with a Mechanical Engineering undegrad, and it worked out just fine for her.

Honestly, with your (assumed) mathematical background, just buy this book, read and understand all of the fundamentals, the data structures, the sorting algorithms, and maybe touch on some of the advanced topics, and you'll be ready.

u/chibrosov · 3 pointsr/askscience

Charles Leiserson, a computer scientist, professor at MIT, and co-author of one of the best algorithms textbooks out there, used to make a fantastic analogy at the beginning of his intro to algorithms course. He would liken computational performance to the currency of the programming world. Want simpler, higher-level code? That'll cost some performance. Want more reliable, fault-tolerant code? Gotta pay out some performance. Want more secure, intrusion-resistant software? That's gonna come out of your performance budget. I really loved that analogy, and the only difference between now and then is that our starting balance is orders of magnitude higher. When you're pulling in $100 a week, you really gotta think about whether you actually need that $10 fancy burrito. When you're pulling $100,000,000 a week, it's not such a difficult decision.

Edit: wrong link

u/balefrost · 3 pointsr/AskProgramming
u/aedalus · 2 pointsr/learnprogramming

This book is what my University uses in their algorithm course:

Introduction to Algorithms, 3rd Edition

It covers a lot of material, and is a pretty good place to start IMO.

u/superAL1394 · 2 pointsr/AskComputerScience

Introduction to Algorithms, also commonly called CLRS (the authors) is the go to for most. Assuming you have knowledge of basic structures this will bring you through the more complicated heaps, trees, hash tables, etc. And their associated algorithms.

I have found in college most textbooks are useless. I had to buy this book 2 years ago and I still reference it regularly.

http://www.amazon.com/gp/aw/d/0262033844?pc_redir=1396075349&robot_redir=1

Also, wikipedia is your friend: http://en.m.wikipedia.org/wiki/List_of_data_structures

u/Alexius-CA · 2 pointsr/cscareerquestions

Sorry. It's a common abbreviation used (of the four authors' last names) for the "Introduction to Algorithms" text. Here:

http://www.amazon.ca/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

u/BabyThatsMyJam2 · 2 pointsr/cscareerquestions

My old textbook, somehow still have it.

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

Random youtube too for things like Rabin Karp Substring Search.

u/logic_programmer · 2 pointsr/learnprogramming
u/rafuzo2 · 2 pointsr/androiddev

Most of the comments here make me realize I should pull the CLR book down off the shelf and do some homework again.

u/obsoletelearner · 2 pointsr/learnprogramming

I'd recommend doing mathematics, It's much important than learning a language. It helps you grab the logic of solving a problem.


Discrete Mathematics by Rosen is the best book from my experience.



Graph Theory by Bollobas is recommended by many but i prefer Graph Theory by Douglas West




Algorithms by Cormen. No introductions needed this book encompasses most of the problems you'll encounter.



However if you're keen on learning a C/C++/Java i'd recommend the Head First Series from O'Reily .




Goodluck!

u/egonSchiele · 2 pointsr/programming
u/oemta · 2 pointsr/compsci

Third edition is out. And it is not so badly priced.

u/penguinland · 2 pointsr/cscareerquestions

CLRS is the standard textbook, and it covers everything /u/Orca- mentioned. I agree with everything he/she listed, but would also add heaps (a.k.a., priority queues) to that list.

u/all_reddits_are_mine · 2 pointsr/college

I'm not sure if you're allowed to purchase these, but the international versions of textbooks are much cheaper than the ones in your campus bookstore.

For example, Introduction to Algorithms is around $45 on Amazon. That's around Rs. 2800. I bought it 3 months ago for Rs. 450. Do you know how much that is? NINE FUCKING DOLLARS.

Again, I'm not sure whether you're allowed to buy international versions, so take this with a grain of salt.

I'll see if I can take a pic of the book.

u/jClark94 · 2 pointsr/Random_Acts_Of_Amazon

I'm studying Computer Science myself, and want to weigh in with:

http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1376563745&sr=8-1&keywords=introduction+to+algorithms

It's not cheap but definitely worth it, and will be useful for years to come. I got my copy after a fourth year recommended it to me (he'd had his out from the library for the entirety of his degree). I've already got the bundle, but thought you might want to see this.

u/koderpat · 2 pointsr/learnprogramming
u/chaotic_thought · 2 pointsr/learnprogramming

Try Open Data Structures and CLRS.

Edit: second URL fixed.

u/rapidient · 2 pointsr/programming

I still consult my copy of CLR from college, though it has been updated since then and is probably now referred to as CLRS: http://www.amazon.com/Introduction-Algorithms-Third-Thomas-Cormen/dp/0262033844/ref=sr_1_3?ie=UTF8&s=books&qid=1261415293&sr=8-3

u/Phenom10x · 2 pointsr/learnpython

So more about data structures and algorithms ey? Well the main book pretty much every college uses is this one:


Introduction to Algorithms Third Edition by Cormen, Leiseron, Rivest, Stein

This book is basically an encyclopedia of algorithms and data structures.

Desktop applications are just programs. You can make python into an executable using: http://www.py2exe.org/index.cgi/Tutorial

If you mean how operating systems work there are books out there that explain that. But I don't think that's what you mean't haha.

Hope this helps.

u/dipittydoop · 2 pointsr/learnprogramming

I started that same coursera course, but found just reading and working my way through Introduction To Algorithms more my style of learning. I like taking things as fast or slow as I want, so books are my preferred method. That being said it'd be nice to have an experienced engineer to pester about extraneous questions. I'm basically meandering my way around the resources recommended by https://teachyourselfcs.com/.

It might be a good idea to build a couple applications at this point. I like to pick a language, framework, etc. and follow a tutorial to a todo/<breakable_toy> type app, then figure out how to make my own modifications.

u/heres_some_advice23 · 2 pointsr/computerscience

Mechanical Keyboards: High quality keyboards with tactile feedback. They have a real impact on your typing speed, and also make programming less boring. They are very commonly used by programmers. Mechanical keyboards have different "switches" that make different tactile sounds. "Blue Switches" are considered the most popular. Here are some examples: https://www.amazon.com/s/ref=nb_sb_noss?url=search-alias%3Daps&field-keywords=mechanical+keyboard.

Gaming Mouse: Same usage as keyboards, but not as useful. Its mostly just nice to have.

Textbooks: In computer science, there are one or two textbooks per subfield that are considered to be "Bibles" of the subfield because of their importance. If your bf just started cs, he won't have any interests in any subfield. However, the subfield of algorithms is more or less all encompassing. More crucially, knowledge of algorithms is the most important (and arguably only) thing you need to know to get a job. If you want to work at a top CS company like Facebook or Google, you need to know your algorithms very well in order to pass the interviews. There are two books I can recommend for this:
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1503472210&sr=8-1&keywords=algorithms
and
https://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693/ref=sr_1_5?ie=UTF8&qid=1503472210&sr=8-5&keywords=algorithms
These are the most prolific algorithms books (imo). Another important book is "Cracking the Coding Interview": https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/0984782850/ref=sr_1_1?s=books&ie=UTF8&qid=1503471832&sr=1-1&keywords=how+to+crack+the+coding+interview

This is the "Bible" textbook for passing tech interviews. Every computer science student I know at school has at least skimmed through this book once.

Personally, if I were starting in CS, I would appreciate either the mechanical keyboard or the "Cracking the Coding Interview" textbook the most. Good luck!

u/TheFakeNoob · 2 pointsr/cscareerquestions

If you plan on self teaching I find these materials to be quite sufficient:

Data Structures and Algorithm Analysis This book also has a C++ version and can be found online for free(legally, from the author). I prefer reading a real book over PDFs so I opt to buy it but your opinion may differ.

The Algorithm Design Manual. This is pretty much the 'go to' book for self learning DS/Algo since it covers a lot of material but does not go that deep into the details beyond a working knowledge.

Introduction to Algorithms. This is the standard text on Algorithms and is used in most undergrad/graduate level courses on the subject. It is very detailed and goes deep into the theory and mathematical proofs of algorithms. It's a much more academic text but still worth mentioning and being aware of.


Edit:
Out of the 3 I think the first is the easiest to read but the second is the best in covering relevant material quickly and sufficiently enough. The last one is only for those who want mastery of the topic or intend to use it for a course.

u/fancysuit · 2 pointsr/learnprogramming

My usual interview prep is: read Introduction to Algorithms

Congrats on the phone screening.

u/Yithar · 2 pointsr/UMD

https://www.reddit.com/r/UMD/comments/5jl020/how_to_prepare_for_cmsc330_and_cmsc351/

---

Key thing to understanding OCaml and functional programming is Lambda Calculus, which I'm pretty sure you will cover in 330.

As for 351, it's really hard to say what to do to prepare as it's less concrete, as what helped me the most was discussing the concepts and going over the homework with my tutor (so find a study group if you can). All I can do is give you some playlists. Also I used "Intoduction to Algorithms - A Creative Approach, by Udi Manber" when I took 351. I mean, I think CLRS is a great book, but I think it's a bit overkill for 351. I mainly used it in 451. I mean, stuff like maximum bipartite matching and maximum cut is in there, but you won't encounter those in 351, only in 451.

https://www.youtube.com/playlist?list=PLEbnTDJUr_IeHYw_sfBOJ6gk5pie0yP-0
https://www.youtube.com/playlist?list=PLUX6FBiUa2g4YWs6HkkCpXL6ru02i7y3Q
https://www.youtube.com/user/Coderisland/videos
https://www.youtube.com/playlist?list=PLTZbNwgO5eboxncIsmq95u_4nCtyziLKX
https://www.youtube.com/watch?v=eHZifpgyH_4

u/gunslinger_006 · 2 pointsr/cscareerquestions

Algorithms.

Algorithms is an important class, but depending on how its taught, it may or may not prepare you for the challenge of actually developing an algorithm to solve a problem.

Its important to be familiar with certain algorithmic concepts. Each concept (CLRS is a great book for this but it can be...difficult to digest) is a type of solution for a certain type of problem.

Once you have some core tools in your algorithm tool box, then you can start to see how certain problems resemble certain other problems and how a solution can be crafted as a modification of a similar solution.

But to me, the real skill with algorithms isn't whether or not you can memorize a ton of algorithms, its taking a very systematic approach to developing the algorithm, and there are lots of books and classes that aren't very good at helping you learn that part. I find that sections of Programming Pearls and Programming Interviews Exposed are actually very good at helping explain the process of finding the solution.

Having a good process of algorithm building is much more important, imvho, than being able to memorize every algorithm in CLRS. That takes some study, but a lot of practice.

Data Structures:

Anytime you are writing a piece of code, you are probably doing a set of steps that looks like this:

  1. Problem definition
  2. Algorithm design
  3. Data Structure choice.
  4. Implementation.
  5. Testing.

    Data structure choice is on that list, separate from implementation for a reason. IMVHO, smart data structure selection is what HELPS you arrive at an elegant implementation...a poor choice can yield similarly poor results in implementation.

    Data structures are important. Learning how to make them from scratch (lists, trees, stacks, etc...) is a good way to build your skills in a language, and its frequently the meat of programming interviews in some languages...but in the real world, you will very likely spend most of your time just focusing on selection and then using an implementation from an already well established/tested library.

    Knowing when to use a queue vs stack, when to use a list/array versus a hash, knowing what kind of tree will perform better under the specific conditions of your program (avl, red/black, splay, etc...)...these are things that when chosen well, will save you a massive amount of headache in the implementation and testing phases of development. Learning how to traverse those data structures is important too, for example: Recursion is taught to every cs graduate when they learn trees but then in production code it can be frowned upon for various reasons such as what happens when someone who isn't great with recursion has to maintain/debug it, or when it would put too heavy a load onto the call stack.

    Also, what /u/bvcxy said is spot on, its one thing to know the theory, but there is that whole other side of understanding source control, how a makefile works, learning how to use continuous integration tools like jenkins.

    And we haven't even gotten into debugging, that is its own skill and you will eventually also need to understand how to debug with breakpoints, inspect memory, check your code for leaks, etc...

    The nice thing is that so many IDE's out there are integrated with source control and memory inspection tools, so you can pick a good IDE and dive deep into understanding how to get the most out of it. Write a program in C/C++ and then deliberately put a heap memory leak into it, and learn how you can catch this with tools but also how you can inspect the memory at runtime with breakpoints to see what happens.
u/Nihili · 2 pointsr/compsci

I'd recommend

u/cjt09 · 2 pointsr/UVA

I'm working for a largish and fairly well known Silicon Valley software company making video games. As far as interviewing goes, I can only speak for software companies, but here are some tips:

  • Phone screens are often the toughest part of the interview, since they often involve taking a well-known algorithmic problem, disguising it, and then having you write some code to solve it in 15 minutes or so. They are deliberately tough to pass. The reason they do this is because false positives are much more damaging than false negatives. The best way to prepare is to simply know a lot of these problems or have an insanely well-developed problem-solving ability.
  • Definitely work on your own projects in your free time, this is almost expected at top firms. It really helps to have something to show off at your interview.
  • Also, at top firms especially, on-site interviews typically last for six hours or more. Get your rest and your coffee.
  • Know the standard "brain-teaser" problems. I found that normally these would come once the interviewer ran out of normal questions to ask. They're really easy to prepare for, so it's worth taking the time out to memorize a couple.
  • Ask a lot of questions! Ask about a typical day, how many meetings there are, what kind of software and languages they use, the best/worst part of the job, etc.
u/yash3ahuja · 2 pointsr/learnprogramming

Honestly, if you don't mind dropping a bit of cash, get the CLRS book (or check your local library for it).

It will teach you pretty much everything you want to know about algorithms, including a lot of common algorithms and how to analyze algorithm time complexity.

u/karmahawk · 2 pointsr/cscareerquestions

So I am more of a book guy these days. I found Algorithms + Data Structures = Programs by Niklaus Wirth to be pretty solid. For something a bit more contemporary Introduction to Algorithms by Cormen, Leiserson, Rivest and Stein is a very good textbook. If you're into math and learn best from repetition I'd suggest The Art of Programming Vol 1 by Knuth as well.

The issue I have with a lot of online content is the economics of the Internet are such that its not profitable to go in-depth, so its definitely worth paring online courses(whether they're from an accredited university or not) with a textbook or two. You might even want to crawl down the rabbit hole further and dig into the camps of mathematics where these concepts derive like Queue Theory or Set Theory. If your the type of person who gets the most out of things by tracing concepts to their roots digging into the maths helps a ton.

u/massivewurstel · 2 pointsr/Python

Mine would be to learn some C for a better understanding of Python internals. Also, go through this book.

u/ziptofaf · 2 pointsr/learnprogramming

MIT has a huuuuuge course on those, it's often recommended too. There's also a book.

Honestly might not be a bad idea to look at Stanford/MIT courses in general.

OOP is something you learn basics of with your programming manual but it won't be until you start working on real projects for it to 'click'. It's simply really useful in programs that start to get big, for smaller stuff it's just extra bloat or at least it feels like it for beginners and not without a good reason, change of paradighm is always difficult.

u/nosoulfood · 2 pointsr/cscareerquestions
u/ryanplant-au · 2 pointsr/learnprogramming
u/dallaylaen · 2 pointsr/javascript

This may sound old fashioned, but maybe this classical book "Introduction to Algorithms" by Cormen et al is the way to go.

I myself learned by another book, "Algorithms and Programming: Problems and Solutions" by Alexander Shen, which was way thinner. Just read it through and solved like 50% of the exercises in C, Java, or Perl.

u/rjcarr · 2 pointsr/learnprogramming

Doesn't the course offer a book? The professor might suck, but what about the textbook?

Otherwise, I think these two are the most commonly recommended algorithm books:

https://www.amazon.com/dp/032157351X

https://www.amazon.com/dp/0262033844



u/rdit_cpp · 2 pointsr/cpp

Intro to Algorithms : Cormen

While the title is Introduction to Algorithms, this book covers data structures as well.

However, this book isn't explicitly targeted at C++ (I used it for C++ just fine).

The material is probably going to be difficult if this is the first time you've seen some of this. Don't let that turn you off.

u/hankovitch · 2 pointsr/cpp

I started from zero with "Programming: Principles and Practice in C++" "The C++ Programming Language". It's a nice book, when you are new to programming. (I wouldn't count Matlab.) It does not only teach C++, but many other more general programming concepts. My second book was "C++ Primer", which is fantastic if you are already a programmer or know C++ a bit. However they go quite fast trough many complex concepts.

When it comes to algorithms and data structures I'd recommend one of the classic textbooks like CLRS. Another nice book I found was this manual to competitive programming, which contains many implementations in C++.

You will properly understand C++ or algorithms and datastructures by reading though. You need to implement stuff. For this you can take a MOOC like Coursera's introduction to algorithms or consider pages like hackerrank which ask you to implement little things and provide test cases.

https://cses.fi/book.html

u/fff1891 · 2 pointsr/computerscience

Some schools don't cover much in the way of discrete math, formal languages, automata, or proofs... at least not very rigorously. My opinion here is colored by my own experience (and subsequent disappointment, but thats another story), and I'm sure most schools sort of exist on a spectrum. YMMV.

Some books that come to mind (might not be to surprising if you spend a lot of time on CS forums):

[Introduction to the Theory of Computation](
https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser-ebook/dp/B00B63LSA6)

CLRS Introduction to Algorithms

SICP

I think it's interesting to look at the history of computer science-- read about Bertrand Russel, David Hilbert, the Vienna Circle, Alonzo Church and his students (Alan Turing was one). Computer Science as an academic discipline was kind of born from the questions mathematicians and philosophers were trying to ask in the early 20th century. It's just as much about language as it is about mathematics. I could probably write a wall of text on the topic, but I'll just leave it at that. :)

u/e_vampire · 2 pointsr/compsci

Either Introduction to Algorithms

or Algorithm Design

Those books were the textbooks for the algorithm and data structures courses, respectively during my bachelor and master's degree in computer science, I find both of them really well written.

u/forzrin · 2 pointsr/technology

It was a few years ago, but lots of entire series of lectures are online. I got through most of the "core" CS concepts in ~2 years of doing intense academic learning alongside actually writing code (and releasing some stuff to small groups or to app stores). Picking straightforward, small projects with a specific academic challenge like a game with a simple concept but needs pathfinding algorithms (and implementing them myself instead of using a framework)

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. Personal accountability is the driver, here.

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.

u/Mekire · 2 pointsr/ProgrammerHumor

> Are we talking about the book by Sedgwick?

CLRS
I tend to agree that the 1 based indexing is annoying but the book is ridiculously comprehensive and anyone in CS would be a fool not to have a copy.

u/IRLeif · 2 pointsr/learnprogramming

Thanks! Just to make sure, do you mean these two books?

  • Introduction to Algorithms
  • Algorithms

    If so, I'm glad you mentioned those. Both of them are already on my to-read list, but they were further down than Knuth's work. Since, as you say, they might better for starters, I'll check those out first.

    By the way, I have also heard some good things about this one:

  • The Algorithm Design Manual

    Have you any experience with that book? It's also on my to-read list.
u/sachal10 · 2 pointsr/learnmath

since you are a computer science student, you can start with proofs in Discrete Mathematics fo this you can look at Kenneth Rosen's book, it can help you with a lot of basic concepts, constructing proofs. Its a good book for those who want to go in algorithms or theoretical cs or a even want to work on pure maths problems. I had this same confusion I wanted to do maths but also cs with it. After this you can try "The art of computer programming"(this has 4 volumes) by Donald Knuth but CLRS is a must along with Rosen's if you want to take cs and maths side by side. If you want to explore further you can look at Design of Approximation Algorithms and Randomised Algorithms. These book can help you with concepts of probability, number theory, geometry, linear algebra etc. But then if you want pure math problems then search for them, go though different journals, SIAM and Combinatorica are really good ones, search them pick a problem you like, then find text relevant to problem and try to give better solutions.

u/Ikor_Genorio · 2 pointsr/computerscience

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

This book. It is one of the most famous books on Algorithms and Datastructures. Has good exercises, but I am not sure about the solutions, though I am sure you can find solutions for them on the internet.

u/Xxyr · 2 pointsr/AskComputerScience

So, you won't see a constant co-efficient in BigO notation because it is asymtotic. The only times you generally see constants if when n is exponential time ie O(n^2) or geometric time ie O(2^n).

Lets start with a simple example, where you loop through an array and do something with every entry. This has a runtime of O(n). It doesn't matter if you do one statement, two statements or twenty statements its still O(n). For small values of n a large constant factory has a noticeable impact, but as n approaches infinity the constant (1/2/20) has very little impact on the overall runtime.

What about O(log n) ? Well lets say you had a sorted array and were doing a binary search in that array to find a value. Each iteration of the algorithm discards half the dataset, so the number of operations is log_base2 (n) where n is the dataset size.

What about O(n * n) ? Well that would be an example where we have an array and for each element in that array we have to compare it to every other element in the array. Since for each of the n times we go through the array we have to go through through the whole array again, with a cost of n. (This is an example of the naive sorting approach of finding the smallest and putting it in the first slot, then the next smallest, and so on).

What about O (n log n) ? That is the standard cost for an efficient sort ie quicksort/mergesort. Where you have to do processing for every element (to get it in the right spot) but the number of operations for each element is approximately log n.

The main takeaway here is that the only thing that impacts the BigO of an algorithm is the way it grows with respect to the input size. So since it says "it runs an O(log n) operation twice for each element of the array" you can break this down into

--> Run an O(log n) operation twice for each element of the array
--> Run an O(log n) operation O (n) times
--> O (n log n).

Sidenote: I highly recommend this book if you want a really good understanding of basic algorithms / theory. http://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1458334047&sr=8-1&keywords=algorithms

u/Heartomics · 2 pointsr/learnmachinelearning

You can check out sites like HackerRank. It has problems from the book,

CrackingTheCodingInterview

I like and recommend this book as well,

Introduction to Algorithms

u/solyanik · 2 pointsr/compsci

Why not change the school?

If this is not an option, you have to study yourself. Here are the books:
http://www.amazon.com/dp/0262033844
http://www.amazon.com/dp/0123704901

u/Cadoc7 · 2 pointsr/learnprogramming
  1. Any discrete math or algorithms text book will have that in there. If you are going to buy one, get Introduction to Algorithms. The chapter on asymptotic runtime analysis is fantastic.

  2. It depends on the job. If you are writing the backend server architecture for Google or Amazon? You better believe Big-O is extremely important. If you are writing some sort of basic application, such as a word processor, then no.

    A good role of thumb, is to ask yourself, "If this product becomes widely successful, will the amount of data going to huge or going to change drastically?". If the answer is yes, then you need to look at the asymptotic runtime.

    Think about MS Word, it is widely successful, but the amount of data is processes is the same no matter how successful it is, and it doesn't process that much. Big-O does not matter that much.

    Now think about Facebook. As more users join, the more data will be going through the system. Your system needs to be able to scale to that, now Big-O is important.

    As for becoming an expert, don't worry about it. A competent programmer should be able to look at an algorithm and give you a ballpark asymptotic runtime, and there is no need to rigorously prove that in industry, and stress tests will be much more important for determining actual runtime.
u/jhartwell · 2 pointsr/AskComputerScience

When I took an algorithms class for my MS we used Introduction To Algorithms and I found the book to be helpful. That said, it isn't cheap, right now $47 is the cheapest used option on Amazon.

u/noah_guy · 2 pointsr/computerscience

For algorithms and runtime I would recommend the CLRS textbook

u/mbrezu · 2 pointsr/csharp

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).

u/slaystation25 · 2 pointsr/learnprogramming

I'm currently doing Intoduction to Algorithms, on OCW, and using this textbook. It's really fun and delving so far. I'm done with 6 lectures and 3 assignments.

u/ProtossIsBroken · 2 pointsr/cscareerquestions

Introduction to Algorithms

Structure and Interpretation of Computer Programs

I linked to Amazon but obviously these can be easily found as .pdfs.

u/deltageek · 2 pointsr/learnprogramming

This is my definitive data structures and algorithms book

http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

[Edit: replaced link with non-gimped version]

u/melancholiclabs · 2 pointsr/Drugs

Read a lot of books. Everything is usually available as a pdf on the internet and the ones that aren't are $10 to rent on Amazon. Here's the ones that I've read that relate to this project.

Java

u/IjonTichy85 · 2 pointsr/compsci

Hi,
do you want to become a computer scientist or a programmer? That's the question you have to ask yourself. Just recently someone asked about some self-study courses in cs and I compiled a list of courses that focuses on the theoretical basics (roughly the first year of a bachelor class). Maybe it's helpful to you so I'm gonna copy&paste it here for you:



I think before you start you should ask yourself what you want to learn. If you're into programming or want to become a sysadmin you can learn everything you need without taking classes.

If you're interested in the theory of cs, here are a few starting points:

Introduction to Automata Theory, Languages, and Computation

The book you should buy

MIT: Introduction to Algorithms

The book you should buy


Computer Architecture<- The intro alone makes it worth watching!

The book you should buy

Linear Algebra

The book you should buy <-Only scratches on the surface but is a good starting point. Also it's extremely informal for a math book. The MIT-channel offers many more courses and are a great for autodidactic studying.

Everything I've posted requires no or only minimal previous education.
You should think of this as a starting point. Maybe you'll find lessons or books you'll prefer. That's fine! Make your own choices. If you've understood everything in these lessons, you just need to take a programming class (or just learn it by doing), a class on formal logic and some more advanced math classes and you will have developed a good understanding of the basics of cs. The materials I've posted roughly cover the first year of studying cs. I wish I could tell you were you can find some more math/logic books but I'm german and always used german books for math because they usually follow a more formal approach (which isn't necessarily a good thing).
I really recommend learning these thing BEFORE starting to learn the 'useful' parts of CS like sql,xml, design pattern etc.
Another great book that will broaden your understanding is this Bertrand Russell: Introduction to mathematical philosophy
If you've understood the theory, the rest will seam 'logical' and you'll know why some things are the way they are. Your working environment will keep changing and 20 years from now, we will be using different tools and different languages, but the theory won't change. If you've once made the effort to understand the basics, it will be a lot easier for you to switch to the next 'big thing' once you're required to do so.

One more thing: PLEASE, don't become one of those people who need to tell everyone how useless a university is and that they know everything they need just because they've been working with python for a year or two. Of course you won't need 95% of the basics unless you're planning on staying in academia and if you've worked instead of studying, you will have a head start, but if someone is proud of NOT having learned something, that always makes me want to leave this planet, you know...

EDIT: almost forgot about this: use Unix, use Unix, and I can't emphasize this enough: USE UNIX! Building your own linux from scratch is something every computerscientist should have done at least once in his life. It's the only way to really learn how a modern operating system works. Also try to avoid apple/microsoft products, since they're usually closed source and don't give you the chance to learn how they work.

u/derpage · 2 pointsr/programming

>Start at the bottom. Some books I liked...
>
>Learn what a computer does: Computer Organization & design - Patterson & Hennessy
>
>Learn C: Programming in C - Stephen Kochan
>
>VERY IMPORTANT learn your data structures: Introduction to Algorithms
>
>You will have learn Java in university, I found this book good: Absolute Java 4th ed.
>
>This is just scratching the surface, a lot more to learn afterword.

Don't worry, FTFH

u/rabidstoat · 2 pointsr/cscareerquestions

Computer science is not programming. So figure out if you want to learn computer science, or programming, or both.

Here's an older, but free, textbook on some of the computer science fundamentals -- I'm not thrilled with the breadth of the text, but they use it where I go to school.

This is my favorite 'programming' book

u/lemniscactus · 2 pointsr/learnprogramming

I'm a beginner in programming but advanced in math. I found the algorithms in the latter half of this guy pretty awesome, in particular the number theoretic ones, fast fourier transforms, and graph algorithms. If you're crafty you can find an online (bootleg) version, which is what I did at first, and ended up liking it so much I bought it.

u/vindvaki · 2 pointsr/learnprogramming

Some more examples for string formatting:

print("My integer: %d" % 10)
print("My float: %f" % 0.5)
print("My string: %s" % "Indeed")
print("Anything: {0} {1}".format("Really", 7)

Just to make sure you know that str(num) is not needed.

And I like Project Euler a lot. In fact, that is how I got into mathematics and programming. However, as Project Euler is very mathematically oriented, you may miss out on many topics in Computer Science. For those, I recommend something like Introduction to Algorithms

u/quad64bit · 2 pointsr/learnprogramming

If you're working with a list that is larger than memory (billions of entries) and it is unordered, then this is quite a task. You can sort elements with something like a merge sort...

However, if you are working with in-memory lists, the best performance you can hope for is to sort the list initially, and then perform the binary search you described.

Bubsyouruncle described a binary search tree. This is a nifty data structure because simply inserting elements into the tree partially orders them. You can then efficiently look up elements without having to presort all the time. It allows for tolerable insertions with excellent lookup times.

If you are using a language like Java, these data structures have all been written for you; you can simply make use of them. If you would like to implement this kind of thing from scratch as a learning exercise, take a look at the wiki for starters.

An excellent (albeit advanced) data structures book can be found here:
Intro to Algorithms

The book contains a bunch of data structures and all the core algorithms you use for just about everything - trees, maps, traversals, in-place structures, etc...

u/Ranalysis · 2 pointsr/cscareerquestions

Learn about:

u/linuxjava · 2 pointsr/compsci
u/doom-o-matic · 2 pointsr/cscareerquestions

Yes, go to your local library and find the Cormen book (by the way, don't buy textbooks, borrow them!).

http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

This is the bible of computing. Don't worry if stuff's hard to understand at first, even I go back to the book every now and then (15 years later). Try to grasp the concepts presented, and most importantly, try to implement them yourself.... and soon (~within a few months) there'll be a breaking point where suddenly everything makes sense.

Ninja edit: yes, I know there are plenty of libraries that implement everything that is in this book. That's not the point, however. Don't look at these libraries for inspiration. Try to create your own code purely from the reference of the book. Only once you're done compare with other people's code.

u/ideasbro · 2 pointsr/ASU

I’m currently taking CSE 310 with Richa, and this is the book we use: Intro to Algorithms. I recommend really practicing asymptotic analysis (i.e. big-O, big-theta, big-omega) for algorithms, as well as reviewing and understanding your basic sorting algorithms. These topics are covered in the first few weeks, and they hit fast. Other than that, we’ve just been learning about data structures (e.g. binary trees, red-black trees, hash tables, etc.) and their pseudocode functions which are in the book. Don’t focus so much on the specifics of the code, but rather how they work conceptually. Good luck!

u/Signt · 2 pointsr/compsci
u/doggertron_ · 2 pointsr/webdev

I own Introduction to Algorithms. Great book.

u/ScrewAttackThis · 2 pointsr/learnprogramming

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844?ie=UTF8&ref_=zg_bs_132570011_2

Pretty common book used in college courses. Can't go wrong with it.

e: Which is the textbook used for the MIT OCW class so you probably already know of it.

u/blurarara · 2 pointsr/argentina

Acá tenes el libro que usan en el mejor curso de algoritmos 1 de la facultad de ingeniería de la uba. Se lee muy fácil y está bueno para aprender.
Este otro es excelente para cuando te termines el primero y quieras algo un poco más teórico, es medio pesado pero es completo.

u/ryptophan · 2 pointsr/learnprogramming

Here's a good free one: opendatastructures.org

Here's a good non-free one: Introduction to Algorithms

u/elev57 · 2 pointsr/math

Concrete Mathematics by Knuth et al. I've heard this is the go to combinatorics (which includes graph theory) book for any mathematician.

Introduction to Algorithms is the classic first book for algorithms.

u/3h53htj3jj · 2 pointsr/learnprogramming
u/dietsnappleman · 1 pointr/cscareerquestions

The most common textbook is this:
http://amzn.com/0262033844

I learned from this:
http://amzn.com/0073523402

Can't say anything about Free Code Camp, but I will say that work experience at the best company that will take you is likely going to trump anything you do on the side OR a master's. You should, ofc, learn as aggressively as possible regardless.

u/ill_mango · 1 pointr/webdev

Have you read "Algorithms and Data Structures"? It's a text often referred to as 'the CLRS' text, because of the last names of the authors. It's required reading for both Amazon and Google technical positions, and likely for FB and twitter as well.

I believe it's this one, actually called intro to algorithms: http://www.amazon.ca/gp/aw/d/0262033844

u/unshift · 1 pointr/programming

CLRS is a great book and you'll likely need it in any reasonable CS dept. It's very heavy on the math and might be a bit over your head right now, but it's a solid book. It's a bit more than $50 but Operating Systems Concepts is also a good buy. I personally don't go for language-specific books since they quickly go obsolete, but books on fundamentals are very useful to have in your library.

u/bautin · 1 pointr/cscareerquestions

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.

u/craiig · 1 pointr/compsci

Sure, how about something like:

http://www.amazon.ca/gp/product/0321295358/ref=pd_lpo_k2_dp_sr_1?pf_rd_p=485327511&pf_rd_s=lpo-top-stripe&pf_rd_t=201&pf_rd_i=0132131080&pf_rd_m=A3DWYIK6Y9EEQB&pf_rd_r=1A71XTJAHD16ZEREQZZ8

Or

http://www.amazon.ca/gp/product/0262033844/ref=s9_simh_se_p14_d0_g14_i2?pf_rd_m=A3DWYIK6Y9EEQB&pf_rd_s=auto-no-results-center-1&pf_rd_r=10D27GV8EP2XF4VJH1FF&pf_rd_t=301&pf_rd_p=478281791&pf_rd_i=liesserson

I prefer the first I think, but I haven't gotten through a lot of it.

There's tons of other books that deal with algorithms of different sorts. AI, Machine Learning, SAT Solvers. They all touch the software side a little bit, because of course, the algorithms have to run on something at some point.

u/mrstacktrace · 1 pointr/learnprogramming

I highly recommend Algorithms Unlocked by Thomas Cormen (one of the authors of the famous CLRS book)

It's very readable; it's about 240 pages. It's basically a bit of a simplified, summarized version of CLRS. He takes time to walk through the algorithms with "real-world" examples, and gives you the algorithmic analysis as well. It doesn't contain the mathematical rigor or any of the problems/exercises of CLRS. It's supposed to be approachable by people who are not CS majors (but do have some Math under their belt).

It's a perfect book to read before studying CLRS, during, and even after (when you are in the industry and haven't touched CLRS since you graduated and you want to prepare for interviews).

u/drdough · 1 pointr/math

Sure, there are a few directions you could go:

Algorithms: A basic understanding of how to think about and analyze algorithms is pretty necessary if you were to go into combinatorial optimization and is a generally useful topic to know in general. CLRS is the most famous introductory book on algorithms, and it gets the job done. It's long, but I thought it was decent enough. There are also plenty of video lectures on algorithms online; I liked the MIT OpenCourseWare of this class.

Graph Theory: Many combinatorial optimization problems involve graphs, so you would definitely want to know some graph theory. It's also super interesting, and definitely worth learning regardless! West is a good book with lots of exercises. Bondy and Murty and Diestel also have good books, which are freely available in PDF if you do a google search. Since you're doing a project on traffic optimization, you might find network flows interesting. Networks are directed graphs, where you think about moving "flow" across the edges of the graph, so they are useful for modelling a lot of real-life problems, including traffic. Ahuja is the best book I know on network flows.

Linear and Integer Programming: Many optimization problems can be described as maximizing (or minimizing) some linear function subject to a set of linear constraints. These are linear programs (LPs). If the variables need to take on integer values, then you have an integer program (IP). Most combinatorial optimization problems can be formulated as integer programs. Integer programming is NP-hard, but in practice there are methods that can solve most IPs , even very large ones, relatively quickly. So, if you actually want to optimize things in real-life this is a very useful thing to know. There's also a mathematically rich field of developing methods to solve IPs. It's a bit of a different flavor than the rest of this stuff, but it's definitely a fertile area of research. Bertsimas is good for learning linear programming. Unfortunately, I don't have a good recommendation for learning integer programming from scratch. Perhaps the chapters in Papadimitriou - Combinatorial Optimization would be a good introduction.

Approximation Algorithms: This is about algorithms which quickly (in polynomial time) find provably good but not necessarily optimal solutions to NP-hard problems. Williamson and Shmoys have a great book that is freely available here.

The last book I'd recommend is Schrijver. This is the bible for the field. I put it here at the end because it's more of a reference book rather than something you could read cover to cover, but it's REALLY good.

Lastly, if you like traffic optimization, maybe look up what people are doing in operations research departments. A lot of OR is about modelling real problems with math and analyzing the models, so this would include things like traffic optimization, vehicle routing problems, designing smart electric grids, financial engineering, etc.

Edit: Not sure why my links aren't all formatting correctly... sorry!

u/hsklr · 1 pointr/compsci

These two are my absolute favorites:

The Algorithm Design Manual and Introduction to Algorithms

They have a quite different take on algorithms. I recommend them both, actually. CLRS (the Introduction to Algorithms) is a staple book in most courses. The Algorithm design manual has a more practical view of things, which might be really great to learn alongside the more technical stuff that CLRS teaches.

I will not recommend the Art of Computer Programming to prepare for an algorithms course. I own the books as a collection, but they will be too hard and focused on things that your algorithm course will just jump over. The other books I mentioned here are in my opinion better suited for that. I've never heard of Art of Computer programming being used in an algorithm course, except for small exempts of it. Also, without reading Knuths Concrete Mathematics (great book) or being well versed in the mathematics he uses, it will be extremely hard.

I've heard good stuff about Sedgwick's book as well, which nerga recommended.

u/loops_____ · 1 pointr/cscareerquestions

>The Algorithm Design Manual

Is this another algorithms book? How is it compared to Cormen's Introduction to Algorithms or Grokking Algorithms? I tried Cormen's and Grokking's, but it was a hard read and I generally prefer Youtube videos (mycodeschool) and so on. Is The Algorithm Design Manual similar?

>EPI, and PIE

What are these?

u/lordyod · 1 pointr/UCSC

That was a typo it's CE12. The past three quarters it has focused on digital logic structures, binary/hex math, basics of building a processor, and the MIPS assembly language. If you want to get a head start on the book pick up Computer Organization and Design.

CS101 will depend on the instructor. If you are assigned to Tantalo's class then you will be doing a mix of programming assignments and proof stuff. I'm not super familiar with the details but luckily, his materials are all posted on his course websites, just google UCSC CMPS 101 and find it. If on the other hand you are assigned to Sesh's class then (at least based on this last quarter) you won't be doing coding, you'll be doing very thorough proofs about algorithms. Both of these classes use CLRS which, if you're serious about CS, you'll probably want to have as a desk reference regardless.

u/__GG · 1 pointr/cscareerquestions

Books on data structures and algorithms.

For example: http://www.amazon.com/books/dp/0262033844

u/Archosis · 1 pointr/learnprogramming

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

u/CodeTinkerer · 1 pointr/learnprogramming

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.

u/ShenmeNamaeSollich · 1 pointr/cscareerquestions

Why stay at a school where you're not studying what you want, and which doesn't even offer what you want nor one of the most popular in-demand majors??

Anyway, there are any number of online courses/tutorials about Data Structures, and how to build/use them in various languages. You can use C++ for them, or try to learn something else too. For speed & simplicity in interviews, a lot of people seem to prefer Python for discussing DS&A, but by their nature the concepts are fairly language-agnostic.

Try visualalgo for one ... there are plenty of others.

Since a lot of algorithms require/suggest the use of specific data structures to make them work, it's probably better to learn what those are first, and then try to tackle the algorithms that rely on them.

Grokking Algorithms - illustrated & pretty basic intro to concepts

Common Sense Guide to Data Structures and Algorithms - slightly less so, but still pretty basic intro to concepts

CTCI - problems covering arrays, linked lists, stacks & queues, trees, graphs ... Actually kind of useless if you don't already know what those are though.

Introduction to Algorithms (CLRS) - 1 of 2 standard U.S. college-level algorithms textbooks

Algorithms, 4th Ed. - the other standard U.S. college-level textbook, w/free online "book site", code, and a free Coursera course to go along with it.

u/Chezni19 · 1 pointr/learnprogramming

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:

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1479248878&sr=8-1&keywords=algorithms+cormen

Probably much cheaper used.

Maybe this goes without saying, but it helps to code all the time.

GL Man

u/FireReadyAim · 1 pointr/learnprogramming

Never not read the CLRS text.

It's not specifically C, but it is worthwhile.

u/incompetentrobot · 1 pointr/compsci

It's very doable, especially if you have both an academic and practical bent. I'm a self-educated programmer and I work on cutting-edge software alongside top-tier CS academics.

I saw in another comment that you have a strong programming background. Here's a great algorithms text: http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

u/pingpong888 · 1 pointr/math

That is very kind of you for your advice and help.

You might be right, I should not get hung up on the Limits section. But my concerns is that it might happen again in other chapters. Bearing in mind, it is only chapter two.

The reason I want to change the current book of Larson's is because the two examples in the formal definition of Limits section omits a few steps, as a result, I cannot understand the example, even I understand its definition. I was happy about the book until that point.

I compared Thomas's Limits section (via ebook), which is more detailed. I like the fact that it has solution books, and is more user-friendly than Lang. However, it is clear explanation that matter the most when buying a book. I don't want to regret again after buying Thomas's.

It all begins with the fact I need to review [Introduction to Algorithms] (http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?s=books&ie=UTF8&qid=1376616674&sr=1-1&keywords=introduction+to+algorithms), and Thomas's Calculus is recommended.

As you mentioned, Calculus might not be required as much as Discrete Maths, Linear Algebra. But I still need to go though all basics (really basics), so I can start reading Introduction to Algorithms ASAP, or Knuth's Vol 1,3 after that.

I have read more negative comments on James Stewart's "Calculus".

I will read the Thomas's Limits section. If I can understand, it will be easier for me to decide.

I find it helpful to know what maths is important in computer science.



u/tufflax · 1 pointr/learnprogramming

This (popular) book has the correct definition. https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 Wikipedia is not so great, because they are abusing the = sign in their "formal definition". How formal is that?

> I also disagree with your assertion that m and n should be unbounded.

I didn't say they "should be unbounded", I said there is no other relationship than that the edges have an upper bound.

> m would always rely on n

Depends on what you mean by "rely" on. Normally, relies on means that there is a stable relationship, like m = 2n + 3. But in this case there is no such relationship, other than that the edges have an upper bound.

> With that said, I would understand O(m*n). I don't think it provides any value or clarity over O(n^2), but I wouldn't bother changing it or correcting it if it came up at work.

You seem to have accepted that this is wrong elsewhere.

u/ToadstoolBeTrippin · 1 pointr/reactjs

The one book that every programmer should read is Code Complete. It goes over all stages of development in a high level overview that applies to any project.

I would then move onto Algorithms by Sedgewick and Wayne. I tried reading Introduction to Algorithms because it was strongly suggested to me, but it goes into higher level math really quick. I haven't taken calculus since high school and never took any higher level math classes in college, so I got lost after about page 30.

After that, I would just look for a book dedicated to design patterns in the main language you work with. There are some overlapping patterns between languages, but it's best to be practical about what you learn.

u/seanfast · 1 pointr/cscareerquestions

im not sure what you do with CIS, but im guessing sysadmin type stuff? if that doesnt interest you and the job listings dont either, look into a straight BS in CS degree. you can probably transfer some credits. check out an algorithms book like this one (google it for the pdf) http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X or this one http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844 and if they interest you check out CS. take some courses for free on codecademy and see if web programming interests you. theres a million ways to go online and check out other cs related avenues that might be more for you. explore cs classes on your campus after reading the course descriptions, audit a class for free. sign up and then leave during drop add. see how things sound. check things out. good luck!

u/thattreesguy · 1 pointr/programming

i would recommend this book even if your course isn't using it - it has very good explanations for non-genius level (rare in CS textbooks it seems), and all the chapters are self-contained (meant to be read non-sequentially)

at my school this book is used for both semesters of algorithms (the intro and advanced)

http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

u/metaphorm · 1 pointr/webdev

try /r/javascript for questions specific to node.js, its a pretty active subreddit and includes a lot of people who are developing more interesting apps than just browser scripting.

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.

u/springy · 1 pointr/algorithms

You don't need very much mathematics at all to learn the implementations of various algorithms. Sure, many algorithms books have mathematics in them to analyze the performance of the algorithms, but if you are mostly interested in the details of the implementations of algorithms, rather than analysis of performance then there is nothing to hold you back.

The Algorithms Design Manual, by Steven Skiena would be a great starting point. http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693

Then, if and when your interest in analysis of performance increases you can move on to a more mathematically demanding book, such as Introduction to Algorithms, by Cormen et al. http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

u/solid7 · 1 pointr/compsci

Excellent reference texts that will give you a good idea of what you are getting yourself into:

u/SamStringTheory · 1 pointr/careerguidance

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.

u/beatbrot · 1 pointr/AskComputerScience

If you maybe need a book recommendation you can take a look at:

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

Hands down the best book in the business.

Even the Java Developers used this exact book to improve their algorithms.

u/hphong591992 · 1 pointr/UMD

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/

This is 351's bible.

For 330, just read last semester's slides.

u/njoubert · 1 pointr/compsci

I would suggest that the carlh programming guides is not a bad idea then!

I would heavily suggest learning C well - this is a language that was designed to stay close to the hardware while being portable, and is a very small language. So, buy a copy of the K&R Book, ever C programmer has one.

Then, Patterson's book is a tome for computer engineering. It'll show you assembly, all the way down to NAND gates.

I would suggest you start by watching and working through Berkeley's CS61C course. It's the logically second course in CS, and after a quick overview of C it dives into the machine itself. Website here, videos here. Also, Dan Garcia is an excellent lecturer.

Once you have all the machine details down, you'll probably feel hampered by your actual program wizardry. This is where you start looking into algorithms and data structures. Your go-to guide here is probably Cormen's Introduction to Algorithms since it handles both data structures and algorithms. It's definitely more of a theoretical/CS-ey book, so if this is not what you want, then Head First Java will teach you a new language (and learning more languages is one of the best ways to grow as a programmer!) and also do many data structures. In fact, you can get both those books and have the light side and the serious side of programming books.

At this point you should be well equipped to go off in whatever direction you want with programming. Start contributing to open source projects! Find things that interest you and try to solve problems! Being a part of the programming community will be your biggest aid in both learning programming and starting to make money through it. People pay for programmers that they know can deliver, and success in the open source world means a lot, and you don't need to go to school for it to get to this point!

Lastly, many CS/programming folks hang out on IRC. If you have questions, find the appropriate IRCS channels and go talk to people. Good luck and welcome to programming!

u/drboyfriend · 1 pointr/algorithms

Introduction to the Design and Analysis of Algorithms, by Levitin, was used at my university and none of us cared for that book and I don't recommend it.

I'm not familiar with #1, but I do recommend:

u/mortyma · 1 pointr/cscareerquestions

CTCI assumes that you already know the basics of algorithms and data structures - it's a set of interview problems, not so much an intro to the topic. If you want to get a head start, get a good algorithms-book. Introduction to Algorithms by Cormen et al! is a well known book and also often used in college courses.

I think that there is a fundamental difference between CTCI and Intro to Algorithms books: The first teaches you a bag of tricks to solve interview problems; the latter focuses on fundamental concepts and proofs.

u/QuisUt-Deus · 1 pointr/OMSCS

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.
u/ApokatastasisPanton · 1 pointr/compsci

It's incredibly expensive as well.

For more affordable resources :

u/DutchmanDavid · 1 pointr/gamedev

>I recommend this book on AI

Maybe after reading up on Algorithms and/or Design Patterns (Not sure if the Gang of Four book is easy on beginners though)? I've read the AI book, but not much of the info really stuck, because it was mostly mathemagical code to me because I knew nothing of design patterns or algorithms.

u/tbid18 · 1 pointr/math

I don't know much about AI, though I do know that (there's a theme, here) linear algebra gets a starring role. So, if you're currently enjoying linear algebra, continue with that. Axler is frequently recommended, if you want a textbook to go through.

After that it's really up to you what you want to go for next, since you have many paths available. Sipser is a great intro to theoretical CS, but, again, don't spend $200 on it. Try to find it in a library, or use something like this to find a much cheaper international edition.

Edit: Forgot to mention, CLRS is the standard for algorithms, but I'm not sure how useful it is as a primary source for learning. Maybe try to borrow a copy to see if you like it.

u/IamNotWrong- · 1 pointr/SJSU

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

u/thruw333 · 1 pointr/SJSU

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

u/Crackthecode15 · 1 pointr/learnmachinelearning

These both seem like okay books. I would actually recommend reading CLRS introduction to algorithms Introduction to Algorithms, 3rd Edition (The MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_api_i_zme3DbCFYP00F
This teaches you algorithms that are less specific to a particular language. But if you really want to focus on python I think the books you picked are okay but won’t Supplement the math background.

u/mountainjew · 1 pointr/devops

I've found a few resources and just going to focus on them until I get it. Then probably start focusing more on coding interview specifics by doing challenges on Leetcode. Guess I just need to self-learn CS.

Introduction to Algorithms

Khan Academy

Udemy

Coursera

u/l19ar · 1 pointr/argentina
u/abr71310 · 1 pointr/uwaterloo

I've been mostly finding that website coding is insanely helpful.

HackerRank, CodeForces, TopCoder are all great resources for "competition" problems (which translate really well into interview problems and problem-solving in general).

I read this book, it actually proved to be a lot more helpful for my Riot Games interview, since it had to do a lot with "in-depth" thinking, which this book is great at helping break down (I always found "Cracking the Coding Interview" to be way too high level, especially if you're in a pinch): http://www.amazon.com/Data-Structures-Algorithms-Made-Easy/dp/1468108867

(NOTE: If you're a primarily Java developer, there's an equivalent book for the above, just search "Data Structures and Algorithms in Java", from the same author)

I learned a lot more from that book than I did McDowell's, since I found that this author actually cared about doing "deep dives" into each of the topics presented. I own an earlier edition - not to say this one isn't great, I'm actually pretty sure the "algorithmic puzzles" he presents are a lot more relevant to current programming interviews.

There's also the age-old CLRS, which I found to be useful for any kind of theoretical computer science topic (Runtime analysis, big-O, etc): http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844/

Let me know what you think! -- I've been using both of these to get my next job (hopefully full-time)! ^_^

u/jj2parkie · 1 pointr/cscareerquestions

I think it depends on your location. If you live in or a commutable distance to a city with a strong technology sector, they will be quite a bit of companies willing to hire an high school level intern.

For example, a friend of a friend got an internship after graduating high school for the summer in the city he lives. I live outside the city and I am taking a year off before university because I got sick in the summer. I'm better now but all the companies near me are kind of old fashioned and they don't accept interns after a lot of cold calling; my calls and emails get sent to their HR manager, and they don't feel like giving me a chance. Also the benefit of an internship in the city for him was that he used pretty modern web development stuff.

As a high school intern unless you find a research group, you will highly unlikely use R. You can probably do front-end web development, so learning HTML, CSS, JavaScript, Jquery, and the Bootstrap framework would be awesome. If you don't want to do front-end web development, you really have to market yourself and make sure you are competent in Python if you want to use Python.

As a person who graduated high school last year and is taking a year before university to recover from an illness, I have to compete with other university students of various years who even the freshman have some sort of qualification as a candidate for a bachelor of applied science or math degree which tells the potential employer the applicant is knowledgeable. If you want to be competitive with the freshman or maybe the sophomore students, you really need a good GitHub portfolio which shows you are knowledgeable as them.

For example, in my GitHub portfolio, I have an Android application (GitHub and Google Play). In this small to medium sized application (35, 000 lines of code), I show I can use a version control system and a bug tracker by using Git and GitHub, respectively. Furthermore, in the bug tracker, I show I can debug by showing results of me using an allocation tracker, a heap dump analyzer, a GPU rendering profiler, and the like. In the actual source code, I show my experience with Java. But more importantly, I show I can implement an architectural pattern like Model-View-Presenter (a deviation from Model-View-Controller), some design patterns like wrappers, singletons, mappers, adapter, presenters, contracts, providers, and factories, and design an API which performs network requests, database queries, and file input and output. In the source code, I try to apply as much as I can from reading, Effective Java (2nd Edition), Clean Code: A Handbook of Agile Software Craftsmanship, Design Patterns: Elements of Reusable Object-Oriented Software, and Introduction to Algorithms while I get acquainted with reading Software Engineering: A Practitioner's Approach. I still need to try to utilize TDD and Agile practices; I read about them, but I never tried them out.

I think if you have a GitHub portfolio with project(s) of a good size that shows a lot of computer science and software engineering concepts, you will be ahead of most freshman students whose only projects might be a small class project in their Intro to Java class which all their peers did.

Currently, the application has around 5,000 downloads in about a month with 4.4 rating to place it 5th in its specific category above 4 stars on Google Play: https://play.google.com/store/search?q=Manga+Reader&c=apps&rating=1; it took about a month and a half. However, every time I send my resume to a local company outside the city for an internship, I get no response. I'm going to a Career Fair at a friend's university in the city on Friday, so I'm a test my luck there; they have quite a few recruiters for mobile application interns, and one company develops a full stack product and service whose mobile applications kind of match mine. Overall, it's feasible if you are near a city, willing to commute, and can prove you know as much as a freshman student who they could hire instead.

u/idmontie · 1 pointr/computerscience

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.

u/doctorpecker · 1 pointr/learnmath

Thanks. It just seems that all the computer science programs at major universities push a lot of math. I just don't want to be limited.

For instance this book is apparently a classic and...I simply can't understand it.

http://www.amazon.com/Introduction-Algorithms-3rd-Thomas-Cormen/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1417658683&sr=8-1&keywords=introduction+to+algorithms

u/Innovashiun · 1 pointr/csharp

Since I'm also a beginner I need to ask: Is there a need for algorithms? I don't see anyone mentioning algorithms. Anyway, if you do care about them I suggest the book Introduction to Algorithms, 3rd edition.

u/michael0x2a · 1 pointr/learnprogramming

While you may feel like you've hit a dead end, I can assure you that you've only touched the surface of what you can do with code/programming.

So far, it looks like you've had mostly enterprise experience. Basically, experience putting together software that fits a need that a business requires.

The thing about enterprise programming is that it's mostly difficult by dint of all the moving parts/the number of pieces that need to fit together and scale. Since you've already gotten good exposure to that kind of difficulty, why not try looking for something that's difficult in a different way?

You have two different ways of doing this. The first is to expand your breadth -- expand the number of topics you know about. It sounds like you already have experience working with HTML/CSS/Javascript, and Java and C#, but not much else. Here are some topics that you can consider exploring, in no particular order:

  • Cryptography, security, and number theory
  • Hacking and exploiting computers
  • Databases
  • Functional programming (Haskell, Lisp, etc)
  • Embedded programming (robotics, arduinos, etc)
  • Graphics and game programming
  • Data mining and machine learning
  • Graphics and audio processing
  • Compilers, interpreters, and programming language construction
  • Mobile development (Android, iOS, Windows phone)
  • Operating systems
  • Artificial intelligence
  • Scientific and mathematical computing
  • Human-computer interaction
  • Systems and network programming

    etc.

    ---

    The other option is to dive deeper into a particular aspect of CS/programming.

    Based on what you're saying, it doesn't sound like you have much experience working with CS-theory heavy material, so I'd try working on that next. That's actually one of the reasons why I suggested writing an interpreter from scratch -- it's conceptually difficult, and touches on a lot of CS concepts and materials.

    Reading books is another good way to dive.

    One book I can recommend is Introduction to Algorithms, 3rd Edition, which is a ridiculously comprehensive introduction to algorithms and data structures. (Do note by "introduction", they mean "graduate-level introduction"). You can find a free pdf download here.

    Another good one is The Structure and Interpretation of Computer Programs.

    I will be very surprised if you recognize everything in those two books and can immediately master all the concepts, regardless of your prior level of experience.

    A third good way to dive is to pick a project which is just barely on the edge of your comprehension/seems almost impossible to you, and just go for it.

    For example, try taking a stab at writing an AI or voice recognition software. Or perhaps you could try writing your own operating system, writing a 3d graphics engine, or take your TI-84 graphing calculator and turn it into a rudimentary web browser. You probably won't succeed in the first two, and will take a long time, if ever, to finish the latter three.

    The point isn't to try and actually finish -- the point is to tons of research and difficult work to try and expand the bounds of your knowledge.

    ---

    I also want to point out that you're already very advanced for your age, and that a lot of things that I'm suggesting will probably be a huge jump in difficulty for you, and in fact will probably be a huge jump in difficulty for many college graduates.

    I'm not saying you have to, or should in any way feel obligated to do these sorts of things, but you do seem eager to learn, and my hope is that my suggestions can inspire you see what's possible and help you find bigger and harder challenges to tackle, and find completely new things to learn.
u/dionidium · 1 pointr/PHP

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:

u/Free_Apples · 1 pointr/learnprogramming

If you still have a handle on the basics, learn/re-learn your data structures and algorithms. CLRS would be a great refresher because it's often used as a reference book. Good luck.

u/zjs · 1 pointr/askscience

> 1) Could someone explain the implications of quantum computing on cryptography? In particular, would it allow us to develop new encryption algorithms that are uncrackable? Or would it make codes that we use now (e.g., RSA) totally trivial? (Or both?)

That's a complicated question, but I can try.

Basically, with a general purpose quantum computer, it would be "easy" to solve a class of proplems, including not only those problems which are "easy" to solve with a classical computer, but also some which are currently "hard".

I'm not sure if this would allow us to develop novel algorithms for encryption, but it would certainly make some algorithms which are currently widely used obselete. For example, because factorization is "easy" with a quantum computer, RSA would no longer be secure.

Do note that there are a variety of algirthms which could be implemented by classical computers that we believe would not be "broken" by quantum computers.

> 2) Could someone recommend some online resources I got use to teach myself intro to algorithms/data structures? Specifically concepts like big O, big theta, and big omega notations. I'm currently in a Mathematical Foundations of Computer Science course (basically intro to discrete math, i.e., combinatorics, probability, graphs, induction) and would like to get a jump start on next semester's material (and the course syllabus doesn't have a textbook).

Introduction to Algorithms by Cormen is the most widely used algorithms textbook, but not very good for self-directed learning (in my opinion). If you've got a bit of free time, you might check out the lectures and problem sets from MIT's Introductions to Algorithms course.

u/csp256 · 1 pointr/digitalnomad

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?

u/YuleTideCamel · 1 pointr/learnprogramming

Sure, not sure if you saw my edit but sites like CodingBat and Exercism are great resources.

Others would be just technical books and tutorials. For example read the following books:

  • Clean Code

  • Code

  • Head First Design Patterns

  • Intro to Algorithms


    There are a ton of great tutorials on Pluralsight.

    You're not going to find any books specifically on problem solving, but reading through technical books and getting better at specific technologies then applying them is the way to get better at problem solving. I guess what I'm saying is that you're not likely to find a book that says "do this to get better at solving problems", you'll find books that give you technical ideas and when you go use them and run into problems that's how you grow.
u/childintime9 · 1 pointr/AskComputerScience

pseudo code and understanding well the cormen . I never did a lot of exercises but I knew well all the properties of the algorithms, the complexity, the invariants. One thing useful is visualizing the algorithms by drawing on paper, see how all the numbers shift etc.

u/the_one2 · 1 pointr/ProgrammerHumor

It's a pretty big topic: Algorithms and data structures. Introduction to Algorithms is a pretty good book.

u/zweischeisse · 1 pointr/jhu

These are what I had. Different professors might use different books, obviously.

u/blexim · 1 pointr/compsci

Introduction to Algorithms is pretty comprehensive.

u/PixelizedPlayer · 1 pointr/gamedev

Well i saw this :

https://www.amazon.co.uk/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=pd_lpo_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=BE94G47A4CPDR79N1Q5N

But its a bit over kill and its not easy to understand some of the syntax since they use computer science type language that i also see in some papers when trying to understand shaders and thats also hard to read too.

Unless you have a good suggestion that covers the information thats accessible for those without CS knowledge?

u/Orbostel · 1 pointr/cscareerquestions

Did you already try the classic from Cormen et.al?

I guess you can learn everything what you demand from this book

u/prajaybasu · 1 pointr/csharp

https://www.amazon.com/dp/032157351X/
https://www.amazon.com/dp/0262033844/

C# is not a popular language with academics who tend to write cryptic Java and C/C++ for a living, so good luck finding a reference written by someone credible.

u/winteriver · 1 pointr/cscareerquestions
  • Read this book: CLRS

  • Only read sections mentioned in this Syllabus

  • Try writing algorithms mentioned in syllabus in your favorite language

  • Move to CTCI, EPI
u/guy_gold · 1 pointr/compsci

The first few chapters of Introduction to Algorithms are great to understand the basics Big-o and other asymptotic notation.

u/SpoobyPls · 1 pointr/learnprogramming

There are a few books I recommend. I think a couple of things are very important to wrap your head around, but before all that comes the basics. For instance, knowing your primitive types, methods, loops, and even OOP which would include things like; classes, structs, inheritance, polymorphism, etc,.

Then move onto some very good readings;

  1. Clean Code - This book is going to go through a lot of concepts and keeping your code maintainable and is a very short read.
  2. The Pragmatic Programmer - This one will go through, what I believe, you're looking for. Helps you get into the mindset of a 'pragmatic programmer.'
  3. Introduction to Algorithms - This I wouldn't start until you're fairly comfortable with programming in the language you are familiar with. By this point you should definitely have the basics down. In fact, I might argue do this one after you've read the other two.
  4. Lastly, I'd recommend doing Project Euler which is really going to put your skills to the test. It is very mathematical but if you're up for the challenge this will push you far.
u/jcarlson08 · 1 pointr/cscareerquestions

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).

u/maksa · 1 pointr/serbia

Ovo su dve "standardne" knjige:

Introduction to Algorithms (Cormen, Leiserson, Rivest, Stein)

Algorithms (Sedgewick)

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.

u/hextree · 1 pointr/compsci

Insertion in O(1) is definitely possible. Because you can just add to the end of a linked list in O(1) time. This would result in duplicates though, which would make for a more complex deletion.

The wiki page for Hash Tables seems to be accurate. If you want more depth, any reputable Algorithms book (e.g. https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844) should be ideal.

u/myevillaugh · 1 pointr/learnprogramming

Data Structures and Algorithms is a class that a lot of employers like. Some will call it the most important class you ever take, while others will describe it as an exercise in frustration and futility, but YMMV. It varies by school. What's the content of the class? Is this the book? http://www.amazon.com/Introduction-Algorithms-Third-Thomas-Cormen/dp/0262033844

But for two classes? In a lot of schools, that would make you part time, and reduce the tuition, and allow you to work part time. If you've already qualified for a BA in Comp Sci, you can probably get a pretty decent part time job.

u/GalacticGlum · 1 pointr/csharp

For a good algorithms and data structures textbook take a look at: Algorithms 4th Ed. by Sedgewick and Wayne (https://www.amazon.ca/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=pd_lpo_sbs_14_img_2?_encoding=UTF8&psc=1&refRID=Y10M1BMYGCSJCJJN2GJT) or Introduction to Algorithms 3rd Ed. by Cormen, Leiserson, Rivest, and Stein (https://www.amazon.ca/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844).

u/puttybuggy · 1 pointr/learnprogramming

I'll throw this out there as well. Language-agnostic, and there's enough meat on these bones to keep you busy for quite some time:

Introduction to Algorithms:
http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

(That, and a copy of GEB for company during long bowel movements.)

u/protein_bricks_4_all · 1 pointr/learnprogramming

Re: Booch, I haven't even seen it, I only know it by reputation so, look before you leap I guess. Hmmm; if I'd know that you have PPP which I haven't read, I might have been more circumspect about recommending Eff C++. A lot of us answering questions are older, and Eff C++ was sort of the pioneering book regarding, "the obvious way isn't always the best way". But in the meantime its wisdom has been absorbed, around. I don't own either, so I can't say. Luckily it doesn't matter :)

Um; on /implementing/ data structures - no, I can't really recommend any; I meant using them, and knowing the Big O characteristics (but of course implementing them is good exercise). For you I'd be looking for a throwaway, used book that does the basics - you'll pay enough again when you buy the textbook at school :). And on that I'm coming up blank; read the reviews at Amazon I guess. Or, google around per data structure, for discussion and implementation of them. Sorry ... I could recommend Cormen but, that's a doorstop => unpleasant to contemplate opening or dragging around with you, overwhelming for someone just starting, and expensive. I'm sure there's a better one but, the only experience I have is of my own old undergrad book and it's probably not even in print.

u/MrKDilkington2 · 1 pointr/AskComputerScience
u/guilherme29 · 1 pointr/portugal

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.

u/Fizz-Buzzkill · 1 pointr/cscareerquestions

Tom Cormen co-authored it also. He's one of the authors of the famous textbook Introduction to Algorithms

u/mrmivo · 1 pointr/learnprogramming

A highly recommended book is Introduction to Algorithms. "clsr" is the group of authors of that book: Cormen, Leiserson, Stein, and Rivest.

u/proginprocess · 1 pointr/learnprogramming

Currently Reading:
JavaScript - Professional Javascript for Web Developers

Software Design - Clean Code

Later on, I'll be reading this for Data Structures and Algorithms:
Introduction to Algorithms

Don't know what I'll do for a specific language later on. Probably go back to C# and see what I can churn out there.

u/Noob-Ranch · 1 pointr/OSU

Text: Introduction to Algorithms. You'll use the same book in Foundations II.

Some of the Course Topics:

  • Propositional Logic
  • Predicate Logic
  • Asymptotic Analysis: Loops and Recurrence Relations, Bounding
  • Graph Theory
  • Hamiltonian/Eulerian Cycles & Paths
  • Depth/Breadth First Search Algorithms using Adjacency Matrix/Lists
  • Other stuff I've forgotten
u/PsYnCere · 1 pointr/UMD

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)

u/veeberz · 1 pointr/compsci

Exercises in this book.

u/jacob1044 · 1 pointr/compsci

Introduction to Algorithms. I still have the 2nd edition within arms reach at work.

EDIT: after re-reading your post, i see you already have a copy :)
nevermind.

u/uhwuggawuh · 1 pointr/compsci

I'm kind of in the same position as you, OP. Thinking of getting CLRS, New Turing Omnibus, The Elements of Computing Systems, and Algorithmics!

So excited.

u/spacez320 · 1 pointr/compsci

I don't know if it's been suggested yet, but this is the algorithms book. http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1314728310&sr=8-1 ...although it's not for the faint of heart (or those scared of math).

u/oridb · 1 pointr/programming

That depends on the book. Books on frameworks or specific languages are rarely useful -- I find that online reference manuals are the best for that.

However, books like TCP/IP Illustrated, The Art of Multiprocessor Programming, Compilers: Principles, techniques, and tools, An Introduction to Algorithms and similar tend to age pretty well, and I still find myself pulling them out and referring to them quite often.

u/Elynole · 1 pointr/nfl

I'll throw out some of my favorite books from my book shelf when it comes to Computer Science, User Experience, and Mathematics - all will be essential as you begin your journey into app development:

Universal Principles of Design

Dieter Rams: As Little Design as Possible

Rework by 37signals

Clean Code

The Art of Programming

The Mythical Man-Month

The Pragmatic Programmer

Design Patterns - "Gang of Four"

Programming Language Pragmatics

Compilers - "The Dragon Book"

The Language of Mathematics

A Mathematician's Lament

The Joy of x

Mathematics: Its Content, Methods, and Meaning

Introduction to Algorithms (MIT)

If time isn't a factor, and you're not needing to steamroll into this to make money, then I'd highly encourage you to start by using a lower-level programming language like C first - or, start from the database side of things and begin learning SQL and playing around with database development.

I feel like truly understanding data structures from the lowest level is one of the most important things you can do as a budding developer.


u/blueshiftlabs · 1 pointr/AskEngineers

If you're a CompE, you're gonna be writing a lot of C. If you haven't read The C Programming Language, by Brian Kernighan and the late Dennis Ritchie, shame on you - it's one of the best, most helpful, and most concise programming books I've ever read. (The design of the book is a lot like the design of C, really.)

Also, if you want a reference for any algorithm you could possibly think of, I can guarantee it's in Knuth's Art of Computer Programming somewhere. CLRS, mentioned by xibernetik below, is another good algorithms book that's more accessible, but less in-depth.

u/jsprogrammer · 1 pointr/programming
u/cheerfulloser · 1 pointr/learnprogramming

The top things that you're tested on during interviews are:

  1. proficiency/skill with your primary programming language
  2. algorithms
  3. data structures

    It looks like you're well on your way to #1. I am not a .NET developer, so can't help much there.

    However, here're my suggestions for #2 and #3

    algorithms - CLRS is a standard book for algorithms in university courses (http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844). However, I found the book a bit of a dull read. It might be better to start off with this book instead (http://www.amazon.com/Algorithm-Design-Jon-Kleinberg/dp/0321295358)

    Data structures - I don't have a specific book in mind but I suggest looking up Amazon reviews and getting a highly rated book.

    The reason algorithms and data structures are tested heavily is because you want to write an efficient algorithm/solution for your work projects & tasks. Depending on the situation, having a good eye for determining the appropriate data structure and algorithm is a must.
u/DataLulz · 1 pointr/learnprogramming

Part of what they are trying to teach via this method is reading other people’s code and correcting mistakes in algorithms(I can tell you that I spend half of my time doing this professionally) If you are worried you haven’t fully learned how to implement from scratch something like a bubble sort, the best thing is to write some small little projects where you need to implement a sorting algorithm and then you can find the formula for pretty much any algorithm online these days. Or I would highly recommend Introduction to Algorithms, 3rd Edition (MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_api_6l.cAbJKG1Q81 it is my top go to when people want to learn algorithms. It’s what I’ve used to teach myself as I am primarily self taught and currently getting my second bachelors in Software Engineering so I am able to pursue higher degrees in the field of Computer Science.

u/mcvoid1 · 1 pointr/Clojure

> I've never taken any CS classes and so I am lacking in my understanding of the O(n*long(n)) stuff. Do you have any good resources so I can do a little research?

The definitive guide or big-O and algorithms is referred to by us CS types as "CLR", though looking up "Big-O Notation" on wikipedia will give you a quick intro. What O(n log n) means is that you calculation is working on every item in the list (n items) on the order of log n times. The smaller the function in the big-O, the more efficient it operates as you increase the input size, such as the length of the list.

u/Log2 · 1 pointr/IWantToLearn

I'd first like to point out that actual math is usually anything but computational. You'd never get anywhere in pure math research if you tried to think computationally, as most proofs would not translate in an algorithm, since they would never reach their end in a countable amount of time (finite or not).

That being said, I'd recommend reading the book Algorithms (this is a link to a pdf, the book is free to be distributed online), by Dasgupta, Papadimitriou and Vazirani. This is considered to be one of the best introductory books to algorithms, specially for people unfamiliar with the subject.

Edit: Some other posters are saying that this is actually difficult. At some of the higher levels, it is. But the book I recommended should be more than accessible to a high school student that knows how to program. Though I'd advise staying away from classic books such as Introduction to Algorithms by Cormen for now, as books like these are much harder to read and usually require at least a minimal background with doing proofs.

u/Nixonite · 1 pointr/cscareerquestions

Oh damn, I am not a team player (although that's something I won't tell future employers) and don't appreciate group work... but still it's an education. That doesn't sound too bad although I thought servers were mainly Unix based stuff? Hmm that syllabus looks similar and I'm wondering, that math/algorithms stuff... don't you get enough knowledge from the Math 482 class (combinatorial algorithms http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844 ) ? It seems heavy on math and I'm taking it over summer 2014.

By the way, while you're here and from CSUN I want to shoot an idea and see what you think of it. So I have 12 units of electives for applied math that I can use for taking CS or other (any "appropriate" classes) and data mining requires 3 classes: intro to data structures, adv data structures, and intro to software engineering (182, 282, and 380?). That's a total of 13 units (SO CLOSE!). I emailed the adv. data structures prof asking if I can skip 182(intro data) and go straight to 282 (adv data) because I thought I knew everything. It turns out I'm quite clueless, but anyway she said to show her my portfolio and prove that I know the stuff by late June, and then she will try and give me a permission number if a spot is available.

So here's my question, should I cram cram cram and produce some work by late June to try and skip data structures and have that extra unit space, or should I just go for the easy A and figure out how to squeeze an extra unit into my course load? Because I finished an economics minor, my units are already going to be near max cap by the time I graduate. Btw, what book would you recommend for the data structures class? So far I'm looking at this http://www.amazon.com/Data-Structures-Algorithms-Java-Edition/dp/0672324539

Thanks in advance.

u/ragnar_deerslayer · 1 pointr/learnprogramming

Introduction to Algorithms seems pretty popular.

This MIT course is by one of the authors of the book above.

u/inopia · 1 pointr/europe

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.

u/borscht · 1 pointr/javascript

Are you being a dick? Or do you just have a weird way of asking genuine questions? It's not a joke, manual memory management has nothing to do with algorithms or data structures. Intro to Algorithms by Cormen is a famous book used by a lot of universities with top computer science programs and all of the examples in the book are written in a garbage-collected pseudo-language. A proper algorithms & data structures course focuses on the mathematical foundation that algorithms & data structures are built upon. Worrying about allocating and freeing memory is a distracting implementation detail that adds no value to the course.

u/hell_0n_wheel · 1 pointr/Python

All I could recommend you are the texts I picked up in college. I haven't looked for any other resources. That being said:

http://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269

This text is really only useful after learning some discrete math, but is THE book to learn algorithms:

http://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

This one wasn't given to me in college, but at my first job. Really opened my eyes to OOD & software architecture:

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

u/hyperqube12 · 1 pointr/MachineLearning

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.

u/AcademicEgo · 1 pointr/ufl

You can rent it on Amazon for $26.53 for the semester, which is way better than Chegg ($73.49).

u/PrimeFactorization · 1 pointr/opengl
u/staringhyena · 1 pointr/cscareerquestions

I suggest you read some books that focus more on the general topic, IMO they provide more information and are more understandable.

Back when I was in university the first book about A/DS I read was "Algorithms and Data Structures" by Niklaus Wirth. I've looked it up now and it's freely distributed by the author in PDF format. http://people.inf.ethz.ch/wirth/

Then I read "Data Structures and Algorithms"
by Aho, Ullman and Hopcroft https://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237

and "Introduction to Algorithms" by Cormen, Leiserson, Rivest and Stein https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

Those books overlap in many parts, but it never hurts to re-read about a subject to better understand and memorize it. The first book is smaller in volume as compared to the other two, so it might be a good start, but judge for yourself - look at the tables of contents and compare what you find more appealing.

u/rudedogg · 1 pointr/swift

I LOVE shopping online for books, so here are my recommendations:

  • Start with Grokking Algorithms. It's the most approachable book on the subject that I know off (disclaimer, I've only read a couple chapters).
  • After that, I'd try The Algorithm Design Manual. It's always highly recommended when people ask for algorithm books.
  • The de-facto book on the subject is Introduction to Algorithms. It's commonly referred to as "CLRS", after the author's last names.

    There are (in my opinion) no good Swift specific algorithm books out. The reviews for the available books are pretty bad.

    PS: Grokking Algorithms is available through https://www.safaribooksonline.com/. They have a free 10-day trial.
u/alanwj · 1 pointr/learnprogramming

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.

u/readysteadyjedi · 1 pointr/learnprogramming
u/fred11212 · 1 pointr/learnprogramming

Data Structures & Algorithms Bible

C Programming Language Bible

Can’t go wrong with either of these books.

u/Xef · 1 pointr/Portland

THANKS FOR THE ADVICE. I DROPPED OUT OF COLLEGE TO GO TO A CODING BOOTCAMP THINKING THAT WOULD GET ME A JOB, BUT IT DIDN'T WORK OUT TOO WELL. COLLEGE WAS TOO SLOW PACED FOR ME. FOR EXAMPLE, I WAS ABLE TO SKIP A FEW CLASSES AND THE FIRST CLASS THAT I HAD TO TAKE WASN'T EVEN GOING TO GET TO POINTERS UNTIL WEEK 12. SO. SLOW. I CAN CODE IN C++ AND JAVA, THOUGH I'VE ONLY BEEN WORKING IN PYTHON FOR THE PAST COUPLE OF YEARS, SO THOSE TWO LANGUAGES ARE INCREDIBLY RUSTY(BUT I HAVE EXPERIENCE WITH OTHERS: SQL, PHP, JAVASCRIPT). I'VE RECENTLY BEEN DIGGING INTO ALGORITHMS AND THE MATHEMATICS OF CS, THOUGH. I'M CURRENTLY READING THE FOLLOWING BOOKS:

  • THE ART OF COMPUTER PROGRAMMING - KNUTH
  • STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS
  • A PRACTICAL THEORY OF PROGRAMMING - CR HEHNER
  • INTRODUCTION TO ALGORITHMS
  • MATHEMATICS FOR COMPUTER SCIENCE
  • CONCRETE MATHEMATICS](https://www.amazon.com/Concrete-Mathematics-Foundation-Computer-Science/dp/0201558025) - KNUTH

    MY MATH SUCKS, SO I'VE BEEN WORKING ON TEACHING MYSELF CALCULUS AND PROBABILITY/STATS.

    HOW SHOULD I MENTION THIS STUFF ON MY RESUME? I'VE CONSIDERED COMPLETELY REMOVING THE EDUCATION PORTION FROM MY RESUME, BECAUSE ALL THAT'S THERE IS SOME PARTIAL COLLEGE THAT WASN'T WORTH ANYTHING FOR CS/PROGRAMMING AND MY WEBDEV BOOTCAMP, WHICH I GET THE IMPRESSION CAUSES MY RESUME TO GO STRAIGHT TO THE REJECTED PILE... THE WORST PART IS THAT WHAT I DO HAS VERY LITTLE TO DO WITH WEB DEVELOPMENT. I'M NOT BUILDING STATIC WEBSITES. I'M BUILDING STUFF THAT SHOULDN'T EVEN BE A WEB APP AND I ONLY DO THE BACK-END STUFF + JAVASCRIPT.

    ANYWAY, I'M GOING TO START TRYING TO FOCUS MORE ON JAVA OR C++ AND SIGN UP FOR LEETCODE AND CODERBYTE LIKE YOU SUGGEST.
u/TonySu · 0 pointsr/learnprogramming

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.

u/CorporalSpoon31 · -1 pointsr/xqcow

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)

u/BICHO_CHICKEN_ · -3 pointsr/learnprogramming

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

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844




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:


http://www.deitel.com/Books/Java/JavaHowtoProgram11e/tabid/3683/Default.aspx




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/

u/VSMNeophyte · -6 pointsr/compsci

The best book by far is the Art of Programming.

The best textbook my university used was Introduction to Algorithms for Algorithms I, and Algorithms II. If you can understand that textbook, you've learned some of the most important lessons in computer science.