- 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è
La potatura alfa-beta dà lo stesso risultato di minimax saltando i rami che non possono cambiare il risultato. Tiene traccia di due limiti: alpha, il miglior punteggio di cui MAX è già sicuro, e beta, il miglior punteggio di cui MIN è già sicuro.
L'albero di gioco è completo: ogni nodo interno ha branching figli e tutte le foglie sono alla stessa profondità. leaves elenca i punteggi delle foglie da sinistra a destra. La radice è un nodo MAX e i livelli si alternano MAX, MIN, MAX, …
Esplora i figli da sinistra a destra, partendo da alpha = -∞ e beta = +∞:
- 'In un nodo MAX, dopo ogni figlio: best = max(best, value), poi alpha = max(alpha, best).'
- 'In un nodo MIN, dopo ogni figlio: best = min(best, value), poi beta = min(beta, best).'
- Appena alpha ≥ beta, salta i figli rimanenti del nodo.
Implementa alpha_beta(leaves, branching).
Input
leaves: I punteggi delle foglie, da sinistra a destra; la lunghezza è una potenza di branching.
branching: Figli per nodo interno.
Output
Restituisci [value, evaluated]: il valore minimax della radice e quante foglie sono state valutate.
Vincoli
2 ≤ branching ≤ 5, lunghezza di leaves = branching^depth con 1 ≤ depth ≤ 8, al massimo 10.000 foglie
-1.000 ≤ ogni foglia ≤ 1.000
Esempi
Esempio 1
Input:
leaves = [3, 12, 8, 2, 4, 6, 14, 5, 2]
branching = 3
Output atteso:
[3, 7]
Spiegazione
Il primo nodo MIN vede 3, 12, 8 e restituisce 3, quindi alpha = 3. Il secondo nodo MIN vede 2, beta = 2 ≤ alpha, quindi 4 e 6 vengono saltati. Il terzo vede 14, 5, 2 e restituisce 2. Il valore della radice è max(3, 2, 2) = 3 dopo 7 foglie su 9.
Esempio 2
Input:
leaves = [5, 6, 7, 4]
branching = 2
Output atteso:
[5, 4]
Spiegazione
Il nodo MIN di sinistra valuta 5 e 6 e restituisce 5, quindi alpha = 5. Il nodo MIN di destra valuta 7 (beta = 7), poi 4 (beta = 4 ≤ 5). Tutte e 4 le foglie vengono valutate e il valore è 5.
Riferimenti
-
Esempio 1 Non eseguitoInput:
leaves = [3, 12, 8, 2, 4, 6, 14, 5, 2] branching = 3Output atteso:[3, 7]Il tuo output -
Esempio 2 Non eseguitoInput:
leaves = [5, 6, 7, 4] branching = 2Output atteso:[5, 4]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.
🚀 339,661 esecuzioni totali (665 questo mese)
Esercitati in JavaScript 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 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.
💡 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"]