Iterazione dei valori

L'iterazione dei valori risolve un processo decisionale di Markov: trova V(s), la migliore ricompensa totale scontata che si può ottenere partendo dallo stato s.

Qui le transizioni sono deterministiche. Nello stato s, l'azione a dà la ricompensa rewards[s][a] e porta allo stato next_states[s][a], dove -1 significa che l'episodio termina. Parti da V(s) = 0 per ogni stato, poi ripeti iterations volte, calcolando ogni nuovo valore dalla passata precedente:

V_new(s) = massimo su a di ( rewards[s][a] + gamma × V(next_states[s][a]) )

dove il termine gamma × V vale 0 quando lo stato successivo è -1.

Implementa value_iteration(next_states, rewards, gamma, iterations).

Input

next_states: Per ogni stato, lo stato successivo di ciascuna delle sue azioni (-1 termina l'episodio). Gli stati possono avere un numero diverso di azioni.

rewards: La ricompensa di ogni azione, con la stessa forma di next_states.

gamma: Il fattore di sconto.

iterations: Il numero di passate.

Output

Restituisci V dopo l'ultima passata, un valore per stato.

Vincoli

1 ≤ stati ≤ 200, 1 ≤ azioni per stato ≤ 10, 0 ≤ iterations ≤ 1.000

-100 ≤ ogni ricompensa ≤ 100, 0 ≤ gamma ≤ 1

Esempi

Esempio 1

Input:
next_states = [
    [0, 1],
    [0, 2],
    [-1]
]
rewards = [
    [0.0, 0.0],
    [0.0, 0.0],
    [10.0]
]
gamma = 0.9
iterations = 3

Output atteso:
[8.1, 9.0, 10.0]

Spiegazione

Passata 1: solo lo stato 2 può ottenere una ricompensa, V = [0, 0, 10]. Passata 2: lo stato 1 va a destra verso di esso, 0.9 × 10 = 9, V = [0, 9, 10]. Passata 3: lo stato 0 ottiene 0.9 × 9 = 8.1. Risultato: [8.1, 9, 10].

Esempio 2

Input:
next_states = [
    [1, 0],
    [0, 1]
]
rewards = [
    [1.0, 2.0],
    [3.0, 0.0]
]
gamma = 0.0
iterations = 5

Output atteso:
[2.0, 3.0]

Spiegazione

Con gamma = 0 il futuro non conta, quindi il valore di ogni stato è semplicemente la sua migliore ricompensa immediata: [2, 3].

Riferimenti

Esegui i test di esempio per verificare il tuo codice senza inviarlo.

Esempio 1 Non eseguito

Input:

next_states = [
    [0, 1],
    [0, 2],
    [-1]
]
rewards = [
    [0.0, 0.0],
    [0.0, 0.0],
    [10.0]
]
gamma = 0.9
iterations = 3

Output atteso:

[8.1, 9.0, 10.0]

Il tuo output

Esempio 2 Non eseguito

Input:

next_states = [
    [1, 0],
    [0, 1]
]
rewards = [
    [1.0, 2.0],
    [3.0, 0.0]
]
gamma = 0.0
iterations = 5

Output atteso:

[2.0, 3.0]

Il 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 JavaScript Runner

Write, run, and debug JavaScript or Node.js online in a full-featured browser IDE. Work with multiple files and packages, save your workspace, and collaborate in real time.

Versione

Librerie preinstallate

🚀 339,661 esecuzioni totali (665 questo mese)

Count pairs of positions whose values add up to a target.

Imparerai Coppie di indiciEvitare i doppi conteggi

ArraysBeginnerLearning-pathNested-loops

Vedi soluzioni (3)

⚡ Informazioni su questo esecutore JavaScript (Node.js) online

Il CodeUtility JavaScript Executor ti consente di scrivere ed eseguire codice JavaScript moderno direttamente nel browser - all'istante e senza alcuna configurazione. Usa veri ambienti Node.js per eseguire il tuo codice in modo sicuro in un contenitore sandbox, supportando le versioni 16, 18 e 20.

Questo strumento è perfetto per testare snippet Node.js, esplorare la sintassi ES6+ o imparare concetti fondamentali di JavaScript come cicli, funzioni, array, promise e il comportamento di async/await.

Puoi anche usarlo per convalidare algoritmi, fare debug di piccoli script o sperimentare la logica di runtime senza installare Node in locale. È ideale per studenti, sviluppatori backend o chiunque abbia bisogno di un modo rapido, basato su browser, per eseguire codice JavaScript.

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.

Inizia a programmare

VersioneSelezionare un runtime prima dell'esecuzione.Le librerie installate appartengono alla versione della lingua selezionata.
File aperti elenca i file di testo non aperti.Selezionane uno per aprirlo in una scheda dell'editor disponibile.
Esegui esegue il file attivo con la sua area di lavoro disponibile per il programma.
Stop termina l'esecuzione corrente prima del limite di tempo.
La modalità avanzata apre il layout IDE con un esploratore di file e un terminale mobile e ridimensionabile.

Spazio di lavoro e biblioteche

Nuovo file crea un file nella directory principale selezionata e lo apre nell'editor.
La nuova cartella crea una directory, fino alla profondità di nidificazione supportata.
Carica file aggiunge uno o più file sicuri a una directory.
Il download salva un file o una directory compressa sul tuo dispositivo.
Copia duplica un file o una directory dell'area di lavoro.
Rinomina modifica il nome di un file e aggiorna la scheda aperta e la cronologia.
Sposta sposta un elemento;è anche possibile trascinare file e directory.
Elimina rimuove un elemento dopo la conferma e chiude la scheda dell'editor aperta.
Le librerie preinstallate mostrano i pacchetti già inclusi in questo runtime.
Aggiungi Lib installa un pacchetto privato per il tuo account e il runtime selezionato.

Terminale e assistenza

La cronologia di esecuzione apre gli output salvati precedenti e successivi.
Esegui con passa JavaScript dal server di esecuzione a JavaScript nel browser. Il browser sincronizza i file dell’area di lavoro; le librerie installate per l’account e l’input interattivo richiedono il server di esecuzione.
Copia output copia il testo del terminale corrente.
Cancella output rimuove tutti gli output della corsa salvati dopo la conferma.
Spiega riassume il codice attivo.
Recenti apre spiegazioni e risultati recenti.
Le impostazioni modificano i caratteri, i temi e i pulsanti visibili della barra degli strumenti.

Condivisione e collaborazione

La condivisione pubblica il file corrente, una directory o l'intera area di lavoro come istantanea o area di lavoro live.Sei tu a controllare l'accesso al collegamento e chi può salvare le modifiche.
I log registrano le azioni salvate dei collaboratori in un'area di lavoro condivisa.
La chat condivisa consente ai partecipanti che hanno effettuato l'accesso di inviare messaggi, menzionare persone, condividere blocchi di codice e vedere i membri online o che stanno digitando.
La collaborazione dal vivo mostra i cursori dei collaboratori e gli aggiornamenti dei file salvati.Gli utenti di sola visualizzazione possono caricare la versione più recente o mantenere le modifiche temporanee.

Quote e limiti

Il tempo di esecuzione è limitato a 20 secondi per esecuzione del server.Usa Interrompi quando vuoi terminarlo prima.
L'archiviazione dell'area di lavoro consente 100 file, 100 directory e 10 MiB in totale per ogni area di lavoro e lingua di ogni utente che ha effettuato l'accesso.
File e cartelle sono limitati a 1 MiB per file e 5 livelli di directory nidificati.I file generati dal tuo codice seguono la stessa quota.
Le librerie private sono limitate a 10 pacchetti installati per ogni account e runtime.
Gli snapshot condivisi possono contenere fino a 100 file, 1 MiB per file e 2 MiB in totale.
Gli inviti alla condivisione supportano fino a 25 persone per condivisione, con autorizzazioni di accesso e salvataggio gestite separatamente.
La chat condivisa consente 2.000 caratteri per messaggio e 10.000 messaggi per condivisione.
L'applicazione delle quote si applica anche durante l'esecuzione del codice.Una scrittura che supera i limiti di numero, dimensione, archiviazione o nidificazione dei file viene rifiutata in modo sicuro.

Buono a sapersi Esegui il codice e installa solo i pacchetti di cui ti fidi.L'esecuzione è isolata e limitata, ma il tuo programma può comunque modificare i file all'interno di un'area di lavoro scrivibile fino alla quota imposta.

💡 Guida alle basi di Node.js per principianti

1. Dichiarare variabili e costanti

Usa let o const per variabili con scope di blocco. const è usato per le costanti.

let x = 10;
const PI = 3.14;
let name = "Alice";
let isActive = true;

2. Condizionali (if / switch)

Usa if, else if, else o switch per il flusso di controllo.

let x = 2;
if (x === 1) {
  console.log("Uno");
} else if (x === 2) {
  console.log("Due");
} else {
  console.log("Altro");
}

switch (x) {
  case 1:
    console.log("Uno");
    break;
  case 2:
    console.log("Due");
    break;
  default:
    console.log("Altro");
}

3. Cicli

Usa for, while e forEach per iterare sui dati.

for (let i = 0; i < 3; i++) {
  console.log(i);
}

let n = 3;
while (n > 0) {
  console.log(n);
  n--;
}

4. Array

Usa gli array per memorizzare liste ordinate di valori. Accedili con gli indici.

let fruits = ["apple", "banana", "cherry"];
console.log(fruits[0]);
console.log(fruits.length);

5. Manipolazione degli array

Usa metodi come push, pop, slice e reverse.

fruits.push("kiwi");
fruits.pop();
console.log(fruits.slice(0, 2));
console.log(fruits.reverse());

let squares = [1, 2, 3, 4, 5].map(x => x * x);
console.log(squares);

6. Input/Output da console

Usa console.log per l’output e il modulo readline per l’input.

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question("Come ti chiami? ", name => {
  console.log(`Ciao, ${name}`);
  rl.close();
});

7. Funzioni

Le funzioni possono essere dichiarate o espresse. Le arrow function sono spesso usate nel JavaScript moderno.

function greet(name) {
  return `Ciao, ${name}`;
}

const add = (a, b) => a + b;

console.log(greet("Alice"));
console.log(add(2, 3));

8. Oggetti (Mappe)

Gli oggetti memorizzano coppie chiave-valore. Sono simili a dizionari o mappe.

let person = { name: "Bob", age: 25 };
console.log(person.name);
console.log(person["age"]);

// Mappa ES6
const map = new Map();
map.set("a", 1);
console.log(map.get("a"));

9. Gestione delle eccezioni

Usa try, catch e finally per gestire gli errori in sicurezza.

try {
  throw new Error("Qualcosa è andato storto");
} catch (e) {
  console.log(e.message);
} finally {
  console.log("Pulizia se necessario");
}

10. I/O su file

Usa il modulo fs di Node.js per leggere e scrivere file.

const fs = require("fs");

fs.writeFileSync("test.txt", "Ciao file");
const data = fs.readFileSync("test.txt", "utf8");
console.log(data);

11. Manipolazione delle stringhe

Usa metodi come trim(), toUpperCase(), replace() e split().

let text = "  Hello World  ";
console.log(text.trim());
console.log(text.toUpperCase());
console.log(text.replace("Hello", "Hi"));
console.log(text.split(" "));

12. Classi e oggetti

ES6+ supporta la OOP con la sintassi class.

class Person {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return `Ciao, sono ${this.name}`;
  }
}

const p = new Person("Alice");
console.log(p.greet());

13. Riferimenti

Oggetti e array in JavaScript sono passati per riferimento.

function update(arr) {
  arr.push("changed");
}

let data = ["original"];
update(data);
console.log(data);  // ["originale", "modificato"]