Tweaked constraints section discussion.

2024-03-22 13:11:13 +08:00 · 2015-07-06 06:03:09 -04:00 · 2015-07-06 06:03:09 -04:00 · fac7bbb1be
commit fac7bbb1be
parent d236679338
60 changed files with 60 additions and 120 deletions
--- a/arrays_strings/compress/compress_challenge.ipynb
+++ b/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",
--- a/arrays_strings/compress/compress_solution.ipynb
+++ b/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",
--- a/arrays_strings/hash_map/hash_map_challenge.ipynb
+++ b/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",
--- a/arrays_strings/hash_map/hash_map_solution.ipynb
+++ b/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",
--- a/arrays_strings/permutation/permutation_challenge.ipynb
+++ b/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",
--- a/arrays_strings/permutation/permutation_solution.ipynb
+++ b/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",
--- a/arrays_strings/reverse_string/reverse_string_challenge.ipynb
+++ b/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",
--- a/arrays_strings/reverse_string/reverse_string_solution.ipynb
+++ b/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",
--- a/arrays_strings/rotation/rotation_challenge.ipynb
+++ b/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",
--- a/arrays_strings/rotation/rotation_solution.ipynb
+++ b/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",
--- a/arrays_strings/unique_chars/unique_chars_challenge.ipynb
+++ b/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",
--- a/arrays_strings/unique_chars/unique_chars_solution.ipynb
+++ b/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",
--- a/linked_lists/add_reverse/add_reverse_challenge.ipynb
+++ b/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",
--- a/linked_lists/add_reverse/add_reverse_solution.ipynb
+++ b/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",
--- a/linked_lists/delete_mid/delete_mid_challenge.ipynb
+++ b/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",
--- a/linked_lists/delete_mid/delete_mid_solution.ipynb
+++ b/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",
--- a/linked_lists/find_loop_start/find_loop_start_challenge.ipynb
+++ b/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",
--- a/linked_lists/find_loop_start/find_loop_start_solution.ipynb
+++ b/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",
--- a/linked_lists/kth_to_last_elem/kth_to_last_elem_challenge.ipynb
+++ b/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",
--- a/linked_lists/kth_to_last_elem/kth_to_last_elem_solution.ipynb
+++ b/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",
--- a/linked_lists/linked_list/linked_list_challenge.ipynb
+++ b/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",
--- a/linked_lists/linked_list/linked_list_solution.ipynb
+++ b/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",
--- a/linked_lists/palindrome/palindrome_challenge.ipynb
+++ b/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",
--- a/linked_lists/palindrome/palindrome_solution.ipynb
+++ b/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",
--- a/linked_lists/partition/partition_challenge.ipynb
+++ b/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",
--- a/linked_lists/partition/partition_solution.ipynb
+++ b/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",
--- a/linked_lists/remove_duplicates/remove_duplicates_challenge.ipynb
+++ b/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",
--- a/linked_lists/remove_duplicates/remove_duplicates_solution.ipynb
+++ b/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",
--- a/online_judges/maximizing_xor/maximizing_xor_challenge.ipynb
+++ b/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)."
   ]
  },
--- a/online_judges/maximizing_xor/maximizing_xor_solution.ipynb
+++ b/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)."
   ]
  },
--- a/online_judges/utopian_tree/utopian_tree_challenge.ipynb
+++ b/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)."
   ]
  },
--- a/online_judges/utopian_tree/utopian_tree_solution.ipynb
+++ b/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)."
   ]
  },
--- a/recursion_dynamic/fibonacci/fibonacci_challenge.ipynb
+++ b/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"
   ]
  },
--- a/recursion_dynamic/fibonacci/fibonacci_solution.ipynb
+++ b/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"
   ]
  },
--- a/sorting_searching/insertion_sort/insertion_sort_challenge.ipynb
+++ b/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"
   ]
--- a/sorting_searching/insertion_sort/insertion_sort_solution.ipynb
+++ b/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"
   ]
--- a/sorting_searching/merge_sort/merge_sort_challenge.ipynb
+++ b/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"
   ]
--- a/sorting_searching/merge_sort/merge_sort_solution.ipynb
+++ b/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"
   ]
--- a/sorting_searching/quick_sort/quick_sort_challenge.ipynb
+++ b/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"
   ]
--- a/sorting_searching/quick_sort/quick_sort_solution.ipynb
+++ b/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"
   ]
--- a/sorting_searching/selection_sort/selection_sort_challenge.ipynb
+++ b/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"
   ]
--- a/sorting_searching/selection_sort/selection_sort_solution.ipynb
+++ b/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"
   ]
--- a/stacks_queues/hanoi/hanoi_challenge.ipynb
+++ b/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"
   ]
--- a/stacks_queues/hanoi/hanoi_solution.ipynb
+++ b/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"
   ]
--- a/stacks_queues/n_stacks/n_stacks_challenge.ipynb
+++ b/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"
   ]
--- a/stacks_queues/n_stacks/n_stacks_solution.ipynb
+++ b/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"
   ]
--- a/stacks_queues/queue_from_stacks/queue_from_stacks_challenge.ipynb
+++ b/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",
--- a/stacks_queues/queue_from_stacks/queue_from_stacks_solution.ipynb
+++ b/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",
--- a/stacks_queues/queue_list/queue_list_challenge.ipynb
+++ b/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",
--- a/stacks_queues/queue_list/queue_list_solution.ipynb
+++ b/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",
--- a/stacks_queues/set_of_stacks/set_of_stacks_challenge.ipynb
+++ b/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",
--- a/stacks_queues/set_of_stacks/set_of_stacks_solution.ipynb
+++ b/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",
--- a/stacks_queues/sort_stack/sort_stack_challenge.ipynb
+++ b/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",
--- a/stacks_queues/sort_stack/sort_stack_solution.ipynb
+++ b/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",
--- a/stacks_queues/stack/stack_challenge.ipynb
+++ b/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"
   ]
  },
--- a/stacks_queues/stack/stack_solution.ipynb
+++ b/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"
   ]
  },
--- a/stacks_queues/stack_min/stack_min_challenge.ipynb
+++ b/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",
--- a/stacks_queues/stack_min/stack_min_solution.ipynb
+++ b/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",
--- a/templates/foo_challenge.ipynb
+++ b/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"
   ]
--- a/templates/foo_solution.ipynb
+++ b/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"
   ]