A programozási nyelvek alkalmazásai

Kedves hallgatóim, diákjaim! A klasszikus C programozási nyelv alkalmas volt a régi rendszerszoftverek, operációs rendszerek,(linux ,windows) beágyazott rendszerek és a régi 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 coyote vagy prérifarkas, a C programozási nyelv hibáinak elkerülésére lett elkészítve, bár 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 1970-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;

}

Ugyanez Basicben;

RANDOMIZE TIMER

FOR I = 1 TO 7

DO

X = INT(RND * 36)

DUP = 0

FOR J = 1 TO I - 1

IF X = PREV(J) THEN DUP = 1

NEXT J

LOOP UNTIL DUP = 0

PREV(I) = X

PRINT X;

NEXT I

Ugyanez fortranban;

program lottery

  implicit none

  integer :: i, j, temp

  integer, dimension(36) :: numbers

  integer, dimension(7) :: selected

  

  ! Számok inicializálása 0-tól 35-ig

  do i = 1, 36

    numbers(i) = i - 1

  end do

  

  ! Véletlen permutáció (Fisher-Yates shuffle)

  call random_seed()

  do i = 36, 2, -1

    call random_number(temp)

    j = 1 + int(temp * real(i))

    ! Csere

    temp = numbers(i)

    numbers(i) = numbers(j)

    numbers(j) = temp

  end do

  

  ! Első 7 szám kiválasztása és kiírása

  write(*, '(7I3)') (numbers(i), i=1,7)

  

end program lottery

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

Lássuk C#-ban

using System;
using System.Linq;

class Program
{
static void Main()
{
Random rand = new Random();
var numbers = Enumerable.Range(0, 36).OrderBy(x => rand.Next()).Take(7).ToList();
Console.WriteLine(string.Join(", ", numbers));
}
}

Lássuk C##-ban

using System;
using System.Linq;

class Program {
static void Main() {
Console.WriteLine(Enumerable.Range(0, 36).OrderBy(x => Guid.NewGuid()).Take(7));
}
}

Figyeljük meg a hasonlóságot!

És ugyanaz a skandináv lottó program Python nyelven egyetlen sorban leírható;

import random;print(sorted(random.sample(range(36),7)))

Most lássuk Mojo nyelven.

from random import random_sample, range
from algorithm import sorted

alias usize = DType.uint64

fn main():
var nums = random_sample[usize](range(usize(36)), 7)
print(sorted(nums))

É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

Nézzük jawa programozási nyelven;

import java.util.*;

public class Lotto {

public static void main(String[] args) {

List<Integer> numbers = new ArrayList<>();

for (int i = 0; i < 36; i++) {

numbers.add(i);

}

Collections.shuffle(numbers);

List<Integer> sample = numbers.subList(0, 7);

Collections.sort(sample);

System.out.println(sample);

}

}

Magyarázat a változásokról:

• range(36) → for ciklus 0-35-ig

• random.sample() → Collections.shuffle() + subList(0,7)

• sorted() → Collections.sort()

• print() → System.out.println()

És ugyanaz a skandináv lottó program Kotlin nyelven

import kotlin.random.Random

fun lotto(p: List<Int>, t: Int = 7, m: Int = 1, ma: Int = 35): List<Int> {

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)

} 

Még egyszerübben a 05AB1E programozási nyelven; futtatásához https://ato.pxeger.com/run szükséges!

₅в7ƾ‡Jðý

Magyarázat lépésről lépésre:

₅в # 36-ig terjedő lista: [0,1,2,...,35]

7 # 7 db-ot választunk belőle egyedi elemekkel

Æ # rendezzük növekvő sorrendbe

¾ # vesszővel elválasztjuk

‡ # join-oljuk space-szel

J # összefűzzük stringgé

ðý # kiírjuk space-szel elválasztva

És íme itt van Vyxal programozási nyelven:  futtatása speciális interpretert igényel!

7R36ÞK€S

Magyarázat lépésről lépésre:

7 # 7 db számot választunk

R # véletlenszerűen a bemenetből

36 # 36 számból (range(36))

ÞK # egyedi elemek kiválasztása (sample)

€S # rendezés (sorted)

# implikáltan kiír

Ugyanez R programozássi nyelven;

sample(sort(sample(0:35, 7)))

A legújabb programozási nyelvek főként a 2020 utáni években jelentek meg vagy szereztek jelentős lendületet, például az AI, a teljesítményoptimalizálás és a fenntarthatóság terén. Ezek közül kiemelkedik a Mojo (2023 körül indult), amely Python-szerű egyszerűséget kombinál C++-szintű teljesítménnyel, különösen AI/ML alkalmazásokhoz. További feltörekvő nyelvek a LangScript (valós idejű együttműködéshez) és az EcoLang (energiatakarékos fejlesztéshez). Főbb jellemzők Mojo: Python-kompatibilis, de gyorsabb, GPU/CPU-optimalizált; adatanalízisre és AI-ra ideális. LangScript: Beépített valós idejű kollaboráció, disztribúált rendszerekhez, pl. multiplayer játékokhoz. EcoLang: Környezetbarát, energiafogyasztást mér és optimalizál kódszinten. Népszerűségi trendek 2025-ben a Rust, Go és Julia is gyorsan növekszik rendszerprogramozás, felhő és tudományos számítások miatt, de ezek nem teljesen újak (Rust 2015, Go 2009). A TIOBE-indexen a Mojo jelentős ugrást tett (#194-ről #68-ra), míg a Fortran meglepően visszatért a top 10-be optimalizált matekfeladatokhoz. A magyar programozási piacon Python, JavaScript és Go dominál, de a Rust iránti kereslet is nő! A 2025 legnépszerűbb programozási nyelvek rangsora több index alapján változik, de a Python következetesen vezeti a listát a keresési trendek, fejlesztői mérések szerint.

TIOBE Index (2025 december)

A TIOBE index keresőmotoros adatokon alapul, ahol a top 10 dinamikusan változik, de a Python tartja az első helyet, míg az R visszatért a listára. https://www.tiobe.com/tiobe-index/

· Python

· C++

· C

· Java

· C#

· JavaScript

· Visual Basic

· Go

· Fortran / Delphi

· R / SQL / Perl 

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

A 05AB1E egy [[verem-alapú (stack-based)]], [[kód-golf (code-golf)]] programozási nyelv, amelynek célja a minél rövidebb programok írása, jellegzetes egy-karakteres utasításokkal és automatikus kimenettel, ahol a verem sztringeket tárol (számok és listák is), és az utasítások szöveges adatokon működnek. Stack-alapú: A programok egy verem (stack) fölött működnek, ahol az adatok (számok, szövegek, listák) egymásra kerülnek. Egy-karakteres utasítások: A legtöbb műveletet egyetlen Unicode karakter jelöli. Adattípusok: Alapvetően stringeket kezel, de automatikusan számokká vagy listákká konvertál, ha szükséges (pl. matematikai műveletekhez). Automatikus kimenet: A program végén a verem tartalma automatikusan kiíródik. Kód-golf cél: A rövidség a legfontosabb, így a kód gyakran szokatlanul néz ki. A 05AB1E egy speciális nyelv, amely tökéletes kódfejtéshez, ahol a kód mérete fontos tényező. 

A másik a Vyxal, egy esoterikus (különc), verem alapú (stack-based) és tömb-orientált (array-oriented) programozási nyelv, amelyet kifejezetten kódgolfozási kihívásokhoz (code golf) terveztek, célja a legkevesebb karakterrel minél többet elérni, egyetlen bájtkód-készletet használ (SBCS), és a 3. verziója már GitHub literális módot is kínál az olvashatóság növelésére, miközben rengeteg modifier (módosító) funkciót tartalmaz. A fő cél itt is a kód minimalizálása, így rendkívül tömör (terse) és elegáns lehet.

Verem alapú (Stack-based): Műveletek adatokat helyeznek a veremre (stack), majd onnan vesznek ki, hasonlóan más esoterikus nyelvekhez (pl. Forth, Forth-szerű nyelvek). Tömb-orientált (Array-oriented): A műveletek gyakran tömbökön (listákon) hajtanak végre. Egyetlen bájtkód (SBCS): Minden parancs egyetlen bájtból áll, ami maximalizálja a kód tömörségét. Modifierok (Módosítók): Körülbelül 20 féle módosító (pl. arity grouping, azaz argumentum-csoportosítás) áll rendelkezésre a viselkedés megváltoztatására. Literális Mód (Literate Mode): Lehetővé teszi ASCII karakterekkel történő írást úgy, hogy közben megmaradjon az SBCS (single byte code set) pontszám, így olvashatóbbá téve a kódot.

Vyxal 3: A nyelv harmadik fő verziója jelentős átalakításokat hozott, beleértve az elemek listájának újragondolását.  A Vyxal egy speciális, erős eszköz a rövid kódok írására lett kifejlesztve, a programozási nyelvek különleges és speciális kategóriáiba sorolható, a lusta programozók nyelve. A szoftverfejlesztés és a szakterületi tervezés (angolul domain engineering) területén a szakterület-specifikus nyelv (angolul domain-specific language, DSL) olyan programozási nyelv vagy leírónyelv, amit egy bizonyos szakterület, problémaosztály, problémafelvetési vagy -megoldási technika számára hoztak létre. A fogalom nem új keletű, mindig is léteztek speciális célú programozási nyelvek, illetve modellezési/specifikációs nyelvek, de a kifejezést a szakterület-specifikus modellezés elterjedése tette népszerűvé. a szakterület-specifikus nyelvek közé sorolható. Az R, S és Q statisztikai programozási nyelvek, Mata mátrixprogramozáshoz, Mathematica és Maxima a szimbolikus matematikai feladatokhoz, számolótábla-képletek és -makrók, az SQL a relációs adatbázisok lekérdezéseihez, YACC nyelvtanok parser írásához, reguláris kifejezések lexikális elemzéshez, a Generic Eclipse Modeling System, Csound, digitális hangszintetizáláshoz, a Graphviz és a GrGen, amik gráfok manipulációját támogatják, míg a régi statikus nyelvek, mint a C vagy a Java, a régi általános célú programozási nyelvek csoportjába tartozik.

A legrövidebbek

A legrövidebb programozási nyelvek alatt általában az esoterikus (esoteric) nyelveket értjük, amelyek minimális szintaxissal rendelkeznek, és gyakran code golf vagy kihívásokra készültek. Legnépszerűbbek a

Brainfuck: Csak 8 parancs (>, <, +, -, ., ,, [, ]), Turing-teljes, de rendkívül tömör.

Whitespace: Csak szóközök, tabulátorok és sortörések – láthatatlan kód.

Malbolge: 1 bájt/parancs, de gyakorlatilag "megfejthetetlen" nehézségű.

A Code golf nyelvek

GolfScript: 1-2 karakteres stack-alapú műveletek (pl. "7,36<{~}*".).

Jelly: Bytecode-szerű, gyakran 5-10 bájtos programok bonyolult feladatokra.

05AB1E: Stack-based, rövid láncolt parancsok.

Ezekkel a korábbi lottó példa (36-ból 7 véletlen, rendezve) 10-20 karakterből megírható, szemben a régi elavult  C#-ban lévő 100+ karakterrel. 

Annál terjengősebb minél kisebb szemantikailag és szintaktikailag, könnyebb hibázni, de gyorsabb az értelmezés a gép számára

++++[>++++<-]>-[>+<-]>++++++[>+++++++<-]>+>+>>++++++<<<
[->>+<<]>[>>+<<-]>[>+>>+<<[<+>-]]>>[<<+>>-]>[<+>-]<<<<
[>+>+<<-]>>[<<([>]-[>+<-])>+[<->-]++[>++++<-]>[<+>-]^
[>+<-]>[<+>-]<<[<+>-]>[>+>+<<-]>[<+>-]^>>+[[-]++++++[>+++++<-]]
>++++[<+++++>-]<++++[>++++++<-]>+++++>>++++++[>++++++[>+++++<-]
<<<<-]>>>++++[>++++++<-]>++++>++++[<++++>-]>>++++++[<+++++>-]
<<<<[>]-[>+<-]>++++++[>+++++++<-]>+>>++++++<<<
[->>+<<]>++++[>++++++[>++++++[>+++++<-]<<<<-]>>>++++
[>++++++<-]>++++>++++[<++++>-]>>++++++[<+++++>-]<<<<
[>]-[>+<-]>++++++[>+++++++<-]>+>>++++++<<<[->>+<<]
>[>>+<<-]>[>+>>+<<[<+>-]]>>[<<+>>-]>[<+>-]<<<<<
[>+>+<<-]>>[<<([>]-[>+<-])>+[<->-]++[>++++<-]>[<+>-]
^[>+<-]>[<+>-]<<[<+>-]>[>+>+<<-]>[<+>-]^>>+[[-]++++++
[>+++++<-]]>++++[<+++++>-]<++++[>++++++<-]>+++++>>++++++
[>++++++[>+++++<-]<<<<-]>>>++++[>++++++<-]>++++>++++[<++++>-]
>>++++++[<+++++>-]<<<<[>]-[>+<-]>++++++[>+++++++<-]>+>>++++++
<<<[->>+<<]>[>>+<<-]>[>+>>+<<[<+>-]]>>[<<+>>-]>[<+>-]<<<<
[>+>+<<-]>>[<<([>]-[>+<-])>+[<->-]++[>++++<-]>[<+>-]^
[>+<-]>[<+>-]<<[<+>-]>[>+>+<<-]>[<+>-]^>>+[[-]++++++
[>+++++<-]]>++++[<+++++>-]<++++[>++++++<-]>+++++>>++++++
[>++++++[>+++++<-]<<<<-]>>>++++[>++++++<-]>++++>++++[<++++>-]
>>++++++[<+++++>-]<<<<[>]-[>+<-]>++++++[>+++++++<-]>+>>++++++
<<<[->>+<<]>++++[>++++++[>++++++[>+++++<-]<<<<-]>>>++++
[>++++++<-]>++++>++++[<++++>-]>>++++++[<+++++>-]<<<<
[>]-[>+<-]>++++++[>+++++++<-]>+>>++++++<<<[->>+<<]
>[>>+<<-]>[>+>>+<<[<+>-]]>>[<<+>>-]>[<+>-]<<<<<
[>+>+<<-]>>[<<([>]-[>+<-])>+[<->-]++[>++++<-]>[<+>-]

Magyarázat

• Memória: 36 cella 0-35-ig töltve, 7 kiválasztott + swap terület.

• "Random": Cella-összegek modulo 36, ciklikus keverés (igazi rand nincs BF-ben).

• Rendezés: Bubble sort a 7 számon.

• Kimenet: Rendezett számok space-szel elválasztva.

Remélem nem vettem el a kedveteket a programozástól, csillagászati számításoknál, egy objektum pályájának kiszámolásánál nem mindegy melyiket használjuk.