Actualizaciones de Q-learning

El Q-learning aprende solo a partir de la experiencia lo buena que es cada acción en cada estado, Q(s, a). Tras realizar la acción a en el estado s, recibir reward y llegar al estado s':

target = reward, si el episodio terminó (done = 1)
target = reward + gamma × máximo sobre a' de Q(s', a'), en caso contrario
Q(s, a) ← Q(s, a) + alpha × (target - Q(s, a))

Empieza con todos los valores Q en 0 y aplica las transiciones en orden.

Implementa q_learning(num_states, num_actions, transitions, alpha, gamma).

Entrada

num_states, num_actions: El tamaño de la tabla.

transitions: Una fila [state, action, reward, next_state, done] por paso.

alpha: La tasa de aprendizaje.

gamma: El factor de descuento.

Salida

Devuelve la tabla Q como una matriz con una fila por estado y una columna por acción.

Restricciones

1 ≤ num_states, num_actions ≤ 100, 0 ≤ número de transiciones ≤ 10.000

-100 ≤ reward ≤ 100, done es 0 o 1

0 < alpha ≤ 1, 0 ≤ gamma ≤ 1

Ejemplos

Ejemplo 1

Entrada:
alpha = 0.5
gamma = 0.9
num_states = 2
num_actions = 2
transitions = [
    [0, 1, 0, 1, 0],
    [1, 0, 10, 0, 1]
]

Salida esperada:
[
    [0.0, 0.0],
    [5.0, 0.0]
]

Explicación

El primer paso aún no encuentra recompensa: target = 0 + 0.9 × max(Q[1]) = 0, así que Q[0][1] sigue en 0. El segundo paso termina el episodio con recompensa 10: Q[1][0] = 0 + 0.5 × (10 - 0) = 5.

Ejemplo 2

Entrada:
alpha = 0.5
gamma = 0.9
num_states = 2
num_actions = 2
transitions = [
    [1, 0, 10, 0, 1],
    [0, 1, 0, 1, 0]
]

Salida esperada:
[
    [0.0, 2.25],
    [5.0, 0.0]
]

Explicación

Los mismos pasos en el orden inverso. Q[1][0] pasa primero a 5, así que el paso desde el estado 0 lo ve: target = 0 + 0.9 × 5 = 4.5 y Q[0][1] = 0.5 × 4.5 = 2.25. La recompensa ha fluido un estado hacia atrás.

Referencias

Ejecuta las pruebas de ejemplo para verificar tu código sin enviarlo.

Ejemplo 1 Sin ejecutar

Entrada:

alpha = 0.5
gamma = 0.9
num_states = 2
num_actions = 2
transitions = [
    [0, 1, 0, 1, 0],
    [1, 0, 10, 0, 1]
]

Salida esperada:

[
    [0.0, 0.0],
    [5.0, 0.0]
]

Tu salida

Ejemplo 2 Sin ejecutar

Entrada:

alpha = 0.5
gamma = 0.9
num_states = 2
num_actions = 2
transitions = [
    [1, 0, 10, 0, 1],
    [0, 1, 0, 1, 0]
]

Salida esperada:

[
    [0.0, 2.25],
    [5.0, 0.0]
]

Tu salida

4 pruebas ocultas también se ejecutan al enviar.

Compilador y depurador C# online

Escribe, compila, ejecuta y depura C# online. Usa puntos de interrupción, ejecución paso a paso e inspección de objetos en una IDE con varios archivos, sin Visual Studio.

Versión

Bibliotecas preinstaladas

🚀 350,747 ejecuciones totales (1 este mes)

Salida

Practica C# 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.

Todos los desafíos de C#

Fácil

Average of Three

Average three whole numbers.

Aprenderás AritméticaDivisión

BeginnerLearning-pathVariables

Ver soluciones (1)

Fácil

Rectangle Perimeter

Compute the perimeter of a rectangle from its sides.

Aprenderás AritméticaValores de retorno

BeginnerLearning-pathVariables

Ver soluciones (1)

Intermedio

Una generación de un algoritmo genético

Cría la siguiente generación de cadenas de bits con selección por torneo, cruce de un punto y mutación.

Aprenderás Algoritmos genéticosBúsqueda evolutiva

OptimizationSimulationai

Aún no hay soluciones

Fácil

Bandido multibrazo epsilon-greedy

Equilibra exploración y explotación en un bandido multibrazo con selección de acciones epsilon-greedy.

Aprenderás Explorar o explotarBandidos

Aprendizaje por refuerzoaiaprendizaje automático

Aún no hay soluciones

Fácil

Distribución de estados de una cadena de Markov

Propaga una distribución de probabilidad a través de la matriz de transición de una cadena de Markov durante varios pasos.

Aprenderás Cadenas de MarkovProbabilidad

Simulationaimath

Aún no hay soluciones

Intermedio

Iteración de valores

Calcula cuánto vale cada estado de un proceso de decisión de Markov aplicando repetidamente la actualización de optimalidad de Bellman.

Aprenderás Ecuación de BellmanMDP

Aprendizaje por refuerzoaiaprendizaje automático

Aún no hay soluciones

Intermedio

Poda alfa-beta

Evalúa un árbol de juego con minimax y poda alfa-beta, y cuenta cuántas hojas examina realmente la búsqueda.

Aprenderás Poda alfa-betaBúsqueda en juegos

RecursionTreesai

Aún no hay soluciones

Intermedio

Tres en raya con minimax

Elige la jugada perfecta en el tres en raya explorando todo el árbol de juego con minimax.

Aprenderás MinimaxÁrboles de juego

Recursionai

Aún no hay soluciones

Intermedio

Búsqueda A* en una cuadrícula ponderada

Encuentra el camino más barato a través de una cuadrícula de costes de terreno con A*, el algoritmo de búsqueda detrás de la navegación en juegos y robots.

Aprenderás Búsqueda A*Heurísticas

GraphsGridsShortest-pathai

Aún no hay soluciones

Intermedio

Muestreo con temperatura y top-k

Elige el siguiente token como un modelo de lenguaje: conserva los k logits más altos, aplica la temperatura y muestrea.

Aprenderás Generación de textoMuestreo

aiaprendizaje automático

Aún no hay soluciones

Difícil

Autoatención multicabeza

Proyecta la entrada en consultas, claves y valores, ejecuta la atención en varias cabezas en paralelo y combínalas.

Aprenderás Atención multicabezaProyecciones matriciales

aiaprendizaje automático

Aún no hay soluciones

Intermedio

Normalización de capa

Normaliza cada fila a media 0 y varianza 1, y luego escala y desplaza, como hace cada bloque Transformer.

Aprenderás Normalización de capaTransformers

Redes neuronalesaiaprendizaje automático

Aún no hay soluciones

🔷 Acerca de este ejecutor en línea de C# / .NET

El CodeUtility C# Executor te permite escribir y ejecutar código C# real directamente en tu navegador - sin instalación, configuración de Visual Studio ni .NET SDK. Funciona con un entorno aislado seguro que admite el runtime de .NET y versiones modernas del lenguaje C#, incluyendo C# 9 y posteriores.

Esta herramienta usa dotnet-script bajo el capó para compilar y ejecutar tu código con comportamiento real de .NET, lo que te permite experimentar tanto con características básicas como avanzadas de C#, como LINQ, async/await, pattern matching y genéricos.

Puedes probar scripts simples, funciones y flujos lógicos, o explorar conceptos como clases, structs, herencia e interfaces - todo en un entorno de código limpio y sin distracciones.

Ya sea que estés aprendiendo C#, probando algoritmos o experimentando con características de .NET, el CodeUtility C# Executor te ofrece una forma rápida, segura y confiable de ejecutar código C# al instante desde cualquier navegador.

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.

Empezar a codificar

VersiónSeleccione un tiempo de ejecución antes de ejecutar.Las bibliotecas instaladas pertenecen a la versión del idioma seleccionado.
Archivos abiertos enumera archivos de texto no abiertos.Seleccione uno para abrirlo en una pestaña del editor disponible.
Ejecutar ejecuta el archivo activo con su espacio de trabajo disponible para el programa.
Stop finaliza la ejecución actual antes de su límite de tiempo.
El modo avanzado abre el diseño IDE con un explorador de archivos y un terminal móvil de tamaño variable.

Espacio de trabajo y bibliotecas

Nuevo archivo crea un archivo en el directorio principal seleccionado y lo abre en el editor.
La nueva carpeta crea un directorio, hasta la profundidad de anidamiento admitida.
Cargar archivos agrega uno o más archivos seguros a un directorio.
La descarga guarda un archivo o un directorio comprimido en su dispositivo.
Copiar duplica un archivo o directorio de espacio de trabajo.
Cambiar nombre cambia el nombre de un archivo y actualiza su pestaña abierta y su historial.
Mover reubica un elemento;También se pueden arrastrar archivos y directorios.
Eliminar elimina un elemento después de la confirmación y cierra la pestaña abierta del editor.
Las bibliotecas preinstaladas muestran los paquetes que ya están incluidos en este tiempo de ejecución.
Add Lib instala un paquete privado para su cuenta y el tiempo de ejecución seleccionado.

Terminal y asistencia

El historial de ejecución abre las salidas guardadas anteriores y siguientes.
Copiar salida copia el texto del terminal actual.
Borrar salida elimina todas las salidas de ejecución guardadas después de la confirmación.
Explicar resume el código activo.
Recientes abre explicaciones y resultados recientes.
La configuración cambia las fuentes, los temas y los botones visibles de la barra de herramientas.

Compartir y colaborar

Share publica el archivo actual, un directorio o todo el espacio de trabajo como una instantánea o un espacio de trabajo en vivo.Usted controla el acceso a los enlaces y quién puede guardar los cambios.
Registra las acciones guardadas de los colaboradores en un espacio de trabajo compartido.
Compartir chat permite a los participantes que han iniciado sesión enviar mensajes, mencionar personas, compartir bloques de código y ver miembros en línea o escribiendo.
La colaboración en vivo muestra los cursores de los colaboradores y las actualizaciones de archivos guardados.Los usuarios de solo lectura pueden cargar la última versión o mantener ediciones temporales.

Cuotas y límites

El tiempo de ejecución está limitado a 20 segundos por ejecución del servidor.Utilice Detener cuando desee finalizarlo antes.
El almacenamiento del espacio de trabajo permite 100 archivos, 100 directorios y 10 MiB en total para cada espacio de trabajo e idioma de usuario que haya iniciado sesión.
Los archivos y carpetas están limitados a 1 MiB por archivo y 5 niveles de directorio anidados.Los archivos generados por su código siguen la misma cuota.
Las bibliotecas privadas están limitadas a 10 paquetes instalados para cada cuenta y tiempo de ejecución.
Las instantáneas compartidas pueden contener hasta 100 archivos, 1 MiB por archivo y 2 MiB en total.
Las invitaciones para compartir admiten hasta 25 personas por acción, con permisos de acceso y guardado administrados por separado.
El chat compartido permite 2000 caracteres por mensaje y 10 000 mensajes por compartir.
La aplicación de cuotas también se aplica mientras se ejecuta el código.Una escritura que exceda los límites de recuento, tamaño, almacenamiento o anidamiento de archivos se rechaza de forma segura.

Es bueno saberlo Sólo ejecute código e instale paquetes en los que confíe.La ejecución es aislada y limitada, pero su programa aún puede modificar archivos dentro de un espacio de trabajo de escritura hasta su cuota impuesta.

💡 Fundamentos de C# y ejemplos que puedes probar arriba

1. Declarar variables y constantes

C# usa declaraciones de variables fuertemente tipadas. Usa const para constantes en tiempo de compilación y readonly para constantes en tiempo de ejecución.

int age = 30;
double pi = 3.14159;
char grade = 'A';
string name = "Alice";
bool isActive = true;

// Constantes
const int MaxUsers = 100;
const string Company = "CodeUtility";

2. Condicionales (if / switch)

Usa if, else if y switch para el control de flujo.

int x = 2;
if (x == 1)
{
    Console.WriteLine("Uno");
}
else if (x == 2)
{
    Console.WriteLine("Dos");
}
else
{
    Console.WriteLine("Otro");
}

switch (x)
{
    case 1:
        Console.WriteLine("Uno");
        break;
    case 2:
        Console.WriteLine("Dos");
        break;
    default:
        Console.WriteLine("Otro");
        break;
}

3. Bucles

C# admite bucles for, while y foreach.

for (int i = 0; i < 3; i++)
{
    Console.WriteLine(i);
}

int n = 3;
while (n > 0)
{
    Console.WriteLine(n);
    n--;
}

4. Arreglos

Los arreglos almacenan colecciones de tamaño fijo de elementos del mismo tipo.

int[] numbers = { 10, 20, 30 };
Console.WriteLine(numbers[1]);

5. Manipulación de listas

Usa List<T> para colecciones dinámicas.

List<int> nums = new List<int> { 1, 2, 3 };
nums.Add(4);
nums.Remove(2);

foreach (int n in nums)
{
    Console.Write(n + " ");
}

6. Entrada/Salida por consola

Usa Console.WriteLine y Console.ReadLine para E/S básica.

Console.Write("Ingresa tu nombre: ");
string name = Console.ReadLine();
Console.WriteLine($"¡Hola, {name}!");

7. Funciones

Define métodos usando un tipo de retorno, nombre y parámetros.

int Add(int a, int b)
{
    return a + b;
}

Console.WriteLine(Add(3, 4));

8. Diccionarios

Dictionary<TKey, TValue> almacena pares clave-valor.

Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Alice"] = 30;
Console.WriteLine(ages["Alice"]);

9. Manejo de excepciones

Maneja errores en tiempo de ejecución usando try, catch y finally.

try
{
    throw new Exception("Algo salió mal");
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

10. E/S de archivos

Usa File y StreamReader/StreamWriter para operaciones con archivos.

File.WriteAllText("file.txt", "Hola archivo");
string text = File.ReadAllText("file.txt");
Console.WriteLine(text);

11. Manipulación de cadenas

Las cadenas de C# admiten métodos como Length, Substring, Contains.

string message = "Hola Mundo";
Console.WriteLine(message.Length);
Console.WriteLine(message.Substring(0, 5));
Console.WriteLine(message.Contains("Mundo"));

12. Clases y objetos

C# admite la programación orientada a objetos mediante clases y objetos.

class Person
{
    public string Name;
    public Person(string name) => Name = name;
    public void Greet() => Console.WriteLine($"Hola, soy {Name}");
}

Person p = new Person("Alice");
p.Greet();