What is Reddit's opinion of
Topcoder?
From 3.5 billion Reddit comments
➔ Topcoder website
By popularity on Reddit, this Service is:
56 reviews of this app found across Reddit:
Why is topcoder so difficult to navigate? Is this site only for live competitions? Are there no practice questions? The only place I can find actual questions is here, and these seem to be bounty type / long term projects - nothing short enough to be interview material.
I keep hearing great things about topcoder, but I cant for the life of me figure out how to use it. Am I missing something?
The problems are interesting and are great for those with an interest in math and number theory for sure. If your goal is to ace a software engineering interview however, you'd probably be better off looking at problems on sites like https://leetcode.com/ or https://www.topcoder.com/
GrabCAD has been running competitions where companies can set up problems for the community to solve for prize money. ULA currently has one running: https://grabcad.com/challenges
NASA had a more complicated one where an actual subsystem was to be designed: https://grabcad.com/challenges/nasa-experiment-attachment-system-eas-challenge
There are software versions of this like Topcoder where there are many more challenges offered. https://www.topcoder.com/challenges/
From my experience I can say that Hash-map, Tree (BST) are most asked question's. They don't ask how will you do a binary search or implement linked list. You can also practice coding question's on leetcode. You will find most of the interview questions asked over there. Tip: You can follow and try challenges on codechef or topcoder for improving your coding skills. But the questions over there are way to tough to ask in interviews.
Almost always it refers to the technique of bitmasking, which basically allows you to combine a lot of different information into a single int/long.
An introduction: https://www.topcoder.com/community/data-science/data-science-tutorials/a-bit-of-fun-fun-with-bits/
The value of a university education derives mainly from the fact that you're put together with smart peers and smart mentors to form a community that will take you out of your comfort zone to undertake challenges that you wouldn't necessarily take on otherwise.
A degree merely shows that you're up to the challenge. But along the way you'll make friendships and acquire insights and timeless problem solving skills that are difficult to acquire at home in your jammies.
If all you want is a job grinding out routine software, by all means seek vocational training elsewhere.
And there are other communities that can take you out of your comfort zone, no matter how good you think you are; e.g.,
https://www.topcoder.com/community/competitive-programming/
But these communities tend to lack the breadth and depth of social interaction that you'll get as a member of the university community.
> Je suis curieux: quel est l’intérêt qu'a Xavier Niel à faire ça ? C'est moins évident qu'en France
Ce n'est qu'une intuition personnelle, mais je pense que l'idée derrière tout ça est de saturer le marché du travail dans l'informatique avec des pisseurs de code afin de pouvoir diminuer les salaires proposés aux ingénieurs en informatique qui coutent relativement cher et pour globaliser le "spec work" dans tout les domaines de l'informatique comme on peut déjà trouver sur des sites comme topcoder.
Yeah, they offer also dev challenges where I participate to learn. When we good there is opportunity to grow/get to remote gig in big tech company. Gigs list is large with various offers https://www.topcoder.com/gigs?referralId=syr0ow, check it out.
I suggest improving your algorithm skills by practicing on old topcoder and codeforces matches. Once you feel like you're able to solve at least one problem within the allotted time for a match, join in on the live matches. That was very helpful for me back in my undergrad days.
Introduction to Algorithms book it's a really good resource but I use it later during college, I actually started with topcoder tutorials while also practicing solving problems in the same site, tutorials are still relevant but for practicing I recommend codeforces.
I would try the Topcoder Archive http://community.topcoder.com/tc?module=ProblemArchive
Here is someone's blog post about their favourites.
I literally could not stop thinking about the knight's dialer problem for two weeks when I learned about the constant-time solution.
I would say the questions I was asked were on the easy-medium scale. To prepare, I bought Leetcode Premium and tackled the problems that are tagged with Google and sorted them by frequency. For algorithms, I'd recommend reading Introduction to Algorithms (the one by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein) if you have the time. Also, I've used these links to help me as well.
http://infotechgems.blogspot.com/2011/11/java-collections-performance-time.html?m=1 https://www.topcoder.com/blog/learning-understanding-big-o-notation/
>Like who?
https://duckduckgo.com/?q=software+bounty+programs&t=ffab&ia=web
I don't mean other "crypto" bounty providers. What I'm wondering is why a business would move their resources away from established bounty programs over to BNTY - what's the value prop for them to do so?
Did you touch on dynamic programming? Understanding that made it conceptually a lot simpler for you.
What it boils down to that Hanoi, like other DP problems, is a matter of breaking down the problem into the simplest version of itself (the smallest tower) and that larger problems (towers) are just a composition of the smallest one.
Esse evento em específico é mais voltado para o público estudante mesmo, mas existem maratonas de programação para o público geral (normalmente profissionais mesmo, já que estas tendem a ser mais avançadas), inclusive estas últimas têm prêmios muito melhores.
Dê uma olhada no TopCoder. Aqui uma descrição mais sucinta do que eu poderia fazer, direto da Wikipedia BR:
> O TopCoder é uma empresa que administra competições de programação. Ele hospeda quinzenalmente competições de algoritmos online, conhecidas como SRMs (Single Round Matches), assim como competições semanais em design e desenvolvimento. O trabalho em design e desenvolvimento produz softwares úteis que são licenciados para lucro pelo TopCoder. Os competidores envolvidos na criação desses componentes recebem royalties baseados nessas vendas. Os programas resultantes das competições de algoritmos e dos menos frequentes marathon matches não costumam ser reaproveitáveis, mas patrocinadores esporadicamente fornecem dinheiro para pagar os vencedores.
u/GHansard gives good advice. For my money (and from his suggestions) it sounds like a Trie-like data structure could solve the problem well, while avoiding the cost of adding and learning any new dependencies.
For general Trie info see: https://www.topcoder.com/community/data-science/data-science-tutorials/using-tries/
Here's how the Trie approach can be related to two of the requirements you outlined:
Requirement 1: Filtering based on search-term input. A critical question is whether this needs to match only the beginning of a string, or any part of the string? If it's the former case, then the problem is a lot simpler: we can traverse the Trie following the character sequence, and use the sub-tree from that point as the one to present in the TableView.
Requirement 2: Loading the search-result strings as table rows. If we maintain a count of the number of leaf nodes below each node (at trie build time), this allows us to efficiently seek the path in the trie and any sub-trie for any given index.
I'd be happy to do an example implementation; but if the search is only useful to you if it matches arbitrary parts of each string, that would we wasted time and we'd have to consider a more complex solution instead.
This discusses exactly the problem that you have (with the constraint that you can choose any number multiple times) - https://www.topcoder.com/community/data-science/data-science-tutorials/dynamic-programming-from-novice-to-advanced/
EDIT: check the first section and try and implement a solution! If you run into issues, you can post your code here and someone will definitely help you out! :-)
The reason this hasn't been upvoted is because (while OP didn't make it clear at all), what's being asked about is to do with e.g. this: https://www.topcoder.com/tc?module=Static&d1=features&d2=010408
What the university teaches is normally not the practical world needs. You need to learn to solve real world problems. The best way to do it is to find people with needs and try to find a solution for them. There are communities online where you can get paid while doing that. But do it for the learning if you're still in University. Check - https://www.topcoder.com - https://www.upwork.com/
Over there, search for the smallest projects and start from basic scripting and coding requests. Then take bigger challenges as you learn more and feel more confident. If you start with big projects, you will only frustrate yourself and it will take ages.
The web is the next big thing, so learn stuff like Ruby and Rails, HTML5 and CSS3.
I'm not sure, I was speaking of O(1) for the update method. Best I've seen is getting the time complexity down to O(log(m) * log(n)) using a binary indexed tree.
More info here: https://www.topcoder.com/community/data-science/data-science-tutorials/binary-indexed-trees/
They cover 2D BIT's at the bottom of the article.
IMO don't expect that you will learn anything useful at university (public ones not sure about private), except maybe the titles of the subjects that you are going to study, that is the only thing that I found useful during my CS studies.
Most of the knowledge you will gain through out your lifetime will be self taught, so prepare yourself for that.
If you have time maybe you can develop your problem-solving skills during your bachelor years by solving problems at topcoder.
Finally, Try to participate in open source project as that will give you an insane amount of experience and one of the best ways to get acknowledged globally between your peers.
Here are some good resources:
- Topcoder Algorithm Tutorials
- UC Berkeley Data Structures Course
- Algorithms 5th Edition Book
To further this point, people have a certain expectation about what's going to happen to them on a given day. Any events outside that expectation have varying degrees of "hmm that was odd" assigned to it. What confirmation bias does is say "ok, the more of an outlier an event is, the more God had a hand in it." Which is fallacious on many accounts.
Here's a graphical representation using the normal distribution (bell curve).
Here are a few online competitive programming websites to get you started (they may be quite hard for a HS student though)
Your code is nearly corrext, except you should probably print n1 in the end. At the moment, your algorithm will always print 0 (your while loop says so). You should also consider printing endl or "\n" at the end.
You can find a very beautiful GCD implementation (and other tutorials) here.
O resursă utilă pentru programare dinamică: https://www.topcoder.com/thrive/articles/Dynamic%20Programming:%20From%20Novice%20to%20Advanced. Un articol cu ceva tehnici mai avansate: https://infoarena.ro/pd. Tot pe infoarena ar trebui să găsești probleme cu care să te pregătești. Mult succes
>Also can you explain what you mean by a "correct conversion?"
I find it quite amazing this needs to be written here...
In computing, whole numbers are tylically represented in "base 2" while fractional, using a sign, mantissa and exponent.
Maybe this isn't too bad as one explanation (quickly googled, just skimmed it)
You have to be careful to be very clear about exactly what you are trying achieve here. Learn C++? Learn CP? Learn enough C++ for CP?
If you're trying to learn C++ itself, then those two books should be a decent start. If you're trying to learn CP, you'll need to get good with Data Structures and Algorithms and then practise a lot. If you're trying to learn enough C++ for CP, then note that it's a very very tiny subset of C++ - just the basics + the STL - if you can understand https://www.topcoder.com/thrive/articles/Power%20up%20C++%20with%20the%20Standard%20Template%20Library%20Part%20One and https://www.topcoder.com/thrive/articles/Power%20up%20C++%20with%20the%20Standard%20Template%20Library%20Part%20Two:%20Advanced%20Uses then you're good to go and can focus on algorithmics and practising problems along with doing contests.
Back in 2009 topcoder.com ran a competition to crack an enigma machine without knowledge of the wiring.
Unfortunately there isn't much information on their website about it but here is the press release https://www.topcoder.com/tc?module=Static&d1=pressroom&d2=pr_122209.
And this is a copy of the problem statement http://topcoder.bgcoder.com/print.php?id=2533.
It is one of the hardest problems ever on topcoder.
IIRC it was solvable if you had enough long messages and knew the language of the plaintext and had some decoded messages to build from.
You can use the past competition programs posted on websites like Codeforces or Topcoder. They are generally meant to be solved in less then a half hour or so and make for fantastic daily practice.
Since you can already figure out the recursive solution, the next step is to do memoization. The chapter about DP in CLRS is very helpful for this.
After solving it with top down (memoization), try using the bottom-up method with array and tables for the problem.
I would also these problems mentioned in these:
This is a little harder:
I don't see any practical applications in this thread yet, so here it goes. It's pretty technical and only slightly more real-world applicable, but I've used this in topcoder-style programming contests.
In the link-cut tree data structure, a tree is decomposed into paths, and each of these paths are stored in a binary tree. The key in the binary tree is the nodes position on the path, so inverting one of these trees means flipping the path upside down. And because the 'flip' state of a subtree can be stored as a single bit on each node, we can flip a tree in O*(1) by lazily propagating the state.
Now, another neat property of a link-cut tree is that you can dynamically shuffle the tree so that you may define any path-to-root subtree in O*(lg n). Using these properties together, we can now do something special.
Choose a non-root-node in the tree, X, and isolate the path-to-root subtree between X and the root. Now flip this subtree. Since 'X' was the 'end' of the path before, it now becomes the root, and we've made X the root of the overall tree.
We now have a tree data structure that we can dynamically re-root in O*(lg n) time, along with all of the other fancy operations we could do with a link-cut tree. In the real world, this could be useful if you wanted to add efficient cycle detection to a dynamically changing tree (when adding an X-Y edge, reroot to Y, find the path from X to root, if Y is the root of that path-to-root subtree then X-Y would create a cycle).
For more details on how a link-cut tree works, I'd recommend watching this lecture.
For learning DS and Algo leetcode is not sufficient as it provides direct interview questions, which most of the time require tricky and weird logic. I like topcoder Algorithm toturial (https://www.topcoder.com/community/competitive-programming/tutorials/) for learning new topics and for practice both topcoder and codeforces has good problems
Topcoder allows you to work freelance. I've never used it so can't give any useful opinion but it might be a starting point e.g. google Topcode vs xxx and see what you find.
https://www.topcoder.com/challenges ?
What kind of algorithms do you need for CRUD/UI apps? Your goal is to remember millions of API calls, hundred frameworks to complete tasks in minutes and do not invent anything.
Making idiomatic framework/platform code you archive generic / reusable / scalable software (as platform designer take care of it as long as you don't push beyond platform/framework idelogy).
This isn't some random rating system I came up with. It's based on the Elo rating system: Elo Rating System (Wikipedia)
Particulary, the following algorithm is adopted given there are 2+ players in a match: Algorithm (Topcoder)
It can't just be simply changed without it drifting to infinite. However, maybe you have some suggestion how the algorithm could be changed to make sure ratings fall between a (0, 3000) range?
I recommend taking a look at the first approach on this site: https://www.topcoder.com/generating-permutations
Once you understand the essence of the algorithm, then you can think about how to implement it with a recursive function.
You'll have to understand a bit of the math behind combinatorics to modify the algorithm to generate 5 card permutations from a 7 card hand.
There is no simple explanation I can give you that would enable you to just knock out the code. You're getting into some complex stuff, and it will require some digging on your part. But of course you can come back and ask more specific questions as you work through this.
Good luck!
https://www.topcoder.com/community/competitive-programming/tutorials/line-sweep-algorithms/
I think this is what you'd want to use if you had a large number of line segments. I started implementing it for puzzle 3 but the code was pretty obtuse
I used to do Topcoder - it's the SRMs you're looking for, not the challenges - but I have no idea if they're still good, it's been well over a decade since I touched it. Codeathons and hackathons aren't really the kind of competitive programming I'm talking about here, this was literally "solve problems as fast as possible for money".
Depends on depth you want to go into, I would recommend book (like Introduction to Algorithms is a book on computer programming by Thomas H. Cormen) if you want to go in deep.
Or topcoder tutorials https://www.topcoder.com/community/competitive-programming/tutorials/ if you want to speed it up.
I hung out on TopCoder for a while, looking for challenges that matched what I was interested in: https://www.topcoder.com/challenges. I learned a lot about how to move quickly and efficiently.
For learning new things, I found a couple well-written projects on GitHub that interested me and used what I didn't quite grasp to research the underlying concepts of what they were doing.
But I should say, I wish to do anything but GUI.
Good competitive coding has two steps: building a library of algos, and learning when to use them. Start with easy problems as /u/eytireyup mentioned. Find commonalities between them. Maybe build functions you commonly use for trigonometry, prime number calculation (Sieve of Eratosthenes), or for shortest path (Dijkstra's algorithm). Get comfortable with when you need to use dynamic programming or memoization. Search these things on Wikipedia -- they'll lead you to other interesting algorithms for your toolbox. Look at how your chosen language implements common functions (sort, string splitting, etc). And when all else fails, check out https://www.topcoder.com/blog/github-repositories-with-competitive-programming-libraries/. :)
Depends on your skill.
You need to win 1st or 2nd to get paid.
Here's the list of active challenges https://www.topcoder.com/challenges?tab=details
There is. You need to think in terms of invariants. Here is the article where I learned this approach (like a decade ago 😅): https://www.topcoder.com/community/competitive-programming/tutorials/binary-search
I'm not sure. But how do you check if a square is inside another square? Maybe you should extrapolate your algorithm to – instead – be: "is one of my square's lines between 2 of these 4 lines?" For a triangle is would be: "is one of my square's lines between 2 of these 3 lines?"
You check this by Linear Algebra: https://www.topcoder.com/community/competitive-programming/tutorials/geometry-concepts-line-intersection-and-its-applications/
​
I'm actually quite proud of myself for coming up with the idea (I've never implemented graphics like this before). The important part is the last section of the Line-Line intersection:
>This gives you the location of the intersection of two lines, but what if you have line segments, not lines. In this case, you need to make sure that the point you found is on both of the line segments. If your line segment goes from (x1,y1) to (x2,y2), then to check if (x,y) is on that segment, you just need to check that min(x1,x2) ≤ x ≤ max(x1,x2), and do the same thing for y. You must be careful about double precision issues though. If your point is right on the edge of the segment, or if the segment is horizontal or vertical, a simple comparison might be problematic. In these cases, you can either do your comparisons with some tolerance, or else use a fraction class.
In linear algebra, it's trivial to find if two lines intersect. However, that assumes lines and not rays.
/u/hiyahiya123, focus on problem solving aspect so you can solve variations of the problems and develop problem solving strategies.
See https://www.topcoder.com/community/data-science/data-science-tutorials/how-to-find-a-solution/
See http://www.comp.nus.edu.sg/~stevenha/myteaching/competitive_programming/cp1.pdf (used this as a resource to help me qualify for usaco gold but it should extend to interview types of questions)
Possibly, but even so I only managed to get the 4 tests to run in maybe 0.7s after switching to the 2.7 runtime and using some other optimizations with ord() instead of using str() and just using for-loops as recursions didn't want to keep below 2.7s
Which is an issue since I'd have to be below 0.1s per test at the most to go through 111 unless I want to time out at 12s
Another issue with this exercise is if you change one of the test cases to deal with 15 digit numbers, the runtime runs outta memory (not that the C library behind it is able to handle an int that large anyways, IIRC) so the exercise is probably un-doable.
>For some reason I just can't wrap my head around recursion so I guess that's something to focus on studying.
I just skimmed through this thing, but it looks good enough and the syntax/language used is close enough to Python that it shouldn't be an issue applying it real quick
Here's a helpful article: https://www.topcoder.com/community/data-science/data-science-tutorials/basics-of-combinatorics/
According to the math concepts presented in this article the number of possible Blind Pick games, (where order doesn't matter and repetition is allowed), is: (134+10-1)!/10!*(n-1)! 7.1416806520e+14 or 7,141,68l,065,207,883
While the number of Draft Pick games, (where order is not important but repetition is NOT allowed), is: 126!/10!*(128-10)! 2.2684615418e+14 or 226,846,154,180,800
This number is smaller than first expected partly because you have 6 less champions to chose from after the Ban phase....
Combinatorics was one of my favorite Math classes.... Hope this helped... Benramz
I mostly mean without referencing materials that describe the algorithm.
Looking up the TreeMap docs in Java is different than looking at a blog post where someone describes how quicksort works and following their code.
Even the standard docs are something you will find yourself looking at less often with enough practice. I used to compete on Topcoder and in other similar competitions all the time (https://www.topcoder.com/members/joncalhoun/details/?track=DATA_SCIENCE&subTrack=SRM) and as I got better I rarely had to look at standard docs because I was familiar with all the standard libraries I was likely to use.
You have to use a disjoint-sets data structure. At first, use the roads that are ok and merge all the cities connected by them in connected components (you can do so very easily using your data structure).
After you've done that, you have created a forest of disjoint trees. You must connect them all, using the remaining edges with minimum cost possible. Consider each tree to be a super node, if you do so, your problem has transformed into MST, you have some disjoint nodes and some edges connecting them with some cost, you must connect them in one component with while keeping the sum of the weights to a minimum. You can easily do so with DSU.
You can read more about the MST problem and possible algorithms as well in the following links:
https://en.wikipedia.org/wiki/Minimum_spanning_tree https://www.topcoder.com/community/data-science/data-science-tutorials/disjoint-set-data-structures/ https://en.wikipedia.org/wiki/Kruskal%27s_algorithm
At least for the C programming get the K&R C book. For coding problems I recommend this subreddit and project euler and topcoder's previous srm archive
As for linux just install a Virtual Machine and I would recommend installing the linux distro Ubuntu. There's plenty of tutorials on the internet.
First, forget about python for a time being. It's just a way of writing the algorithm down. Google for dynamic programming, dynamic programming on profile, broken-profile dynamic programming. Some links which may help:
http://sk765.blogspot.fi/2012/02/dynamic-programming-with-profile.html
https://en.wikipedia.org/wiki/Dynamic_programming
It's quite a broad topic.
Leetcode has a classification on the site. Look at the right sidebar next to the list of questions.
The sidebars go contribute, sessions, top 10, companies, tags. You want to look at the tags.
EDIT: Also the TopCoder problem archive labels problems by type:
https://www.topcoder.com/tc?module=ProblemArchive
Have you taken a look at Top Coder? It might be a good way to get some practical experience + make some side income: https://www.topcoder.com/
I did an internship in college with a guy whose dad was a long-haul truck driver. He and his dad were some cool, down-to-earth folks. Good luck!
Times have probably moved on since I was doing these, but I used the Topcoder Arena (Challenges -> Arena from the menu). Lots of automatically marked, timed puzzles in there, solvable in a variety of languages, including Java.
I quite like Project Euler for more mathematical puzzles too.