How to print out 2d ascii letters horizontally

I have mapped user input with 2d ascii letters and now I am trying to print out ascii letters below horizontally, so they could be printed side by side not top down as they are right now. Letter height is 8 lines and width varies. I run the code go run . "hello" Could really appriciate some help. I have tried to loop over the Table, but no success and haveb't been able to figure out yet how to print letters side by side.

 _      
| |     
| |__   
|  _ \  
| | | | 
|_| |_| 
        
        
       
       
  ___  
 / _ \ 
|  __/ 
 \___| 
       
       
 _  
| | 
| | 
| | 
| | 
|_| 
    
    
 _  
| | 
| | 
| | 
| | 
|_| 
    
    
        
        
  ___   
 / _ \  
| (_) | 
 \___/  
        
        

I use struct for mapping and storying data on that format below:

{h 104 [[ ] [_] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{h 104 [[|] [ ] [|] [ ] [ ] [ ] [ ] [ ]] []}
{h 104 [[|] [ ] [|] [_] [_] [ ] [ ] [ ]] []}
{h 104 [[|] [ ] [ ] [_] [ ] [\] [ ] [ ]] []}
{h 104 [[|] [ ] [|] [ ] [|] [ ] [|] [ ]] []}
{h 104 [[|] [_] [|] [ ] [|] [_] [|] [ ]] []}
{h 104 [[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{h 104 [[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{e 101 [[ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{e 101 [[ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{e 101 [[ ] [ ] [_] [_] [_] [ ] [ ]] []}
{e 101 [[ ] [/] [ ] [_] [ ] [\] [ ]] []}
{e 101 [[|] [ ] [ ] [_] [_] [/] [ ]] []}
{e 101 [[ ] [\] [_] [_] [_] [|] [ ]] []}
{e 101 [[ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{e 101 [[ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{l 108 [[ ] [_] [ ] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [_] [|] [ ]] []}
{l 108 [[ ] [ ] [ ] [ ]] []}
{l 108 [[ ] [ ] [ ] [ ]] []}
{l 108 [[ ] [_] [ ] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [ ] [|] [ ]] []}
{l 108 [[|] [_] [|] [ ]] []}
{l 108 [[ ] [ ] [ ] [ ]] []}
{l 108 [[ ] [ ] [ ] [ ]] []}
{o 111 [[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{o 111 [[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{o 111 [[ ] [ ] [_] [_] [_] [ ] [ ] [ ]] []}
{o 111 [[ ] [/] [ ] [_] [ ] [\] [ ] [ ]] []}
{o 111 [[|] [ ] [(] [_] [)] [ ] [|] [ ]] []}
{o 111 [[ ] [\] [_] [_] [_] [/] [ ] [ ]] []}
{o 111 [[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}
{o 111 [[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]] []}

My code ascii.go:

import (
	"fmt"
	"os"
	"strings"
)

type letter struct {
	Letter string
	Ascii  int
	Table  [][]string
	Color  []string
}

func mapFont(font string) ([]letter, error) {
	readFile, err := os.ReadFile(font)
	if err != nil {
		return nil, fmt.Errorf("could not read the content in the file: %v", err)
	}
	slice := strings.Split(string(readFile), "\n")

	letters := make([]letter, 0)
	index := 31

	for _, row := range slice {
		if row == "" {
			index++
			continue
		}

		grid := make([][]string, 0)

		for _, char := range row {
			grid = append(grid, []string{string(char)})
		}

		letters = append(letters, letter{
			Letter: string(index),
			Ascii:  index,
			Table:  grid,
		})
	}
	return letters, nil
}

func mapInput(input string, letters []letter) ([]letter, error) {
	lines := strings.Split(input, "\\n")
	output := make([]letter, 0)

	for _, line := range lines {
		characters := []rune(line)

		if line != "" {
			for _, ch := range characters {
				if ch >= 32 && ch <= 126 {
					for _, v := range letters {
						if rune(v.Ascii) == ch {
							output = append(output, v)
						}
					}
				} else {
					return nil, fmt.Errorf("input includes non ascii character(s), please use ascii character(s)")
				}
			}
		} else {
			output = append(output, letter{})
		}
	}
	return output, nil
}

func printLettersSideBySide(mapping []letter) {
	output := ""
	for i := 0; i < len(mapping); i++ {
		for j := 0; j < len(mapping[i].Table); j++ {
			output = output + strings.Join(mapping[i].Table[j], "")
		}
		output = output + "\n"
	}

	fmt.Println(output)
}

main.go

package main

import (
	"fmt"
)

func main() {
	args := os.Args

	banners := "banner/standard.txt"
	str := args[1]

	letter, _ := mapFont(banners)
	mapping, _ := mapInput(str, letter)

    printLettersSideBySide(mapping)

	for _, item := range mapping {
		fmt.Println(item)
	}

}

Leaving answer to others who may need it:

Was able to solve it by making data structure for Table in type letter simpler. Replaced [][]string with []string in and made changes in mapFont function where I used that struct. Then I added new function for printing letters horizontally.

ascii.go

import (
"fmt"
"os"
"strings"
)
type letter struct {
Letter string
Ascii  int
Table  []string
}
func mapFont(font string) ([]letter, error) {
readFile, err := os.ReadFile(font)
if err != nil {
return nil, fmt.Errorf("could not read the content in the file: %v", err)
}
slice := strings.Split(string(readFile), "\n")
letters := make([]letter, 0)
index := 31
for _, row := range slice {
if row == "" {
index++
continue
}
grid := make([]string, 0)
for _, char := range row {
grid = append(grid, string(char))
}
letters = append(letters, letter{
Letter: string(index),
Ascii:  index,
Table:  grid,
})
}
return letters, nil
}
func mapInput(input string, letters []letter) ([]letter, error) {
lines := strings.Split(input, "\\n")
output := make([]letter, 0)
for _, line := range lines {
characters := []rune(line)
if line != "" {
for _, ch := range characters {
if ch >= 32 && ch <= 126 {
for _, v := range letters {
if rune(v.Ascii) == ch {
output = append(output, v)
}
}
} else {
return nil, fmt.Errorf("input includes non ascii character(s), please use ascii character(s)")
}
}
} else {
output = append(output, letter{})
}
}
return output, nil
}
func printInput(str string, letter []letter) []string {
var pixelRows []string
for row := 0; row < 8; row++ {
pixelRow := ""
for letterIndex := 0; letterIndex < len(str); letterIndex++ {
character, _ := mapInput(string(str[letterIndex]), letter)
for column := 0; column < len(character[row].Table); column++ 
pixelRow = pixelRow + character[row].Table[column]
}
}
pixelRows = append(pixelRows, pixelRow)
}
return pixelRows
}

main.go

package main
import (
"fmt"
"os"
)
func main() {
args := os.Args
banners := "banner/standard.txt"
str := args[1]
letter, _ := mapFont(banners)
sentence, _ := mapInput(str, letter)
output := printInput(str, sentence)
for _, v := range output {
fmt.Println(v)
}
}

Output:

❯ go run . "hello"
_              _   _          
| |            | | | |         
| |__     ___  | | | |   ___   
|  _ \   / _ \ | | | |  / _ \  
| | | | |  __/ | | | | | (_) | 
|_| |_|  \___| |_| |_|  \___/