Programming Praxis

I really like Advent of Code: http://adventofcode.com The problems aren't restricted to mathy things (project Euler) or really super specific algorithm or optimization problems. They are more open ended, where often times much of the problem is figuring out what kind of problem you're dealing with. The weird story arcs for each year are fun, too. More hit or miss, but also https://programmingpraxis.com

I like Programming Praxis: https://programmingpraxis.com/ There's a pretty extensive collection of problems there now, and they span a variety of topics, from basic CS stuff (e.g., implement a stack or a binary tree), to cryptography, number theory, and trivia (e.g., write a quine, calculate the date of Easter, or solve a Sudoku puzzle). Note that the chronological list of exercises isn't up to date.

You might be interested in Programming Praxis https://programmingpraxis.com/, a blog that posts a few exercises per week, with solutions. Some of them are more interesting, some of them less so.

For those who wanted to sharpen their skills in programming and wanted an exercise everyday. http://programmingpraxis.com/

It's not specifically for python, but I have found the exercises at http://programmingpraxis.com to be really good for this kind of thing (and the comments will usually contain some solutions in python).

I like Programming Praxis (http://programmingpraxis.com/), it has mostly algorithmic problems and the questions also include solutions.

Another good one for (more general) programming problems is Programming Praxis: http://programmingpraxis.com/

The website http://programmingpraxis.com has a ton of interesting puzzles.

Programming Praxis[1] is a site that has been constantly updated with these kind of exercises. [1] - http://programmingpraxis.com/

Programming Praxis has a ton of interesting problems, many from fundamental Computer Science and often with a functional bent. http://programmingpraxis.com/

There are a variety of problem-solving sites you can practice on, if that's the sort of thing you're looking for... http://codekata.pragprog.com/2007/01/code_kata_backg.html# http://projecteuler.net/ http://www.spoj.pl/tutorials/ http://programmingpraxis.com/

Programming Praxis (http://programmingpraxis.com) provides a collection of etudes, updated weekly, for the education and enjoyment of the savvy programer. Although there is some math content (the current exercise uses the chinese remainder theorem), Programming Praxis is much less math-oriented than Project Euler.

Am I the only one here who finds the dailywtf sometimes extremely depressing?! Take the stories with a huge grain of salt. Many people have complained about their stories being hugely exaggerated before being published. Alex Papadimoulis (the author of the website) has also admitted in an email that he often makes up new stories by embellishing old ones. The email used to be on the following link, but now you must ask the Programming Praxis author for a copy. http://programmingpraxis.com/2009/08/13/the-daily-wtf-maliciously-infr…

1 Pick an Interesting Language 2 Learn the Syntax 3 Pick a Problem 4 Solve the Problem 5 Goto 3 if Done 6 Goto 1 after 1--2 Years As for problems, http://rubyquiz.com/ and http://programmingpraxis.com/ are good starting resources. To learn the syntax of a language, just search for the language and the word "tutorial". Pick a site and read through the material provided. If you can't decide on a language, try: http://www.ruby-doc.org/docs/ProgrammingRuby/ http://mislav.uniqpath.com/poignant-guide/

Writing a brainfuck interpreter in a language is a good way to size it up. Unlike "hello world", it actually gives you a meaningful impression of how string handling, data structures, etc. work. It's not hard, but it's just enough to work up a sweat -- like a web-programmer writing a blogging engine or a wiki to try out a web framework. (If it is hard in the language, that should also tell you something.) See also: * Project Euler (http://projecteuler.net/), for math problems * Programming Praxis (http://programmingpraxis.com/)

I also work at Google and what mystifies me when I do interviews is just how consistently people manage to screw up even the medium difficulty questions. I used to love asking this question until it was banned: https://programmingpraxis.com/2012/01/20/knights-on-a-keypad/ This is a great question because it has several levels of solutions: 1. A recursive solution that iterates over all sequences, exponential time and logarithmic in space. Interviewing for T3 (entry level, think college grad), getting only this far in 45 minutes earns a "leaning no hire" in my book. 2. The above solution except with memoization, which reduces the runtime to linear but requires linear space. This one earns a "leaning hire" from me. 3. A dynamic programming solution that takes linear time and constant space. This one gets a "hire" to a "strong hire," depending on the elegance of the implementation and the strength of the discussion we have around it. 4. A logarithmic time solution involving adjacency matrices, matrix multiplication, and binary decomposition of numbers. I've never seen anyone get this and I only learned about it after months of asking this question. It's shocking how few candidates actually got as far as solution 1. I kinda want to open this up to the HN comments section, because this does not strike me as a brutally difficult problem, but the rate at which people fell on their faces when presented with this question suggests either something about our interview process…

Check out http://programmingpraxis.com/

May I suggest a wander through http://programmingpraxis.com/

This looks like a wheel sieve: https://programmingpraxis.com/2012/01/06/pritchards-wheel-sieve/

I used Mathematica to give the solution to Wirth's Problem (http://programmingpraxis.com/2012/12/07/wirth-problem-15-12/). Screenshot: https://dl.dropbox.com/u/315/math/problems/wirth/wirth.png Output: https://dl.dropbox.com/u/315/math/problems/wirth/wirth_output.png Notebook: https://dl.dropbox.com/u/315/math/problems/wirth/wirth.nb Mathematica code turns out to be surprisingly readable.

Currently in my RSS reader: * Coding the Wheel - http://www.codingthewheel.com/ * Good Math, Bad Math - http://scienceblogs.com/goodmath/ * Gödel’s Lost Letter and P=NP - http://rjlipton.wordpress.com/ * Polymath Programmer - http://polymathprogrammer.com/ * The Endeavor - http://www.johndcook.com/blog/ * Programming Praxis - http://programmingpraxis.com/ * Pragmatic Bookshelf News - http://www.pragprog.com/news/ * Sutter's Mill - http://herbsutter.wordpress.com/ * Schneier on Security - http://www.schneier.com/blog/

I think the difference becomes clear when you consider that a language syntax is not just source code. Raw, text source code is just the means by which humans express utilizing the syntax of the language. Once that source code file is tokenized and parsed, it's no longer tied to whatever that text was. It becomes an abstract object in memory that either represents a process (a series of machine instructions) or is fed to a process to be manipulated and processed (i.e. interpreted scripting languages). For example, this blog post walks through McCarthy's original specification for Scheme: http://programmingpraxis.com/2011/11/01/rip-john-mccarthy/ apply[fn;x;a] = [atom[fn] → [eq[fn;CAR] → caar[x]; eq[fn;CDR] → cdar[x]; eq[fn;CONS] → cons[car[x];cadr[x]]; eq[fn;ATOM] → atom[car[x]]; eq[fn;EQ] → eq[car[x];cadr[x]]; T → apply[eval[fn;a];x;a]]; eq[car[fn];LAMBDA] → eval[caddr[fn]; pairlis[cadr[fn];x;a]]; eq[car[fn];LABEL] → apply[caddr[fn];x;cons[cons[cadr[fn];caddr[fn]];a]]] This is a type of source code. Notice it even includes non-ASCII characters. But this code isn't executable as it is. It has to first be translated into a program, somehow. See the first reply at the original link, which I will not reproduce here, for brevity. It is a Scheme interpreter. The call to `evaluate` at the end of each test function is where the program gets…