This problem is actually easy. Once you fully understand what the problem want, you can quickly write a program to solve it. This what I did:

1. Store the values to an array (to compare the value with the next item, and so on)
2. You start from I=0 (first array index)
3. If itemI=itemI+1 then increment NEUTRALVALUE
4. If itemI<itemI+1 then increment TOTALUP
5. If itemI>itemI+1 then increment TOTALDOWN
6. If the first deviation is UP -> add NEUTRALVALUE to TOTALUP
7. If the first deviation is DOWN -> add NEUTRALVALUE to TOTALDOWN
8. If there is a deviation change (DOWNWARDS to UPWARDS), inc TOTALUPSEQUENCES
9. If there is a deviation change (UPWARDS to DOWNWARDS), inc TOTALDOWNSEQUENCES
10. Go back to (2) until I>Total array elements
11. Print out the result (Total array elements, TOTALUP / TOTALUPSEQUENCES, TOTALDOWN / TOTALDOWNSEQUENCES)

Common Mistake:
1. Incorrect flagging (You must set flag to UP or DOWN !!!)
2. If TotalUpSequences=0 or TotalDownSequences=0, change their values to 1 or you’ll get DIVISION BY ZERO

414 - Machined Surfaces

Straightforward... just simulate the process, count the number of blanks after that.

416 - LED Test

This problem seems confusing at first... but it's just a simulation problem..., try all the possibility, that is, try if you can get a possibly valid 'countdown' sequence. Don't forget that if a segment is burnt, then this segment will still unusable for subsequent checks!!! My suggestion for solving this problem is to generate test cases by yourself, and then test it to your program. If your program can solve it, then you're getting it correct :)

417 - Word Index (by: Ruan David)

1. Make a hash table which contains key a, b, c...z, ab, ac...vwxyz by using 5 for loops!
   It's doable even though it is slow (because there is only 26 alphabets), btw, you actually
   loop 83681 times... Look at the pseudo code below

   curIndex = 1;

  for (i=0; i<26; i++)
    map string ('a'+i) to hashTable with index curIndex
    curIndex++

  for (i=0; i<26; i++)
    for (j=i+1; j<26; j++) {
      map string ('a'+i,'a'+j) to hashTable with index curIndex
      curIndex++
    }

  // and so on until 5 nested loops... if everything is correct,
  // you'll fill in the indexes from 1 to 83681

2. Get the input. If it is legal, find it in hash table and output index; otherwise, output zero.

422 - Word Search Wonder (by: Felix Halim)

Backtracking will solve this problem :)

423 - MPI Maelstrom

Find all-pairs-shortest-path (I use Floyd Warshall), and then determine the longest of these minimum connection between processor 1 to any other processor.

424 - Integer Inquiry

Use string to represent this big numbers and do manual addition.

429 - Word Transformation

View this problem as a graph problem.
You have a list of words. These words are the vertices of the graph.
Connect 2 vertices (words) with an edge if they differ in exactly one single letter.
Find the shortest path from starting vertex (starting word) to ending vertex (ending word)
BFS works perfectly here, since BFS can find the shortest vertex from the starting vertex quickly.

433 - Bank (Not Quite O.C.R.)

A backtracking problem. Start with empty digits, add digit from left to right one by one. You need a good data structure (I use array of 10*7, 10 digits, 7 segments/digit) to quickly identify these properties, for example:

 _
 _|
 _

can be 2,3,8,9, but all with some segments missing... (convince yourself that this is correct), whereas

 _
 _|
|_

can be exactly 2 (no segment missing), or 8 (with some segments missing)... (convince yourself that this should be the correct one)

Now, backtrack all these combination of possibilities, make sure that at the end of the 9th digits, the sum (according to the formula given) is divisible by 11, and number of digits that must be corrected <= 1. Otherwise print ambiguous or failure, respectively.

435 - Block Voting

Study the definition of power index as described in the problem, and then calculate all the power index for each party.

436 - Arbitrage (II)

Similar to problem 104, use all-pairs-shortest-path algorithm to find whether an arbitrage cycle exist...

437 - The Tower of Babylon (by: Felix Halim)

Find the highest tower that can be built using the unlimited given types of blocks. Even though there are unlimited amount of blocks, we can only use the same type of blocks maximum three times because of the rule that states the upper blocks should have strictly smaller base. As a result, we can simplify the recursion by using blocks without rotating it at all by changing 1 type of block with three same blocks with different base. This will eliminate the needs of rotating the blocks.

438 - The Circumference of the Circle

If you study well during your Senior High School, this problem should be easy.
Note: the following formula is not the only way to compute circumference of the circle!

First, compute a,b,c where a,b,c are the length of Triangle side
Find S where S is (a+b+c)/2 (1/2 of triangle’s circumference)
Find L =sqrt(s*(s-a)*(s-b)*(s-c))
Compute r:=(a*b*c)/(4*l) (R= half diameter of the circle)
Output (2*Pi*r) (the circumference of circle)

439 - Knight Moves

You can always find a Knight tour from a square to another square in a chessboard. The problem is, can you find the shortest. Breadth First Search will do.

Common Mistake:
1. Forget to initialize minmoves with maxint (anything big)
2. Wrong recursion, you’ve to include all 8 knight possible movements

440 - Eeny Meeny Moo

This is just a modification from problem no 151, You only need to change 13 (Wellington at problem no 151) to 2 (Ulm at this problem)

441 - Lotto

If you read the problem carefully, you’ll realize that you can solve this problem by using 6 nested loops O(n⁶). It is something like this: (j,k,l,m,n,o are variables used for loops, x is the number of elements.)

  for j:= to x-5 do
    for k:=j+1 to x-4 do
      for l:=k+1 to x-3 do
        for m:=l+1 to x-2 do
          for n:=m+1 to x-1 do
            for o:=n+1 to x do

442 - Matrix Chain Multiplication

Read in the matrices, and then calculate the number of multiplication needed to multiple the matrices using the parentheses given.

443 - Humble Numbers (by Niaz Morshed Chowdhury)

According to the problem description we need to find the numbers whose only prime factors are 2,3,5 and 7. So, we can represent the numbers as 2^i x 3^j x 5^k x 7^l. For the different values of i,j,k, and l we will get different numbers. As the maximum range is 5842 and from the last sample input and output we get that 5842nd number is 2000000000. So our maximum value will be this value. Now, by using 4 loops we can generate and preserve
all the humble numbers in between 1 and 2000000000. After that we need to sort them. But here we must use at least O(n log n) sort. Quick Sort is enough for this problem.

Be careful about giving output.
1. After 11,12 and 13 there will be th
2. After 21....91 there will be st
3. After 22....92 there will be nd
4. After 23....93 there will be rd
5  Always after 1,2 and 3 there will be st, nd and rd respectively.

Look at the samples

Input
1
11
1001
100
99

Output
The 1st humble number is 1.
The 11th humble number is 12.
The 1001st humble number is 387072.
The 100th humble number is 450.
The 99th humble number is 448.

Note: This problem can also be solved using Dynamic Programming (refer to problem 136)

444 - Encoder Decoder

Read line by line (this is okay since max chars per line = 80)
If it contains numbers => encoded message, decode the line. (reverse their rule)
If it contains characters => normal message, encode the line. (using their rule)

445 - Marvelous Mazes

You only have to do what this problem wants you to do, i.e:
Read one character per character…
If you encounter ‘b’, print space
If you encounter ‘!’, print line break (change line)
else, print that character

Be careful with your output, whitespaces and linebreaks

446 - Kibbles n Bits n Bits n Bits (by: Sayutee)

The problem is pretty straightforward. You have to do base conversions only. The input is two Hexadecimal number and the output is two binary numbers and one decimal number. It is like this:

input : Number1(Hex) Operator Number2(Hex)
output: Number1(Bin) Operator Number2(Bin) = Number3(Dec)

For changing to Hex to Bin, simply divide it up with 2 and taking the reminder into a string.
Then just reversed it.

If you use C, you need not change the base from 16 to 10 Explicitly. Just use %X for input and %d for output. The compiler will change that. while changing to binary, use the Hexadecimal number as if it is a decimal the compiler will do whatever needed for you. Use the two statements below:

Input -> scanf("%X %X", &number1, &number2);
Output -> printf("%d", result);

447 - Population Explosion

A problem similar to 457, called 'Game of Life' in Biology. Again, what you can do is to simulate the process and output accordingly. :)

448 - OOPS!

A reverse engineering task. Given a binary compiled code, using the Assembler rule given, reconstruct back the code. A bit tedious I think...

450 - Little Black Book (with help from: Reuber's webpage)

A simple record sorting problem. Simply read the input, tokenize it and put each token into appropriate place in a well defined record, then sort these database by last name, and then output it again using the given format.

The problem is how big is the data? i.e. how many person in the input data?, after several trial and error (yes, I wasted a lot of submissions just to gather this data...), I found out that a line in the input data can be very long, so allocate enough buffer for gets (maybe 1 million chars), and total persons will not exceed 50000... I don't know the exact lower limit, I don't want to waste any more submissions :p

451 - Poker Solitaire Evaluator

This should be just a tedious but straightforward problem... However, I already spent 2-3 hours trying to debug my code, without finding any more error(s) that I can think of... But still WA -_-'''... So, rather than stressing my brain by finding where is the bug... can anyone sent me an idea or some very very difficult test cases for this problem to check my code?

452 - Project Scheduling

This is the first problem that I solve using DAG Shortest Paths algorithms (refer to my programming section or CLRS chapter 24).

The input format is tricky... You have to construct a dependency graph from the given input, and store all weight of vertices somewhere else, then do a Topological Sort (refer to CLRS chapter 23). From this topological order, compute the Critical Path (i.e. find the longest path).

Note that the problem DIDN'T say that ALL vertices will be in a single connected component!!!, make sure your algorithm can cater this, for example:

1

A 1
B 2

Task A (1 day) and Task B (2 days) can both be executed in parallel, so total time needed is 2 days only (and not 3 days or 1 day...)

454 - Anagrams

Max input = 100 lines, maximum O(100^2 ~ 10.000), this is acceptable :)

Just do a brute force matching per every pair of line i and line j. Two lines are anagram if they have the same frequency of characters (ignoring whitespaces). Of course you can do speed-ups by storing their character frequencies first, then do this O(10.000) comparison.

455 - Periodic Strings

A periodic string will always start from the beginning of a string, then that substring will repeat itself until the END of the string

Example:
HoHoHo, “Ho” will repeat itself 3 times (with length 2)
HoHoHoH, “HoHoHoH” will repeat itself only once (with length 7), ie periodic string = original string

Since this problem wants us to find the SMALLEST substring length, we start searching periodic string from the smallest first

My solution will require O(N^2), the outline of my solution is like this:

Outer loop (Incrementing the length L of substring, starting from 1) {
   Create a substring with length L
   Inner loop (starting from 1 to length of the original string) {
      check the occurrence of substring, if it occurs from index 1 till the end of
      original string, print current L, then exit program

     if substring does not match the original string, break and go back to outer loop
     to increment L
   }
}

The full code to implement this is up to you :-)