The Complexity of Simplicity

Tips on designing POS material with optimization in mind

Administrator — Sat, 27 Feb 2010 19:52:37 +0000

Last month we were working with our manufacturing company on a new footwear wall system for good level stores. While watching the design, I insisted on the company logo, which was located in the upper middle section, just like most logos are, flat against the wall, be repositioned as a perpendicular piece, right smack on the center between two shoe-shelves.

The designer had mixed feelings about my proposition (as most designers do when you change their ideas around) but I proceeded to explain why.

A good level store is one where you merchandise good level product, that sells in fairly good volumes, but limited to entry-level and core shoes. The price is usually a factor, and despite being good outlets for mass, it is not your primary channel for brand development (or at least it should not.)

Thus, the imperative is not so much highlighting your brand but optimizing volume in the wall for turnover. In my particular case, the 48 SKU wall had two options for the logo: displaying it prominently flat against the wall with excellent view at the cost the space equivalent of 4 SKU (and reducing capacity to 44 SKU), or displaying the logo perpendicular to the wall, less prominently, and enjoying a full capacity of shoes.

Good stores are small. In my case in Colombia, they are narrow yet deep. With 4 meters from wall to wall, not a lot of people get to see the logo flat against the panels. But since the store is deep, a lot of people will see the logo standout in their view into the store. But that is not so much the case as optimizing turnover.

If you lose 4 SKU, at retail price, you lose a lot. Average retail price is 70 USD for a shoe. When you take 4 SKU down, you are taking down 48 shoes, since the average case in musical size run for any brand in Latin America is 12 shoes. Further more, if you get a decent rotation of 4 times per year, the industry standard, you lost the sale of 48 x 4 = 192 shoes, which at 70 USD retail price equal 13,440 dollars.

And that is one wall. My particular project was about rolling out an initial one hundred walls, so the final sales lost to brand exposure would have summed 1,344,000 dollars. One million three hundred and forty four dollars is a lot of money to lose just for not wanting to change the logo positioning in a footwear panel.

I explained this in my usual college professor way, so the design team not only took it well, but learned a little of retail math and sales optimization along the way. A lot of point-of-sale material is designed to create impact and awareness but when the purpose is more about storage and sales, optimizing for better turnover (function over form) might be the better case.

Let the marketing guys worry about creating brand awareness…

Farewell to ELR

Administrator — Tue, 16 Feb 2010 02:03:44 +0000

I can not describe all the fun moments I had with ELR, the Extra Life Radio podcast. I still remember laughing so hard inside my office, while people who passed by wondered what in hell I was doing with tears running down my eyes. From 2007 until last week I enjoyed every week or so the rumblings and nerd comments from Scott Johnson, Obsidian and Brian Dunnway. Thanks to my job, I was even able to meet Obsidian, a Medellin-based web comic, in person, which is probably one of the best things that happened to me in life.

In every show, Scott and his minions would jump into every nerd movie, video game, comic, show, and being they could get their hands on, and argue, discuss and even sometimes agree on issues. I had some depressive times in my life, but whenever the pressure got to me, I would search the archives for a particularly nasty show and blast away the speakers in iTunes. The topics ranged from video game reviews (How are the graphics? was the name of the section) to movies (Iron Man and Transformers) to the particular and philosophical anecdotes from Obsidian.

Each had a particular style. Brian was the quiet, mild-manner and supportive spokesperson. Obsidian was rough and provocative, always on the edge of things and represented the more radical side of things. Scott was the foundation of the program and the host of ELR, a prolific nerd/father/social communicator whose function in every show was to serve as catalytic to O’s audacity and Brian’s politically correctness. The trio functioned perfectly, and if one was missing, the program lacked the punch from the triumvirate formula.

Perhaps the one thing I will always carry on my head is the early musical curtain, the theme for Mario Bros games, especially one played using a xylophone.

I can understand that after five years the crew felt the need to move to better and more productive things (Scott Johnson owns several podcast, some as The Instance, with very large followings.) But never the less, I will miss the show and I find it hard to believe that I will find another podcast to ever replace it.

A Little Business Gratitude

Administrator — Sun, 14 Feb 2010 04:06:01 +0000

Let me share a little piece of advice that will make your sales sky-rocket. It’s called a little business gratitude.

And it’s very simple. Show me a little gratitude. For example, return my calls. You called me a thousand times to get my money, now that I have a problem, don’t make me go cell-hunting for some help. Return my calls, even if we don’t have a solution at hand. It will make me feel better. It’s as easy as picking up the phone and confronting me. Because if you return my calls and you even provide me a solution, you have a loyal, returning customer for life. One who might even recommend you to lots of friends and business partners and spread the word about your business.

Also, show up at meetings. And you can even give me great service or a product and commit. Certain company who used to be my ISP provider never gave me a good service. I called them once, twice, three times and they never solved the problem. The new company is not very nice, but I admit I never had to call them because their service is top notch. If they did called me, I would probably upgrade my service because it’s good. But since they show no gratitude, I won’t. And it’s a shame, they have a good product, they could get more sales just by sending me a mail and making me feel special…

A customer called to complain last Friday, and I took the call. I had someone in the case in the next five minutes. You know what? We were right, he was just confused, we had delivered the goods on time and quantity and quality, he just needed a little direction. We provided it in minutes, and case solved. I know he is happy, and it only took a call. He knows we are in 24/7, 365 days a year behind our customers.

Show a little gratitude, it goes a long way. And it will make you feel warm inside.

Solution to Project Euler problem 25

Administrator — Sat, 13 Feb 2010 01:27:40 +0000

At first the problem seems easy:

Problem 25

The Fibonacci sequence is defined by the recurrence relation:

F_n = F_n1 + F_n2 , where F₁ = 1 and F₂ = 1.

Hence the first 12 terms will be:

F₁ = 1
F₂ = 1
F₃ = 2
F₄ = 3
F₅ = 5
F₆ = 8
F₇ = 13
F₈ = 21
F₉ = 34
F₁₀ = 55
F₁₁ = 89
F₁₂ = 144

The 12th term, F₁₂, is the first term to contain three digits.

What is the first term in the Fibonacci sequence to contain 1000 digits?

The Solution

At first, one would think the solution is easy. All you need to do is evaluate the length of the answer of Fibonacci terms until you get the first one with 1.000 digits. So you use your Python magic:

^?View Code PYTHON

def fib(n):
if n == 0:
  return 0
elif n == 1:
  return 1
else:
  return fib(n-1) + fib(n-2)
 
n = 0
digitsLen = 0
 
while digitsLen &lt; 1000:
  digitsLen = (len(str(fib(n))))
  n = n + 1
 
print (n-1), digitsLen

Now, that works for a small series, but not for a bigger series, since you hit two problems. The first one is that recursive algorithms are, well, recursive. The magic behind Python that makes the return fib(n-2) + fib(n+1) function works gets really slow as n gets bigger. Second, the recursive algorithm has a limit. Once you exceed that limit you get error messages at running time.

At first I thought that the recursive algorithm kept calculating known values each time the loop incremented, and I was better off saving those values in a map, so instead of cycling inside the loop all I had to do was ask if the value was known (by using the map index) and returning the value if truth, or calculating the value if false.

Then I realized all this was true yet not necessary. You only need to keep two known values at any time, n-2 and n-1. This is all the record keeping worth taking, as you never go deeper than n-2 for this result to be known (but not necessarily for more general solutions of Fibonacci series).

Thus this second solution (rather trivial) was born:

^?View Code PYTHON

## Project Euler Number 25
 
digitsLen = 0
nMinus1 = 1
nMinus2 = 1
n = 2
 
while digitsLen &lt; 1000:
    n = n + 1
    digitsLen = len(str(nMinus1 + nMinus2))
    nMinus2 = nMinus1
    nMinus1 = answer
 
print "solution is Fibonacci sequence ", n, " with digits", digitsLen

It runs in a few seconds in my laptop, and I was taken by surprise by how easy the solution algorithm is.

Project Euler Problem 22

Administrator — Thu, 31 Dec 2009 02:29:09 +0000

The Problem:
Using names.txt (right click and ‘Save Link/Target As…’), a 46K text file containing over five-thousand first names, begin by sorting it into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.

For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would obtain a score of 938 × 53 = 49714.

What is the total of all the name scores in the file?

The Solution:

^?View Code PYTHON

def getValue(name):
    counter = 0
    for letter in name:
        counter = counter + (ord(letter)-64)
    return counter
 
# Open the file and parse into a list without commas
f = open("names.txt")
names = f.readline()
f.close()
namesList = names.split(",")
 
# Now dump into a list and strip those nasty aphostrophes
nList = []
for names in namesList:
    names = names.strip('"')
    nList.append(names)
 
nList.sort()
 
totalSum = 0
counter = 0
 
for names in nList:
    counter = counter + 1
    totalSum = totalSum + (getValue(names) * counter)
 
print "The solution is ", totalSum

Enjoy!

Project Euler Problem 21

Administrator — Thu, 31 Dec 2009 01:05:54 +0000

The problem:

Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n).
If d(a) = b and d(b) = a, where a b, then a and b are an amicable pair and each of a and b are called amicable numbers.

For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.

Evaluate the sum of all the amicable numbers under 10000.

The solution:

^?View Code PYTHON

def properDivisor(n):
    listProperDivisor = []
 
    for i in range(1, (int(n/2)+1)):
        if n%i == 0:
            listProperDivisor.append(i)
 
    return listProperDivisor
 
def sumList(aList):
 
    total = 0
 
    for number in aList:
        total = total + number
    return total
 
def checkAmicablePair (n,m):
    if (sumList(properDivisor(n)) == m) and (sumList(properDivisor(m)) == n) and (n <> m):
        return 1
 
listAmicablePairs = []
counterAmicablePairs = 0
sumAmicablePairs = 0
 
for x in range (1,10001):
    tempList = properDivisor(x)
    tempVar = sumList(tempList)
    if checkAmicablePair(x, tempVar) == 1:     
        listAmicablePairs.append([x, tempVar])
        counterAmicablePairs = counterAmicablePairs + 1
        sumAmicablePairs = sumAmicablePairs + x + tempVar
 
print "TOTAL AMICABLE PAIRS ", counterAmicablePairs
print listAmicablePairs
print
 
print "Evaluation of exclusive sum = ", sumAmicablePairs / 2

Reinventing the blog

Administrator — Wed, 30 Dec 2009 16:39:34 +0000

No, I did not want to reinvent the blog. It happened by accident.

What I was really trying to do was add some sort of capacity to make code indentation possible. I have again taken on my passion for solving problems using Python, and trying to up my (miserable) score at Project Euler. Every time you solve a problem you get the chance to visit the forums and leave your solution. But people are so far ahead of the game, and some of the problems I am trying to solve are so old, that the forums for those I manage to solve are closed. Unable to keep quiet and not leave my little grain of sand in the programming world, I was looking for a way to add neatly tabulated Python code on the website, and while trying some plugins, the database corrupted.

This is not new, it has happened several times in my Yahoo! hosting life, and I wonder why I still keep using Small Business as my hosting provider…

Anyway, it took the better part of the day to reinstall Wordpress 2.9 and find a theme I liked. I am not sure about the capabilities of F8 LITE, but if needs come to be, we’ll get under the hood and add more PHP code to support other functions.

Enjoy!