Adding 2 non OO approaches to solving this. Hopefully verbose enough to be self

documenting. The second one even gets the corect answer...

Author: r-sharp

puzzles/do_camels_eat_bananas/roddys_attempt/camel_prob.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+
+from method_a import calc_max_bananas_transported as calc_max_bananas_transported_a
+from method_b import calc_max_bananas_transported as calc_max_bananas_transported_b
+
+GLOBAL_BANANA_COUNT = 3000
+MAX_BANANA_CARRY = 1000
+TOTAL_DISTANCE_TO_TRAVEL = 1000
+
+def main():
+
+    print("Calling method A :")
+    bananas_left_A = calc_max_bananas_transported_a( GLOBAL_BANANA_COUNT,
+                                                     MAX_BANANA_CARRY,
+                                                     TOTAL_DISTANCE_TO_TRAVEL)
+
+    print("", "="*30, "\n")
+    print("Calling method B :")
+    bananas_left_B = calc_max_bananas_transported_b( GLOBAL_BANANA_COUNT,
+                                                     MAX_BANANA_CARRY,
+                                                     TOTAL_DISTANCE_TO_TRAVEL)
+    print("\n", "="*30, "\n")
+    print(f"method A reckons I can shift {bananas_left_A}")
+    print(f"method B reckons I can shift {bananas_left_B}")
+    print("", "="*30, "\n")
+
+if __name__ == '__main__':
+    main()

puzzles/do_camels_eat_bananas/roddys_attempt/common_functions.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+def bananas_transported(initial_banana_load, distance, make_return_trip=True):
+    '''Calculated the number of bananas transprted onwards allowing for both
+    single and return trip costs'''
+    bananas_transported = initial_banana_load - distance
+    if make_return_trip:
+        bananas_transported -= distance
+    if bananas_transported < 0 :
+        raise ValueError('Distance too far, the camel has died....')
+    return bananas_transported
+
+def calc_bananas_transported(initial_banana_count, distance, camels_carry_limit):
+    '''Calculates the total number of bananas moved along one leg of the total
+    journey'''
+    bananas_left = initial_banana_count
+    transported_bananas = 0
+    # Iterate over return trips to shift bananas while it's worth doing so :
+    #  i.e. there are more bananas left than it takes to make a final trip
+    #       after a 'full load' has been transported
+    while (bananas_left >  camels_carry_limit + distance):
+        carried_bananas = min(bananas_left, camels_carry_limit)
+        transported_bananas += bananas_transported(carried_bananas, distance,
+                                                   True)
+        bananas_left -= carried_bananas
+    # Make the final one-way trip to next banana_store carrying as many bananas
+    # as possible.
+    carried_bananas = min(bananas_left, camels_carry_limit)
+    transported_bananas += bananas_transported(carried_bananas, distance,
+                                               False)
+    return transported_bananas
+

puzzles/do_camels_eat_bananas/roddys_attempt/method_a.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+
+from common_functions import bananas_transported, calc_bananas_transported
+
+def calc_furthest_limit(bananas_to_shift, camels_carry_limit,
+                        distance_left_to_travel, return_trip=True):
+    '''Theoretically, How far can a camel go at 1 banana/km...
+    Assuming that if there are more bananas than the camel can carry, it needs
+    to make a return trip and can olny go half as far as the number of bananas
+    it can carry. If no return trip, range is limited by the number of banans.'''
+    limit_by_banana = min(bananas_to_shift, camels_carry_limit)
+    # Check if a return trip needs to be made.
+    # I appreciate this is /wrong/ in the case of abandoning bananas not worth
+    # returning for - but that should be handled elsewhere.
+    if (bananas_to_shift > camels_carry_limit):
+        limit_by_banana = limit_by_banana // 2
+    furthest_possible = min(distance_left_to_travel, limit_by_banana)
+    return furthest_possible
+    
+def calc_next_stop(bananas_to_shift, camels_carry_limit,
+                          distance_left_to_travel):
+    '''The cost function : asumes that the highest score of number of bananas
+    transported * distance travelled is the optimum distance to go before making
+    a 'banana store'
+    This turns out to be the wrong approach.
+    2nd attempt was to try and find the minimum cost in terms of bananas eaten
+    per km travelled - it failed also.'''
+    max_banana_miles = 0
+    best_distance = -100
+    best_bananas_transported = -100
+    min_banana_cost = bananas_to_shift
+    best_distance_2 = -100
+    best_bananas_transported_2 = -100
+    furthest_limit = calc_furthest_limit(bananas_to_shift,
+                                         camels_carry_limit,
+                                         distance_left_to_travel)
+    for propsed_distance in range(1,furthest_limit + 1):
+        bananas_transported = calc_bananas_transported(bananas_to_shift,
+                              propsed_distance, camels_carry_limit)
+        banana_miles =  bananas_transported * propsed_distance
+        if banana_miles > max_banana_miles:
+            max_banana_miles = banana_miles
+            best_distance = propsed_distance
+            best_bananas_transported = bananas_transported
+            #print("New high score of {0} moving {1:5d} {2:5d} kilometers".format(
+            #      max_banana_miles, bananas_transported, propsed_distance))
+        #elif banana_miles == max_banana_miles:
+        #    print("Curious_point = got a double identical score of "
+        #          "{0:5d} at {1:5d} and {2:5d}".format(max_banana_miles,
+        #           best_distance, propsed_distance))
+# Second attempt at cost function - even worse than the the first....
+# Then I realised why - you need the cost of the next leg, not the current one
+# to decide where to place the banana store.... I'd be very curious if there was
+# a cost function which would iterate from 1 to n km and calculate a
+# trasportation cost that gave the cutoff for the first leg at the same place as
+# one which works out when the cost of the next leg changes and then calculates
+# how far you can go until that happens...
+#        milage_cost = (bananas_to_shift - bananas_transported) / propsed_distance
+#        bananana_cost = bananas_transported / milage_cost
+#        if bananana_cost < min_banana_cost:
+#            min_banana_cost = bananana_cost
+#            best_distance = propsed_distance
+#            best_bananas_transported = bananas_transported
+#            #print("New best cost of {0} moving {1:5d} {2:5d} kilometers".format(
+#            #      min_banana_cost, bananas_transported, propsed_distance))
+#        #elif milage_cost == min_banana_cost:
+#        #    print("Curious_point = got a double identical cost of "
+#        #          "{0} at {1:5d} and {2:5d}".format(min_banana_cost,
+#        #           best_distance, propsed_distance))
+    return best_distance, best_bananas_transported
+
+    
+def calc_max_bananas_transported(initial_banana_count, camels_carry_limit,
+                                 distance_to_transport):
+    '''Given a total distance to cover, and an intial number of bananas along
+    with a load limit for the camel - calculates the maximum number of bananas
+    that can be delivered to the destination.'''
+    distance_left_to_go = distance_to_transport
+    bananas_left = initial_banana_count
+    while distance_left_to_go > 0:
+        (best_leg, bananas_left) = calc_next_stop(bananas_left,
+                                   camels_carry_limit, distance_left_to_go)
+        distance_left_to_go = distance_left_to_go - best_leg
+        print(f"Have travelled {best_leg},  got {bananas_left} bananas left "
+               f"and {distance_left_to_go} kilometers to go")
+    return bananas_left

puzzles/do_camels_eat_bananas/roddys_attempt/method_b.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+from common_functions import bananas_transported, calc_bananas_transported
+
+def ceil_div(a, b):
+    ''' Ceiling division - rounds up to the next whole integer'''
+    return -(-a // b)
+
+def calc_next_stop(bananas_to_shift, camels_carry_limit,
+                          distance_left_to_travel):
+    ''' Works out distance until the number of bananas remaining is one less
+    load than is currently available. Which is where the 'cost' of onward travel
+    drops'''
+    bananas_avail = bananas_to_eat(bananas_to_shift, camels_carry_limit)
+    distance = how_far_on_a_banana(bananas_to_shift, camels_carry_limit,
+                                   bananas_avail, distance_left_to_travel)
+    return distance
+
+def bananas_to_eat(bananas_to_shift, camels_carry_limit):
+    ''' Works out the numbr of bananas that can be consumed before the number of
+    loads that can be carried drops.'''
+    n_loads_at_next_store = (bananas_to_shift -1) // camels_carry_limit
+    return bananas_to_shift - (n_loads_at_next_store * camels_carry_limit)
+
+def how_far_on_a_banana(bananas_to_shift, camels_carry_limit, bananas_avail,
+                        distance_left_to_travel):
+    '''Given an arbitrary number of bananas to 'consume' and the number of loads
+    to shift onwards - calculates the maximum distance that can be travelled'''
+    no_of_loads = ceil_div(bananas_to_shift, camels_carry_limit)
+    no_of_trips = (no_of_loads * 2) - 1
+    distance = min(bananas_avail // no_of_trips, distance_left_to_travel)
+    if distance == 0 and bananas_to_shift > camels_carry_limit:
+        print("Using emergency banana munch protocol...")
+        no_of_trips -= 2
+        bananas_avail = camels_carry_limit
+        distance = min(bananas_avail // no_of_trips, distance_left_to_travel)
+    return distance
+
+def calc_max_bananas_transported(initial_banana_count, camels_carry_limit,
+                                 distance_to_transport):
+    '''Given a total distance to cover, and an intial number of bananas along
+    with a load limit for the camel - calculates the maximum number of bananas
+    that can be delivered to the destination.'''
+    distance_left_to_go = distance_to_transport
+    bananas_left = initial_banana_count
+    while distance_left_to_go > 0:
+        best_leg = calc_next_stop(bananas_left,
+                                    camels_carry_limit, distance_left_to_go)
+        bananas_left = calc_bananas_transported(bananas_left, best_leg,
+                                                  camels_carry_limit)
+        distance_left_to_go = distance_left_to_go - best_leg
+        print(f"Have travelled {best_leg},  got {bananas_left} bananas left "
+               f"and {distance_left_to_go} kilometers to go")
+    return bananas_left

puzzles/do_camels_eat_bananas/roddys_attempt/test_common_functions.py

@@ -0,0 +1,48 @@
+import pytest
+from common_functions import bananas_transported, calc_bananas_transported
+
+GLOBAL_BANANA_COUNT = 3000
+MAX_BANANA_CARRY = 1000
+TOTAL_DISTANCE_TO_TRAVEL = 1000
+
+TEST_LEG_DISTANCE = 200
+
+def test_bananas_transported_return_trip():
+    return_trip = True
+    no_bananas_transported = bananas_transported(MAX_BANANA_CARRY,
+                                                 TEST_LEG_DISTANCE,
+                                                 return_trip)
+    assert no_bananas_transported == MAX_BANANA_CARRY - ( 2 * TEST_LEG_DISTANCE)
+
+def test_bananas_transported_one_way_trip():
+    return_trip = False
+    no_bananas_transported = bananas_transported(MAX_BANANA_CARRY,
+                                                 TEST_LEG_DISTANCE,
+                                                 return_trip)
+    assert no_bananas_transported == MAX_BANANA_CARRY - TEST_LEG_DISTANCE
+
+def test_bananas_transported_too_far():
+    intial_load = TEST_LEG_DISTANCE // 2
+    return_trip = False
+    with pytest.raises(ValueError):
+        no_bananas_transported = bananas_transported(intial_load,
+                                                     TEST_LEG_DISTANCE,
+                                                     return_trip)
+
+def test_calc_bananas_transported_3000_200km():
+    no_bananas_transported = calc_bananas_transported(GLOBAL_BANANA_COUNT,
+                                                      TEST_LEG_DISTANCE,
+                                                      MAX_BANANA_CARRY)
+    assert no_bananas_transported == 2000
+
+def test_calc_bananas_transported_2600_200km():
+    no_bananas_transported = calc_bananas_transported(2600,
+                                                      TEST_LEG_DISTANCE,
+                                                      MAX_BANANA_CARRY)
+    assert no_bananas_transported == 1600
+
+def test_calc_bananas_transported_too_far():
+    with pytest.raises(ValueError):
+        no_bananas_transported = calc_bananas_transported(2600,
+                                                          600,
+                                                          MAX_BANANA_CARRY)

puzzles/do_camels_eat_bananas/roddys_attempt/test_method_a.py

@@ -0,0 +1,78 @@
+import pytest
+from method_a import calc_furthest_limit, calc_next_stop, calc_max_bananas_transported
+
+GLOBAL_BANANA_COUNT = 3000
+MAX_BANANA_CARRY = 1200
+TOTAL_DISTANCE_TO_TRAVEL = 1000
+
+TEST_LEG_DISTANCE = 200
+
+def test_calc_furthest_limit_sub_full_load():
+    '''If the number of bananas you've got is less than a full load, you don't
+    need to come back for a second load and the furtest you could go is 1km for
+    every banana you have.'''
+    bananas_to_shift = max(MAX_BANANA_CARRY-100, 1)
+    max_theoretical_distance = bananas_to_shift
+    furthest_limit = calc_furthest_limit(bananas_to_shift, MAX_BANANA_CARRY,
+                                         max_theoretical_distance)
+    assert furthest_limit == max_theoretical_distance
+
+def test_calc_furthest_limit_exceed_full_load():
+    '''If the number of bananas you have is greater than a full load, you need
+    to come back for the others and the furthest you can go is 1k for every 2
+    babnanas you can carry.
+    : I realise this is actually wrong - there is a case where it is more
+    efficient to abandon some bananas and not come back. Initially the 'cost
+    function' was supposed to highlight that distance and this was just the
+    furthest theoretical - it's still wrong because that approach is flawed :
+    Discuss.....'''
+    bananas_to_shift = MAX_BANANA_CARRY+100
+    furthest_limit = calc_furthest_limit(bananas_to_shift, MAX_BANANA_CARRY,
+                                         TOTAL_DISTANCE_TO_TRAVEL)
+    assert furthest_limit == MAX_BANANA_CARRY // 2
+
+def test_calc_furthest_limit_last_leg():
+    '''If you've got more bananas than the distance to the final goal, but less
+    than a full load so no return trip will be required, the furthest you need
+    to go is the remaining distance.'''
+    bananas_to_shift = max(MAX_BANANA_CARRY-1, 1)
+    distance_remaining = max(bananas_to_shift-1 , 1)
+    furthest_limit = calc_furthest_limit(bananas_to_shift, MAX_BANANA_CARRY,
+                                         distance_remaining)
+    assert furthest_limit == distance_remaining
+
+def test_calc_next_stop_first_leg():
+    '''This is where writing tests post writing code is interesting:
+    A : I didn't know before writing the code what the answer to this function
+    would be - so how do I write a test?.
+    B : After writing the code, and ruuning it I spotted that this function will
+    give the wrong answer and I'm not sure it can be fixed as the methodology is
+    flawed.
+    This test just fails if the answer changes from the first time it was run.'''
+    distance, bananas_left = calc_next_stop(GLOBAL_BANANA_COUNT,
+                                            MAX_BANANA_CARRY,
+                                            TOTAL_DISTANCE_TO_TRAVEL)
+    assert distance == 300
+    assert bananas_left == 1500
+
+def test_calc_next_stop_last_leg():
+    '''This is where writing tests post writing code is interesting:
+    See previous test for reasons.
+    This test just fails if the answer changes from the first time it was run.'''
+    last_leg = max(MAX_BANANA_CARRY // 2, 1)
+    distance, bananas_left = calc_next_stop(MAX_BANANA_CARRY,
+                                            MAX_BANANA_CARRY,
+                                            last_leg)
+    assert distance == last_leg
+    assert bananas_left == MAX_BANANA_CARRY - last_leg
+
+calc_max_bananas_transported
+def test_calc_max_bananas_transported():
+    '''Another test where I didn't know the answer before running the code.
+    So Again, this just tests if the answer has changed from the previous run
+    where a human decidied the answer would do.'''
+    bananas_left = calc_max_bananas_transported(GLOBAL_BANANA_COUNT,
+                                                MAX_BANANA_CARRY,
+                                                TOTAL_DISTANCE_TO_TRAVEL)
+    assert bananas_left == 500
+