problem_mapping.js

problem_mapping = {
    "Chapter 04: Primitive Types": {
        "4.00 Bootcamp: Primitive Types": {
            "C++: count_bits.cc": {
                "passed": 0,
                "total": 10001
            },
            "Java: CountBits.java": {
                "passed": 0,
                "total": 10001
            },
            "Python: count_bits.py": {
                "passed": 0,
                "total": 10001
            }
        },
        "4.01 Computing the parity of a word": {
            "C++: parity.cc": {
                "passed": 0,
                "total": 10000
            },
            "Java: Parity.java": {
                "passed": 0,
                "total": 10000
            },
            "Python: parity.py": {
                "passed": 0,
                "total": 10000
            }
        },
        "4.02 Swap bits": {
            "C++: swap_bits.cc": {
                "passed": 0,
                "total": 10001
            },
            "Java: SwapBits.java": {
                "passed": 0,
                "total": 10001
            },
            "Python: swap_bits.py": {
                "passed": 0,
                "total": 10001
            }
        },
        "4.03 Reverse bits": {
            "C++: reverse_bits.cc": {
                "passed": 0,
                "total": 10000
            },
            "Java: ReverseBits.java": {
                "passed": 0,
                "total": 10000
            },
            "Python: reverse_bits.py": {
                "passed": 0,
                "total": 10000
            }
        },
        "4.04 Find a closest integer with the same weight": {
            "C++: closest_int_same_weight.cc": {
                "passed": 0,
                "total": 10000
            },
            "Java: ClosestIntSameWeight.java": {
                "passed": 0,
                "total": 10000
            },
            "Python: closest_int_same_weight.py": { 
                "passed": 0,
                "total": 10000
            }
        },
        "4.05 Compute product without arithmetical operators": {
            "C++: primitive_multiply.cc": {
                "passed": 0,
                "total": 10006
            },
            "Java: PrimitiveMultiply.java": {
                "passed": 0,
                "total": 10006
            },
            "Python: primitive_multiply.py": {
                "passed": 0,
                "total": 10006
            }
        },
        "4.06 Compute quotient without arithmetical operators": {
            "C++: primitive_divide.cc": {
                "passed": 0,
                "total": 10000
            },
            "Java: PrimitiveDivide.java": {
                "passed": 0,
                "total": 10000
            },
            "Python: primitive_divide.py": {
                "passed": 0,
                "total": 10000
            }
        },
        "4.07 Compute pow(x,y)": {
            "C++: power_x_y.cc": {
                "passed": 0,
                "total": 10002
            },
            "Java: PowerXY.java": {
                "passed": 0,
                "total": 10002
            },
            "Python: power_x_y.py": {
                "passed": 0,
                "total": 10002
            }
        },
        "4.08 Reverse digits": {
            "C++: reverse_digits.cc": {
                "passed": 0,
                "total": 19952
            },
            "Java: ReverseDigits.java": {
                "passed": 0,
                "total": 19952
            },
            "Python: reverse_digits.py": {
                "passed": 0,
                "total": 19952
            }
        },
        "4.09 Check if a decimal integer is a palindrome": {
            "C++: is_number_palindromic.cc": {
                "passed": 0,
                "total": 20000
            },
            "Java: IsNumberPalindromic.java": {
                "passed": 0,
                "total": 20000
            },
            "Python: is_number_palindromic.py": {
                "passed": 0,
                "total": 20000
            }
        },
        "4.10 Generate uniform random numbers": {
            "C++: uniform_random_number.cc": {
                "passed": 0,
                "total": 7
            },
            "Java: UniformRandomNumber.java": {
                "passed": 0,
                "total": 7
            },
            "Python: uniform_random_number.py": {
                "passed": 0,
                "total": 7
            }
        },
        "4.11 Rectangle intersection": {
            "C++: rectangle_intersection.cc": {
                "passed": 0,
                "total": 10000
            },
            "Java: RectangleIntersection.java": {
                "passed": 0,
                "total": 10000
            },
            "Python: rectangle_intersection.py": {
                "passed": 0,
                "total": 10000
            }
        }
    },
    "Chapter 05: Arrays": {
        "5.00 Bootcamp: Arrays": {
            "C++: even_odd_array.cc": {
                "passed": 0,
                "total": 1001
            },
            "Java: EvenOddArray.java": {
                "passed": 0,
                "total": 1001
            },
            "Python: even_odd_array.py": {
                "passed": 0,
                "total": 1001
            }
        },
        "5.01 The Dutch national flag problem": {
            "C++: dutch_national_flag.cc": {
                "passed": 0,
                "total": 204
            },
            "Java: DutchNationalFlag.java": {
                "passed": 0,
                "total": 204
            },
            "Python: dutch_national_flag.py": {
                "passed": 0,
                "total": 204
            }
        },
        "5.02 Increment an arbitrary-precision integer": {
            "C++: int_as_array_increment.cc": {
                "passed": 0,
                "total": 505
            },
            "Java: IntAsArrayIncrement.java": {
                "passed": 0,
                "total": 505
            },
            "Python: int_as_array_increment.py": {
                "passed": 0,
                "total": 505
            }
        },
        "5.03 Multiply two arbitrary-precision integers": {
            "C++: int_as_array_multiply.cc": {
                "passed": 0,
                "total": 1000
            },
            "Java: IntAsArrayMultiply.java": {
                "passed": 0,
                "total": 1000
            },
            "Python: int_as_array_multiply.py": {
                "passed": 0,
                "total": 1000
            }
        },
        "5.04 Advancing through an array": {
            "C++: advance_by_offsets.cc": {
                "passed": 0,
                "total": 2004
            },
            "Java: AdvanceByOffsets.java": {
                "passed": 0,
                "total": 2004
            },
            "Python: advance_by_offsets.py": {
                "passed": 0,
                "total": 2004
            }
        },
        "5.05 Delete duplicates from a sorted array": {
            "C++: sorted_array_remove_dups.cc": {
                "passed": 0,
                "total": 2003
            },
            "Java: SortedArrayRemoveDups.java": {
                "passed": 0,
                "total": 2003
            },
            "Python: sorted_array_remove_dups.py": {
                "passed": 0,
                "total": 2003
            }
        },
        "5.06 Buy and sell a stock once": {
            "C++: buy_and_sell_stock.cc": {
                "passed": 0,
                "total": 402
            },
            "Java: BuyAndSellStock.java": {
                "passed": 0,
                "total": 402
            },
            "Python: buy_and_sell_stock.py": {
                "passed": 0,
                "total": 402
            }
        },
        "5.07 Buy and sell a stock twice": {
            "C++: buy_and_sell_stock_twice.cc": {
                "passed": 0,
                "total": 402
            },
            "Java: BuyAndSellStockTwice.java": {
                "passed": 0,
                "total": 402
            },
            "Python: buy_and_sell_stock_twice.py": {
                "passed": 0,
                "total": 402
            }
        },
        "5.08 Computing an alternation": {
            "C++: alternating_array.cc": {
                "passed": 0,
                "total": 203
            },
            "Java: AlternatingArray.java": {
                "passed": 0,
                "total": 203
            },
            "Python: alternating_array.py": {
                "passed": 0,
                "total": 203
            }
        },
        "5.09 Enumerate all primes to n": {
            "C++: prime_sieve.cc": {
                "passed": 0,
                "total": 24
            },
            "Java: PrimeSieve.java": {
                "passed": 0,
                "total": 24
            },
            "Python: prime_sieve.py": {
                "passed": 0,
                "total": 24
            }
        },
        "5.10 Permute the elements of an array": {
            "C++: apply_permutation.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: ApplyPermutation.java": {
                "passed": 0,
                "total": 101
            },
            "Python: apply_permutation.py": {
                "passed": 0,
                "total": 101
            }
        },
        "5.11 Compute the next permutation": {
            "C++: next_permutation.cc": {
                "passed": 0,
                "total": 2001
            },
            "Java: NextPermutation.java": {
                "passed": 0,
                "total": 2001
            },
            "Python: next_permutation.py": {
                "passed": 0,
                "total": 2001
            }
        },
        "5.12 Sample offline data": {
            "C++: offline_sampling.cc": {
                "passed": 0,
                "total": 8
            },
            "Java: OfflineSampling.java": {
                "passed": 0,
                "total": 8
            },
            "Python: offline_sampling.py": {
                "passed": 0,
                "total": 8
            }
        },
        "5.13 Sample online data": {
            "C++: online_sampling.cc": {
                "passed": 0,
                "total": 7
            },
            "Java: OnlineSampling.java": {
                "passed": 0,
                "total": 7
            },
            "Python: online_sampling.py": {
                "passed": 0,
                "total": 7
            }
        },
        "5.14 Compute a random permutation": {
            "C++: random_permutation.cc": {
                "passed": 0,
                "total": 6
            },
            "Java: RandomPermutation.java": {
                "passed": 0,
                "total": 6
            },
            "Python: random_permutation.py": {
                "passed": 0,
                "total": 6
            }
        },
        "5.15 Compute a random subset": {
            "C++: random_subset.cc": {
                "passed": 0,
                "total": 9
            },
            "Java: RandomSubset.java": {
                "passed": 0,
                "total": 9
            },
            "Python: random_subset.py": {
                "passed": 0,
                "total": 9
            }
        },
        "5.16 Generate nonuniform random numbers": {
            "C++: nonuniform_random_number.cc": {
                "passed": 0,
                "total": 10
            },
            "Java: NonuniformRandomNumber.java": {
                "passed": 0,
                "total": 10
            },
            "Python: nonuniform_random_number.py": {
                "passed": 0,
                "total": 10
            }
        },
        "5.17 The Sudoku checker problem": {
            "C++: is_valid_sudoku.cc": {
                "passed": 0,
                "total": 745
            },
            "Java: IsValidSudoku.java": {
                "passed": 0,
                "total": 745
            },
            "Python: is_valid_sudoku.py": {
                "passed": 0,
                "total": 745
            }
        },
        "5.18 Compute the spiral ordering of a 2D array": {
            "C++: spiral_ordering.cc": {
                "passed": 0,
                "total": 51
            },
            "Java: SpiralOrdering.java": {
                "passed": 0,
                "total": 51
            },
            "Python: spiral_ordering.py": {
                "passed": 0,
                "total": 51
            }
        },
        "5.19 Rotate a 2D array": {
            "C++: matrix_rotation.cc": {
                "passed": 0,
                "total": 51
            },
            "Java: MatrixRotation.java": {
                "passed": 0,
                "total": 51
            },
            "Python: matrix_rotation.py": {
                "passed": 0,
                "total": 51
            }
        },
        "5.20 Compute rows in Pascal's Triangle": {
            "C++: pascal_triangle.cc": {
                "passed": 0,
                "total": 35
            },
            "Java: PascalTriangle.java": {
                "passed": 0,
                "total": 35
            },
            "Python: pascal_triangle.py": {
                "passed": 0,
                "total": 35
            }
        }
    },
    "Chapter 06: Strings": {
        "6.00 Bootcamp: Strings": {
            "C++: is_string_palindromic.cc": {
                "passed": 0,
                "total": 10000
            },
            "Java: IsStringPalindromic.java": {
                "passed": 0,
                "total": 10000
            },
            "Python: is_string_palindromic.py": {
                "passed": 0,
                "total": 10000
            }
        },
        "6.01 Interconvert strings and integers": {
            "C++: string_integer_interconversion.cc": {
                "passed": 0,
                "total": 15002
            },
            "Java: StringIntegerInterconversion.java": {
                "passed": 0,
                "total": 15002
            },
            "Python: string_integer_interconversion.py": {
                "passed": 0,
                "total": 15002
            }
        },
        "6.02 Base conversion": {
            "C++: convert_base.cc": {
                "passed": 0,
                "total": 20001
            },
            "Java: ConvertBase.java": {
                "passed": 0,
                "total": 20001
            },
            "Python: convert_base.py": {
                "passed": 0,
                "total": 20001
            }
        },
        "6.03 Compute the spreadsheet column encoding": {
            "C++: spreadsheet_encoding.cc": {
                "passed": 0,
                "total": 10000
            },
            "Java: SpreadsheetEncoding.java": {
                "passed": 0,
                "total": 10000
            },
            "Python: spreadsheet_encoding.py": {
                "passed": 0,
                "total": 10000
            }
        },
        "6.04 Replace and remove": {
            "C++: replace_and_remove.cc": {
                "passed": 0,
                "total": 501
            },
            "Java: ReplaceAndRemove.java": {
                "passed": 0,
                "total": 501
            },
            "Python: replace_and_remove.py": {
                "passed": 0,
                "total": 501
            }
        },
        "6.05 Test palindromicity": {
            "C++: is_string_palindromic_punctuation.cc": {
                "passed": 0,
                "total": 305
            },
            "Java: IsStringPalindromicPunctuation.java": {
                "passed": 0,
                "total": 305
            },
            "Python: is_string_palindromic_punctuation.py": {
                "passed": 0,
                "total": 305
            }
        },
        "6.06 Reverse all the words in a sentence": {
            "C++: reverse_words.cc": {
                "passed": 0,
                "total": 103
            },
            "Java: ReverseWords.java": {
                "passed": 0,
                "total": 103
            },
            "Python: reverse_words.py": {
                "passed": 0,
                "total": 103
            }
        },
        "6.07 The look-and-say problem": {
            "C++: look_and_say.cc": {
                "passed": 0,
                "total": 40
            },
            "Java: LookAndSay.java": {
                "passed": 0,
                "total": 40
            },
            "Python: look_and_say.py": {
                "passed": 0,
                "total": 40
            }
        },
        "6.08 Convert from Roman to decimal": {
            "C++: roman_to_integer.cc": {
                "passed": 0,
                "total": 3999
            },
            "Java: RomanToInteger.java": {
                "passed": 0,
                "total": 3999
            },
            "Python: roman_to_integer.py": {
                "passed": 0,
                "total": 3999
            }
        },
        "6.09 Compute all valid IP addresses": {
            "C++: valid_ip_addresses.cc": {
                "passed": 0,
                "total": 10008
            },
            "Java: ValidIpAddresses.java": {
                "passed": 0,
                "total": 10008
            },
            "Python: valid_ip_addresses.py": {
                "passed": 0,
                "total": 10008
            }
        },
        "6.10 Write a string sinusoidally": {
            "C++: snake_string.cc": {
                "passed": 0,
                "total": 500
            },
            "Java: SnakeString.java": {
                "passed": 0,
                "total": 500
            },
            "Python: snake_string.py": {
                "passed": 0,
                "total": 500
            }
        },
        "6.11 Implement run-length encoding": {
            "C++: run_length_compression.cc": {
                "passed": 0,
                "total": 200
            },
            "Java: RunLengthCompression.java": {
                "passed": 0,
                "total": 200
            },
            "Python: run_length_compression.py": {
                "passed": 0,
                "total": 200
            }
        },
        "6.12 Find the first occurrence of a substring": {
            "C++: substring_match.cc": {
                "passed": 0,
                "total": 835
            },
            "Java: SubstringMatch.java": {
                "passed": 0,
                "total": 835
            },
            "Python: substring_match.py": {
                "passed": 0,
                "total": 835
            }
        }
    },
    "Chapter 07: Linked Lists": {
        "7.00 Bootcamp: Linked Lists": {
            "C++: delete_from_list.cc": {
                "passed": 0,
                "total": 457
            },
            "C++: insert_in_list.cc": {
                "passed": 0,
                "total": 504
            },
            "C++: search_in_list.cc": {
                "passed": 0,
                "total": 505
            },
            "Java: DeleteFromList.java": {
                "passed": 0,
                "total": 457
            },
            "Java: InsertInList.java": {
                "passed": 0,
                "total": 504
            },
            "Java: SearchInList.java": {
                "passed": 0,
                "total": 505
            },
            "Python: delete_from_list.py": {
                "passed": 0,
                "total": 457
            },
            "Python: insert_in_list.py": {
                "passed": 0,
                "total": 504
            },
            "Python: search_in_list.py": {
                "passed": 0,
                "total": 505
            }
        },
        "7.01 Merge two sorted lists": {
            "C++: sorted_lists_merge.cc": {
                "passed": 0,
                "total": 501
            },
            "Java: SortedListsMerge.java": {
                "passed": 0,
                "total": 501
            },
            "Python: sorted_lists_merge.py": {
                "passed": 0,
                "total": 501
            }
        },
        "7.02 Reverse a single sublist": {
            "C++: reverse_sublist.cc": {
                "passed": 0,
                "total": 210
            },
            "Java: ReverseSublist.java": {
                "passed": 0,
                "total": 210
            },
            "Python: reverse_sublist.py": {
                "passed": 0,
                "total": 210
            }
        },
        "7.03 Test for cyclicity": {
            "C++: is_list_cyclic.cc": {
                "passed": 0,
                "total": 102
            },
            "Java: IsListCyclic.java": {
                "passed": 0,
                "total": 102
            },
            "Python: is_list_cyclic.py": {
                "passed": 0,
                "total": 102
            }
        },
        "7.04 Test for overlapping lists---lists are cycle-free": {
            "C++: do_terminated_lists_overlap.cc": {
                "passed": 0,
                "total": 106
            },
            "Java: DoTerminatedListsOverlap.java": {
                "passed": 0,
                "total": 106
            },
            "Python: do_terminated_lists_overlap.py": {
                "passed": 0,
                "total": 106
            }
        },
        "7.05 Test for overlapping lists---lists may have cycles": {
            "C++: do_lists_overlap.cc": {
                "passed": 0,
                "total": 120
            },
            "Java: DoListsOverlap.java": {
                "passed": 0,
                "total": 120
            },
            "Python: do_lists_overlap.py": {
                "passed": 0,
                "total": 120
            }
        },
        "7.06 Delete a node from a singly linked list": {
            "C++: delete_node_from_list.cc": {
                "passed": 0,
                "total": 512
            },
            "Java: DeleteNodeFromList.java": {
                "passed": 0,
                "total": 512
            },
            "Python: delete_node_from_list.py": {
                "passed": 0,
                "total": 512
            }
        },
        "7.07 Remove the kth last element from a list": {
            "C++: delete_kth_last_from_list.cc": {
                "passed": 0,
                "total": 306
            },
            "Java: DeleteKthLastFromList.java": {
                "passed": 0,
                "total": 306
            },
            "Python: delete_kth_last_from_list.py": {
                "passed": 0,
                "total": 306
            }
        },
        "7.08 Remove duplicates from a sorted list": {
            "C++: remove_duplicates_from_sorted_list.cc": {
                "passed": 0,
                "total": 203
            },
            "Java: RemoveDuplicatesFromSortedList.java": {
                "passed": 0,
                "total": 203
            },
            "Python: remove_duplicates_from_sorted_list.py": {
                "passed": 0,
                "total": 203
            }
        },
        "7.09 Implement cyclic right shift for singly linked lists": {
            "C++: list_cyclic_right_shift.cc": {
                "passed": 0,
                "total": 507
            },
            "Java: ListCyclicRightShift.java": {
                "passed": 0,
                "total": 507
            },
            "Python: list_cyclic_right_shift.py": {
                "passed": 0,
                "total": 507
            }
        },
        "7.10 Implement even-odd merge": {
            "C++: even_odd_list_merge.cc": {
                "passed": 0,
                "total": 1015
            },
            "Java: EvenOddListMerge.java": {
                "passed": 0,
                "total": 1015
            },
            "Python: even_odd_list_merge.py": {
                "passed": 0,
                "total": 1015
            }
        },
        "7.11 Test whether a singly linked list is palindromic": {
            "C++: is_list_palindromic.cc": {
                "passed": 0,
                "total": 203
            },
            "Java: IsListPalindromic.java": {
                "passed": 0,
                "total": 203
            },
            "Python: is_list_palindromic.py": {
                "passed": 0,
                "total": 203
            }
        },
        "7.12 Implement list pivoting": {
            "C++: pivot_list.cc": {
                "passed": 0,
                "total": 208
            },
            "Java: PivotList.java": {
                "passed": 0,
                "total": 208
            },
            "Python: pivot_list.py": {
                "passed": 0,
                "total": 208
            }
        },
        "7.13 Add list-based integers": {
            "C++: int_as_list_add.cc": {
                "passed": 0,
                "total": 2002
            },
            "Java: IntAsListAdd.java": {
                "passed": 0,
                "total": 2002
            },
            "Python: int_as_list_add.py": {
                "passed": 0,
                "total": 2002
            }
        }
    },
    "Chapter 08: Stacks and Queues": {
        "8.01 Implement a stack with max API": {
            "C++: stack_with_max.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: StackWithMax.java": {
                "passed": 0,
                "total": 101
            },
            "Python: stack_with_max.py": {
                "passed": 0,
                "total": 101
            }
        },
        "8.02 Evaluate RPN expressions": {
            "C++: evaluate_rpn.cc": {
                "passed": 0,
                "total": 108
            },
            "Java: EvaluateRpn.java": {
                "passed": 0,
                "total": 108
            },
            "Python: evaluate_rpn.py": {
                "passed": 0,
                "total": 108
            }
        },
        "8.03 Is a string well-formed?": {
            "C++: is_valid_parenthesization.cc": {
                "passed": 0,
                "total": 78
            },
            "Java: IsValidParenthesization.java": {
                "passed": 0,
                "total": 78
            },
            "Python: is_valid_parenthesization.py": {
                "passed": 0,
                "total": 78
            }
        },
        "8.04 Normalize pathnames": {
            "C++: directory_path_normalization.cc": {
                "passed": 0,
                "total": 255
            },
            "Java: DirectoryPathNormalization.java": {
                "passed": 0,
                "total": 255
            },
            "Python: directory_path_normalization.py": {
                "passed": 0,
                "total": 255
            }
        },
        "8.05 Compute buildings with a sunset view": {
            "C++: sunset_view.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: SunsetView.java": {
                "passed": 0,
                "total": 101
            },
            "Python: sunset_view.py": {
                "passed": 0,
                "total": 101
            }
        },
        "8.06 Compute binary tree nodes in order of increasing depth": {
            "C++: tree_level_order.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: TreeLevelOrder.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: tree_level_order.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "8.07 Implement a circular queue": {
            "C++: circular_queue.cc": {
                "passed": 0,
                "total": 65
            },
            "Java: CircularQueue.java": {
                "passed": 0,
                "total": 65
            },
            "Python: circular_queue.py": {
                "passed": 0,
                "total": 65
            }
        },
        "8.08 Implement a queue using stacks": {
            "C++: queue_from_stacks.cc": {
                "passed": 0,
                "total": 65
            },
            "Java: QueueFromStacks.java": {
                "passed": 0,
                "total": 65
            },
            "Python: queue_from_stacks.py": {
                "passed": 0,
                "total": 65
            }
        },
        "8.09 Implement a queue with max API": {
            "C++: queue_with_max.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: QueueWithMax.java": {
                "passed": 0,
                "total": 201
            },
            "Python: queue_with_max.py": {
                "passed": 0,
                "total": 201
            }
        }
    },
    "Chapter 09: Binary Trees": {
        "9.01 Test if a binary tree is height-balanced": {
            "C++: is_tree_balanced.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: IsTreeBalanced.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: is_tree_balanced.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.02 Test if a binary tree is symmetric": {
            "C++: is_tree_symmetric.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: IsTreeSymmetric.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: is_tree_symmetric.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.03 Compute the lowest common ancestor in a binary tree": {
            "C++: lowest_common_ancestor.cc": {
                "passed": 0,
                "total": 948
            },
            "Java: LowestCommonAncestor.java": {
                "passed": 0,
                "total": 948
            },
            "Python: lowest_common_ancestor.py": {
                "passed": 0,
                "total": 948
            }
        },
        "9.04 Compute the LCA when nodes have parent pointers": {
            "C++: lowest_common_ancestor_with_parent.cc": {
                "passed": 0,
                "total": 948
            },
            "Java: LowestCommonAncestorWithParent.java": {
                "passed": 0,
                "total": 948
            },
            "Python: lowest_common_ancestor_with_parent.py": {
                "passed": 0,
                "total": 948
            }
        },
        "9.05 Sum the root-to-leaf paths in a binary tree": {
            "C++: sum_root_to_leaf.cc": {
                "passed": 0,
                "total": 3849
            },
            "Java: SumRootToLeaf.java": {
                "passed": 0,
                "total": 3849
            },
            "Python: sum_root_to_leaf.py": {
                "passed": 0,
                "total": 3849
            }
        },
        "9.06 Find a root to leaf path with specified sum": {
            "C++: path_sum.cc": {
                "passed": 0,
                "total": 7690
            },
            "Java: PathSum.java": {
                "passed": 0,
                "total": 7690
            },
            "Python: path_sum.py": {
                "passed": 0,
                "total": 7690
            }
        },
        "9.07 Implement an inorder traversal without recursion": {
            "C++: tree_inorder.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: TreeInorder.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: tree_inorder.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.08 Compute the kth node in an inorder traversal": {
            "C++: kth_node_in_tree.cc": {
                "passed": 0,
                "total": 3851
            },
            "Java: KthNodeInTree.java": {
                "passed": 0,
                "total": 3851
            },
            "Python: kth_node_in_tree.py": {
                "passed": 0,
                "total": 3851
            }
        },
        "9.09 Compute the successor": {
            "C++: successor_in_tree.cc": {
                "passed": 0,
                "total": 948
            },
            "Java: SuccessorInTree.java": {
                "passed": 0,
                "total": 948
            },
            "Python: successor_in_tree.py": {
                "passed": 0,
                "total": 948
            }
        },
        "9.10 Implement an inorder traversal with constant space": {
            "C++: tree_with_parent_inorder.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: TreeWithParentInorder.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: tree_with_parent_inorder.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.11 Reconstruct a binary tree from traversal data": {
            "C++: tree_from_preorder_inorder.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: TreeFromPreorderInorder.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: tree_from_preorder_inorder.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.12 Reconstruct a binary tree from a preorder traversal with markers": {
            "C++: tree_from_preorder_with_null.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: TreeFromPreorderWithNull.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: tree_from_preorder_with_null.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.13 Compute the leaves of a binary tree": {
            "C++: tree_connect_leaves.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: TreeConnectLeaves.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: tree_connect_leaves.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.14 Compute the exterior of a binary tree": {
            "C++: tree_exterior.cc": {
                "passed": 0,
                "total": 3852
            },
            "Java: TreeExterior.java": {
                "passed": 0,
                "total": 3852
            },
            "Python: tree_exterior.py": {
                "passed": 0,
                "total": 3852
            }
        },
        "9.15 Compute the right sibling tree": {
            "C++: tree_right_sibling.cc": {
                "passed": 0,
                "total": 10
            },
            "Java: TreeRightSibling.java": {
                "passed": 0,
                "total": 10
            },
            "Python: tree_right_sibling.py": {
                "passed": 0,
                "total": 10
            }
        }
    },
    "Chapter 10: Heaps": {
        "10.01 Merge sorted files": {
            "C++: sorted_arrays_merge.cc": {
                "passed": 0,
                "total": 152
            },
            "Java: SortedArraysMerge.java": {
                "passed": 0,
                "total": 152
            },
            "Python: sorted_arrays_merge.py": {
                "passed": 0,
                "total": 152
            }
        },
        "10.02 Sort an increasing-decreasing array": {
            "C++: sort_increasing_decreasing_array.cc": {
                "passed": 0,
                "total": 203
            },
            "Java: SortIncreasingDecreasingArray.java": {
                "passed": 0,
                "total": 203
            },
            "Python: sort_increasing_decreasing_array.py": {
                "passed": 0,
                "total": 203
            }
        },
        "10.03 Sort an almost-sorted array": {
            "C++: sort_almost_sorted_array.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: SortAlmostSortedArray.java": {
                "passed": 0,
                "total": 101
            },
            "Python: sort_almost_sorted_array.py": {
                "passed": 0,
                "total": 101
            }
        },
        "10.04 Compute the k closest stars": {
            "C++: k_closest_stars.cc": {
                "passed": 0,
                "total": 51
            },
            "Java: KClosestStars.java": {
                "passed": 0,
                "total": 51
            },
            "Python: k_closest_stars.py": {
                "passed": 0,
                "total": 51
            }
        },
        "10.05 Compute the median of online data": {
            "C++: online_median.cc": {
                "passed": 0,
                "total": 55
            },
            "Java: OnlineMedian.java": {
                "passed": 0,
                "total": 55
            },
            "Python: online_median.py": {
                "passed": 0,
                "total": 55
            }
        },
        "10.06 Compute the k largest elements in a max-heap": {
            "C++: k_largest_in_heap.cc": {
                "passed": 0,
                "total": 102
            },
            "Java: KLargestInHeap.java": {
                "passed": 0,
                "total": 102
            },
            "Python: k_largest_in_heap.py": {
                "passed": 0,
                "total": 102
            }
        }
    },
    "Chapter 11: Searching": {
        "11.01 Search a sorted array for first occurrence of k": {
            "C++: search_first_key.cc": {
                "passed": 0,
                "total": 314
            },
            "Java: SearchFirstKey.java": {
                "passed": 0,
                "total": 314
            },
            "Python: search_first_key.py": {
                "passed": 0,
                "total": 314
            }
        },
        "11.02 Search a sorted array for entry equal to its index": {
            "C++: search_entry_equal_to_index.cc": {
                "passed": 0,
                "total": 501
            },
            "Java: SearchEntryEqualToIndex.java": {
                "passed": 0,
                "total": 501
            },
            "Python: search_entry_equal_to_index.py": {
                "passed": 0,
                "total": 501
            }
        },
        "11.03 Search a cyclically sorted array": {
            "C++: search_shifted_sorted_array.cc": {
                "passed": 0,
                "total": 307
            },
            "Java: SearchShiftedSortedArray.java": {
                "passed": 0,
                "total": 307
            },
            "Python: search_shifted_sorted_array.py": {
                "passed": 0,
                "total": 307
            }
        },
        "11.04 Compute the integer square root": {
            "C++: int_square_root.cc": {
                "passed": 0,
                "total": 2000
            },
            "Java: IntSquareRoot.java": {
                "passed": 0,
                "total": 2000
            },
            "Python: int_square_root.py": {
                "passed": 0,
                "total": 2000
            }
        },
        "11.05 Compute the real square root": {
            "C++: real_square_root.cc": {
                "passed": 0,
                "total": 11003
            },
            "Java: RealSquareRoot.java": {
                "passed": 0,
                "total": 11003
            },
            "Python: real_square_root.py": {
                "passed": 0,
                "total": 11003
            }
        },
        "11.06 Search in a 2D sorted array": {
            "C++: search_row_col_sorted_matrix.cc": {
                "passed": 0,
                "total": 194
            },
            "Java: SearchRowColSortedMatrix.java": {
                "passed": 0,
                "total": 194
            },
            "Python: search_row_col_sorted_matrix.py": {
                "passed": 0,
                "total": 194
            }
        },
        "11.07 Find the min and max simultaneously": {
            "C++: search_for_min_max_in_array.cc": {
                "passed": 0,
                "total": 501
            },
            "Java: SearchForMinMaxInArray.java": {
                "passed": 0,
                "total": 501
            },
            "Python: search_for_min_max_in_array.py": {
                "passed": 0,
                "total": 501
            }
        },
        "11.08 Find the kth largest element": {
            "C++: kth_largest_in_array.cc": {
                "passed": 0,
                "total": 503
            },
            "Java: KthLargestInArray.java": {
                "passed": 0,
                "total": 503
            },
            "Python: kth_largest_in_array.py": {
                "passed": 0,
                "total": 503
            }
        },
        "11.09 Find the missing IP address": {
            "C++: absent_value_array.cc": {
                "passed": 0,
                "total": 100
            },
            "Java: AbsentValueArray.java": {
                "passed": 0,
                "total": 100
            },
            "Python: absent_value_array.py": {
                "passed": 0,
                "total": 100
            }
        },
        "11.10 Find the duplicate and missing elements": {
            "C++: search_for_missing_element.cc": {
                "passed": 0,
                "total": 50
            },
            "Java: SearchForMissingElement.java": {
                "passed": 0,
                "total": 50
            },
            "Python: search_for_missing_element.py": {
                "passed": 0,
                "total": 50
            }
        }
    },
    "Chapter 12: Hash Tables": {
        "12.00 Bootcamp: Hash Tables": {
            "C++: anagrams.cc": {
                "passed": 0,
                "total": 9
            },
            "Java: Anagrams.java": {
                "passed": 0,
                "total": 9
            },
            "Python: anagrams.py": {
                "passed": 0,
                "total": 9
            }
            "Rust: anagrams.rs": {
                "passed": 0,
                "total": 9
            }
        },
        "12.01 Test for palindromic permutations": {
            "C++: is_string_permutable_to_palindrome.cc": {
                "passed": 0,
                "total": 305
            },
            "Java: IsStringPermutableToPalindrome.java": {
                "passed": 0,
                "total": 305
            },
            "Python: is_string_permutable_to_palindrome.py": {
                "passed": 0,
                "total": 305
            }
            "Rust: is_string_permutable_to_palindrome.rs": {
                "passed": 0,
                "total": 305
            }
        },
        "12.02 Is an anonymous letter constructible?": {
            "C++: is_anonymous_letter_constructible.cc": {
                "passed": 0,
                "total": 212
            },
            "Java: IsAnonymousLetterConstructible.java": {
                "passed": 0,
                "total": 212
            },
            "Python: is_anonymous_letter_constructible.py": {
                "passed": 0,
                "total": 212
            }
        },
        "12.03 Implement an ISBN cache": {
            "C++: lru_cache.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: LruCache.java": {
                "passed": 0,
                "total": 101
            },
            "Python: lru_cache.py": {
                "passed": 0,
                "total": 101
            }
        },
        "12.04 Compute the LCA, optimizing for close ancestors": {
            "C++: lowest_common_ancestor_close_ancestor.cc": {
                "passed": 0,
                "total": 948
            },
            "Java: LowestCommonAncestorCloseAncestor.java": {
                "passed": 0,
                "total": 948
            },
            "Python: lowest_common_ancestor_close_ancestor.py": {
                "passed": 0,
                "total": 948
            }
        },
        "12.05 Find the nearest repeated entries in an array": {
            "C++: nearest_repeated_entries.cc": {
                "passed": 0,
                "total": 505
            },
            "Java: NearestRepeatedEntries.java": {
                "passed": 0,
                "total": 505
            },
            "Python: nearest_repeated_entries.py": {
                "passed": 0,
                "total": 505
            }
        },
        "12.06 Find the smallest subarray covering all values": {
            "C++: smallest_subarray_covering_set.cc": {
                "passed": 0,
                "total": 904
            },
            "Java: SmallestSubarrayCoveringSet.java": {
                "passed": 0,
                "total": 904
            },
            "Python: smallest_subarray_covering_set.py": {
                "passed": 0,
                "total": 904
            }
        },
        "12.07 Find smallest subarray sequentially covering all values": {
            "C++: smallest_subarray_covering_all_values.cc": {
                "passed": 0,
                "total": 629
            },
            "Java: SmallestSubarrayCoveringAllValues.java": {
                "passed": 0,
                "total": 629
            },
            "Python: smallest_subarray_covering_all_values.py": {
                "passed": 0,
                "total": 629
            }
        },
        "12.08 Find the longest subarray with distinct entries": {
            "C++: longest_subarray_with_distinct_values.cc": {
                "passed": 0,
                "total": 987
            },
            "Java: LongestSubarrayWithDistinctValues.java": {
                "passed": 0,
                "total": 987
            },
            "Python: longest_subarray_with_distinct_values.py": {
                "passed": 0,
                "total": 987
            }
        },
        "12.09 Find the length of a longest contained interval": {
            "C++: longest_contained_interval.cc": {
                "passed": 0,
                "total": 203
            },
            "Java: LongestContainedInterval.java": {
                "passed": 0,
                "total": 203
            },
            "Python: longest_contained_interval.py": {
                "passed": 0,
                "total": 203
            }
        },
        "12.10 Compute all string decompositions": {
            "C++: string_decompositions_into_dictionary_words.cc": {
                "passed": 0,
                "total": 171
            },
            "Java: StringDecompositionsIntoDictionaryWords.java": {
                "passed": 0,
                "total": 171
            },
            "Python: string_decompositions_into_dictionary_words.py": {
                "passed": 0,
                "total": 171
            }
        },
        "12.11 Test the Collatz conjecture": {
            "C++: collatz_checker.cc": {
                "passed": 0,
                "total": 7
            },
            "Java: CollatzChecker.java": {
                "passed": 0,
                "total": 7
            },
            "Python: collatz_checker.py": {
                "passed": 0,
                "total": 7
            }
        }
    },
    "Chapter 13: Sorting": {
        "13.01 Compute the intersection of two sorted arrays": {
            "C++: intersect_sorted_arrays.cc": {
                "passed": 0,
                "total": 202
            },
            "Java: IntersectSortedArrays.java": {
                "passed": 0,
                "total": 202
            },
            "Python: intersect_sorted_arrays.py": {
                "passed": 0,
                "total": 202
            }
        },
        "13.02 Merge two sorted arrays": {
            "C++: two_sorted_arrays_merge.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: TwoSortedArraysMerge.java": {
                "passed": 0,
                "total": 201
            },
            "Python: two_sorted_arrays_merge.py": {
                "passed": 0,
                "total": 201
            }
        },
        "13.03 Computing the h-index": {
            "C++: h_index.cc": {
                "passed": 0,
                "total": 1001
            },
            "Java: HIndex.java": {
                "passed": 0,
                "total": 1001
            },
            "Python: h_index.py": {
                "passed": 0,
                "total": 1001
            }
        },
        "13.04 Remove first-name duplicates": {
            "C++: remove_duplicates.cc": {
                "passed": 0,
                "total": 202
            },
            "Java: RemoveDuplicates.java": {
                "passed": 0,
                "total": 202
            },
            "Python: remove_duplicates.py": {
                "passed": 0,
                "total": 202
            }
        },
        "13.05 Smallest nonconstructible value": {
            "C++: smallest_nonconstructible_value.cc": {
                "passed": 0,
                "total": 308
            },
            "Java: SmallestNonconstructibleValue.java": {
                "passed": 0,
                "total": 308
            },
            "Python: smallest_nonconstructible_value.py": {
                "passed": 0,
                "total": 308
            }
        },
        "13.06 Render a calendar": {
            "C++: calendar_rendering.cc": {
                "passed": 0,
                "total": 97
            },
            "Java: CalendarRendering.java": {
                "passed": 0,
                "total": 97
            },
            "Python: calendar_rendering.py": {
                "passed": 0,
                "total": 97
            }
        },
        "13.07 Merging intervals": {
            "C++: interval_add.cc": {
                "passed": 0,
                "total": 103
            },
            "Java: IntervalAdd.java": {
                "passed": 0,
                "total": 103
            },
            "Python: interval_add.py": {
                "passed": 0,
                "total": 103
            }
        },
        "13.08 Compute the union of intervals": {
            "C++: intervals_union.cc": {
                "passed": 0,
                "total": 191
            },
            "Java: IntervalsUnion.java": {
                "passed": 0,
                "total": 191
            },
            "Python: intervals_union.py": {
                "passed": 0,
                "total": 191
            }
        },
        "13.09 Partitioning and sorting an array with many repeated entries": {
            "C++: group_equal_entries.cc": {
                "passed": 0,
                "total": 33
            },
            "Java: GroupEqualEntries.java": {
                "passed": 0,
                "total": 33
            },
            "Python: group_equal_entries.py": {
                "passed": 0,
                "total": 33
            }
        },
        "13.10 Team photo day---1": {
            "C++: is_array_dominated.cc": {
                "passed": 0,
                "total": 105
            },
            "Java: IsArrayDominated.java": {
                "passed": 0,
                "total": 105
            },
            "Python: is_array_dominated.py": {
                "passed": 0,
                "total": 105
            }
        },
        "13.11 Implement a fast sorting algorithm for lists": {
            "C++: sort_list.cc": {
                "passed": 0,
                "total": 209
            },
            "Java: SortList.java": {
                "passed": 0,
                "total": 209
            },
            "Python: sort_list.py": {
                "passed": 0,
                "total": 209
            }
        },
        "13.12 Compute a salary threshold": {
            "C++: find_salary_threshold.cc": {
                "passed": 0,
                "total": 1005
            },
            "Java: FindSalaryThreshold.java": {
                "passed": 0,
                "total": 1005
            },
            "Python: find_salary_threshold.py": {
                "passed": 0,
                "total": 1005
            }
        }
    },
    "Chapter 14: Binary Search Trees": {
        "14.00 Bootcamp: Binary Search Trees": {
            "C++: search_in_bst.cc": {
                "passed": 0,
                "total": 955
            },
            "Java: SearchInBst.java": {
                "passed": 0,
                "total": 955
            },
            "Python: search_in_bst.py": {
                "passed": 0,
                "total": 955
            }
        },
        "14.01 Test if a binary tree satisfies the BST property": {
            "C++: is_tree_a_bst.cc": {
                "passed": 0,
                "total": 3139
            },
            "Java: IsTreeABst.java": {
                "passed": 0,
                "total": 3139
            },
            "Python: is_tree_a_bst.py": {
                "passed": 0,
                "total": 3139
            }
        },
        "14.02 Find the first key greater than a given value in a BST": {
            "C++: search_first_greater_value_in_bst.cc": {
                "passed": 0,
                "total": 949
            },
            "Java: SearchFirstGreaterValueInBst.java": {
                "passed": 0,
                "total": 949
            },
            "Python: search_first_greater_value_in_bst.py": {
                "passed": 0,
                "total": 949
            }
        },
        "14.03 Find the k largest elements in a BST": {
            "C++: k_largest_values_in_bst.cc": {
                "passed": 0,
                "total": 949
            },
            "Java: KLargestValuesInBst.java": {
                "passed": 0,
                "total": 949
            },
            "Python: k_largest_values_in_bst.py": {
                "passed": 0,
                "total": 949
            }
        },
        "14.04 Compute the LCA in a BST": {
            "C++: lowest_common_ancestor_in_bst.cc": {
                "passed": 0,
                "total": 951
            },
            "Java: LowestCommonAncestorInBst.java": {
                "passed": 0,
                "total": 951
            },
            "Python: lowest_common_ancestor_in_bst.py": {
                "passed": 0,
                "total": 951
            }
        },
        "14.05 Reconstruct a BST from traversal data": {
            "C++: bst_from_preorder.cc": {
                "passed": 0,
                "total": 950
            },
            "Java: BstFromPreorder.java": {
                "passed": 0,
                "total": 950
            },
            "Python: bst_from_preorder.py": {
                "passed": 0,
                "total": 950
            }
        },
        "14.06 Find the closest entries in three sorted arrays": {
            "C++: minimum_distance_3_sorted_arrays.cc": {
                "passed": 0,
                "total": 51
            },
            "Java: MinimumDistance3SortedArrays.java": {
                "passed": 0,
                "total": 51
            },
            "Python: minimum_distance_3_sorted_arrays.py": {
                "passed": 0,
                "total": 51
            }
        },
        "14.07 Enumerate extended integers": {
            "C++: a_b_sqrt2.cc": {
                "passed": 0,
                "total": 13
            },
            "Java: ABSqrt2.java": {
                "passed": 0,
                "total": 13
            },
            "Python: a_b_sqrt2.py": {
                "passed": 0,
                "total": 13
            }
        },
        "14.08 Build a minimum height BST from a sorted array": {
            "C++: bst_from_sorted_array.cc": {
                "passed": 0,
                "total": 87
            },
            "Java: BstFromSortedArray.java": {
                "passed": 0,
                "total": 87
            },
            "Python: bst_from_sorted_array.py": {
                "passed": 0,
                "total": 87
            }
        },
        "14.09 Test if three BST nodes are totally ordered": {
            "C++: descendant_and_ancestor_in_bst.cc": {
                "passed": 0,
                "total": 958
            },
            "Java: DescendantAndAncestorInBst.java": {
                "passed": 0,
                "total": 958
            },
            "Python: descendant_and_ancestor_in_bst.py": {
                "passed": 0,
                "total": 958
            }
        },
        "14.10 The range lookup problem": {
            "C++: range_lookup_in_bst.cc": {
                "passed": 0,
                "total": 954
            },
            "Java: RangeLookupInBst.java": {
                "passed": 0,
                "total": 954
            },
            "Python: range_lookup_in_bst.py": {
                "passed": 0,
                "total": 954
            }
        },
        "14.11 Add credits": {
            "C++: adding_credits.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: AddingCredits.java": {
                "passed": 0,
                "total": 201
            },
            "Python: adding_credits.py": {
                "passed": 0,
                "total": 201
            }
        }
    },
    "Chapter 15: Recursion": {
        "15.00 Bootcamp: Recursion": {
            "C++: euclidean_gcd.cc": {
                "passed": 0,
                "total": 10034
            },
            "Java: EuclideanGcd.java": {
                "passed": 0,
                "total": 10034
            },
            "Python: euclidean_gcd.py": {
                "passed": 0,
                "total": 10034
            }
        },
        "15.01 The Towers of Hanoi problem": {
            "C++: hanoi.cc": {
                "passed": 0,
                "total": 10
            },
            "Java: Hanoi.java": {
                "passed": 0,
                "total": 10
            },
            "Python: hanoi.py": {
                "passed": 0,
                "total": 10
            }
        },
        "15.02 Compute all mnemonics for a phone number": {
            "C++: phone_number_mnemonic.cc": {
                "passed": 0,
                "total": 102
            },
            "Java: PhoneNumberMnemonic.java": {
                "passed": 0,
                "total": 102
            },
            "Python: phone_number_mnemonic.py": {
                "passed": 0,
                "total": 102
            }
        },
        "15.03 Generate all nonattacking placements of n-Queens": {
            "C++: n_queens.cc": {
                "passed": 0,
                "total": 10
            },
            "Java: NQueens.java": {
                "passed": 0,
                "total": 10
            },
            "Python: n_queens.py": {
                "passed": 0,
                "total": 10
            }
        },
        "15.04 Generate permutations": {
            "C++: permutations.cc": {
                "passed": 0,
                "total": 8
            },
            "Java: Permutations.java": {
                "passed": 0,
                "total": 8
            },
            "Python: permutations.py": {
                "passed": 0,
                "total": 8
            }
        },
        "15.05 Generate the power set": {
            "C++: power_set.cc": {
                "passed": 0,
                "total": 15
            },
            "Java: PowerSet.java": {
                "passed": 0,
                "total": 15
            },
            "Python: power_set.py": {
                "passed": 0,
                "total": 15
            }
        },
        "15.06 Generate all subsets of size k": {
            "C++: combinations.cc": {
                "passed": 0,
                "total": 120
            },
            "Java: Combinations.java": {
                "passed": 0,
                "total": 120
            },
            "Python: combinations.py": {
                "passed": 0,
                "total": 120
            }
        },
        "15.07 Generate strings of matched parens": {
            "C++: enumerate_balanced_parentheses.cc": {
                "passed": 0,
                "total": 11
            },
            "Java: EnumerateBalancedParentheses.java": {
                "passed": 0,
                "total": 11
            },
            "Python: enumerate_balanced_parentheses.py": {
                "passed": 0,
                "total": 11
            }
        },
        "15.08 Generate palindromic decompositions": {
            "C++: enumerate_palindromic_decompositions.cc": {
                "passed": 0,
                "total": 522
            },
            "Java: EnumeratePalindromicDecompositions.java": {
                "passed": 0,
                "total": 522
            },
            "Python: enumerate_palindromic_decompositions.py": {
                "passed": 0,
                "total": 522
            }
        },
        "15.09 Generate binary trees": {
            "C++: enumerate_trees.cc": {
                "passed": 0,
                "total": 10
            },
            "Java: EnumerateTrees.java": {
                "passed": 0,
                "total": 10
            },
            "Python: enumerate_trees.py": {
                "passed": 0,
                "total": 10
            }
        },
        "15.10 Implement a Sudoku solver": {
            "C++: sudoku_solve.cc": {
                "passed": 0,
                "total": 400
            },
            "Java: SudokuSolve.java": {
                "passed": 0,
                "total": 400
            },
            "Python: sudoku_solve.py": {
                "passed": 0,
                "total": 400
            }
        },
        "15.11 Compute a Gray code": {
            "C++: gray_code.cc": {
                "passed": 0,
                "total": 10
            },
            "Java: GrayCode.java": {
                "passed": 0,
                "total": 10
            },
            "Python: gray_code.py": {
                "passed": 0,
                "total": 10
            }
        }
    },
    "Chapter 16: Dynamic Programming": {
        "16.00 Bootcamp: Dynamic Programming": {
            "C++: fibonacci.cc": {
                "passed": 0,
                "total": 46
            },
            "C++: max_sum_subarray.cc": {
                "passed": 0,
                "total": 1001
            },
            "Java: Fibonacci.java": {
                "passed": 0,
                "total": 46
            },
            "Java: MaxSumSubarray.java": {
                "passed": 0,
                "total": 1001
            },
            "Python: fibonacci.py": {
                "passed": 0,
                "total": 46
            },
            "Python: max_sum_subarray.py": {
                "passed": 0,
                "total": 1001
            }
        },
        "16.01 Count the number of score combinations": {
            "C++: number_of_score_combinations.cc": {
                "passed": 0,
                "total": 1003
            },
            "Java: NumberOfScoreCombinations.java": {
                "passed": 0,
                "total": 1003
            },
            "Python: number_of_score_combinations.py": {
                "passed": 0,
                "total": 1003
            }
        },
        "16.02 Compute the Levenshtein distance": {
            "C++: levenshtein_distance.cc": {
                "passed": 0,
                "total": 100
            },
            "Java: LevenshteinDistance.java": {
                "passed": 0,
                "total": 100
            },
            "Python: levenshtein_distance.py": {
                "passed": 0,
                "total": 100
            }
        },
        "16.03 Count the number of ways to traverse a 2D array": {
            "C++: number_of_traversals_matrix.cc": {
                "passed": 0,
                "total": 1775
            },
            "Java: NumberOfTraversalsMatrix.java": {
                "passed": 0,
                "total": 1775
            },
            "Python: number_of_traversals_matrix.py": {
                "passed": 0,
                "total": 1775
            }
        },
        "16.04 Compute the binomial coefficients": {
            "C++: binomial_coefficients.cc": {
                "passed": 0,
                "total": 5906
            },
            "Java: BinomialCoefficients.java": {
                "passed": 0,
                "total": 5906
            },
            "Python: binomial_coefficients.py": {
                "passed": 0,
                "total": 5906
            }
        },
        "16.05 Search for a sequence in a 2D array": {
            "C++: is_string_in_matrix.cc": {
                "passed": 0,
                "total": 186
            },
            "Java: IsStringInMatrix.java": {
                "passed": 0,
                "total": 186
            },
            "Python: is_string_in_matrix.py": {
                "passed": 0,
                "total": 186
            }
        },
        "16.06 The knapsack problem": {
            "C++: knapsack.cc": {
                "passed": 0,
                "total": 100
            },
            "Java: Knapsack.java": {
                "passed": 0,
                "total": 100
            },
            "Python: knapsack.py": {
                "passed": 0,
                "total": 100
            }
        },
        "16.07 Building a search index for domains": {
            "C++: is_string_decomposable_into_words.cc": {
                "passed": 0,
                "total": 41
            },
            "Java: IsStringDecomposableIntoWords.java": {
                "passed": 0,
                "total": 41
            },
            "Python: is_string_decomposable_into_words.py": {
                "passed": 0,
                "total": 41
            }
        },
        "16.08 Find the minimum weight path in a triangle": {
            "C++: minimum_weight_path_in_a_triangle.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: MinimumWeightPathInATriangle.java": {
                "passed": 0,
                "total": 101
            },
            "Python: minimum_weight_path_in_a_triangle.py": {
                "passed": 0,
                "total": 101
            }
        },
        "16.09 Pick up coins for maximum gain": {
            "C++: picking_up_coins.cc": {
                "passed": 0,
                "total": 162
            },
            "Java: PickingUpCoins.java": {
                "passed": 0,
                "total": 162
            },
            "Python: picking_up_coins.py": {
                "passed": 0,
                "total": 162
            }
        },
        "16.10 Count the number of moves to climb stairs": {
            "C++: number_of_traversals_staircase.cc": {
                "passed": 0,
                "total": 546
            },
            "Java: NumberOfTraversalsStaircase.java": {
                "passed": 0,
                "total": 546
            },
            "Python: number_of_traversals_staircase.py": {
                "passed": 0,
                "total": 546
            }
        },
        "16.11 The pretty printing problem": {
            "C++: pretty_printing.cc": {
                "passed": 0,
                "total": 102
            },
            "Java: PrettyPrinting.java": {
                "passed": 0,
                "total": 102
            },
            "Python: pretty_printing.py": {
                "passed": 0,
                "total": 102
            }
        },
        "16.12 Find the longest nondecreasing subsequence": {
            "C++: longest_nondecreasing_subsequence.cc": {
                "passed": 0,
                "total": 200
            },
            "Java: LongestNondecreasingSubsequence.java": {
                "passed": 0,
                "total": 200
            },
            "Python: longest_nondecreasing_subsequence.py": {
                "passed": 0,
                "total": 200
            }
        }
    },
    "Chapter 17: Greedy Algorithms and Invariants": {
        "17.00 Bootcamp: Greedy Algorithms and Invariants": {
            "C++: making_change.cc": {
                "passed": 0,
                "total": 49999
            },
            "Java: MakingChange.java": {
                "passed": 0,
                "total": 49999
            },
            "Python: making_change.py": {
                "passed": 0,
                "total": 49999
            }
        },
        "17.01 Compute an optimum assignment of tasks": {
            "C++: task_pairing.cc": {
                "passed": 0,
                "total": 500
            },
            "Java: TaskPairing.java": {
                "passed": 0,
                "total": 500
            },
            "Python: task_pairing.py": {
                "passed": 0,
                "total": 500
            }
        },
        "17.02 Schedule to minimize waiting time": {
            "C++: minimum_waiting_time.cc": {
                "passed": 0,
                "total": 501
            },
            "Java: MinimumWaitingTime.java": {
                "passed": 0,
                "total": 501
            },
            "Python: minimum_waiting_time.py": {
                "passed": 0,
                "total": 501
            }
        },
        "17.03 The interval covering problem": {
            "C++: minimum_points_covering_intervals.cc": {
                "passed": 0,
                "total": 103
            },
            "C++: two_sum.cc": {
                "passed": 0,
                "total": 1005
            },
            "Java: MinimumPointsCoveringIntervals.java": {
                "passed": 0,
                "total": 103
            },
            "Java: TwoSum.java": {
                "passed": 0,
                "total": 1005
            },
            "Python: minimum_points_covering_intervals.py": {
                "passed": 0,
                "total": 103
            },
            "Python: two_sum.py": {
                "passed": 0,
                "total": 1005
            }
        },
        "17.04 The 3-sum problem": {
            "C++: three_sum.cc": {
                "passed": 0,
                "total": 1008
            },
            "Java: ThreeSum.java": {
                "passed": 0,
                "total": 1008
            },
            "Python: three_sum.py": {
                "passed": 0,
                "total": 1008
            }
        },
        "17.05 Find the majority element": {
            "C++: majority_element.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: MajorityElement.java": {
                "passed": 0,
                "total": 201
            },
            "Python: majority_element.py": {
                "passed": 0,
                "total": 201
            }
        },
        "17.06 The gasup problem": {
            "C++: refueling_schedule.cc": {
                "passed": 0,
                "total": 202
            },
            "Java: RefuelingSchedule.java": {
                "passed": 0,
                "total": 202
            },
            "Python: refueling_schedule.py": {
                "passed": 0,
                "total": 202
            }
        },
        "17.07 Compute the maximum water trapped by a pair of vertical lines": {
            "C++: max_trapped_water.cc": {
                "passed": 0,
                "total": 204
            },
            "Java: MaxTrappedWater.java": {
                "passed": 0,
                "total": 204
            },
            "Python: max_trapped_water.py": {
                "passed": 0,
                "total": 204
            }
        },
        "17.08 Compute the largest rectangle under the skyline": {
            "C++: largest_rectangle_under_skyline.cc": {
                "passed": 0,
                "total": 1004
            },
            "Java: LargestRectangleUnderSkyline.java": {
                "passed": 0,
                "total": 1004
            },
            "Python: largest_rectangle_under_skyline.py": {
                "passed": 0,
                "total": 1004
            }
        }
    },
    "Chapter 18: Graphs": {
        "18.01 Search a maze": {
            "C++: search_maze.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: SearchMaze.java": {
                "passed": 0,
                "total": 101
            },
            "Python: search_maze.py": {
                "passed": 0,
                "total": 101
            }
        },
        "18.02 Paint a Boolean matrix": {
            "C++: matrix_connected_regions.cc": {
                "passed": 0,
                "total": 50
            },
            "Java: MatrixConnectedRegions.java": {
                "passed": 0,
                "total": 50
            },
            "Python: matrix_connected_regions.py": {
                "passed": 0,
                "total": 50
            }
        },
        "18.03 Compute enclosed regions": {
            "C++: matrix_enclosed_regions.cc": {
                "passed": 0,
                "total": 51
            },
            "Java: MatrixEnclosedRegions.java": {
                "passed": 0,
                "total": 51
            },
            "Python: matrix_enclosed_regions.py": {
                "passed": 0,
                "total": 51
            }
        },
        "18.04 Deadlock detection": {
            "C++: deadlock_detection.cc": {
                "passed": 0,
                "total": 71
            },
            "Java: DeadlockDetection.java": {
                "passed": 0,
                "total": 71
            },
            "Python: deadlock_detection.py": {
                "passed": 0,
                "total": 71
            }
        },
        "18.05 Clone a graph": {
            "C++: graph_clone.cc": {
                "passed": 0,
                "total": 91
            },
            "Java: GraphClone.java": {
                "passed": 0,
                "total": 91
            },
            "Python: graph_clone.py": {
                "passed": 0,
                "total": 91
            }
        },
        "18.06 Making wired connections": {
            "C++: is_circuit_wirable.cc": {
                "passed": 0,
                "total": 85
            },
            "Java: IsCircuitWirable.java": {
                "passed": 0,
                "total": 85
            },
            "Python: is_circuit_wirable.py": {
                "passed": 0,
                "total": 85
            }
        },
        "18.07 Transform one string to another": {
            "C++: string_transformability.cc": {
                "passed": 0,
                "total": 48
            },
            "Java: StringTransformability.java": {
                "passed": 0,
                "total": 48
            },
            "Python: string_transformability.py": {
                "passed": 0,
                "total": 48
            }
        },
        "18.08 Team photo day---2": {
            "C++: max_teams_in_photograph.cc": {
                "passed": 0,
                "total": 69
            },
            "Java: MaxTeamsInPhotograph.java": {
                "passed": 0,
                "total": 69
            },
            "Python: max_teams_in_photograph.py": {
                "passed": 0,
                "total": 69
            }
        }
    },
    "Chapter 24: Honors Class": {
        "24.01 Compute the greatest common divisor": {
            "C++: gcd.cc": {
                "passed": 0,
                "total": 10034
            },
            "Java: Gcd.java": {
                "passed": 0,
                "total": 10034
            },
            "Python: gcd.py": {
                "passed": 0,
                "total": 10034
            }
        },
        "24.02 Find the first missing positive entry": {
            "C++: first_missing_positive_entry.cc": {
                "passed": 0,
                "total": 1001
            },
            "Java: FirstMissingPositiveEntry.java": {
                "passed": 0,
                "total": 1001
            },
            "Python: first_missing_positive_entry.py": {
                "passed": 0,
                "total": 1001
            }
        },
        "24.03 Buy and sell a stock at most k times": {
            "C++: buy_and_sell_stock_k_times.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: BuyAndSellStockKTimes.java": {
                "passed": 0,
                "total": 201
            },
            "Python: buy_and_sell_stock_k_times.py": {
                "passed": 0,
                "total": 201
            }
        },
        "24.04 Compute the maximum product of all entries but one": {
            "C++: max_product_all_but_one.cc": {
                "passed": 0,
                "total": 35
            },
            "Java: MaxProductAllButOne.java": {
                "passed": 0,
                "total": 35
            },
            "Python: max_product_all_but_one.py": {
                "passed": 0,
                "total": 35
            }
        },
        "24.05 Compute the longest contiguous increasing subarray": {
            "C++: longest_increasing_subarray.cc": {
                "passed": 0,
                "total": 100
            },
            "Java: LongestIncreasingSubarray.java": {
                "passed": 0,
                "total": 100
            },
            "Python: longest_increasing_subarray.py": {
                "passed": 0,
                "total": 100
            }
        },
        "24.06 Rotate an array": {
            "C++: rotate_array.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: RotateArray.java": {
                "passed": 0,
                "total": 101
            },
            "Python: rotate_array.py": {
                "passed": 0,
                "total": 101
            }
        },
        "24.07 Identify positions attacked by rooks": {
            "C++: rook_attack.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: RookAttack.java": {
                "passed": 0,
                "total": 201
            },
            "Python: rook_attack.py": {
                "passed": 0,
                "total": 201
            }
        },
        "24.08 Justify text": {
            "C++: left_right_justify_text.cc": {
                "passed": 0,
                "total": 30
            },
            "Java: LeftRightJustifyText.java": {
                "passed": 0,
                "total": 30
            },
            "Python: left_right_justify_text.py": {
                "passed": 0,
                "total": 30
            }
        },
        "24.09 Implement list zipping": {
            "C++: zip_list.cc": {
                "passed": 0,
                "total": 51
            },
            "Java: ZipList.java": {
                "passed": 0,
                "total": 51
            },
            "Python: zip_list.py": {
                "passed": 0,
                "total": 51
            }
        },
        "24.10 Copy a postings list": {
            "C++: copy_posting_list.cc": {
                "passed": 0,
                "total": 34
            },
            "Java: CopyPostingList.java": {
                "passed": 0,
                "total": 34
            },
            "Python: copy_posting_list.py": {
                "passed": 0,
                "total": 34
            }
        },
        "24.11 Compute the longest substring with matching parens": {
            "C++: longest_substring_with_matching_parentheses.cc": {
                "passed": 0,
                "total": 342
            },
            "Java: LongestSubstringWithMatchingParentheses.java": {
                "passed": 0,
                "total": 342
            },
            "Python: longest_substring_with_matching_parentheses.py": {
                "passed": 0,
                "total": 342
            }
        },
        "24.12 Compute the maximum of a sliding window": {
            "C++: max_of_sliding_window.cc": {
                "passed": 0,
                "total": 149
            },
            "Java: MaxOfSlidingWindow.java": {
                "passed": 0,
                "total": 149
            },
            "Python: max_of_sliding_window.py": {
                "passed": 0,
                "total": 149
            }
        },
        "24.13 Compute fair bonuses": {
            "C++: bonus.cc": {
                "passed": 0,
                "total": 106
            },
            "Java: Bonus.java": {
                "passed": 0,
                "total": 106
            },
            "Python: bonus.py": {
                "passed": 0,
                "total": 106
            }
        },
        "24.14 Search a sorted array of unknown length": {
            "C++: search_unknown_length_array.cc": {
                "passed": 0,
                "total": 206
            },
            "Java: SearchUnknownLengthArray.java": {
                "passed": 0,
                "total": 206
            },
            "Python: search_unknown_length_array.py": {
                "passed": 0,
                "total": 206
            }
        },
        "24.15 Search in two sorted arrays": {
            "C++: kth_largest_element_in_two_sorted_arrays.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: KthLargestElementInTwoSortedArrays.java": {
                "passed": 0,
                "total": 201
            },
            "Python: kth_largest_element_in_two_sorted_arrays.py": {
                "passed": 0,
                "total": 201
            }
        },
        "24.16 Find the kth largest element---large n, small k": {
            "C++: kth_largest_element_in_long_array.cc": {
                "passed": 0,
                "total": 503
            },
            "Java: KthLargestElementInLongArray.java": {
                "passed": 0,
                "total": 503
            },
            "Python: kth_largest_element_in_long_array.py": {
                "passed": 0,
                "total": 503
            }
        },
        "24.17 Find an element that appears only once": {
            "C++: element_appearing_once.cc": {
                "passed": 0,
                "total": 102
            },
            "Java: ElementAppearingOnce.java": {
                "passed": 0,
                "total": 102
            },
            "Python: element_appearing_once.py": {
                "passed": 0,
                "total": 102
            }
        },
        "24.18 Find the line through the most points": {
            "C++: line_through_most_points.cc": {
                "passed": 0,
                "total": 282
            },
            "Java: LineThroughMostPoints.java": {
                "passed": 0,
                "total": 282
            },
            "Python: line_through_most_points.py": {
                "passed": 0,
                "total": 282
            }
        },
        "24.19 Convert a sorted doubly linked list into a BST": {
            "C++: sorted_list_to_bst.cc": {
                "passed": 0,
                "total": 100
            },
            "Java: SortedListToBst.java": {
                "passed": 0,
                "total": 100
            },
            "Python: sorted_list_to_bst.py": {
                "passed": 0,
                "total": 100
            }
        },
        "24.20 Convert a BST to a sorted doubly linked list": {
            "C++: bst_to_sorted_list.cc": {
                "passed": 0,
                "total": 950
            },
            "Java: BstToSortedList.java": {
                "passed": 0,
                "total": 950
            },
            "Python: bst_to_sorted_list.py": {
                "passed": 0,
                "total": 950
            }
        },
        "24.21 Merge two BSTs": {
            "C++: bst_merge.cc": {
                "passed": 0,
                "total": 474
            },
            "Java: BstMerge.java": {
                "passed": 0,
                "total": 474
            },
            "Python: bst_merge.py": {
                "passed": 0,
                "total": 474
            }
        },
        "24.22 Implement regular expression matching": {
            "C++: regular_expression.cc": {
                "passed": 0,
                "total": 1596
            },
            "Java: RegularExpression.java": {
                "passed": 0,
                "total": 1596
            },
            "Python: regular_expression.py": {
                "passed": 0,
                "total": 1596
            }
        },
        "24.23 Synthesize an expression": {
            "C++: insert_operators_in_string.cc": {
                "passed": 0,
                "total": 101
            },
            "Java: InsertOperatorsInString.java": {
                "passed": 0,
                "total": 101
            },
            "Python: insert_operators_in_string.py": {
                "passed": 0,
                "total": 101
            }
        },
        "24.24 Count inversions": {
            "C++: count_inversions.cc": {
                "passed": 0,
                "total": 1001
            },
            "Java: CountInversions.java": {
                "passed": 0,
                "total": 1001
            },
            "Python: count_inversions.py": {
                "passed": 0,
                "total": 1001
            }
        },
        "24.25 Draw the skyline": {
            "C++: drawing_skyline.cc": {
                "passed": 0,
                "total": 30
            },
            "Java: DrawingSkyline.java": {
                "passed": 0,
                "total": 30
            },
            "Python: drawing_skyline.py": {
                "passed": 0,
                "total": 30
            }
        },
        "24.26 Measure with defective jugs": {
            "C++: defective_jugs.cc": {
                "passed": 0,
                "total": 200
            },
            "Java: DefectiveJugs.java": {
                "passed": 0,
                "total": 200
            },
            "Python: defective_jugs.py": {
                "passed": 0,
                "total": 200
            }
        },
        "24.27 Compute the maximum subarray sum in a circular array": {
            "C++: maximum_subarray_in_circular_array.cc": {
                "passed": 0,
                "total": 501
            },
            "Java: MaximumSubarrayInCircularArray.java": {
                "passed": 0,
                "total": 501
            },
            "Python: maximum_subarray_in_circular_array.py": {
                "passed": 0,
                "total": 501
            }
        },
        "24.28 Determine the critical height": {
            "C++: max_safe_height.cc": {
                "passed": 0,
                "total": 3829
            },
            "Java: MaxSafeHeight.java": {
                "passed": 0,
                "total": 3829
            },
            "Python: max_safe_height.py": {
                "passed": 0,
                "total": 3829
            }
        },
        "24.29 Find the maximum 2D subarray": {
            "C++: max_square_submatrix.cc": {
                "passed": 0,
                "total": 101
            },
            "C++: max_submatrix.cc": {
                "passed": 0,
                "total": 100
            },
            "Java: MaxSquareSubmatrix.java": {
                "passed": 0,
                "total": 101
            },
            "Java: MaxSubmatrix.java": {
                "passed": 0,
                "total": 100
            },
            "Python: max_square_submatrix.py": {
                "passed": 0,
                "total": 101
            },
            "Python: max_submatrix.py": {
                "passed": 0,
                "total": 100
            }
        },
        "24.30 Implement Huffman coding": {
            "C++: huffman_coding.cc": {
                "passed": 0,
                "total": 11
            },
            "Java: HuffmanCoding.java": {
                "passed": 0,
                "total": 11
            },
            "Python: huffman_coding.py": {
                "passed": 0,
                "total": 11
            }
        },
        "24.31 Trapping water": {
            "C++: max_water_trappable.cc": {
                "passed": 0,
                "total": 1001
            },
            "Java: MaxWaterTrappable.java": {
                "passed": 0,
                "total": 1001
            },
            "Python: max_water_trappable.py": {
                "passed": 0,
                "total": 1001
            }
        },
        "24.32 The heavy hitter problem": {
            "C++: search_frequent_items.cc": {
                "passed": 0,
                "total": 265
            },
            "Java: SearchFrequentItems.java": {
                "passed": 0,
                "total": 265
            },
            "Python: search_frequent_items.py": {
                "passed": 0,
                "total": 265
            }
        },
        "24.33 Find the longest subarray with sum constraint": {
            "C++: longest_subarray_with_sum_constraint.cc": {
                "passed": 0,
                "total": 102
            },
            "Java: LongestSubarrayWithSumConstraint.java": {
                "passed": 0,
                "total": 102
            },
            "Python: longest_subarray_with_sum_constraint.py": {
                "passed": 0,
                "total": 102
            }
        },
        "24.34 Road network": {
            "C++: road_network.cc": {
                "passed": 0,
                "total": 50
            },
            "Java: RoadNetwork.java": {
                "passed": 0,
                "total": 50
            },
            "Python: road_network.py": {
                "passed": 0,
                "total": 50
            }
        },
        "24.35 Test if arbitrage is possible": {
            "C++: arbitrage.cc": {
                "passed": 0,
                "total": 201
            },
            "Java: Arbitrage.java": {
                "passed": 0,
                "total": 201
            },
            "Python: arbitrage.py": {
                "passed": 0,
                "total": 201
            }
        }
    }
};