如果/ else替代

Question

I'm new to programming, but I'm doing a task for an assignment. I've written function so that the amount of Bytes that the user enters is translated into a "human readable" format. Basically to return in the appropriate B,KB,MB,GB,TB.

However, the assignment says we should try writing the code without loops or if statements, but we can use an array.

I was wondering how I might do this...

Here's my current code:

def memory_size(n):
    if n < 1024:
        print n,"B"
    if 1024 <= n < 1048576:
        nKB = n / 1024
        print nKB,"KB"
    if 1048576 <= n < 1073741824:
        nMB = (n / 1024) / 1024
        print nMB,"MB"
    if 1073741824 <= n < 1.099511628*(10**12):
        nGB = ((n / 1024) / 1024) / 1024
        print nGB,"GB"
    if 1.099511628*(10**12) <= n < 1.125899907*(10**15):
        nTB =(((n / 1024) / 1024) / 1024) / 1024
        print nTB,"TB"

Answer 1

Because this is a homework, I'm not going to post a whole code, just going to say that it can feat in a few lines.

take a look at math library specifically to pow and log

You can define you ranges like this:

>>> ranges = ['B', 'KB', 'MB', 'GB', 'TB']

Then

1. log of n and truncate decimal.
2. Calculate the size, using math.pow and the value from #1
3. Print the size and do a lookup to the ranges array by using number from #1 to get a value "b, kb, mb and so on".

This way you will not use any if/else statements or for/while loops.

Answer 2

Without giving you code, because this is homework, the basic approach is that you store the range data (a heap might be a nice solution), and then search through it to find the entry for the given range, and have that entry store the other data you need. Then you, only have one version of the code like this:

nKB = n / 1024
print nKB,"KB"

With the retrieved data in place of the hardcoded constants.

Update:

As DavidRobinson points out, you can't use loops, and any method of searching implicitly or explicitly uses a loop. So, the alternative is to take your input data, and transform it into a form which can be used for a single, constant-time lookup against your chosen datastructure. An array of logarithms is the way to go here, and again map to the data which replaces constants in the above snippet.

Answer 3

Couple thoughts; neither fulfill the requirements, but maybe they'll help your thinking

Method 1: Create a dictionary from lower/upper bounds to divisors and display strings. Loop through the dictionary to find the appropriate entry, then use the values.

Method 2: divide the input by 1024 until it is less than 1024. Use the number of operations to look up the display string.

Answer 4

Just for fun. You can use results of the division on 1024 as dictionary keys. Dictionary can store the resulting data. Here some python 3 code, which solves the task without loops or if statements:

def memory_size(n):
    is_b = int(n >= 1)
    is_kb = int(n / 1024 >= 1)
    is_mb = int(n / 1024**2 >= 1)
    is_gb = int(n / 1024**3 >= 1)
    is_tb = int(n / 1024**4 >= 1)

    array = {}
    array[1, 0, 0, 0, 0] = (0, 'B')
    array[1, 1, 0, 0, 0] = (1, 'KB')
    array[1, 1, 1, 0, 0] = (2, 'MB')
    array[1, 1, 1, 1, 0] = (3, 'GB')
    array[1, 1, 1, 1, 1] = (4, 'TB')

    power, name = array[is_b, is_kb, is_mb, is_gb, is_tb]
    print(n / 1024**power, name)

memory_size(100)
memory_size(1024)
memory_size(1048576)
memory_size(1073741824)
memory_size(1099511627776)

But, of course, likely meant that it must be solved in another way, for example using logarithms.