Tweaked constraints section discussion.

arrays_strings/compress/compress_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/compress/compress_solution.ipynb

@@ -35,8 +35,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/hash_map/hash_map_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* For simplicity, are the keys integers only?\n",
     "    * Yes\n",
     "* For collision resolution, can we use linked lists?\n",

arrays_strings/hash_map/hash_map_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* For simplicity, are the keys integers only?\n",
     "    * Yes\n",
     "* For collision resolution, can we use linked lists?\n",

arrays_strings/permutation/permutation_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/permutation/permutation_solution.ipynb

@@ -35,8 +35,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/reverse_string/reverse_string_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can I assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/reverse_string/reverse_string_solution.ipynb

@@ -36,8 +36,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can I assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/rotation/rotation_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can you assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/rotation/rotation_solution.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can you assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/unique_chars/unique_chars_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can you assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

arrays_strings/unique_chars/unique_chars_solution.ipynb

@@ -37,8 +37,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can you assume the string is ASCII?\n",
     "    * Yes\n",
     "    * Note: Unicode strings could require special handling depending on your language\n",

linked_lists/add_reverse/add_reverse_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Do you expect the return to be in reverse order too?\n",
     "    * Yes\n",
     "* What if one of the inputs is None?\n",

linked_lists/add_reverse/add_reverse_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Do you expect the return to be in reverse order too?\n",
     "    * Yes\n",
     "* What if one of the inputs is None?\n",

linked_lists/delete_mid/delete_mid_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* What if the final node is being deleted, for example a single node list?  Do we make it a dummy with value None?\n",
     "    * Yes\n",
     "* Can we assume we already have a linked list class that can be used for this problem?\n",

linked_lists/delete_mid/delete_mid_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* What if the final node is being deleted, for example a single node list?  Do we make it a dummy with value None?\n",
     "    * Yes\n",
     "* Can we assume we already have a linked list class that can be used for this problem?\n",

linked_lists/find_loop_start/find_loop_start_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is this a singly linked list?\n",
     "    * Yes\n",
     "* Can we assume we are always passed a circular linked list?\n",

linked_lists/find_loop_start/find_loop_start_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is this a singly linked list?\n",
     "    * Yes\n",
     "* Can we assume we are always passed a circular linked list?\n",

linked_lists/kth_to_last_elem/kth_to_last_elem_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume k is a valid integer?\n",
     "    * Yes\n",
     "* If k = 0, does this return the last element?\n",

linked_lists/kth_to_last_elem/kth_to_last_elem_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume k is a valid integer?\n",
     "    * Yes\n",
     "* If k = 0, does this return the last element?\n",

linked_lists/linked_list/linked_list_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is this a singly or doubly linked list?\n",
     "    * Singly\n",
     "* Is this a circular list?\n",

linked_lists/linked_list/linked_list_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is this a singly or doubly linked list?\n",
     "    * Singly\n",
     "* Is this a circular list?\n",

linked_lists/palindrome/palindrome_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a single character or number a palindrome?\n",
     "    * No\n",
     "* Can we assume we already have a linked list class that can be used for this problem?\n",

linked_lists/palindrome/palindrome_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a single character or number a palindrome?\n",
     "    * No\n",
     "* Can we assume we already have a linked list class that can be used for this problem?\n",

linked_lists/partition/partition_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we create additional data structures?\n",
     "    * Yes\n",
     "* Do you expect the function to return a new list?\n",

linked_lists/partition/partition_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we create additional data structures?\n",
     "    * Yes\n",
     "* Do you expect the function to return a new list?\n",

linked_lists/remove_duplicates/remove_duplicates_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is this a singly or doubly linked list?\n",
     "    * Singly\n",
     "* Can you insert None values in the list?\n",

linked_lists/remove_duplicates/remove_duplicates_solution.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is this a singly or doubly linked list?\n",
     "    * Singly\n",
     "* Can you insert None values in the list?\n",

online_judges/maximizing_xor/maximizing_xor_challenge.ipynb

@@ -36,8 +36,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "See the [HackerRank problem page](https://www.hackerrank.com/challenges/maximizing-xor)."
    ]
   },

online_judges/maximizing_xor/maximizing_xor_solution.ipynb

@@ -35,8 +35,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "See the [HackerRank problem page](https://www.hackerrank.com/challenges/maximizing-xor)."
    ]
   },

online_judges/utopian_tree/utopian_tree_challenge.ipynb

@@ -36,8 +36,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "See the [HackerRank problem page](https://www.hackerrank.com/challenges/utopian-tree)."
    ]
   },

online_judges/utopian_tree/utopian_tree_solution.ipynb

@@ -35,8 +35,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "See the [HackerRank problem page](https://www.hackerrank.com/challenges/utopian-tree)."
    ]
   },

recursion_dynamic/fibonacci/fibonacci_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* None"
    ]
   },

recursion_dynamic/fibonacci/fibonacci_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* None"
    ]
   },

sorting_searching/insertion_sort/insertion_sort_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient?\n",
     "    * Yes"
    ]

sorting_searching/insertion_sort/insertion_sort_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient?\n",
     "    * Yes"
    ]

sorting_searching/merge_sort/merge_sort_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient?\n",
     "    * Yes"
    ]

sorting_searching/merge_sort/merge_sort_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient?\n",
     "    * Yes"
    ]

sorting_searching/quick_sort/quick_sort_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient (ie not in-place)?\n",
     "    * Yes"
    ]

sorting_searching/quick_sort/quick_sort_solution.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient (ie not in-place)?\n",
     "    * Yes"
    ]

sorting_searching/selection_sort/selection_sort_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient (ie not stable, not based on a heap)?\n",
     "    * Yes"
    ]

sorting_searching/selection_sort/selection_sort_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is a naiive solution sufficient (ie not stable, not based on a heap)?\n",
     "    * Yes"
    ]

stacks_queues/hanoi/hanoi_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume we already have a stack class that can be used for this problem?\n",
     "    * Yes"
    ]

stacks_queues/hanoi/hanoi_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume we already have a stack class that can be used for this problem?\n",
     "    * Yes"
    ]

stacks_queues/n_stacks/n_stacks_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Are the stacks and array a fixed size?\n",
     "    * Yes"
    ]

stacks_queues/n_stacks/n_stacks_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Are the stacks and array a fixed size?\n",
     "    * Yes"
    ]

stacks_queues/queue_from_stacks/queue_from_stacks_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Do you expect the methods to be enqueue and dequeue?\n",
     "    * Yes\n",
     "* Can we assume we already have a stack class that can be used for this problem?\n",

stacks_queues/queue_from_stacks/queue_from_stacks_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Do you expect the methods to be enqueue and dequeue?\n",
     "    * Yes\n",
     "* Can we assume we already have a stack class that can be used for this problem?\n",

stacks_queues/queue_list/queue_list_challenge.ipynb

@@ -35,8 +35,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* If there is one item in the list, do you expect the first and last pointers to both point to it?\n",
     "    * Yes\n",
     "* If there are no items on the list, do you expect the first and last pointers to be None?\n",

stacks_queues/queue_list/queue_list_solution.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* If there is one item in the list, do you expect the first and last pointers to both point to it?\n",
     "    * Yes\n",
     "* If there are no items on the list, do you expect the first and last pointers to be None?\n",

stacks_queues/set_of_stacks/set_of_stacks_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume we already have a stack class that can be used for this problem?\n",
     "    * Yes\n",
     "* If a stack becomes full, we should automatically create one?\n",

stacks_queues/set_of_stacks/set_of_stacks_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume we already have a stack class that can be used for this problem?\n",
     "    * Yes\n",
     "* If a stack becomes full, we should automatically create one?\n",

stacks_queues/sort_stack/sort_stack_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* When sorted, should the largest element be at the top or bottom?\n",
     "    * Top\n",
     "* Can you have duplicate values like 5, 5?\n",

stacks_queues/sort_stack/sort_stack_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* When sorted, should the largest element be at the top or bottom?\n",
     "    * Top\n",
     "* Can you have duplicate values like 5, 5?\n",

stacks_queues/stack/stack_challenge.ipynb

@@ -35,8 +35,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* None"
    ]
   },

stacks_queues/stack/stack_solution.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* None"
    ]
   },

stacks_queues/stack_min/stack_min_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume this is a stack of ints?\n",
     "    * Yes\n",
     "* If we call this function on an empty stack, can we return max int?\n",

stacks_queues/stack_min/stack_min_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Can we assume this is a stack of ints?\n",
     "    * Yes\n",
     "* If we call this function on an empty stack, can we return max int?\n",

templates/foo_challenge.ipynb

@@ -34,8 +34,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is it foo or bar?\n",
     "    * foo"
    ]

templates/foo_solution.ipynb

@@ -33,8 +33,7 @@
    "source": [
     "## Constraints\n",
     "\n",
-    "*Problem statements are sometimes ambiguous.  Identifying constraints and stating assumptions can help to ensure you code the intended solution.*\n",
+
-    "\n",
     "* Is it foo or bar?\n",
     "    * foo"
    ]