Some project ideas which everyone can utilize to create demonstrative skill-proofing applications - to post them to GitHub and thus to create portfolio to be shown to potential employer.
There are many versions of games with dice. In simplest cases you just want to throw more points than your opponent. Here is a more whimsical (for implementation) version:
1 to 6) - players throw it in turns, accumulating the points;1 is thrown;1 appears
(in this case he scores nothing for the turn);100 wins the game.Example:
player1 throws: 5 3 3 (stops, +11)
player2 throws: 4 6 (stops, +10)
player1 throws: 2 5 1 (bust, +0)
player2 throws: 3 2 3 4 (stops, +12)
Here after first two turns for each side the totals are 11 versus 22.
Easy level - implement it as a console game.
Advanced level - create graphic user interface, perhaps for mobile platform.
Master level - invent some kind of computer opponent to play against.
Related problems: Dice Rolling, Double Dice Roll
Create the game to display the board and allow two users to play. Take care of re-running the game after it is over.
For reference example check the interactive game at Tic-Tac-Toe problem. The AI for the game is discussed in this problem.
Easy level - implement as a console or GUI/mobile version.
Advanced level - implement "take back" option.
Master level - add a computer opponent.
This application have two goals - at first you need to learn and implement from scratch several sorting algorithms - and
secondly you need to create some simple application which allows calling them for comparison. This "framework" should take
care of generating randomized data and then serving them to several sorts (it would be unfair to call different algorithms
on different input data). Also the input sizes should be gradually increased (e.g. 1000 elements, 3000, 10000, 30000 etc.),
time spent on each sorting measured and some resulting comparison reported. Make sure that your "framework" code do not
look like a total mess!
Easy level - make comparison of only "quadratic" sorts BubbleSort,
InsertionSort, SelectionSort.
Advanced level - implement QuickSort and MergeSort also.
Unix-like systems usually have useful small programs sort and uniq. First of them reads text lines from file (or
console) and outputs them in sorted order. The second allows to filter out unique or non-unique lines from the file.
Implement both of these utilities in your favorite language. Compare the performance with the original programs.
Advanced level - you'll need to create some random text generating tool to create larger input files. You also need
to have a tool to check the results.
Master level - make sure they work even for large files of several gigabytes (i.e. not fitting into memory) - and
do it fast enough.
Create the simple but useful web-page: let it contain the form and some script to convert temperature between Fahrenheit and Celsius scales, as described in this task
If you code in JavaScript, you can make it static web-page with client-side scripts. Otherwise you'll need some
active server to host your application (though with Python you can use JS interpreter skulpt).
Browse our web-development problems and related wiki pages if you need some introduction to web.
Advanced level for server-based variand add an API-endpoint - i.e. URL which, if called with parameters like
/index.php?celsius=60 returns response in machine-readable format (e.g. JSON) so it could be used by other
applications over the web.
Master level use sessions or local-storage to remember the recent conversions so the user can see them when
returning to your page.
This is the advanced version of Caesar's Cipher - instead of single value for
shift key we use the keyword, say, of length M. It is converted to array of M values (for example by taking
ASCII indexes of the letters) which are used as shift keys for consecutive letters. Read more at wikipedia article.
Create a console tool which gets as command-line parameters the name of file and the keyword - then encrypts or decrypts the given file.
You can use XOR operation instead of shift so that encryption and decryption are the same.
Advanced level use the keyword (or key value) to seed some kind of custom-made random number generator - and use
these values for shifts. This will effectually be the Vigenere cipher with very long key.
Master level create web-tool for encrypting files or small texts online. It would be greate if you can make it
compatible with some other tools.
Create a simple web-page which allows to throw two dice, side-by-side. See notes for Fahrenheit-and-Celsius above
about implementation. Try to make the page beautiful and probably use graphics for dice sides. If possible - add an
animation. The purpose of such page should be to allow people to make quick decisions based on fair random lots casting.
E.g. when wife and husband could not decide whether to go watch soccer or opera - they will visit your page and by clicking
Throw button the winner will be determined at once.
Related problem: Dynamic Web Page
Use one or more algorithms of data compression, e.g. Huffman to create a file tool
which allows compressing and decompressing files. E.g. you may have two utilities, call them pack and unpack or
aggregate both in one. Decide how to store additional information (e.g. huffman table). Make thorough check to be
sure that your tools work correctly. This could be a tough challenge.
Advanced level - combine algorithms. E.g. use LZW and then huffman on its results (perhaps, separately on lenghts
and indexes).
Master level - allow archiver to pack multiple files into one (and then unpack them back properly). This will require
inventing some internal structure of archive file. Allowing to store directories would be extremely great.
Create the game of exploring randomly generated maze. Inventing an algorithm for maze generation is up to you - this is an interesting challenge itself. The game screen should show the small portion of the maze (e.g. current cell and few adjacent ones) and an icon of the hero traversing the maze. User should give directions (by pressing keys or entering commands) where to go, after which the screen is redrawn.
The goal could be, for example, to find randomly placed chest of gold. You can implement additional features - like leaving inscriptions in the cells (to help user recollecting where he already was). The Maze of the Wumpus may give you additional ideas on placing some invisible monsters in the game.
It is worth to allow user to enter random seed so that he can replay the same maze more than once.
Advanced level implement it as GUI / mobile / web-page. Provide means to store and load the game state.
The game is single-player. The computer shuffles the deck, then gives 5 cards to user. User marks the cards which should be exchanged. This is repeated, say, twice. The goal is to collect anything better than 1 pair.
Variant - implement BlackJack game instead, its logic may be somewhat simpler.
Master level - implement computer opponent to allow playing against it.
Related problems: Cards Shuffling, Yacht or Dice Poker
Implement Conway's Game of Life. Preferably use some graphics rendering. Study the Hard Life puzzle to come up with some fast processing algorithm. Your game should preferably use infinite (or almost infinite) field, not limited to small matrix. Try to use some GUI library or create mobile/web version.
Advanced level - add functions to load and store configurations - it would be good if configuration could be loaded into the user selected place - and also features like flipping or rotating selected fragments of the field.