We are pleased to announce a contest for students in the pioneering cs101 class!
The goal of this contest is to build on the ideas in the CS101 class in a creative way. The contest is open to all students enrolled in Udacity’s CS101 Course. You can do anything you want, so long as it is legal and tasteful (please see the full contest rules for details).
To enter the contest, post an answer here containing a first line, Submission, followed by:
All the material you submit for the contest must be released under a Creative Commons CC BY-NC-SA license. Contest submissions must be posted by 23:59 UTC on Friday 20 April 2012 to be eligible for the contest.
Note added 9 April: Gabriel Weinberg, creator or DuckDuckGo will be one of the judges for the contest!
Note added 11 May: The winners are now announced! Congratulations to everyone who participated in the contest.
I am a portuguese guy that loves cooking. I love to cook different dishes to please my family and friends.
The site structure is very handy if one has already an idea of what one wants to cook. However, for an inexperienced cook like me, it would certainly be more useful to know which dishes can be cooked from a set of ingredients. Moreover, the dish names do not contain explicit information about the ingredients they contain. If you have, for instance a certain fish ("peixe") in your house, by checking the recipe names, you may not know that you can make a dish called "Caldeirada à Algarvia". Besides that, a search by ingredients can be really useful when a person is diabetic or allergic to some food (such as chocolate)!
Being this course about search engines, I decided to make myself a recipe search engine. My world wide web is the "gastromias" website, and my websites are the recipe descriptions. My recipe search engine, entitled "reciPY" (recipe + python [.py]), allows to search recipes by ingredients and by dish names. Besides that, my search engine allows to discriminate the ingredients I don't want in my search results. If a person is allergic to chocolate, she simply needs to specify that in the search query!
< Recipe Name / Ingredients > : Bacalhau com Natas, Cebola, Azeite
The user may not need to insert commas between the ingredient names. If there is more than one ingredient, the search engine will lookup all the recipes that include each of them. For this query in particular, the results will include:
1: recipes containing all four ingredients
(1 has the larger priority)
( page 1 of 20)
 salada de bacalhau com feijao frade
The user can simply specify the id (inside brackets) of the recipe she wants to check, and press enter.
Well... Thats it! If you want to check the awesome user-friendly interface I made, please check this screenshot: http://dl.dropbox.com/u/7923799/reciPY.png.
The code is here: https://github.com/Amarals/reciPY
NOTE: I use an external function to convert diacritics. The credits are in the "external.py".
NOTE_v2: I forgot to mention that, in order to make the interface more user-friendly, i used some unix commands, such as "clear". If you try to use reciPY on Windows, please change those commands :)
The entire code was made by me, Amarals (firstname.lastname@example.org).
Have yourself a good meal :)
I've always been intrigued by the power of the internet, particularly when programs can talk with each other. I've seen many companies advertising APIs but I've never quite been able to figure out how they work, or how to utilize them. This class helped me understand data structures like lists and dictionaries and things like web requests just enough that I decided to try to build something using an API.
Aside from the multimedia and real-time data, modern online newspapers look about the same as the paper ones did 100 years ago. There is way too much information out there for any one person to read, and personalization algorithms sometimes make it hard to be exposed to new and interesting pieces of news. I decided to experiment with a different way to find articles to read.
I created a program that automatically creates what I will call a "news story". It starts by requesting the most recent 10 articles published to the New York Times website. The program randomly selects one of those ten, and then selects one of the words in the title to search the New York Times archives (back to 1984 I believe) for another article (randomly selecting one of the first few articles returned for that keyword), and then selecting a word from this second article title, and so on. The result is ten usually unrelated headlines that sound like they go together because they use some of the same words. It is really interesting to read the headlines and make connections that otherwise wouldn't be there (usually these stories wouldn't end up in the same section of a newspaper). In reality, everything is connected. It is also fun that the "news story" is different every time because of the frequency of the updates from the New York Times and the random element in each article selection (which then affects the search keywords).
The python code can be accessed here:
However, I've removed my private API key issued by the New York Times so that code won't run in your interpreter unless you go to developer.nytimes.com and request keys for the Times NewsWire API and the Article Search API. Knowing that would be a pain for you to do, I was able to read some tutorials on Twitter's Bootstrap and Google App Engine and apply what little I've learned so far about computer science to create a web app that uses the procedures I wrote to generate a "news story" complete with links to the accompanying articles. That can be found here:
(The "news stories" are best read out loud.)
Just me on this one, though will look forward to collaborating with others in the future.
Thanks, Dave and Peter and all at Udacity! This course was great and I learned a lot. I've recommended it to at least 3 people who are planning to take it this next hexemester. I look forward to developing my developer skills through future courses. Cheers!
To be more effective, don't think about the winning bit, see how you can apply whatever we've learnt to SOLVE A REAL WORLD PROBLEM. Let winning come secondary, so that you won't be surprised if you don't win :-) But at the end of the day, you have your usable product... I hope we'll bring the GitHub servers down by 20th April, due to the traffic :-D All the best!
Uspicious is a search engine for python code. In a large project using many files, you might have a procedure you wish to use but not remember the exact order of the arguments. Uspicious indexes all defined procedures in all .py files in the seed directory and the whole underlying tree. When you search for the procedure name, you get the names of all of the files that contain procedures with that name. Furthermore, for each one you also get all of the text from 'def' to ':', so that you can see the order for the parameters; think of this as akin to the context provided when you do a search on any big search engine.
Comments are also indexed. You can search for a string and find all of the files that contain that word in a comment plus the comments themselves containing that word, as the context. However, it's often the case that comments have uncertain punctuation or spacing so that you might not be able to find what you want. Therefore, Uspicious also provides the ability to search for fragments of keys, providing the same results as above for all keys which contain the fragment as a substring, case-insensitive. This ability to look for fragments is also available for procedures.
There is also a recursively defined procedure for printing the returned results in a more readable way than as a python list of strings or a dictionary.
The README file in the github repository contains some results from running the code on the directory containing its own source code. This demonstrates how to use the features.
Code Uspicious on github
Project Name: Monitor Web
Did you came across a website in which you were really interested, and wanted to check for any updates, or maybe you are interested in getting updates if the documentation of your favorite library or code repository was updated, If the answer is yes, Monitor-Web is your one stop solution, Monitor-Web tracks any changes in your favorite content and alerts you with proper log of differences. So, now never waste time surfing the web to check if there are any updates, Simply add the website you wish to monitor and relax, Whenever you need to check simply run the program and it will automatically sync for any changes or are provide you with a diff like output. It works best for static websites, mainly online HTML ebooks, online documentation, course lists, wiki's or something similar.
The project uses each and every skill/aspect which i learnt in this 7 week class and I have tried to apply what we were taught in a creative way. The project is totally dedicated to The Udacity Team (Prof. Evans, Dr Thrun, Mr.Chapman [Thanks for answering my stupid questions] and others.), Greetings to fellow Udacians.
Aneesh Dogra (lionaneesh-at-gmail-dot-com) @Aneesh Dogra
The main point of my submission was to enhance the search results,
What has been done:
To initialise the webcrawler:
My submission can be run in two modes:
In the webserver mode you can use your browser for searching
Once the crawler has begun it traverses only up to the limit specified by 'max_urls',
If running in standalone mode, the criteria will be applied against the crawled urls,
The results will be listed in sections giving the full range of search results:
If running in webserver mode, the browser can be directed to the url given in the python console.
From here you can choose which search mode to operate, and modify your criteria many times,
I'm curious about whether we are expected to stick with concepts and syntax we have learned in CS101 for this project. From the forums, it is quite evident that there are several folks here who are already quite well versed in Python and some of the advanced syntax/functionality. Is there any sort of leveling of the playing field as far as judging the entries go, or are folks who are more well versed with programming and Python going to be at a big advantage?
===== PURPOSE =====
This simple program helps you learn English through this great game called Draw Something by finding all possible words in an anagram with the given characters and it also prints a definition and a translation in the wanted language of all the possible solutions
===== BACKGROUND =====
I love gaming, a month ago I started playing this awesome game called Draw Something which is about drawing and guessing what another user has drawn for us (more information here: http://itunes.apple.com/us/app/draw-something-by-omgpop/id488627858?mt=8 it's just 1 dollar in case you want to buy it :D) by using the given letters which are at most 12 and selecting wisely some of them (at most 8) to guess what the other player has drawn for us. My little sister who watched me playing it started to cry because she wanted to play but she doesn't know English (Spanish is our native language here in Bolivia :P) so I decided to make a simple program so she could play Draw Something.
===== SOLUTION =====
FIRST PART: Solve the anagram
The game gives you 12 letters, to guess the friend's drawn you're also given the length of the guess which is at most 8 letters. First I wanted to know how many words with the given length I could make, it turns out that the number of words is proporcional to the length of the word so if the length is 5 then the number of words is 12 * 11 * 10 * 9 * 8 considering that in the first spot one character of twelve left can be used and in the next spot one character of 11 left can be used (one character has already been used in the previous spot) so I guessed this formula to find the total number of words [number_words = factorial(12) / factorial(12 - desired_length + 1)], in the worst case it gives around 19958400 possible words (generating all the words takes some time) but we also have to check how many of this words are valid in English (there may be cases like aaaaaa which is not a valid English word) so we also need to have a python dictionary with most of the english words to check if a generated word is in the dictionary, however doing this took me a looot of time (in the worst case took like 20 minutes to solve the anagram :O).
I needed another approach to solve this problem and after some googling I found about this data structure called Trie which saves a dictionary and looks if a word is in the dictionary pretty fast and also it helped me avoid going through further branchs in the Trie!!! so if a word started like "azq" (we know that there's no word starting like this) then instead of going further making words with this prefix we simply erase the last character and start checking with the next character available :D
The first step is to create the dictionary, with some google searches I found that Ubuntu holds it's own dictionary at
SECOND PART: Analyzing the data
Solving the anagram could provide a possible answer for the game however this can't help us to learn english :[, so the next thing I did was to browse over the internet (using python of course) and look for a definition for the current possible answer so that my sister could also look the definition of the word (in english) in case she didn't know what was the meaning of the word and I also printed the translation of the possible word in spanish so she could learn both the definition of the word and it's translation in english :D, then I expanded the translation to most given languages.
The second step is to grab the user input: the "scrabbled" characters, the wanted length and the language of the translation, then we try to find all the possible permutations of the word and for those valid we make some queries in the page http://oxforddictionaries.com/definition/ to get the correct definition and also a query in the page http://translate.reference.com/ to get the translation of the possible answer in the provided language
===== HOW TO USE IT =====
Just run the script: scrabble_find.py and provide the required inputs, the outputs are:
===== REPOSITORY =====
===== UDACITY ID =====
maurizzzio - email@example.com
I started this course to learn how to build a search engine, so that's what I did. I made some heavy modifications to the crawler and incorporated multi-term search capabilities. I also built a text UI for the console to actually allow for searches. The full code, along with a pretty in-depth comment/markup can be found here.
I made the following modifications:
Project: Extended search engine, and a tutorial: searching the right way
Incentives to make this little application:
When I first read about this contest, I really felt obliged to participate: I learned a lot from this course, and I would love to show what I've learned to the Udacity staff and my fellow Udacians, so I started thinking and brainstorming. I thought about the biggest, most ridiculous applications that I could make, but most of them had nothing to do with what we learned. That's when I started thinking: why make something extra? Why not just extend it, and why not just make sure everyone can use a search engine?
That was the moment when the idea popped in my head: make a tutorial for using a search engine! Of course everyone can use a search engine. It's the same as playing table tennis: a lot of people have a table at home, and they can play table tennis. But can they?
I constantly read on forums that people can't find information about a certain subject. I then suggest them to go search for it on Google or any other search engine, and they then claim they already did! After 1 simple search query, I found everything he needed.
There are tons of features a search engine supports that nobody uses. Simple symbols that would make your search so much more better and efficient, but people simply don't know about them. With my program, I would like to change this.
This would mainly be used for kids starting to use the internet and search engines, but even adults could profit from this application. It is clearly not designed for IT people, or kids/adults skilled in the Computer Science.
My ultimate goal for this project:
See the idea (not my application, it's too small and too limited due to my skills and the given time frame) being used by the big search engines like Google and Yahoo, to make the internet and search world an easier, less frustrating place
What I actually made:
I extended the current search engine we had to make for multiple queries, so that it was able to read in a query, parse it into the right format, and give back the correct url(s).
I extended that, so that also random order of words were allowed.
About the use of an interface: I am sort of convinced that I would've been able to make it fancier, by the use of a graphical package, but the goal of this project is to show what Udacity learned you, and therefore I decided not to do the research.
Everything I did in my project was learned through Udacity courses. The only thing I did "lookup" (kinda knew it from courses)
Some extra information can be found in the README, I suggest you go read it
I was the only person who worked on this project. I figured I'd do it on my own, since it's more the idea than the application itself that I would like to submit
Udacity CS101 Profile link - ID 2728), E-MAIL: firstname.lastname@example.org
Link to code:
My code can be found in my github repository
PS: A friend of mine was so kind to lend me some hosting space on his website: