Dictionary (Go map) — Programuoki

Code

Refactor main.go — counting and lookup

Two new powers for YOUR app, both built on maps. Item grows a Category field (Add now asks for it), and the menu gains 4) Stats by category and 5) Find by title — Add / List / Mark read stay.

Grow the struct and the Add flow:

type Item struct {
	Title     string
	Pages     int
	PagesRead int
	Read      bool
	Category  string // NEW
}

			fmt.Print("Category: ")
			category := readLine()
			items = append(items, Item{Title: title, Pages: pages, Category: category})

Counting by category — the m[k]++ pattern. One helper folds the slice into a category → count map:

func countByCategory(items []Item) map[string]int {
	counts := make(map[string]int)
	for _, it := range items {
		counts[it.Category]++ // a missing key starts at 0, then +1
	}
	return counts
}

No "have I seen this category yet?" check — a missing key reads as 0, so ++ just works. showStats (menu 4) ranges the counts and prints them. Remember step 2: that order is random.

Finding by title — comma-ok on a map[string]Item. Build the lookup once, then read it with the comma-ok idiom (menu 5):

func indexByTitle(items []Item) map[string]Item {
	index := make(map[string]Item, len(items))
	for _, it := range items {
		index[it.Title] = it
	}
	return index
}

		case "5":
			fmt.Print("Exact title: ")
			index := indexByTitle(items)
			if it, ok := index[readLine()]; ok {
				fmt.Printf("Found: %s — %d pages, %s\n", it.Title, it.Pages, it.Category)
			} else {
				fmt.Println("Not found.")
			}

The ok is what makes it safe: a missing title gives the zero Item{} with ok == false, so you print "Not found." instead of a blank record.

Verify — add three books in two categories, then stats and find:

> 1
Title: Dune
Pages: 412
Category: sci-fi
Added: Dune
... (add War and Peace / history, Hyperion / sci-fi the same way)

> 4
sci-fi       2
history      1

> 5
Exact title: Dune
Found: Dune — 412 pages, sci-fi

> 5
Exact title: Unknown Book
Not found.

Gotcha (random map order). Run 4 twice — the two category lines can swap order. Go deliberately randomizes range over a map so no one leans on an order that was never promised. Don't fight it; a map is for lookup and counting, not for order.

main.go MODIFY 47 lines changed

Edit this file in ./

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
	"unicode/utf8"
)

const appName = "Book list"

// Item is one record of the list.
type Item struct {
	Title     string
	Pages     int
	PagesRead int
	Read      bool
	Category  string
}

// scanner is the ONE place the program reads keyboard input.
var scanner = bufio.NewScanner(os.Stdin)

func main() {
	var items []Item

	printHeader()

	for {
		fmt.Println("\n1) Add  2) List  3) Mark read  4) Stats by category  5) Find by title  q) Quit")
		fmt.Print("> ")

		switch readLine() {
		case "1":
			fmt.Print("Title: ")
			title := readLine()
			if msg := validateTitle(title); msg != "" {
				fmt.Println(msg)
				continue
			}
			pages := readInt("Pages: ")
			if pages <= 0 {
				fmt.Println("Pages must be a positive number.")
				continue
			}
			fmt.Print("Category: ")
			category := readLine()
			items = append(items, Item{Title: title, Pages: pages, Category: category})
			fmt.Println("Added:", title)
		case "2":
			listItems(items)
		case "3":
			n := readInt("Item number: ")
			if n < 1 || n > len(items) {
				fmt.Println("No item with that number.")
				continue
			}
			items[n-1].Read = true // index form — changes the REAL element
			fmt.Println("Marked as read:", items[n-1].Title)
		case "4":
			showStats(items)
		case "5":
			fmt.Print("Exact title: ")
			index := indexByTitle(items)
			if it, ok := index[readLine()]; ok { // comma-ok: found?
				fmt.Printf("Found: %s — %d pages, %s\n", it.Title, it.Pages, it.Category)
			} else {
				fmt.Println("Not found.")
			}
		case "q":
			fmt.Println("Bye!")
			return
		default:
			fmt.Println("Unknown choice — try again.")
		}
	}
}

// validateTitle checks the title's REAL length in characters (runes), not bytes.
// len("ąžuolas") is 9 (bytes) but utf8.RuneCountInString is 7 (characters) — a
// Lithuanian title must not be rejected for the wrong length.
func validateTitle(title string) string {
	title = strings.TrimSpace(title)
	n := utf8.RuneCountInString(title)
	if n == 0 {
		return "Title cannot be empty."
	}
	if n > 60 {
		return fmt.Sprintf("Title is too long: %d characters (max 60).", n)
	}
	return ""
}

// readLine reads ONE whole line of input (spaces included) and trims it.
// Unlike fmt.Scanln, which stops at the first space, this reads a full title
// like "Buy milk" instead of just "Buy".
func readLine() string {
	scanner.Scan()
	return strings.TrimSpace(scanner.Text())
}

// readInt keeps asking until the user types a whole number — the retry loop.
func readInt(prompt string) int {
	for {
		fmt.Print(prompt)
		n, err := strconv.Atoi(readLine())
		if err == nil {
			return n
		}
		fmt.Println("Please enter a whole number.")
	}
}

// printHeader prints the app title line (from lesson 3).
func printHeader() {
	fmt.Println("App:", appName)
}

// formatItem builds a clean, ALIGNED one-line summary. %-30s left-aligns the
// title in a 30-column field so a list of items lines up.
func formatItem(it Item) string {
	status := "reading"
	if it.Read {
		status = "done"
	}
	return fmt.Sprintf("%-30s %3d/%-3d  [%s]", it.Title, it.PagesRead, it.Pages, status)
}

// listItems prints every item on the shelf, numbered.
func listItems(items []Item) {
	if len(items) == 0 {
		fmt.Println("No items yet.")
		return
	}
	for i, it := range items {
		fmt.Printf("%2d. %s\n", i+1, formatItem(it))
	}
}

// countByCategory tallies how many items fall in each category.
func countByCategory(items []Item) map[string]int {
	counts := make(map[string]int)
	for _, it := range items {
		counts[it.Category]++ // missing key starts at 0, then +1
	}
	return counts
}

// showStats prints the per-category counts.
func showStats(items []Item) {
	counts := countByCategory(items)
	if len(counts) == 0 {
		fmt.Println("No items yet.")
		return
	}
	// Note: map order is random — the lines may appear in any order.
	for category, n := range counts {
		fmt.Printf("%-12s %d\n", category, n)
	}
}

// indexByTitle builds a title -> Item lookup for an instant find.
func indexByTitle(items []Item) map[string]Item {
	index := make(map[string]Item, len(items))
	for _, it := range items {
		index[it.Title] = it
	}
	return index
}