Stanley Wilkins - 1 year ago 241

Python Question

In this section, they want us to create this table:

`apples Alice dogs`

oranges Bob cats

cherries Carol moose

banana David goose

It must be justified to the right, and the input is tableData. Here's my code:

`tableData=[['apples', 'oranges', 'cherries', 'banana'],`

['Alice', 'Bob', 'Carol', 'David'],

['dogs', 'cats', 'moose', 'goose']]

listlens=[]

tour=0

lists={}

for m in tableData:

total=0

tour+=1

for n in m:

total+=len(n)

lists["list:",tour]=total

print("list",tour,total)

itemcount=list(lists.values())

sortedlen=(sorted(itemcount,reverse=True))

longest=sortedlen[0]

#print (lists['list:', 1])

#print (longest)

for m in range(len(tableData[0])):

for n in range(len(tableData)):

print (tableData[n][m],end=" ")

n+=1

print ("".rjust(lists['list:', 1],"-"))

m+=1

I'm almost done except for one thing, I can't make it right-justified. This output is the closest I came so far.

`apples Alice dogs ---------------------------`

oranges Bob cats ---------------------------

cherries Carol moose ---------------------------

banana David goose ---------------------------

If I put rjust inside the inner for-loop the output is much different:

`apples-------------------------- Alice-------------------------- dogs--------------------------`

oranges-------------------------- Bob-------------------------- cats--------------------------

cherries-------------------------- Carol-------------------------- moose--------------------------

banana-------------------------- David-------------------------- goose--------------------------

Answer

Here's an alternate method that perhaps you could apply to your own code. I first took `tableData`

and sorted it out into a dictionary so it's easier to work with. After that I found the longest list in terms of characters. This allows us to know how far over the shorter lists should go. Finally, I printed out each lists adding spaces in front of the shorter ones based on the difference from the longest.

```
# orginal data
tableData=[['apples', 'oranges', 'cherries', 'banana'],
['Alice', 'Bob', 'Carol', 'David'],
['dogs', 'cats', 'moose', 'goose']]
# empty dictonary for sorting the data
newTable = {0:[], 1:[], 2:[], 3:[]}
# iterate through each list in tableData
for li in tableData:
for i in range(len(li)):
# put each item of tableData into newTable by index
newTable[i].append(li[i])
# determine the longest list by number of total characters
# for instance ['apples', 'Alice', 'dogs'] would be 15 characters
# we will start with longest being zero at the start
longest = 0
# iterate through newTable
# for example the first key:value will be 0:['apples', 'Alice', 'dogs']
# we only really care about the value (the list) in this case
for key, value in newTable.items():
# determine the total characters in each list
# so effectively len('applesAlicedogs') for the first list
length = len(''.join(value))
# if the length is the longest length so far,
# make that equal longest
if length > longest:
longest = length
# we will loop through the newTable one last time
# printing spaces infront of each list equal to the difference
# between the length of the longest list and length of the current list
# this way it's all nice and tidy to the right
for key, value in newTable.items():
print(' ' * (longest - len(''.join(value))) + ' '.join(value))
```

Source (Stackoverflow)