add solutions to warmup1,2,string1,list1

Author: oookevin53

python/list-1/common_end.py

@@ -0,0 +1,7 @@
+"""
+Given 2 arrays of ints, a and b, return True if they have the same first element
+or they have the same last element. Both arrays will be length 1 or more.
+"""
+
+def common_end(a, b):
+    return a[0] == b[0] or a[-1] == b[-1]

python/list-1/first_last6.py

@@ -0,0 +1,7 @@
+"""
+Given an array of ints, return True if 6 appears as either the first
+or last element in the array. The array will be length 1 or more.
+"""
+
+def first_last6(nums):
+    return 6 == nums[0] or 6 == nums[-1]

python/list-1/has23.py

@@ -0,0 +1,6 @@
+"""
+Given an int array length 2, return True if it contains a 2 or a 3.
+"""
+
+def has23(nums):
+    return 2 in nums or 3 in nums

python/list-1/make_ends.py

@@ -0,0 +1,8 @@
+"""
+Given an array of ints, return a new array length 2 containing the
+first and last elements from the original array. The original
+array will be length 1 or more.
+"""
+
+def make_ends(nums):
+    return [nums[0], nums[-1]]

python/list-1/make_pi.py

@@ -0,0 +1,6 @@
+"""
+Return an int array length 3 containing the first 3 digits of pi, {3, 1, 4}.
+"""
+
+def make_pi():
+    return [3,1,4]

python/list-1/max_end3.py

@@ -0,0 +1,8 @@
+"""
+Given an array of ints length 3, figure out which is larger, the
+first or last element in the array, and set all the other elements
+to be that value. Return the changed array.
+"""
+
+def max_end3(nums):
+    return [nums[-1]] * 3 if nums[-1] > nums[0] else [nums[0]] * 3

python/list-1/middle_way.py

@@ -0,0 +1,7 @@
+"""
+Given 2 int arrays, a and b, each length 3, return a new
+array length 2 containing their middle elements.
+"""
+
+def middle_way(a, b):
+    return [a[len(a)/2], b[len(b)/2]]

python/list-1/reverse3.py

@@ -0,0 +1,7 @@
+"""
+Given an array of ints length 3, return a new array with the elements
+in reverse order, so {1, 2, 3} becomes {3, 2, 1}.
+"""
+
+def reverse3(nums):
+    return nums[::-1]

python/list-1/rotate_left3.py

@@ -0,0 +1,7 @@
+"""
+Given an array of ints length 3, return an array with the elements
+"rotated left" so {1, 2, 3} yields {2, 3, 1}.
+"""
+
+def rotate_left3(nums):
+    return nums[1:] + nums[0:1]

python/list-1/same_first_last.py

@@ -0,0 +1,7 @@
+"""
+Given an array of ints, return True if the array is length 1 or
+more, and the first element and the last element are equal.
+"""
+
+def same_first_last(nums):
+    return len(nums) >= 1 and nums[0] == nums[-1]

python/list-1/sum2.py

@@ -0,0 +1,8 @@
+"""
+Given an array of ints, return the sum of the first 2 elements in
+the array. If the array length is less than 2, just sum up the elements
+that exist, returning 0 if the array is length 0.
+"""
+
+def sum2(nums):
+    return sum(nums[0:2]) if len(nums) > 2 else sum(nums)

python/list-1/sum3.py

@@ -0,0 +1,6 @@
+"""
+Given an array of ints length 3, return the sum of all the elements.
+"""
+
+def sum3(nums):
+    return sum(nums)

python/logic-1/cigar_party.py

@@ -0,0 +1,12 @@
+"""
+When squirrels get together for a party, they like to have cigars.
+A squirrel party is successful when the number of cigars is between
+40 and 60, inclusive. Unless it is the weekend, in which case there
+is no upper bound on the number of cigars. Return True if the party
+with the given values is successful, or False otherwise.
+"""
+
+def cigar_party(cigars, is_weekend):
+    if is_weekend:
+        return cigars >= 40
+    return 60 >= cigars >= 40

python/logic-1/date_fashion.py

@@ -0,0 +1,13 @@
+"""
+You and your date are trying to get a table at a restaurant. The
+parameter "you" is the stylishness of your clothes, in the range
+0..10, and "date" is the stylishness of your date's clothes. The
+result getting the table is encoded as an int value with 0=no,
+1=maybe, 2=yes. If either of you is very stylish, 8 or more, then
+the result is 2 (yes). With the exception that if either of you has
+style of 2 or less, then the result is 0 (no). Otherwise the
+result is 1 (maybe).
+"""
+
+def date_fashion(you, date):
+    if you >= 8 or date >= 8 and you 

python/logic-2/make_chocolate.py

@@ -6,14 +6,12 @@
 
 def make_chocolate(small, big, goal):
 
-  # check if enough chocolate in the first place
+    # check if enough chocolate in the first place
+    if goal > big * 5 + small or goal % 5 > small:
+        return -1
 
-  if goal > big * 5 + small or goal % 5 > small:
-    return -1
+    # if enough, figure out how many big is needed then small
+    elif goal // 5 > big:
+        return goal - big * 5
 
-  # if enough, figure out how many big is needed then small
-
-  elif goal // 5 > big:
-    return goal - big * 5
-
-  return goal - (goal // 5) * 5
+    return goal - (goal // 5) * 5

python/string-1/combo_string.py

@@ -0,0 +1,8 @@
+"""
+Given 2 strings, a and b, return a string of the form short+long+short,
+with the shorter string on the outside and the longer string on the inside.
+The strings will not be the same length, but they may be empty (length 0).
+"""
+
+def combo_string(a, b):
+    return "{}{}{}".format(a,b,a) if len(a) < len(b) else "{}{}{}".format(b,a,b)

python/string-1/extra_end.py

@@ -0,0 +1,7 @@
+"""
+Given a string, return a new string made of 3 copies of the last 2
+chars of the original string. The string length will be at least 2.
+"""
+
+def extra_end(str):
+    return str[-2:] * 3

python/string-1/first_half.py

@@ -0,0 +1,7 @@
+"""
+Given a string of even length, return the first half.
+So the string "WooHoo" yields "Woo".
+"""
+
+def first_half(str):
+    return str[:len(str) / 2]

python/string-1/first_two.py

@@ -0,0 +1,9 @@
+"""
+Given a string, return the string made of its first two chars,
+so the String "Hello" yields "He". If the string is shorter
+than length 2, return whatever there is, so "X" yields "X",
+and the empty string "" yields the empty string "".
+"""
+
+def first_two(str):
+    return str if len(str) < 2 else str[:2]

python/string-1/hello_name.py

@@ -0,0 +1,6 @@
+"""
+Given a string name, e.g. "Bob", return a greeting of the form "Hello Bob!".
+"""
+
+def hello_name(name):
+    return "Hello {}!".format(name)

python/string-1/left2.py

@@ -0,0 +1,7 @@
+"""
+Given a string, return a "rotated left 2" version where the first 2
+chars are moved to the end. The string length will be at least 2.
+"""
+
+def left2(str):
+    return str[2:] + str[:2]

python/string-1/make_abba.py

@@ -0,0 +1,7 @@
+"""
+Given two strings, a and b, return the result of putting them
+together in the order abba, e.g. "Hi" and "Bye" returns "HiByeByeHi".
+"""
+
+def make_abba(a, b):
+    return "{}{}{}{}".format(a,b,b,a)

python/string-1/make_out_word.py

@@ -0,0 +1,8 @@
+"""
+Given an "out" string length 4, such as "<<>>", and
+a word, return a new string where the word is in
+the middle of the out string, e.g. "<<word>>".
+"""
+
+def make_out_word(out, word):
+    return out[:len(out) / 2] + word + out[len(out) / 2:]

python/string-1/make_tags.py

@@ -0,0 +1,9 @@
+"""
+The web is built with HTML strings like "<i>Yay</i>" which draws
+Yay as italic text. In this example, the "i" tag makes <i> and
+</i> which surround the word "Yay". Given tag and word strings,
+create the HTML string with tags around the word, e.g. "<i>Yay</i>".
+"""
+
+def make_tags(tag, word):
+    return "<{}>{}</{}>".format(tag,word,tag)

python/string-1/non_start.py

@@ -0,0 +1,7 @@
+"""
+Given 2 strings, return their concatenation, except omit
+the first char of each. The strings will be at least length 1.
+"""
+
+def non_start(a, b):
+    return a[1:] + b[1:]

python/string-1/without_end.py

@@ -0,0 +1,7 @@
+"""
+Given a string, return a version without the first and last char,
+so "Hello" yields "ell". The string length will be at least 2.
+"""
+
+def without_end(str):
+    return str[1:-1]

python/warmup-1/diff21.py

@@ -0,0 +1,7 @@
+"""
+Given an int n, return the absolute difference between n and 21,
+except return double the absolute difference if n is over 21.
+"""
+
+def diff21(n):
+    return 21 - n if n <= 21 else 2 * (n - 21)

python/warmup-1/front3.py

@@ -0,0 +1,9 @@
+"""
+Given a string, we'll say that the front is the first 3
+chars of the string. If the string length is less than 3,
+the front is whatever is there. Return a new string which
+is 3 copies of the front.
+"""
+
+def front3(str):
+    return str * 3 if len(str) < 3 else str[:3] * 3

python/warmup-1/front_back.py

@@ -0,0 +1,8 @@
+"""
+Given a string, return a new string where the first and last chars have been exchanged.
+"""
+
+def front_back(str):
+    if len(str) <= 1:
+        return str
+    return str[-1] + str[1:-1] + str[0]

python/warmup-1/makes10.py

@@ -0,0 +1,6 @@
+"""
+Given 2 ints, a and b, return True if one if them is 10 or if their sum is 10.
+"""
+
+def makes10(a, b):
+    return a == 10 or b == 10 or a + b == 10

python/warmup-1/missing_char.py

@@ -0,0 +1,9 @@
+"""
+Given a non-empty string and an int n, return a new string where
+the char at index n has been removed. The value of n will be a
+valid index of a char in the original string (i.e. n will be
+in the range 0..len(str)-1 inclusive).
+"""
+
+def missing_char(str, n):
+    return str[:n] + str[n+1:]

python/warmup-1/monkey_trouble.py

@@ -0,0 +1,8 @@
+"""
+We have two monkeys, a and b, and the parameters a_smile and b_smile
+indicate if each is smiling. We are in trouble if they are both smiling
+or if neither of them is smiling. Return True if we are in trouble.
+"""
+
+def monkey_trouble(a_smile, b_smile):
+    return a_smile == b_smile

python/warmup-1/near_hundred.py

@@ -0,0 +1,7 @@
+"""
+Given an int n, return True if it is within 10 of 100 or 200.
+Note: abs(num) computes the absolute value of a number.
+"""
+
+def near_hundred(n):
+    return abs(n - 100) <= 10 or abs(n - 200) <= 10

python/warmup-1/not_string.py

@@ -0,0 +1,8 @@
+"""
+Given a string, return a new string where "not " has been
+added to the front. However, if the string already begins
+with "not", return the string unchanged.
+"""
+
+def not_string(str):
+    return str if str[:3] == 'not' else 'not ' + str

python/warmup-1/parrot_trouble.py

@@ -0,0 +1,8 @@
+"""
+We have a loud talking parrot. The "hour" parameter is the current hour time
+in the range 0..23. We are in trouble if the parrot is talking and the hour
+is before 7 or after 20. Return True if we are in trouble.
+"""
+
+def parrot_trouble(talking, hour):
+    return talking and (hour < 7 or hour > 20)

python/warmup-1/pos_neg.py

@@ -0,0 +1,8 @@
+"""
+Given 2 int values, return True if one is negative and one
+is positive. Except if the parameter "negative" is True,
+then return True only if both are negative.
+"""
+
+def pos_neg(a, b, negative):
+    return a < 0 and b < 0 if negative else a * b < 0

python/warmup-1/sleep_in.py

@@ -0,0 +1,8 @@
+"""
+The parameter weekday is True if it is a weekday, and the parameter
+vacation is True if we are on vacation. We sleep in if it is not a
+weekday or we're on vacation. Return True if we sleep in.
+"""
+
+def sleep_in(weekday, vacation):
+    return True if not weekday or vacation else False

python/warmup-1/sum_double.py

@@ -0,0 +1,7 @@
+"""
+Given two int values, return their sum. Unless the two
+values are the same, then return double their sum.
+"""
+
+def sum_double(a, b):
+    return 4 * a if a == b else a + b

python/warmup-2/array123.py

@@ -0,0 +1,9 @@
+"""
+Given an array of ints, return True if the sequence of numbers 1, 2, 3 appears in the array somewhere.
+"""
+
+def array123(nums):
+    for i in range(len(nums)-2):
+        if nums[i] == 1 and nums[i+1] == 2 and nums[i+2] == 3:
+            return True
+    return False

python/warmup-2/array_count9.py

@@ -0,0 +1,6 @@
+"""
+Given an array of ints, return the number of 9's in the array.
+"""
+
+def array_count9(nums):
+    return nums.count(9)

python/warmup-2/array_front9.py

@@ -0,0 +1,7 @@
+"""
+Given an array of ints, return True if one of the first 4 elements
+in the array is a 9. The array length may be less than 4.
+"""
+
+def array_front9(nums):
+    return 9 in nums[0:4]

python/warmup-2/front_times.py

@@ -0,0 +1,9 @@
+"""
+Given a string and a non-negative int n, we'll say
+that the front of the string is the first 3 chars,
+or whatever is there if the string is less than
+length 3. Return n copies of the front.
+"""
+
+def front_times(str, n):
+    return str * n if len(str) < 3 else str[:3] * n

python/warmup-2/last2.py

@@ -0,0 +1,16 @@
+"""
+Given a string, return the count of the number of times
+that a substring length 2 appears in the string and also
+as the last 2 chars of the string, so "hixxxhi" yields 1
+(we won't count the end substring).
+"""
+
+def last2(str):
+    if len(str) < 3:
+        return 0
+
+    count = 0
+    for i in range(len(str)-2):
+        if str[i:i+2] == str[-2:]:
+            count +=1
+    return count