- Ejecutores
-
Aprender
Aprender Python Ejemplos ejecutables, NumPy, pandas y más Aprender IARedes neuronales, ML y LLM desde cero Aprender C y C++ Punteros, memoria, STL y C++ moderno Aprender C#Fundamentos, POO, LINQ, async y ejercicios de .NET Aprender MatplotlibGráficos de líneas, barras, dispersión y sectores con visualizadores Algoritmos en Python Búsqueda, ordenación, recursión y visualizadores O(n) Algoritmos en C y C++ Compara implementaciones en C y C++ Programación para niños ¡Aprende a programar jugando!
- RetosNuevo
- Para docentesNuevo
- Actualizaciones
- Invítame a un café
Los modelos de lenguaje eligen el siguiente token a partir de una distribución de probabilidad. Dos ajustes le dan forma:
- 'Top-k: conserva solo los k tokens con los logits más altos (con logits iguales, el índice menor queda por delante).'
- 'Temperatura T: divide los logits conservados entre T antes del softmax. Una T baja hace la elección más predecible y una T alta, más aleatoria.'
Para que el muestreo se pueda probar, el número aleatorio se proporciona:
- Conserva los tokens del top-k y lístalos por su índice original (ascendente).
- Calcula softmax(logit / T) sobre los tokens conservados (resta el mayor antes de calcular e^x).
- Recorre la lista sumando probabilidades; devuelve el índice del primer token en el que el total acumulado supera
random_value. Si eso nunca ocurre (redondeo), devuelve el último token conservado.
Con k = 1 esto es decodificación voraz: siempre el token más probable.
Implementa sample_token(logits, temperature, k, random_value).
Entrada
logits: Una puntuación por token del vocabulario.
temperature: T, mayor que 0.
k: Cuántos de los mejores tokens conservar.
random_value: Un número aleatorio en [0, 1).
Salida
Devuelve el índice del token elegido.
Restricciones
1 ≤ k ≤ número de logits ≤ 1.000
0 < temperature ≤ 100, 0 ≤ random_value < 1
-100 ≤ cada logit ≤ 100
Ejemplos
Ejemplo 1
Entrada:
logits = [1.0, 3.0, 2.0, 0.5]
temperature = 1.0
k = 1
random_value = 0.99
Salida esperada:
1Explicación
k = 1 conserva solo el logit más alto, 3.0 en el índice 1. Su probabilidad es 1, así que se elige sin importar el número aleatorio: decodificación voraz.
Ejemplo 2
Entrada:
logits = [2.0, 1.0, 0.0]
temperature = 1.0
k = 2
random_value = 0.8
Salida esperada:
1Explicación
El top-2 conserva los índices 0 y 1 (logits 2 y 1). El softmax da aproximadamente 0.731 y 0.269. El total acumulado es 0.731 después del índice 0 (no supera 0.8) y 1 después del índice 1, así que se elige el índice 1.
Referencias
-
Ejemplo 1 Sin ejecutarEntrada:
logits = [1.0, 3.0, 2.0, 0.5] temperature = 1.0 k = 1 random_value = 0.99Salida esperada:1Tu salida -
Ejemplo 2 Sin ejecutarEntrada:
logits = [2.0, 1.0, 0.0] temperature = 1.0 k = 2 random_value = 0.8Salida esperada:1Tu salida
4 pruebas ocultas también se ejecutan al enviar. Si tu código falla alguna, verás esa prueba. Resuelve el reto para verlas todas.
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 ejecuciones totales (135 este mes)
Practica Rust con desafíos de código
Resuelve problemas prácticos en este editor: ejecuta las pruebas de ejemplo, envía tu solución y recibe una revisión de código por IA.
🦀 Acerca de este ejecutor de Rust en línea
El CodeUtility Rust Executor te permite escribir y ejecutar código Rust directamente en tu navegador - sin instalación, configuración de la toolchain ni entorno local. Está impulsado por un sandbox seguro que admite versiones reales del compilador de Rust 1.70, 1.72, 1.73 y 1.74.
Esta herramienta compila y ejecuta tus programas de Rust en la nube usando un compilador rustc auténtico,
garantizando resultados precisos y coherentes. Puedes experimentar con variables, ownership, borrowing,
pattern matching, traits, genéricos y otras características modernas de Rust con facilidad.
Es ideal para aprender los conceptos clave de Rust - especialmente seguridad de memoria, manejo de errores y concurrencia - sin necesidad de instalar Cargo ni ninguna configuración local. Todo se ejecuta directamente en tu navegador en cuestión de segundos.
Más que un ejecutor de código
Utiliza un editor de varios archivos, un terminal de ejecución aislado, bibliotecas específicas del entorno, espacios de trabajo persistentes, opciones para compartir y colaboración en tiempo real desde el mismo ejecutor.
¿Cómo se utiliza este ejecutor?
Elige un entorno de ejecución, abre o crea un archivo, escribe el código y selecciona Ejecutar. El resultado aparece en el terminal; los usuarios que han iniciado sesión pueden conservar archivos en un espacio de trabajo, instalar bibliotecas y colaborar mediante elementos compartidos.
- Selecciona una versión y edita el archivo actual o abre otro archivo del espacio de trabajo.
- Ejecuta el código, introduce datos en el terminal cuando se soliciten y revisa el historial de ejecuciones guardado.
- Utiliza bibliotecas, herramientas del espacio de trabajo, opciones para compartir y el chat cuando la tarea requiera más de un fragmento.
💡 Conceptos básicos de Rust y ejemplos que puedes probar arriba
1. Declaración de variables y constantes
Usa let para declarar variables. Usa const para constantes y mut para variables mutables.
let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;
const MAX_USERS: u32 = 100;2. Condicionales (if / match)
Rust usa if para condiciones y match para coincidencia de patrones.
let x = 2;
if x == 1 {
println!("Uno");
} else if x == 2 {
println!("Dos");
} else {
println!("Otro");
}
match x {
1 => println!("Uno"),
2 => println!("Dos"),
_ => println!("Otro"),
}3. Bucles
Rust admite for, while y loop para bucles infinitos.
for i in 0..3 {
println!("{}", i);
}
let mut n = 3;
while n > 0 {
println!("{}", n);
n -= 1;
}4. Arrays
Los arrays de tamaño fijo en Rust usan corchetes. Usa slices como vistas.
let nums = [10, 20, 30];
println!("{}", nums[1]);5. Vectores (arrays dinámicos)
Vec se usa para arrays dinámicos.
let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();
for fruit in &fruits {
println!("{}", fruit);
}6. Entrada/Salida por consola
Usa println! para salida y std::io para entrada.
use std::io;
let mut name = String::new();
println!("Ingresa tu nombre:");
io::stdin().read_line(&mut name).unwrap();
println!("Hola, {}", name.trim());7. Funciones
Las funciones usan fn y pueden devolver valores usando ->.
fn greet(name: &str) -> String {
format!("Hola, {}", name)
}
println!("{}", greet("Alice"));8. HashMaps
Usa std::collections::HashMap para datos clave-valor.
use std::collections::HashMap;
let mut person = HashMap::new();
person.insert("nombre", "Bob");
println!("{}", person["nombre"])9. Manejo de errores
Rust maneja los errores usando Result y match o unwrap().
fn fail() -> Result<(), String> {
Err("Algo salió mal".to_string())
}
match fail() {
Ok(_) => println!("Éxito"),
Err(e) => println!("{}", e),
}10. E/S de archivos
Usa std::fs para leer y escribir archivos.
use std::fs;
fs::write("file.txt", "Hola archivo").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);11. Manipulación de cadenas
Las cadenas en Rust se asignan en el heap y admiten muchos métodos.
let mut text = String::from(" Hola Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hola", "Hola");
println!("{}", text);12. Structs y métodos
Rust usa struct para tipos de datos e impl para métodos.
struct Person {
name: String,
}
impl Person {
fn greet(&self) -> String {
format!("Hola, soy {}", self.name)
}
}
let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());13. Referencias y préstamo
Rust usa & para tomar prestados valores y &mut para referencias mutables.
fn update(x: &mut i32) {
*x += 1;
}
let mut value = 10;
update(&mut value);
println!("{}", value);