Riepilogo - Collezione generica

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 72 di 107.

Sfida

Facile

Costruiamo una struttura dati Queue generica che dimostri tutto ciò che hai imparato sui generics in Go! A differenza di uno stack (LIFO), una coda segue l’ordine First-In-First-Out (FIFO): il primo elemento aggiunto è il primo a essere rimosso.

Organizzerai il codice in due file:

queue.go: definisci la tua collezione generica di code.
Crea una struct generica Queue[T any] che memorizzi gli elementi al suo interno. La tua coda deve supportare queste operazioni:
- Enqueue(item T) - aggiunge un elemento alla fine della coda
- Dequeue() (T, bool) - rimuove e restituisce l’elemento all’inizio della coda, insieme a un booleano che indica se l’operazione è riuscita (restituisci il valore zero e false se la coda è vuota)
- Peek() (T, bool) - restituisce l’elemento all’inizio senza rimuoverlo (stesso schema di restituzione di Dequeue)
- Size() int - restituisce il numero di elementi nella coda
- IsEmpty() bool - restituisce true se la coda non contiene elementi
Crea anche una funzione costruttrice NewQueue[T any]() *Queue[T] che restituisca un puntatore a una coda vuota inizializzata.
main.go: mostra la tua coda con tipi diversi in base all’input.
Leggi un indicatore di tipo (int o string), poi leggi una serie di comandi da eseguire sulla coda. Ogni comando si trova su una riga separata:
- enqueue [value] - aggiunge il valore alla coda
- dequeue - rimuove e stampa l’elemento all’inizio (stampa empty se la coda è vuota)
- peek - stampa l’elemento all’inizio senza rimuoverlo (stampa empty se la coda è vuota)
- size - stampa la dimensione attuale
Leggi i comandi finché non ricevi done.

Verranno forniti i seguenti input:

Riga 1: indicatore di tipo (int o string)
Righe successive: comandi fino a done

Per esempio, dato:

int
enqueue 10
enqueue 20
enqueue 30
peek
dequeue
size
dequeue
dequeue
dequeue
done

Il tuo output dovrebbe essere:

10
10
2
20
30
empty

E dato:

string
enqueue hello
enqueue world
size
peek
dequeue
peek
done

Il tuo output dovrebbe essere:

2
hello
hello
world

La tua coda dovrebbe funzionare allo stesso modo sia con i tipi interi sia con quelli stringa, dimostrando come una singola implementazione generica possa gestire più tipi concreti mantenendo la piena sicurezza dei tipi.

Provalo tu

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Leggi l'indicatore del tipo
	scanner.Scan()
	typeIndicator := scanner.Text()
	
	if typeIndicator == "int" {
		// TODO: Crea una coda di interi usando NewQueue[int]()
		// Elabora i comandi per la coda di interi
		
		for scanner.Scan() {
			line := scanner.Text()
			if line == "done" {
				break
			}
			
			parts := strings.SplitN(line, " ", 2)
			command := parts[0]
			
			// TODO: Gestisci i comandi: enqueue, dequeue, peek, size
			// Per enqueue, ricava il valore intero da parts[1]
			// Per dequeue/peek, stampa "empty" se la coda è vuota
			_ = command
		}
	} else if typeIndicator == "string" {
		// TODO: Crea una coda di stringhe usando NewQueue[string]()
		// Elabora i comandi per la coda di stringhe
		
		for scanner.Scan() {
			line := scanner.Text()
			if line == "done" {
				break
			}
			
			parts := strings.SplitN(line, " ", 2)
			command := parts[0]
			
			// TODO: Gestisci i comandi: enqueue, dequeue, peek, size
			// Per enqueue, usa il valore stringa di parts[1]
			// Per dequeue/peek, stampa "empty" se la coda è vuota
			_ = command
		}
	}
	
	// Queste istruzioni servono a evitare errori dovuti a import inutilizzati durante lo sviluppo
	_ = strconv.Atoi
	_ = fmt.Println
}