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-------------------------- 33 Answers
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)) This is how I did.
For the first part of the code I just used the hint they give to us.
In Chapter 4 / Practice Project / Character Picture Grid we've learned how to "rotate" and then print a list of lists. It was useful for the second part of my code.
#!/usr/bin/python3 # you can think of x and y as coordinates tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(table): # create a new list of 3 "0" values: one for each list in tableData colWidths = [0] * len(table) # search for the longest string in each list of tableData # and put the numbers of characters in the new list for y in range(len(table)): for x in table[y]: if colWidths[y] < len(x): colWidths[y] = len(x) # "rotate" and print the list of lists for x in range(len(table[0])) : for y in range(len(table)) : print(table[y][x].rjust(colWidths[y]), end = ' ') print() x += 1 printTable(tableData) Here you go young padawan:
tableData=[['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] maxlen = 0 for fruit,name,animal in zip(tableData[0], tableData[1], tableData[2]): maxlen = max(len(fruit) + len (name) + len (animal), maxlen) for fruit,name,animal in zip(tableData[0], tableData[1], tableData[2]): length = len(fruit) + len (name) + len (animal) print ((' ' * (maxlen - length)) + fruit, name, animal) Looping to determine maxlen is probably not optimal, copypasting was just the quickest thing that came to my mind.
3that's my method to solve this problem.
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(mylist): #getting the item who has the max length in the inner tables maxLength = 0 for item in mylist: for i in item: if len(i) > maxLength: maxLength = len(i) else: maxLength = maxLength # make a seperated rjust for every item in the inner lists for item in mylist: for i in range(len(item)): item[i] = (item[i].rjust(maxLength)) # convert list to dictionary data type it's more easier to deal with. myNewlist = {0: [], 1: [], 2: [], 3: []} for i in range(len(item)): for u in tableData: myNewlist[i].append(u[i]) # print the out put :) for key, value in myNewlist.items(): print(''.join(value)) (printTable(tableData)) First join elements, then find the longest one and then you can use %*s to write lines. More in comments in code.
tableData=[['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] longest = 0 # to find the longest line lines = [] # to keep lines for elements in zip(tableData[0], tableData[1], tableData[2]): # join elements in line - like 'apples' + ' ' + 'Alice' + ' ' + 'dogs' line = ' '.join(elements) # add line to the list lines.append(line) #print(line) # you can print it to see what you get # find the longest line length = len(line) if length > longest: longest = length #print('the longest:', longest) longest += 1 # to get one space more at left side # print lines using `%*s` # if `longest` is 21 then it will works as `%21s` for line in lines: print('%*s' % (longest, line)) Here is a solution. It works even if no.of inner lists changes or no.of elements in inner list changes given all inner lists have the same no.of elements.
tableData = [ ['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose'] ] col_widths = list() for i, record in enumerate(tableData): col_widths.insert(i, max(len(item) for item in record)) for i in range(len(tableData[0])): print(' '.join(record[i].rjust(col_widths[j]) for j, record in enumerate(tableData))) I know it has been years, but i started reading the book couple of weeks ago and this is how figured out that one :'D
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] n=0 x='' colWidths=[0]*len(tableData) for i in range(len(tableData)): for n in range(len(tableData[0])-1): if colWidths[i]<len(tableData[i][n])+1: colWidths[i]=len(tableData[i][n])+1 for n in range(len(tableData[n])): x='' for i in range(len(tableData)): x+=str(tableData[i][n]).rjust(colWidths[i]) print(x) I was having exactly the opposite problem: I had already figured out how to determine the parameter for right-justification, and how to right-justify the items. Yet I had difficulty printing several items in one single line. I tried the "end=''" but the output still looked strange. Eventually I tried to concatenate the items to be printed in one line and call the print function one more time in the loop. And it worked.
It took me hours to do this simple exercise but it was definitely worth it!:) It feels really good looking back at how all the incremental improvements finally made the code work!
Here is my code. Hopefully it will help.
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(tableData): colWidths = [0] * len(tableData) for i in range(len(tableData)): for j in range(len(tableData[i])): if colWidths[i] <= len(tableData[i][j]): colWidths[i] = len(tableData[i][j]) else: colWidths[i] = colWidths[i] for j in range(len(tableData[i])): for i in range(len(tableData)): print(''.join(tableData[i][j].rjust(colWidths[i] + 1)), end = '') #the "+ 1" is used to allow for a space in between print() printTable(tableData) Btw, I was surprised that
for j in range(len(tableData[i])): for i in range(len(tableData)): actually worked.
Shouldn't one always use i before j in this case? It seemed counterintuitive to me yet when gave it a try anyway it miraculously worked.
#! python3 #table printer prints takes a list of lists of strings and displays it in a #well-organized table with each column right-justified. tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(data): #in this section we are creating a list containing each column's width colWidths = [0] * len(data) for m in range(len(colWidths)): for n in range(len(data[0])): if colWidths[m] < len(data[m][n]): colWidths[m] = len(data[m][n]) #optionally you can also print colWidths for a better understanding #print(colWidths) will output [8, 5, 5] #this section of the code helps arranging the list in a table format for u in range(len(data[0])): for v in range(len(data)): print(data[v][u].rjust(colWidths[v] + 1), end='') print() printTable(tableData) Based on the author's hint:
"Hint: Your code will first have to find the longest string in each of the inner lists so that the whole column can be wide enough to fit all the strings. You can store the maximum width of each column as a list of integers. The printTable() function can begin with colWidths = [0] * len(tableData), which will create a list containing the same number of 0 values as the number of inner lists in tableData. That way, colWidths[0] can store the width of the longest string in tableData[0], colWidths[1] can store the width of the longest string in tableData[1], and so on. You can then find the largest value in the colWidths list to find out what integer width to pass to the rjust() string method."
Here is my answer:
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def table_printer(tab_data): col_widths = [0] * len(tab_data) # creates 3 lists based on the list length for j in range(len(tab_data[0])): # finds a length of 4 items (aka rows) for i in range(len(tab_data)): # finds a length of 3 items (aka columns) col_widths[i] = len((max(tab_data[i], key=len))) # sets the column width to the maximum length of an item in the list a = tab_data[i][j] print(a.rjust(col_widths[i]), end=" ") # every time we print a column, we rjust it to the max width. print("\n") table_printer(tableData) So this is what I ended up with..without too much internet help. That print line sucks however. I liked some of the above but wasn't going to copycat.
tableData = [['apples','oranges','cherries','banana'], ['Alice','Bob','Carol','David'], ['dogs','cats','moose','goose']] def printTable(): colWidths=[0]*len(tableData) for i in range(len(tableData)): for x in range(len(tableData[i])): if colWidths[i]<len(tableData[i][x]): colWidths[i]=len(tableData[i][x]) for x in range(len(tableData[i])): print(tableData[0][x].rjust(colWidths[0]+1) + tableData[1][x].rjust(colWidths[1]+1) + tableData[2][x].rjust(colWidths[2]+1)) printTable() The print comes out correct, but I do not like how it doesn't allow for a dynamic use. Back to the drawing board on the print line.
def print_table(tab): for j in range(len(tab[0])): for i in range(len(tab)): m = max([len(s) for s in tab[i]]) print(tab[i][j].rjust(m), end=' ') print('') tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] print_table(tableData) Here's how I did it, using both the hint and only information used in the book so far.
This code works no matter how many sublists are within tableData, and no matter how many items are in each sublist.
I used a loop within a loop to achieve this, and print a space after each printed item. If it's the last category item, then print a new line.
tableData = [['apples', 'oranges', 'cherries', 'banana','orange'], ['Alice', 'Bob', 'Carol', 'David','Phillip'], ['dogs', 'cats', 'moose', 'goose','anteater'], ['mitsubishi','honda','toyota','ford','range rover']] def printTable(table): colWidths = [0] * len(table) for i in range(len(table)): for x in table[i]: if len(x) > colWidths[i]: colWidths[i] = len(x) print(colWidths) for i in range(len(table[0])): for x in range(len(table)): print(table[x][i].rjust(colWidths[x]),end = ' ') if x == len(table)-1: print('\r') printTable(tableData) ''' table[0,0] + table [1,0] + table [2,0] table[1,0] + table [1,1] ''' So many different solutions! The book teaches us to each range(len(x)) and I've read online that this is not a good way of getting indexes. A better suggested solution is enumerate which I used in my code, you can find more information here:
#! python3 # printTable.py - Displays a list in a well organized table tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] columnWidth = [] # Creates a empty list def printtable(printdata): for data in printdata: # Adds the length of the longest string to the columnWidth list columnWidth.append(len(max(data, key=len))) # For loop to decide the determine the number of columns to cycle through for x, columnData in enumerate(printdata[0]): # For loop for the number of rows to cycle through for y, rowData in enumerate(printdata): # Print each row data with the correct justification print(printdata[y][x].rjust(columnWidth[y]), end=' ') # Create a new line before reiterating print('') printtable(tableData) I think this would be the answer if you follow the book. Tips and what you have learned so far included.
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] Create the function 'printTable'. First thing is getting the length of the 3 longest string in the 3 lists and putting the integer values in de list 'colWidths'
def printTable(table): colWidths = [0] * len(table) # The tip from the book for i in range(len(table)): for s in range(len(table[i])): l = len(table[i][s]) # get the length of the individual strings if colWidths[i] < l: # check wich one is the longest colWidths[i] = l # save the value in the list Next part of the function is getting the right column oirder from the items in the list. I've had some troubl;e with this part, but eventually i've got it.
for x in range(len(table[0])): for y in range(len(table)): if y == len(table) - 1: print(table[y][x].rjust(colWidths[y], ' ')) else: print(table[y][x].rjust(colWidths[y], ' '), end=' ') execute the function:
printTable(tableData) My solution below.
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(tableData): finalList = [] for i in range (0, 4): #iterate through each list in tableData for lists in tableData: #value of longest string in each list longestValue = len(max(lists, key=len)) #add each value list0[0], list1[0], etc. to finalList... #width = longestValue finalList += lists[i].rjust(longestValue) + " " #skip to new line at end of sequence finalList += '\n' #join list into a string for output s = '' finalList = s.join(finalList) #return final list as a formatted string print(finalList) printTable(tableData) To be more dynamic, I have written the script in Python 3.
tableData = [['apples', 'oranges', 'cherries', 'banana', 'dragonfruit'], ['Alice', 'Bob', 'Carol', 'David', 'Steve'], ['dogs', 'cats', 'moose', 'goose', 'lioness']] """ apples Alice dogs oranges Bob cats cherries Carol moose banana David goose dragonfruit Steve lioness """ results = [] final = [] list_length = 0 elements_length = 0 long_str = {} def printTable(tableData, list_length): # Get the max elements which exists inside list of list for elements in tableData: if list_length != len(elements): list_length = len(elements) # To create keys to store the maximum length of string in the list of ist for i, names in enumerate(tableData): col = 'col' col = col + str(i+1) max_length = 0 for name in names: if len(name) > max_length: max_length = len(name) long_str[col] = max_length else: pass # To gather the elements across multiple lists based on their index value for iteration in range(list_length): initial_list = [] for element in tableData: initial_list.append(element[iteration]) results.insert(iteration, initial_list) # To right adjust all the elements in the list of list for i, result in enumerate(results): indent_list = [] for index in range(len(result)): col_no = 'col' + str(index+1) indent_list.append(result[index].rjust(long_str[col_no])) final.insert(i, indent_list) # To get the string like output for final_element in final: print(' '.join(final_element)) printTable(tableData, list_length)So, I know this is an old answer but some people are starting to learn python just now, and this book is amazing! Here is my answer, I think it's a bit simpler than what other's wrote:
#! Python 3 #Table printer tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def Tableprinter(tableData): listademax=[] for i in range(len(tableData)): listademax.append(len(max(tableData[i],key=len))) elmax=int(max(listademax)) for m in range(len(tableData[0])): for n in range(len(tableData)): print(tableData[n][m].rjust(elmax),end=' ') print() Tableprinter(tableData) W = 3 H = 4 def printTable(table): colWidth = [] for i in range(W): r =[] for j in range(H): count = len(table[i][j]) r.append(count) colWidth.append(r) right = [] for i in range(len(colWidth)): m = max(colWidth[i]) right.append(m) for j in range(H): for i in range(W): print(table[i][j].rjust(right[i]), end = ' ') print() tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] printTable(tableData) tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(): #List colWidth contains the longest string in each of the inner lists colWidth=[0]*len(tableData) n=0 #To find the longest string in each of the inner lists and store in colWidth for li in tableData: num=0 for j in li: if(num<len(j)): num=len(j) colWidth[n]=num n=n+1 #To find the largest value in the colWidths list to find out what integer width to pass to the rjust() string method. c=0 for i in colWidth: if(c<i): c=i #To print the data for m in range(len(tableData[0])): for n in range(len(tableData)): print (tableData[n][m]).rjust(c), print('') printTable() tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(list): len_list = [] for i in range(len(list)): len_list.append(len(max(list[i], key=len))) for m in range(len(list[i])): for i in range(len(list)): print(list[i][m].rjust(len_list[i]+1), end = "") print() #to add a new line printTable(tableData) I think the easiest solution is to find the length of maximum size string in the whole list(inner and outter) and then set it as argument for right justification method (rjust()) then use loops for printing the list values according to the question.
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] innerlen=0 for m in tableData: for n in m: if innerlen < len(n): innerlen = len(n) for m in range(len(tableData[0])): for n in range(len(tableData)): print(tableData[n][m].rjust(innerlen),end="") print("") Here is my approach to the exercise:
#!/usr/bin/env python3 tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose','goose']] def printTable(): colWidths = [0] * len(tableData) # find longest word in each list, convert to int # and add to colWidths var for i in range(len(tableData)): for l in tableData[i]: if len(l) >= colWidths[i]: colWidths[i] = len(l) # print and justify using the values from colWidths + 1 for t in range(4): print(tableData[0][t].rjust(colWidths[0]+1) + \ tableData[1][t].rjust(colWidths[1]+1) + \ tableData[2][t].rjust(colWidths[2]+1)) printTable() Maybe not the best way, but here is my solution to the task:
def printtable(listlist): # variable stores the maximum length of the words in the lists lenghtCounter = 0 #8 listCounter = 0 #3 dict = {} for list in listlist: listCounter += 1 wordcounter = 0 for pos in range(len(list)): wordcounter += 1 for word in list[pos:len(list):len(list)]: dict.update({list[pos]: pos}) # length counter will store the longest value if len(word) > lenghtCounter: lenghtCounter = len(word) for i in range(wordcounter): line = [] strline = '' for k, v in dict.items(): if v == i: line.append(k) strline.join(k.ljust(lenghtCounter)) for el in line: strline += el.ljust(lenghtCounter + 5) print(strline) tableData = [ ['apples', 'oranges', 'cherries', 'bananas'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose'] ] printtable(tableData) tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def find_max_length(item_list): #find the length of the "item_list" parameter colWidth = [0] * len(item_list) #an empty list created to hold a single inner list from the #"item_list" parameter not_so_emptylist = [] i = 0 maxlength = 0 #variable to hold max length of an item in the inner list for i in range(len(item_list)): not_so_emptylist = item_list[i] for item in not_so_emptylist: if len(item) > maxlength: maxlength = len(item) colWidth[i] = maxlength maxlength = 0 return colWidth #an empty list to pass colwidth to width = [] def print_table_data(a_list): width = find_max_length(a_list) i = 0 for i in range(4): print(a_list[0][i].rjust(width[0]) + ' ' + a_list[1][i].rjust(width[1]) + ' ' + a_list[2][i].rjust(width[2])) print_table_data(a_list=tableData) Here, first of all we have to calculate the length of longest string in each of inner list, which we will store in the "colWidths" list. After that we will simply traverse through the "tableData" list. But while printing, we need to right justify each string by maximum column width (i.e. stored in colwidth) for that string so that symmetry can be maintained.Else is just printing.
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(t): colWidths=[0] * len(tableData) l=[] for j in range(len(t)): for i in t[j]: l+=[len(i)] colWidths[j]= max(l) l=[] print(colWidths) for j in range(len(t[0])): for i in range(len(t)): print(t[i][j].rjust(colWidths[i]),end=' ') print(end='\n') printTable(tableData) def table_print(tabledata): column=[0]*len(tabledata) for k in range(len(tabledata)): column[k]=len(max(tabledata[k],key=len)) for i in range(len(tabledata[0])): for j in range(len(tabledata)): print(tabledata[j][i].rjust(column[j]+1),end="") print() return table_Data = [['app', 'oranges', 'cherries', 'banana'], ['Ale', 'Bob', 'Crol', 'Dad'], ['dogs', 'cats', 'moose', 'ge']] table_print(table_Data) It's fun to see how everyone does it differently but still gets the same result. I did it like this:
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(table): table_len = [] max_of_table = [] next_item = '' for i in range(len(table)): temp_len = [] for k in range(len(table[i])): temp_len.append(len(table[i][k])) table_len.append(temp_len) for b in table_len: max_of_table.append(max(b)) for a in range(len(table[0])): for s in range(len(table)): next_item = str(table[s][a]) next_item = next_item.rjust(max_of_table[s]) print(next_item, end=' ') print('') printTable(tableData) My solution:
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(table): liste = 0 colWidths = [0] * len(tableData) for lister in table: liste = liste +1 longest =0 for strenge in lister: if len(strenge) > longest: longest = len(strenge) colWidths.insert((liste-1),longest) for i in range(len(lister)): print() for lister in table: print (lister[i].rjust(colWidths[0]),end='') printTable(tableData) This is the simplest way I found to satisfy the goal. Here is my code:
tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] def printTable(myTable): #each column is a different width, so colWidth is a list which contains the width of each column #this is also suggested in the problem itself colWidth=[0]*len(myTable) for x in range(len(myTable)): for item in myTable[x]: if len(item)>colWidth[x]: colWidth[x]=len(item) #printing the table is similar to the exercise at the end of Chapter 4 for a in range (len(myTable[0])): for b in range (len(myTable)): print (str(myTable[b][a]).rjust(colWidth[b]), end = ' ') print('\n') printTable(tableData) 
