Rust programozási nyelv alapjai

Skandináv lottószámok generálása;

használata  rand::seq::SliceRandom;  //  A  véletlenszerű  választáshoz 

use  rand::thread_rng;       //  A  véletlenszám-generátorhoz 

use  std::collections ::HashKészlet; 

fn  main()  { 

    //  Létrehozunk  egy  számhalmazt  1-45  között 

    let  mut  numbers: Vec<u32> = (1..=45).collect();

    // Véletlenszerűsítjük a számokat

    let mut rng = thread_rng();

    numbers.shuffle(&mut rng);

    // Kiválasztjuk az első 6 számot

    let lottery_numbers: HashSet<u32> = numbers.iter().take(7).cloned().collect();

   // Kiírjuk a lottószámokat

    println!("A generált lottószámok: {:?}", lottery_numbers);

}

aCargo.toml:

[dependencies]

rand = "0.8"

egy Rust program, amely egy ciklust és egy feltételt tartalmaz . A program kiírja az 1-től 10-ig terjedő számokat, és megmondja, hogy az adott szám páros vagy páratlan:

Ciklus : Afor i in 1..=10sor egy ciklust indít, amely az i változó értékét 1-től 10-ig (belértve a 10-et) növeli.

Feltétel : Az if i % 2 == 0sor határozza meg, hogy aziszám páros-e. Ha igaz, akkor kiírja, hogy "páros, ellenkező esetben páratalan.

fn  main()  { 

    for  i  in  1..=10  { 

        if  i  %  2 == 0 {

            println!("{} páros", i);

        } else {

            println!("{} páratlan", i);

        }

    }

}

--------------

A Rast egy titkosító algoritmus, általában a hírközlés védelmére has ználnak. Ha szeretnél egy egyszerű minta programot, amely bemutatja a Rast algoritmus alapvető működését, itt van egy példa Pythonban. Ez a példa csak bemutató jellegű, nem biztos biztonságot.

def  rast_encrypt(üzenet,  kulcs):

    encrypted_message = []

    key_length = len(key)

    for i in range(len(message)):

        # Egyszerű XOR titkosítás a kulccsal

        encrypted_char =  chr(ord(üzenet[i]) ^ ord(key[i % key_length]))

        encrypted_message.append(titkosított_kar) 

   

        encrypted_message.append(encrypted_char)

            encrypted_message.appendreturn  ''.join (titkosított_üzenet) 

def  rast_decrypt(titkosított_üzenet,  kulcs): 

    decrypted_message  =  [] 

    key_length  =  

    decrypted_message = []

    key_length = len(kulcs) 

  

    for  i  in  range(len)(encrypted_message)):

        # Egyszerű XOR visszafejtés a kulccsal

        decrypted_char = chr(ord(encrypted_message[i]) ^ ord(key[i % key_length]))

        decrypted_message.append(decrypted_char)

    return ''.join(decrypted_message)

if __name__ == "__main__":

    original_message = "Hello, World!"

    key = "mysecretkey"

    encrypted = rast_encrypt(original_message, key)

    

    encrypted = rast_encrypt(originalprint(f"Encrypted: {encrypted}")

    decrypted = rast_decrypt(encrypted, key)

        decrypted = rast_decrypt(encrypted, key)

    decrypted = rast_deprint(f"Decrypted: {decrypted}")

``

Program Magyarázata:

XOR titkosítás : A program egy egyszerű XOR műveletet használ a titkosításhoz és visszafejtéshez, amely egy alap szintű titkosítási mód. Míg a RAST algoritmus sokkal bonyolultabb, ez a példa jól megmutatja az alapelveket. Kulcs használata: A kulcsot (key) ismételjük az üzenet hossza szerint, így minden karakterhez egy karakter a kulcsból kerül.

Nincs a világon semmi, ami akkora fájdalmat tud okozni mint a saját gondolataid.