Warmup-2 completed

Author: akiltipu

Warmup-2/ string_times.py

@@ -0,0 +1,20 @@
+
+# Given a string and a non-negative int n,
+# return a larger string that is n copies of the original string.
+
+
+# string_times('Hi', 2) → 'HiHi'
+# string_times('Hi', 3) → 'HiHiHi'
+# string_times('Hi', 1) → 'Hi'
+
+def string_times(str, n):
+    return str*n
+
+
+
+# Official Solution:
+# def string_times(str, n):
+#   result = ""
+#   for i in range(n):  # range(n) is [0, 1, 2, .... n-1]
+#     result = result + str  # could use += here
+#   return result

Warmup-2/array123.py

@@ -0,0 +1,14 @@
+# Given an array of ints, 
+# return True if the sequence of numbers 1, 2, 3 appears in the array somewhere.
+
+
+# array123([1, 1, 2, 3, 1]) → True
+# array123([1, 1, 2, 4, 1]) → False
+# array123([1, 1, 2, 1, 2, 3]) → True
+
+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
+

Warmup-2/array_count9.py

@@ -0,0 +1,21 @@
+# Given an array of ints, return the number of 9's in the array.
+
+
+# array_count9([1, 2, 9]) → 1
+# array_count9([1, 9, 9]) → 2
+# array_count9([1, 9, 9, 3, 9]) → 3
+
+
+def array_count9(nums):
+    return nums.count(9)
+
+
+# Solution:
+# def array_count9(nums):
+#   count = 0
+#   # Standard loop to look at each value
+#   for num in nums:
+#     if num == 9:
+#       count = count + 1
+
+#   return count

Warmup-2/array_front9.py

@@ -0,0 +1,27 @@
+# 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.
+
+
+# array_front9([1, 2, 9, 3, 4]) → True
+# array_front9([1, 2, 3, 4, 9]) → False
+# array_front9([1, 2, 3, 4, 5]) → False
+
+def array_front9(nums):
+    if len(nums) <= 4:
+        return 9 in nums
+    else:
+        return 9 in nums[:4]
+
+
+# Solution:
+# def array_front9(nums):
+#   # First figure the end for the loop
+#   end = len(nums)
+#   if end > 4:
+#     end = 4
+  
+#   for i in range(end):  # loop over index [0, 1, 2, 3]
+#     if nums[i] == 9:
+#       return True
+#   return False

Warmup-2/front_times.py

@@ -0,0 +1,30 @@
+
+# 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;
+
+
+# front_times('Chocolate', 2) → 'ChoCho'
+# front_times('Chocolate', 3) → 'ChoChoCho'
+# front_times('Abc', 3) → 'AbcAbcAbc'
+
+
+def front_times(str, n):
+    if len(str) <= 3:
+        return str * n
+    else:
+        return str[:3] * n
+
+
+# Official Solution:
+# def front_times(str, n):
+#   front_len = 3
+#   if front_len > len(str):
+#     front_len = len(str)
+#   front = str[:front_len]
+  
+#   result = ""
+#   for i in range(n):
+#     result = result + front
+#   return result

Warmup-2/last2.py

@@ -0,0 +1,19 @@
+# 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).
+
+
+# last2('hixxhi') → 1
+# last2('xaxxaxaxx') → 1
+# last2('axxxaaxx') → 2
+
+def last2(str):
+    if len(str) < 2:
+        return 0
+    last2 = str[len(str)-2:]
+    count = 0
+    for i in range(len(str)-2):
+        sub = str[i:i+2]
+        if sub == last2:
+            count += 1
+    return count

Warmup-2/string_bits.py

@@ -0,0 +1,25 @@
+# Given a string, return a new string made of every other char starting with the first, 
+# so "Hello" yields "Hlo".
+
+
+# string_bits('Hello') → 'Hlo'
+# string_bits('Hi') → 'H'
+# string_bits('Heeololeo') → 'Hello'
+
+def string_bits(str):
+    result = ''
+    for i in range(len(str)):
+        if i % 2 == 0:
+            result += str[i]
+    return result
+
+
+# Official Solution:
+# def string_bits(str):
+#   result = ""
+#   # Many ways to do this. This uses the standard loop of i on every char,
+#   # and inside the loop skips the odd index values.
+#   for i in range(len(str)):
+#     if i % 2 == 0:
+#       result = result + str[i]
+#   return result

Warmup-2/string_match.py

@@ -0,0 +1,22 @@
+# Given 2 strings, a and b, return the number of the positions 
+# where they contain the same length 2 substring.
+# So "xxcaazz" and "xxbaaz" yields 3, since the "xx", "aa", and "az"
+# substrings appear in the same place in both strings.
+
+
+# string_match('xxcaazz', 'xxbaaz') → 3
+# string_match('abc', 'abc') → 2
+# string_match('abc', 'axc') → 0
+
+
+def string_match(a, b):
+    shorter = min(len(a), len(b))
+    count = 0
+  
+    for i in range(shorter-1):
+        a_sub = a[i:i+2]
+        b_sub = b[i:i+2]
+    
+    if a_sub == b_sub:
+        count += 1
+    return count

Warmup-2/string_splosion.py

@@ -0,0 +1,13 @@
+
+# Given a non-empty string like "Code" return a string like "CCoCodCode".
+
+
+# string_splosion('Code') → 'CCoCodCode'
+# string_splosion('abc') → 'aababc'
+# string_splosion('ab') → 'aab'
+
+def string_splosion(str):
+    result = ''
+    for i in range(len(str)+1):
+        result += str[:i]
+    return result