- 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 Rust Compiler
Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.
🚀 252,702 esecuzioni totali (135 questo mese)
Esercitati in Rust 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 Rust online
Il CodeUtility Rust Executor ti permette di scrivere ed eseguire codice Rust direttamente nel browser - nessuna installazione, configurazione della toolchain o ambiente locale richiesti. È alimentato da una sandbox sicura che supporta le vere versioni del compilatore Rust 1.70, 1.72, 1.73 e 1.74.
Questo strumento compila ed esegue i tuoi programmi Rust nel cloud utilizzando un vero compilatore rustc,
garantendo risultati accurati e coerenti. Puoi sperimentare con variabili, ownership, borrowing,
pattern matching, trait, generics e altre funzionalità moderne di Rust con facilità.
È ideale per imparare i concetti fondamentali di Rust - in particolare la sicurezza della memoria, la gestione degli errori e la concorrenza - senza dover installare Cargo o alcuna configurazione locale. Tutto gira direttamente nel tuo browser in pochi secondi.
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 Rust ed esempi che puoi provare qui sopra
1. Dichiarare variabili e costanti
Usa let per dichiarare variabili. Usa const per le costanti e mut per variabili mutabili.
let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;
const MAX_USERS: u32 = 100;2. Condizionali (if / match)
Rust usa if per le condizioni e match per il pattern matching.
let x = 2;
if x == 1 {
println!("Uno");
} else if x == 2 {
println!("Due");
} else {
println!("Altro");
}
match x {
1 => println!("Uno"),
2 => println!("Due"),
_ => println!("Altro"),
}3. Cicli
Rust supporta for, while e il ciclo infinito loop.
for i in 0..3 {
println!("{}", i);
}
let mut n = 3;
while n > 0 {
println!("{}", n);
n -= 1;
}4. Array
Gli array a dimensione fissa in Rust usano le parentesi quadre. Usa gli slice per ottenere viste.
let nums = [10, 20, 30];
println!("{}", nums[1]);5. Vettori (array dinamici)
Vec è usato per array dinamici.
let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();
for fruit in &fruits {
println!("{}", fruit);
}6. Input/Output da console
Usa println! per l'output e std::io per l'input.
use std::io;
let mut name = String::new();
println!("Inserisci il tuo nome:");
io::stdin().read_line(&mut name).unwrap();
println!("Ciao, {}", name.trim());7. Funzioni
Le funzioni usano fn e possono restituire valori usando ->.
fn greet(name: &str) -> String {
format!("Ciao, {}", name)
}
println!("{}", greet("Alice"));8. HashMap
Usa std::collections::HashMap per dati chiave-valore.
use std::collections::HashMap;
let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])9. Gestione degli errori
Rust gestisce gli errori usando Result e match o unwrap().
fn fail() -> Result<(), String> {
Err("Qualcosa è andato storto".to_string())
}
match fail() {
Ok(_) => println!("Successo"),
Err(e) => println!("{}", e),
}10. I/O su file
Usa std::fs per leggere e scrivere file.
use std::fs;
fs::write("file.txt", "Ciao File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);11. Manipolazione delle stringhe
Le stringhe in Rust sono allocate sull'heap e supportano molti metodi.
let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);12. Struct e metodi
Rust usa struct per i tipi di dato e impl per i metodi.
struct Person {
name: String,
}
impl Person {
fn greet(&self) -> String {
format!("Ciao, sono {}", self.name)
}
}
let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());13. Riferimenti e borrowing
Rust usa & per prendere in prestito valori e &mut per riferimenti mutabili.
fn update(x: &mut i32) {
*x += 1;
}
let mut value = 10;
update(&mut value);
println!("{}", value);