- Esecutori
-
Impara
Impara Python Esempi eseguibili, NumPy, pandas e altro Impara l'IAReti neurali, ML e LLM da zero Impara C e C++ Puntatori, memoria, STL e C++ moderno Impara C#Fondamenti, OOP, LINQ, async ed esercizi .NET Impara MatplotlibGrafici a linee, barre, dispersione e torta con visualizzatori Algoritmi Python Ricerca, ordinamento, ricorsione e visualizzazioni O(n) Algoritmi C e C++ Confronta le implementazioni in C e C++ Programmazione per bambini Impara a programmare giocando!
- SfideNuovo
- Per docentiNuovo
- Aggiornamenti
- Offrimi un caffè
I modelli linguistici scelgono il token successivo da una distribuzione di probabilità. Due impostazioni le danno forma:
- 'Top-k: tieni solo i k token con i logit più alti (a parità di logit, l''indice minore viene prima).'
- 'Temperatura T: dividi i logit tenuti per T prima del softmax. Una T bassa rende la scelta più prevedibile, una T alta più casuale.'
Per rendere il campionamento verificabile, il numero casuale viene fornito:
- Tieni i token del top-k ed elencali per indice originale (crescente).
- Calcola softmax(logit / T) sui token tenuti (sottrai il maggiore prima di calcolare e^x).
- Scorri la lista sommando le probabilità; restituisci l'indice del primo token in cui il totale cumulato supera
random_value. Se non succede mai (arrotondamento), restituisci l'ultimo token tenuto.
Con k = 1 è la decodifica greedy: sempre il token più probabile.
Implementa sample_token(logits, temperature, k, random_value).
Input
logits: Un punteggio per ogni token del vocabolario.
temperature: T, maggiore di 0.
k: Quanti token migliori tenere.
random_value: Un numero casuale in [0, 1).
Output
Restituisci l'indice del token scelto.
Vincoli
1 ≤ k ≤ numero di logit ≤ 1.000
0 < temperature ≤ 100, 0 ≤ random_value < 1
-100 ≤ ogni logit ≤ 100
Esempi
Esempio 1
Input:
logits = [1.0, 3.0, 2.0, 0.5]
temperature = 1.0
k = 1
random_value = 0.99
Output atteso:
1Spiegazione
k = 1 tiene solo il logit più alto, 3.0 all'indice 1. La sua probabilità è 1, quindi viene scelto qualunque sia il numero casuale: decodifica greedy.
Esempio 2
Input:
logits = [2.0, 1.0, 0.0]
temperature = 1.0
k = 2
random_value = 0.8
Output atteso:
1Spiegazione
Il top-2 tiene gli indici 0 e 1 (logit 2 e 1). Il softmax dà circa 0.731 e 0.269. Il totale cumulato è 0.731 dopo l'indice 0 (non supera 0.8) e 1 dopo l'indice 1, quindi viene scelto l'indice 1.
Riferimenti
-
Esempio 1 Non eseguitoInput:
logits = [1.0, 3.0, 2.0, 0.5] temperature = 1.0 k = 1 random_value = 0.99Output atteso:1Il tuo output -
Esempio 2 Non eseguitoInput:
logits = [2.0, 1.0, 0.0] temperature = 1.0 k = 2 random_value = 0.8Output atteso:1Il tuo output
4 test nascosti vengono eseguiti anche al momento dell'invio. Se il tuo codice ne fallisce uno, vedrai quel test. Risolvi la sfida per vederli tutti.
Online Go Compiler
Write, compile, run, and debug Go code online in a full-featured browser IDE. Work with multiple files, save your workspace, and collaborate in real time - no setup required.
🚀 206,970 esecuzioni totali (799 questo mese)
Esercitati in Go con le sfide di codice
Risolvi problemi pratici direttamente in questo editor: esegui i test di esempio, invia la soluzione e ricevi una revisione AI del codice.
🐹 Informazioni su questo esecutore Go online
Il CodeUtility Go Executor ti permette di scrivere ed eseguire codice Go direttamente nel browser - senza installazioni, configurazioni o ambiente locale. È basato su una sandbox sicura che supporta le reali versioni del compilatore Go 1.19, 1.20 e 1.21.
Questo strumento compila ed esegue veri programmi Go nel cloud, fornendo un ambiente Go autentico. Puoi testare brevi snippet, sperimentare con i pacchetti ed esplorare le potenti funzionalità di concorrenza di Go usando goroutine e canali.
È perfetto per imparare ed esercitarsi con i concetti base di Go come variabili, funzioni, struct, slice, map, interfacce e gestione degli errori - tutto senza installare alcun tool in locale.
Che tu stia esplorando Go per la prima volta, testando logica backend o imparando come funziona la concorrenza, il CodeUtility Go Executor offre un modo pulito, veloce e basato sul browser per eseguire codice Go all'istante.
Più di un semplice esecutore di codice
Usa nello stesso esecutore un editor multifile, un terminale di esecuzione isolato, librerie specifiche per il runtime, spazi di lavoro persistenti, condivisione e collaborazione in tempo reale.
Come si usa questo esecutore?
Scegli un runtime, apri o crea un file, scrivi il codice e seleziona Esegui. L’output appare nel terminale; gli utenti che hanno effettuato l’accesso possono conservare i file in uno spazio di lavoro, installare librerie e collaborare tramite le condivisioni.
- Seleziona una versione e modifica il file corrente oppure apri un altro file dello spazio di lavoro.
- Esegui il codice, inserisci i dati nel terminale quando richiesto e consulta la cronologia delle esecuzioni salvate.
- Usa librerie, strumenti dello spazio di lavoro, condivisione e chat quando l’attività richiede più di un frammento di codice.
💡 Basi di Go ed esempi che puoi provare sopra
1. Dichiarare variabili e costanti
Usa var o := per dichiarare variabili. Usa const per le costanti.
package main
var x int = 10
const Pi = 3.14
func main() {
name := "Alice"
isActive := true
println(x, Pi, name, isActive)
}2. Condizionali (if / switch)
Go supporta le istruzioni if-else e switch con una sintassi pulita.
x := 2
if x == 1 {
println("Uno")
} else if x == 2 {
println("Due")
} else {
println("Altro")
}
switch x {
case 1:
println("Uno")
case 2:
println("Due")
default:
println("Altro")
}3. Cicli
Go usa solo il ciclo for, ma può comportarsi come un ciclo while.
for i := 0; i < 3; i++ {
println(i)
}
n := 3
for n > 0 {
println(n)
n--
}4. Array
Gli array hanno dimensione fissa. Usa le slice per liste dinamiche.
var nums = [3]int{10, 20, 30}
println(nums[1])5. Manipolazione delle slice
Usa le slice e le funzioni integrate append, len, copy e la sintassi di slicing.
fruits := []string{"mela", "banana"}
fruits = append(fruits, "ciliegia")
fruits = fruits[1:] // slice
println(len(fruits))
for _, fruit := range fruits {
println(fruit)
}6. Input/Output da console
Usa fmt.Print, fmt.Scan e fmt.Println.
import "fmt"
var name string
fmt.Print("Inserisci il tuo nome: ")
fmt.Scan(&name)
fmt.Println("Ciao", name)7. Funzioni
Le funzioni si dichiarano con func e possono restituire più valori.
func greet(name string) string {
return "Ciao, " + name
}
message := greet("Alice")
println(message)8. Mappe
Le mappe sono archivi chiave-valore. Dichiarale con make().
ages := map[string]int{"Alice": 30}
ages["Bob"] = 25
println(ages["Alice"])9. Gestione degli errori
Go usa valori di ritorno multipli per gli errori invece delle eccezioni.
import "errors"
func fail() error {
return errors.New("qualcosa è andato storto")
}
err := fail()
if err != nil {
println(err.Error())
}10. I/O su file
Usa i pacchetti os e io/ioutil per leggere/scrivere file.
import (
"fmt"
"os"
"io/ioutil"
)
ioutil.WriteFile("file.txt", []byte("Ciao file"), 0644)
data, _ := ioutil.ReadFile("file.txt")
fmt.Println(string(data))11. Manipolazione di stringhe
Usa il pacchetto strings per operazioni sulle stringhe.
import "strings"
text := " Ciao mondo "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Ciao", "Ehi"))
words := strings.Split(text, " ")
fmt.Println(words)12. Struct e oggetti
Usa le struct per definire tipi personalizzati con metodi.
type Person struct {
Name string
}
func (p Person) Greet() string {
return "Ciao, sono " + p.Name
}
p := Person{Name: "Alice"}
println(p.Greet())13. Riferimenti (puntatori)
Go supporta i puntatori usando * e &.
x := 10
ptr := &x
*ptr = 20
println(x) // 20