Prodotto scalare di due vettori

Ogni neurone inizia con lo stesso calcolo: moltiplica ogni input per il suo peso e somma tutto. Questo è il prodotto scalare di due vettori:

a · b = a₁×b₁ + a₂×b₂ + … + aₙ×bₙ

Implementa dot_product(a, b).

Input

a, b: Due liste di numeri della stessa lunghezza.

Output

Restituisci il prodotto scalare come numero decimale.

Vincoli

1 ≤ lunghezza di a = lunghezza di b ≤ 1.000

-1.000 ≤ ogni valore ≤ 1.000

Esempi

Esempio 1

Input:
a = [1.0, 2.0, 3.0]
b = [4.0, 5.0, 6.0]

Output atteso:
32.0

Spiegazione

1×4 + 2×5 + 3×6 = 4 + 10 + 18 = 32.

Esempio 2

Input:
a = [0.5, -1.5]
b = [2.0, 4.0]

Output atteso:
-5.0

Spiegazione

0.5×2 + (-1.5)×4 = 1 - 6 = -5.

Riferimenti

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

Esempio 1 Non eseguito
Input:
```
a = [1.0, 2.0, 3.0]
b = [4.0, 5.0, 6.0]
```
Output atteso:
```
32.0
```
Il tuo output
Esempio 2 Non eseguito
Input:
```
a = [0.5, -1.5]
b = [2.0, 4.0]
```
Output atteso:
```
-5.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 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.

Versione

Librerie preinstallate

🚀 252,702 esecuzioni totali (135 questo mese)

Output

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.

Tutte le sfide Rust

Facile

Rectangle Perimeter

Compute the perimeter of a rectangle from its sides.

Imparerai AritmeticaValori di ritorno

BeginnerLearning-pathVariables

Vedi soluzioni (12)

Facile

Distance Between Points

Compute the straight-line distance between two points.

Imparerai Teorema di PitagoraRadici quadrate

BeginnerFunctionsLearning-pathmath

Vedi soluzioni (7)

Facile

Days in a Month

Return how many days a month has, including leap years.

Imparerai Regole del calendarioFunzioni di supporto

BeginnerConditionsFunctionsLearning-path

Vedi soluzioni (6)

Facile

Average of Three

Average three whole numbers.

Imparerai AritmeticaDivisione

BeginnerLearning-pathVariables

Vedi soluzioni (6)

Facile

Largest of Three

Pick the largest of three numbers without a built-in max.

Imparerai ConfrontiCombinare condizioni

BeginnerConditionsLearning-path

Vedi soluzioni (4)

Facile

Verifica Numero Primo

Stabilisci se un numero è primo.

Imparerai DivisibilitàOttimizzare i cicli

BeginnerLoopsNumbersStudent-beginner

Vedi soluzioni (3)

Facile

Triangolo di Numeri

Costruisci un triangolo di numeri crescenti.

Imparerai Righe crescentiContatore tra le righe

BeginnerLearning-pathNested-loopsPatterns

Vedi soluzioni (3)

Facile

Numero di Armstrong

Verifica se un numero è uguale alla somma delle sue cifre elevate alla quantità di cifre.

Imparerai Estrarre le cifrePotenze

BeginnerNumbersStudent-beginner

Vedi soluzioni (3)

Facile

Row Sums

Add up every row of a grid.

Imparerai Liste 2DCicli annidati

BeginnerGridsLearning-path

Vedi soluzioni (3)

Facile

Min and Max Together

Find the smallest and largest value in one pass.

Imparerai Un solo passaggioPiù valori di ritorno

ArraysBeginnerFunctionsLearning-path

Vedi soluzioni (3)

Facile

Count Pairs With a Sum

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

Imparerai Coppie di indiciEvitare i doppi conteggi

ArraysBeginnerLearning-pathNested-loops

Vedi soluzioni (3)

Facile

Hollow Square

Draw the outline of a square with * characters.

Imparerai Riconoscere i bordiCostruire stringhe

BeginnerLearning-pathNested-loopsPatterns

Vedi soluzioni (3)

🦀 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.

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.
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.

💡 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);