A régi C programozási nyelv kiválóan alkalmas volt a régi rendszerszoftverek, operációs rendszerek,(linux ,windows) beágyazott rendszerek és játékok fejlesztésére, mivel alacsony szinten, közvetlenül a hardverhez közel működik, rendkívül gyors, és más objektumorientált nyelvek mint a C++, Java, Python alapjait is képezi. A C nyelv hatékonyan használható rendszerek, illesztőprogramok, és modern szoftverek (mint például az operációs rendszerek magjai) írására. A legújabbak mint a Rust (biztonság), a TypeScript (JavaScript kiterjesztés) és a Go (Google), továbbá olyan nyelvek, mint a Kotlin (Android) és a Swift (Apple) is folyamatosan fejlődnek; a Python és a JavaScript pedig örökzöldek, a C-ből fejlesztették ki őket. A legkönnyebben tanulható programozási nyelv a Python, mert egyszerű, emberi nyelvet utánzó szintaxisa van, sokoldalú (web, AI, adatelemzések), óriási közössége és rengeteg könyvtára van, ami ideálissá teszi kezdőknek, és remek ugródeszka más nyelvekhez. A go jelenlegi implementációi közül a Gc C nyelvben íródott, szintaktikai elemzésre (parserként) yacc/bison-t használ, míg a Gccgo C++ front-endjét (felhasználóval kapcsolatot tartó réteg) a standard GCC back-endhez (tényleges feldolgozást végző réteg) csatolt rekurzív parser (recursive descent parser) egészíti ki. A Go szintaxisa a C nyelvéhez áll közel, a típusdeklaráció kivételével; az egyéb szintaktikai eltérések közé tartoznak a for ciklus és a feltételes kifejezés (if) hiányzó zárójelei. A kihagyott funkciók közé tartozik a kivételkezelés, az öröklődés, a generikus programozás és a metódusok újradefiniálása (method overriding). A Javától és a C++-tól eltérően a map-ek (asszociatív tömbök) beépített nyelvi elemek, éppúgy mint a stringek. A Kotlin erősen típusos programozási nyelv. Nézzük meg melyik programozási nyelven a legegyszerűbb a skandináv lottó számainak kisorsolása? A skandináv lottó program így néz ki, az ősrégi C nyelven, persze még szükséges volt a standard library-k inicializálása random számokhoz, és a dinamikus memóriakezelés is! A programozási nyelvet 1972-ben fejlesztették ki, a UNIX operációs rendszer fejlesztésére.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int* lotto(int* p, int p_size, int t, int m, int ma) {
int exclude_count = 0;
// Számoljuk meg a kizárt számokat (itt üres a p tömb)
for (int i = 0; i < p_size; i++) {
if (p[i] >= m && p[i] <= ma) {
exclude_count++;
}
}
int available_count = ma - m + 1 - exclude_count;
if (available_count < t) {
fprintf(stderr, "Error: Not enough available numbers\n");
exit(1);
}
// Elérhető számok tömbje
int* available = malloc(available_count * sizeof(int));
int idx = 0;
for (int num = m; num <= ma; num++) {
int excluded = 0;
for (int i = 0; i < p_size; i++) {
if (num == p[i]) {
excluded = 1;
break;
}
}
if (!excluded) {
available[idx++] = num;
}
}
// Véletlenszerű kiválasztás
int* selected = malloc(t * sizeof(int));
srand(time(NULL));
for (int i = 0; i < t; i++) {
int rand_idx;
do {
rand_idx = rand() % available_count;
} while (rand_idx == -1); // Egyszerűsített Fisher-Yates
selected[i] = available[rand_idx];
// Eltávolítjuk a kiválasztott elemet (swap and shrink)
available[rand_idx] = available[--available_count];
}
// Rendezés
for (int i = 0; i < t - 1; i++) {
for (int j = i + 1; j < t; j++) {
if (selected[i] > selected[j]) {
int temp = selected[i];
selected[i] = selected[j];
selected[j] = temp;
}
}
}
free(available);
return selected;
}
int main() {
int p[] = {}; // Üres kizárt számok tömb
int p_size = 0;
int* szam = lotto(p, p_size, 7, 1, 35);
printf("Lotto számok: ");
for (int i = 0; i < 7; i++) {
printf("%d ", szam[i]);
}
printf("\n");
free(szam);
return 0;
}
És ugyanaz a skandináv lottó program Python
nyelven egyetlen sorban leírható;
import random;print(sorted(random.sample(range(36),7)))
És ugyanaz a skandináv lottó program GO
nyelven
package main
import (
"fmt"
"math/rand"
"sort"
"time"
)
func lotto(p []int, t, m, ma int)
[]int {
// Létrehozzuk a lehetséges számok listáját
possible := make([]int, 0, ma-m+1)
for num := m; num <= ma; num++ {
found := false
for _, forbidden := range p {
if num == forbidden {
found = true
break
}
}
if !found {
possible = append(possible, num)
}
}
// Ellenőrizzük, hogy elég szám van-e
if len(possible) < t {
panic("Nincs elég szám a kiválasztáshoz")
}
// Véletlenszerűen kiválasztjuk a t számot
rand.Seed(time.Now().UnixNano())
selected := make([]int, t)
used := make(map[int]bool)
for i := 0; i < t; i++ {
for {
idx := rand.Intn(len(possible))
if !used[idx] {
selected[i] = possible[idx]
used[idx] = true
break
}
}
}
// Rendezés
sort.Ints(selected)
return selected
}
func
main() {
pr := []int{}
szam := lotto(pr, 7, 1, 35)
fmt.Println(szam)
}
És ugyanaz a skandináv lottó program Rust
nyelven
use rand::prelude::*;
fn lotto(p: &[i32], t: usize, m: i32, ma: i32) ->
Result<Vec<i32>, &'static str> {
let mut available: Vec<i32> = (m..=ma).collect();
// Kivesszük a tiltott számokat
available.retain(|&num| !p.contains(&num));
if available.len() < t {
return Err("Nem elég szám áll rendelkezésre");
}
// Véletlen válogatás
let mut rng = rand::thread_rng();
let mut selected: Vec<i32> = available
.choose_multiple(&mut rng, t)
.cloned()
.collect();
selected.sort_unstable();
Ok(selected)
}
fn main() {
let tiltott_szamok = vec![];
match lotto(&tiltott_szamok, 7, 1, 35) {
Ok(szamok) => println!("{:?}", szamok),
Err(e) => eprintln!("Hiba: {}", e),
}
}
Futtatáshoz szükséges
lépések:
1.
Hozz létre egy új Rust projektet: cargo new
lotto
2.
Módosítsd a Cargo.toml fájlt:
[dependencies]
rand = "0.8.5"
3.
Másold be a kódot a src/main.rs-be
4.
Futtasd: cargo run
És ugyanaz a skandináv lottó program Kotlin nyelven
import
kotlin.random.Random
val a = mutableListOf<Int>()
for (num in m..ma) {
if (num !in p) {
a.add(num)
}
}
if (a.size < t) {
throw IllegalArgumentException("Nem elég szám a válogatáshoz")
}
return a.shuffled().take(t).sorted()
}
fun main() {
val pr = emptyList<Int>()
val szam = lotto(pr)
println(szam)
}
Nos láthatjuk, hogy a python képes a legegyszerübb módon megvalósítani az algoritmust, 6 sorban, míg a többiek komplikáltabban és hosszaban írják meg a programot.
Lásd; http://nyelvek.inf.elte.hu/leirasok/Go/
https://dl.ebooksworld.ir/motoman/No.Starch.Press.The.Rust.Programming.Language.www.EBooksWorld.ir.pdf
http://nyelvek.inf.elte.hu/leirasok/Rust/
https://python.hu/peldaprogramok
Nincsenek megjegyzések:
Megjegyzés küldése