title: Dice Throw Problem 1
signature: diceThrowProblem1 :: Integer -> Integer -> Integer -> Integer
  diceThrowProblem1 f d s = 
test_code: import Text.Printf
  import Control.Exception (catch, SomeException)
  import Data.Typeable
  import qualified Data.List as List
  import qualified Data.Map as Map
  import qualified Data.Set as Set
  
  -- SOLUTION CODE
  -- ============================================
  
  PLACEHOLDER_CODE_BODY
  
  -- TESTING CODE 
  -- ============================================
  validateSolution :: Integer -> Integer -> Bool
  validateSolution actual expected = do
      actual == expected
  
  
  driver :: Integer -> Integer -> Integer -> Integer -> String
  driver f d s expected = do
      if (validateSolution (PLACEHOLDER_FN_NAME f d s) expected)
          then "PASSED"
      else "FAILED"
  
  main = do
      printf "TEST-0...%s\n" (driver (57) (5) (33) (35960) )
  
      printf "TEST-1...%s\n" (driver (58) (45) (4) (0) )
  
      printf "TEST-2...%s\n" (driver (38) (89) (9) (0) )
  
      printf "TEST-3...%s\n" (driver (5) (39) (30) (0) )
  
      printf "TEST-4...%s\n" (driver (91) (90) (47) (0) )
  
      printf "TEST-5...%s\n" (driver (76) (56) (46) (0) )
  
      printf "TEST-6...%s\n" (driver (97) (26) (52) (247959266474052) )
  
      printf "TEST-7...%s\n" (driver (97) (90) (90) (1) )
  
      printf "TEST-8...%s\n" (driver (99) (2) (26) (25) )
  
source_py: def dice_throw_problem_1(f, d, s):
      mem = [[0 for i in range((s + 1))] for j in range((d + 1))]
      mem[0][0] = 1
      for i in range(1, (d + 1)):
          for j in range(1, (s + 1)):
              mem[i][j] = (mem[i][(j - 1)] + mem[(i - 1)][(j - 1)])
              if (((j - f) - 1) >= 0):
                  mem[i][j] -= mem[(i - 1)][((j - f) - 1)]
      return mem[d][s]
source_cpp: long dice_throw_problem_1(int f, int d, int s) {
    long mem [ d + 1 ] [ s + 1 ];
    memset ( mem, 0, sizeof mem );
    mem [ 0 ] [ 0 ] = 1;
    for ( int i = 1;
    i <= d;
    i ++ ) {
      for ( int j = i;
      j <= s;
      j ++ ) {
        mem [ i ] [ j ] = mem [ i ] [ j - 1 ] + mem [ i - 1 ] [ j - 1 ];
        if ( j - f - 1 >= 0 ) mem [ i ] [ j ] -= mem [ i - 1 ] [ j - f - 1 ];
      }
    }
    return mem [ d ] [ s ];
  }