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.
