Adding Logic 2 and List 2

Author: Jem Chang

List-2/big_diff.py

@@ -0,0 +1,9 @@
+"""
+Given an array length 1 or more of ints, return the difference between the largest and smallest values
+in the array. Note: the built-in min(v1, v2) and max(v1, v2) functions return the smaller or larger of
+two values.
+"""
+def big_diff(nums):
+  maxn = max(nums)
+  minn = min(nums)
+  return abs(maxn-minn)

List-2/centered_average.py

@@ -0,0 +1,9 @@
+"""
+Return the "centered" average of an array of ints, which we'll say is the mean average of the values,
+except ignoring the largest and smallest values in the array.
+If there are multiple copies of the smallest value, ignore just one copy,
+and likewise for the largest value. Use int division to produce the final average.
+You may assume that the array is length 3 or more.
+"""
+def centered_average(nums):
+  return (sum(nums)- max(nums) - min(nums))/(len(nums)-2)

List-2/count_evens.py

@@ -0,0 +1,12 @@
+"""
+Return the number of even ints in the given array. Note: the % "mod" operator computes the remainder,
+e.g. 5 % 2 is 1.
+"""
+def count_evens(nums):
+  count = 0
+  for i in nums:
+    if i % 2 == 0:
+      count = count + 1
+    if i % 2 == 1:
+      count = count
+  return count

List-2/has22.py

@@ -0,0 +1,8 @@
+"""
+Given an array of ints, return True if the array contains a 2 next to a 2 somewhere.
+"""
+def has22(nums):
+  for i in range(len(nums)-1):
+    if nums[i] == 2 and nums[i+1] == 2:
+      return True
+  return False

List-2/sum13.py

@@ -0,0 +1,19 @@
+"""
+Return the sum of the numbers in the array, returning 0 for an empty array.
+Except the number 13 is very unlucky, so it does not count and numbers that come immediately
+after a 13 also do not count.
+"""
+def sum13(nums):
+  a = [i for i,x in enumerate(nums) if x == 13]
+  b = [x+1 for x in a]
+  adjb = list()
+  allpos = list()
+  for i in b:
+    if i < (len(nums)-1) or i == (len(nums)-1):
+      adjb = adjb + [i]
+  allpos = a + adjb
+  all = 0
+  for i in range(len(nums)):
+    if i in allpos: continue
+    all = all + nums[i]
+  return all

List-2/sum67.py

@@ -0,0 +1,19 @@
+"""
+Return the sum of the numbers in the array, except ignore sections of numbers starting with a 6
+and extending to the next 7 (every 6 will be followed by at least one 7). Return 0 for no numbers.
+"""
+# based on online answer
+# create a flag
+def sum67(nums):
+        state=0
+        s=0
+        for n in nums:
+                if state == 0:
+                        if n == 6:
+                                state=1
+                        else:
+                                s+=n
+                else:
+                        if n == 7:
+                                state=0 # else: s = s
+        return s

Logic-2/close_far.py

@@ -0,0 +1,12 @@
+"""
+Given three ints, a b c, return True if one of b or c is "close" (differing from a by at most 1),
+while the other is "far", differing from both other values by 2 or more.
+Note: abs(num) computes the absolute value of a number.
+"""
+def close_far(a, b, c):
+  if abs(a-b) <= 1 and abs(a-c) >=2 and abs(b-c) >=2:
+    return True
+  elif abs(a-c) <= 1 and abs(a-b) >=2 and abs(b-c) >=2:
+    return True
+  else:
+    return False

Logic-2/lone_sum.py

@@ -0,0 +1,15 @@
+"""
+Given 3 int values, a b c, return their sum. However, if one of the values is the same as another
+of the values, it does not count towards the sum.
+"""
+def lone_sum(a, b, c):
+  if a == b and b !=c:
+    return c
+  elif b == c and b !=a:
+    return a
+  elif c == a and c !=b:
+    return b
+  elif a == b and b == c:
+    return 0
+  else:
+    return a+b+c

Logic-2/lucky_sum.py

@@ -0,0 +1,14 @@
+"""
+Given 3 int values, a b c, return their sum. However, if one of the values is 13 then it does not count
+towards the sum and values to its right do not count.
+So for example, if b is 13, then both b and c do not count.
+"""
+def lucky_sum(a, b, c):
+  if a == 13:
+    return 0
+  elif b == 13:
+    return a
+  elif c == 13:
+    return a+b
+  else:
+    return a+b+c

Logic-2/make_bricks.py

@@ -0,0 +1,14 @@
+"""
+We want to make a row of bricks that is goal inches long. We have a number of small bricks (1 inch each)
+and big bricks (5 inches each). Return True if it is possible to make the goal by choosing from the
+given bricks. This is a little harder than it looks and can be done without any loops.
+"""
+def make_bricks(small, big, goal):
+# 1. not enough bricks
+  if goal > (small + big*5):
+    return False
+# 2. not enough small bricks
+  if (goal % 5) > small:
+    return False
+  else:
+    return True