"Cogito ergo sum."

Nem tudom hogy hány lelkes linux felhasználó volt már úgy vele hogy feltelepített egy Ubuntu-t, Debian-t vagy akármi más, és amikor megnézte a rendszert tele volt olyan programmal amiről az életben nem is hallott, nem hogy használta volna.. Most nem bántani akarom azokat az embereket akik vért izzadva raknak össze telepítő lemezeket, hogy hírdessék az igét. VIszont valamilyen szintem szerintem csorbul a szabadság filozófiája ezen a téren. Itt arra gondolok hogy az aki kezdőként átjön linuxra jó hogy nem ál neki parancssorból telepíteni csomagokat, és csak is azokat ami neki kellenek. Hanem az 'advanced' felhasználókra, akik már fel mernek 'dpkg -i' paranccsal telepíteni valamilyen csomagot a Debianra vagy Ubuntura. Szerintem nekik kellene biztosítani egy még "pucérabb" ami annyit tesz hogy feltelepíti az Adott Distro parancssoros változatát, és egy választási lehetőséggel a legtöbb ablakkezelőt fel tudja telepíteni. Először is kell nekünk egy ISO amit innen lehet letölteni.

http://cdimage.debian.org/debian-cd/current-live/amd64/bt-hybrid/

Ha ez megvan akkor a következő parancsot ki is adhatjuk a parancssorban.

kvm -m 1024 -cpu kvm64 -drive file=Gnome,if=virtio,cache=none -boot c -cdrom ../../Downloads/debian-live-7.2-amd64-standard.iso

Itt a "-drive" jelöli a virtuális HDD-t, a "-cdrom" az amiről bootolunk.Itt lehet a  Graphical installra menni. Next-next-finish után a következőt kell látnunk. Indítsuk el a VM-et.

kvm -m 1024 -cpu kvm64 -drive file=Gnome,if=virtio,cache=none -boot d -vga std Láthatjuk hogy nincsen itt semmi féle csili-vili GUI. De mindjárt varázsolunk rá. :) Először adjuk ki a következő 2 parancsot hogy felfrissítsük az OS-t.

aptitude update && aptitude upgrade

Ha ez megvolt akkor mehet a következő parancs:

apt-get install --no-install-recommends gnome-core

Ez fel fogja telepíteni a Gnome legalapabb összettevőit és lesz egy minimális "fölösleges" csomagokkal ellátott GUI-nk amivel azt kezdünk amit akarunk. A következő csomag amit fel akarunk tenni ez lesz:

aptitude install xinit

Ez a csomag a grafikus felület kezeléséhez járul hozzá teljes mértékben. Már csak egy restart kell és készen is vagyunk.

Voil'a meg is vagyunk vele, el lehet kezdeni a  testreszabást. :) Mi az ami az alapban benne van?

• böngésző
• dokumentum és kép nézegető
• dictionary
• Brasero Disk Burner
• Meg az alap system toolok.

Ezek alá nem tudom hogy le lehet-e menni, de nekem már ez is bőven kielégíti az én szeretném testreszabni igényemet.

Egy újabb Debian derivatíva, most éppen a testing Branchról.

http://sparkylinux.org/

Paweł Pijanowski jeletette be a kiadást, aminek a kódneve "Game Over". Ez egy kimondottan "gamer" edisön disztró ami a Linux kernel 3.11.10, köré épül fel. Azt mondja hogy renegteg játék játszható ezen a platformon, illetve javult az AMD/Ati kártyák támogatása is, mindezt egy Intel HD graphics 2000-en teszteljük is. :)

Ez az installer nem egyértelmű, lehet viszont csak én vagyok értetlen. De sikerült elindítani  végre a telepítést.

Csini az a ninja a háttérben. Nade nézzük csak végig, van sokminden az asztalon, egy conky monitor jobb oldalt, egy dockbar felül, tele sok mókával, Desura, Steam, DosBox, stb... Van még egy platform ami említésre méltó az a Doomsday engine. Az alatt Hexen, Heretic, Doom és társai gond nélkül elfutnak linux alatt de az egy másik post lesz. Mivel Debian alapú ez a rendszer is, így az RDP és SSH beállítása egyszerű kell hogy legyen.

Így is van, minden simán ment, statikus IP, networking restart, ifconfig kimenete stimmel. Viszont az SSH és az RDP standard nincs rajta. :( A következő 2 paranccsal hozzuk naprakészre az OS-t.

aptitude update && aptitude upgrade

Ezek után adjuk ki a következő 2 parancsot.

aptitude install xrdp

aptitude install openssh-server

A következő 2 parancs kimenete mutatja ha minden rendben volt az install közben.

A 22-es port a default ssh port a 3389-es pedig a default rdp port.

Íme az SSH:

íme az RDP:

Nem is volt olyan nehéz életre kelteni. Ami talán a legmeglepőbb volt, hogy mennyi érdekes "régi" játékot talál az ember az "other" menüpont alatt. Mindenképpen érdemes időt szánni a distronak.

HF&GL

Hmm annak aki régen foglalkozott a Backtrack kiadásokkal egy szívmelengető érzés lehet ezt a kiadást feltelepíteni. Úgy is lehet mondani hogy az elhatalmasodott és nagyszámú csomagokat kiszelektálták a Backtrackből és csak a lényeget hagyták meg a Kali-ban. Alapjában véve ez is egy Debian alapú OS, ami egy régebbi 3.7-es kernelre épül. A "vas" amit kapott a VM az nem más mint 2vCPU és 1GB RAM, Virtio disk, no cache, native.

Innen lehet letölteni: http://www.kali.org/

Izzítsuk is be a masinát. A telepítés nem más mint next-next-finish metodika, Nem veszi különösebben igénybe az ember, maximum az 1 root jelszó kitalálása. Miután feltelepült hozzuk naprakészre a rendszert.Ezek után a már Ubuntuból/Debianból ismert parancsokkal frissítsük fel a rendszert.

apt-get update && apt-get upgrade && apt-get dist-upgrade

aptitude update && aptitude upgrade

Emlékszem a Backtrackben a legelső dolog ami megfogott az volt hogy nem kellett használni a "sudo su" vagy "su" parancsokat hogy bármi komolyat változtassak a rendszereken, egyszerűen "root" volt a terminál ami elindult. Húdekafa :) Amíg frissül a rendszerünk nem árt ha felmérjük a terepet, milyen softwarek találhatóak meg a rendszeren.

Rengeteg érdekes és hasznos és Veszélyes tool van a Kali-ban amiket nagy elővigyázatossággal kell használni. Ahhoz hogy távolról is tudjuk hackelni a rendszert kell az SSH és valamilyen RDP a VM-re. Az SSH adott az RDP pedig legyen az xrdp csomag amit az

apt-get install xrdp

paranccsal tudunk feltelepíteni. Miután es feltelepült nincs más dolgunk mint hogy statikus IP címet kapjon a masina és a megfelelő servicek fussanak. Adjuk ki a következő parancsot.

nano /etc/network/interfaces

Ide attól függően hogy mi a neve a hálózati kártyánknak a következő sorokat írjuk be.

auto eth0

iface eth0 inet static

address 192.168.1.160

netmask 255.255.255.0

network 192.168.1.0

gateway 192.168.1.17

dns-nameservers 8.8.8.8

Ezek után mentsük el a fájlt a CTRL+x után az "y" gombbal és indítsuk újra a networking-et.

/etc/init.d/networking restart

Ezzel a network része meg is van, most jön egy kis turkálás a boot folyamatot vezérlő scriptekben.

Menjünk a cd /etc/rc2.d/ mappába és adjuk ki az "ls -l"  parancsot.

Látunk kismillió szimbolikus linket azokra  a folyamatokra amelyek a bootolás közben elindulnak. Először is adjuk ki a következő 2 parancsot

ls -l | grep ssh

ls -l | grep xrdp

Az adott mappában ezeknek a parancsoknak a kimenetét töröljük ki. Adjuk ki a következő 2 parancsot ezek után.

Már csak 2 parancsnyira vagyunk a működéstől.

update-rc.d ssh enable

update-rc.d xrdp enable

Miután újraindítottuk a masinát menni fog az RDP.

Illetve az SSH is menni fog.

Most már bárhonnan széles-e világon egy megfelelő router configgal el tudjuk érni ezt a virtuális masinát.

Miért is jó a virtualizálás? Rugalmasságot ad, energiát takarít meg, sokkal gyorsabb mint a natív technológiák olyan értelemben hogy helyreállítani vagy a 0-ról feltelepíteni bármit is. Ahhoz hogy a blog posztjai létrejöhessenek nem kell mást tenni mint a szükséges technológiát feltelepíteni a Debian-ra. A következő parancsokra lesz szükségünk hozzá.

aptitude install qemu-kvm libvirt-bin virt-manager bridge-utils uml-utilities

gpasswd -a username libvirt

gpasswd -a username kvm

Ekkel megvagyunk a software rész előkészítésével. Most már csak egy restart fog kelleni ahhoz hogy használni is tudjuk. Nagyon fontos hogy a KVM csak akkor lesz használva ha a CPU támogatja illetve be is van kapcsolva a BIOS-ban. Restart után lehet használni a virt-managert. Azokat az ISO-kat amikről telepíteni szeretnénk másoljuk be a

/var/lib/libvirt/images

mappába és mehet a buli. Amennyiben pingelni/ssh/rdp kapcsolatokkal akarjuk bombázni a VM-et, nem árt kicsit a hálózaton alakítani. Adjuk ki a következő  parancsokat hogy elfedjük a hostot és teljes értékű Computernek látszódjon a VM-ünk bármelyik másik masináról.

brctl addbr HostBridge

brctl addif HostBridge eth0

ifconfig eth0 0.0.0.0 promisc

dhclient HostBridge

Ebben az esetben a VM-eken az NIC-t ki kell cseréni "Shared device name" -re.

Ezek után ne felejtsük el startup scriptbe betenni az előzőeket és el is felejthetjük.

Kicsit több mint 1 éve dolgozom az egyik Debreceni informatikai szolgáltató cégnek. Kaptam már hideget, meleget, jót, kevésbé jót de hát ilyen az élet. Ami viszont nagyon dícséretre méltó az a tudás amihez hozzájuttatják az embert, azok a high-tech kütyük amikkel a munkánkat végezhetjük.  Utóbbi időben a szabadidőm nagy részét a virtualizáció és a Dota 2 teszi ki. Az újabb posztok a főként a www.Distrowatch.com oldalon publikált Linuxok beüzemelését és használatát fogja célul kitűzni.

Ezek az operációs rendszerek QEMU-KVM virtualizációs technika segítségével fognak életre kelni, és a virt-manager nevű package fogja szolgáltatni a GUI-t hozzá.

Ez a poszt egy másik MI-s problémának lesz szentelve. Mégpedig az N négyzetnek. Biztos mindenki találkozozz már azzal a kirakós játékkal ahol tipikusan 9 négyzet fér el a táblán, 3x3as felbontásban. Mégpedig csak 8 részből áll a kép és van egy üres hely. A négyzeteket meg lehet ide-oda tologatni és a képet kell visszakapnunk ha jól toljuk... :) Hát ez nem egy grafikus program, és nem is tökéletes, de egyfajta heurisztika van beleépítve. A lényege az az hogy adott végállapot:

1 2 3

4 5 6

7 8 0

és kiinduló állapot:

1 2 0

4 6 3

7 5 8

esetén tud megfelelő operátorsorozatot találni melyet alkalmazva eljutunk a kezdő állapotból a végállapotba!

A heurisztika lényege hogy megnézi hogy mely operátorok alkalmazhatóak az adott állapotra, és ezekről megnézi hogy mennyivel, hány különböző elemmel térnek el a kívánt végállapottól. Illetve nagyon fontos megemlíteni hogy arra sose megy egyből vissza amerről jött! Iletve számon tartja a legkedvezőbb, és második legkedvezőbb utat! Mivel ha a legkedvezőbb az amerről jöttünk akkor jön képbe a második legkedvezőbb út!

Három argumentuma van az első a négyzetek száma a második a kézi kezdő vagy random kezdő állapot, a harmadik pedig kézi vég vagy alap végállapot megadását jelenti!

./n 3 0 0

Kimenete:

#################     Itt a kezdőállatpot!!     #################
1 2 0
4 6 3
7 5 8
#################################################################

#####################      Itt célállapot!    ###################
1 2 3
4 5 6
7 8 0
#################################################################


##################Let the hunt begin!!!##########################
############################## 1. kör############################
LE
1 2 3
4 6 0
7 5 8
############################## 2. kör############################
BALRA
1 2 3
4 0 6
7 5 8
############################## 3. kör############################
LE
1 2 3
4 5 6
7 0 8
############################## 4. kör############################
JOBBRA
1 2 3
4 5 6
7 8 0

Hát rég volt már poszt, de ezzel együtt ihlet is rég szállt meg.... :) Most viszont új erőre kapva a Mesterséges Intelligencia tárgytól a következő posztot ennek szentelem.  A poszt témája az N királynő probléma. Tömören annyi a lényege hogy adott egy NxN-es sakktábla, ahova úgy kell felhelyezni N darab királynőt hogy nem üthetik egymást. Más szóval oszloponként és átlónként és soronként is csak 1 darab megengedett a királynőkből, ez szükséges de nem elégséges feltétele a dolognak!

A programom úgy működik hogy, elindul a sakktábla bal felső sarkából és N darab esetén NxN tesztesetet generál ami abból áll hogy leteszi az első helyre a királynőt és aztán az ütött mezők értékét 1-esre állítja. Utána megkeresi hogy melyek a szabad mezők, majd azok közül választ véletlenszerűen 1-et és oda rak le egy királynőt, és az általa ütött mezőket is 1-esre állítja, és megint keresi a szabadon maradt mezőket... Ez mind addig meg míg el nem fogynak a szabad mezők. Ha elfogyott a szabad mezők száma és N darab királynő van a táblán akkor talált egy megoldást a program és meg előre csak a soron következő  mezőre rakja a királynőt és kezdi az egészet elölről, mindaddig míg nincs meg a megfelelő számú megoldás...Van viszont egy kis szépség hibája a proginak, mégpedig hogy semmi garancia nincs hogy a megoldások amiket talál nem egyeznek meg mert nincsenek rögzítve a megoldások az ellenőrzésre. Viszont kb 10 királynő esetén már elég kis eséllyel járja be ugyan azt az utat 2x, és a királynők számával ez még radikálisabban csökken. :)

4 Királynő esetén:

./nkir 4 2 <paraméterekkel indítva>

Ez a megoldas a 1. kör 3. teszesetében van!
Ez a 1. megoldasa a feladatnak!!
1 1 9 1
9 1 1 1
1 1 1 9
1 9 1 1

Ez a megoldas a 1. kör 9. teszesetében van!
Ez a 2. megoldasa a feladatnak!!
1 9 1 1
1 1 1 9
9 1 1 1
1 1 9 1
 

10 királynő esetén:

Ez a megoldas a 1. kör 16. teszesetében van!
Ez a 1. megoldasa a feladatnak!!
1 1 9 1 1 1 1 1 1 1
1 1 1 1 1 9 1 1 1 1
1 1 1 1 1 1 1 1 9 1
9 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 9 1 1
1 1 1 9 1 1 1 1 1 1
1 9 1 1 1 1 1 1 1 1
1 1 1 1 1 1 9 1 1 1
1 1 1 1 9 1 1 1 1 1
1 1 1 1 1 1 1 1 1 9

Ez a megoldas a 1. kör 24. teszesetében van!
Ez a 2. megoldasa a feladatnak!!
1 1 1 1 9 1 1 1 1 1
1 1 1 1 1 1 1 1 1 9
1 1 1 9 1 1 1 1 1 1
1 1 1 1 1 1 1 1 9 1
1 1 9 1 1 1 1 1 1 1
1 1 1 1 1 1 1 9 1 1
1 9 1 1 1 1 1 1 1 1
1 1 1 1 1 1 9 1 1 1
9 1 1 1 1 1 1 1 1 1
1 1 1 1 1 9 1 1 1 1
 

Ennek a proginak a lényege hogy megy végig a megadott tömbön és ha az i-edik eleme prím akkor i+1-től kezdve kimaskolja a prímek többszöröseit.

Például: 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

            megvan hogy a kettő prím így

             2 3 5 7 9 11 13 15 17 19

           megvan hogy a három is prím így

             2 3 5 7 11 13 17 19

Forrás a tovább után--->

Egyik altalam leginkább kedvelt tárgy ebben a félévben a "Nagy számításteljesítményű párhuzamos programozási eszközök" ezt a tárgyat egy kiváló ember és tanár tartotta Kovács György. E félév végen beadandót kellett készíteni egy választott témában. Az én témám pedig Pthread+OpenMP kombó volt. Röviden annyit a programról hogy 10 szálon keresi a prímszámokat mégpedig úgy hogy a megadott intervallumot feldarabolja 10 részre és mindegyik szál meg kap egy kissebb intervallumot. UTánna elindul a keresés itt pedig mutexel van védeve az a kritikus szakasz míg a prímet belerakja a gyüjtő tömbbe. Továb bután a források--->

Lényegében egy olyan algoritmus amely képes meghatározni hogy 12-nek az 1356-ik hatványa mennyivel egyenlő. Amit lehetne bruteforce-al ami ugye úgy nézne ki hogy (12*12*12*12....) és ez 1356-szor elvégezni amit nem is nagyon tudhatnánk letárolni.... vagyis csak nagy nehézségek árán. De mint mindenből van egy kicsit szebb, egy kicsit jobb így erre is van egy elegáns megodás. Ez nem mondja ki konkrétan hogy ennyivel, vagy annyival egyenlő a mi hatványunk hanem zárt alakban adja meg.Forrás atovább után---->>

Ez alkalommal egy olyan algoritmust elebrálok ami nem kis fáradalommal de napvilágot látott, olyan mint a magyar narancs kicsit sárge, kicsit savanyú, de a mienk. :) Jöjjön a mű. Lényege hogy körmérkőzésnek a fordulóit állítja elő, de úgy hogy mindenk játszik mindenkivel, és ugyan az a két csapat csak egyszer játszik egymás ellen.Forrás a tovább után---->>

Ez nem más mint két szám legnagyobb közös osztóját meghatározó algoritmus. Legyen adott 2 számunk a 245 és a 832.

832 245

245 97

97 51

51 46

46 5

5 1

0

Röviden a bal oldali szám mod jobb oldali és a jobboldali meg a bal alá az eredmény meg  ajobb alá, mind addig míg a bal oldali nem lesz nulla, mert ekkor az utolsó jobboldali adja az lnko-t.

Forrás a tovább után---->>

Az alábbi kis progi a Phi(N) értéket adja vissza ami nem jelent mást. Mint azt hogy a relatív prímek száma N-hez 1-től. A relatív prímek olyan számok melyek legnagyobb közös osztója az 1. Itt is lehet agyalni azon hogy akkor most prímtényzős felbontás, miegyebek. Ami jó megoldáshoz vezet de rengeteg munkát igényel mint le programozni mint végrehajtani a számítógépnek. Talán az egyik legelegánsabb megoldás az lnko meghatározására az EUKLIDESZI ALGORITMUS.

Forrás a tovább után---->

Az alap ötlet az volt hogy végtelen db prímszám van-e? Ez a program azt csinálja hogy bekéri egyszer azt hogy meddig menjen el, utánna bekéri hogy hány részre osszuk fel a tartományt. Végül kiírja hogy adott részre felosztott tartományba hány darab prímszám esik. Akkor lenne érdekes ha el lehetne érni hogy végtelenig menjen, mert akkor lehetne saccolni... :)

Forrás a tovább után---->>

A számelméletben azokat a számpárokat, amelyekre igaz, hogy az egyik szám önmagánál kisebb osztóinak összege a másik számmal egyenlő (és fordítva), barátságos számoknak hívjuk.

Ilyen például a (220; 284) számpár.

220 önmagánál kisebb osztói: 1, 2, 4, 5, 10, 11, 20, 22, 44, 55, 110.

1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284

284 önmagánál kisebb osztói: 1, 2, 4, 71, 142.

1 + 2 + 4 + 71 + 142 = 220.

Röviden a hurok úgy néz ki hogy elindulunk egy számból, megnézzük hogy mennyi osztóinak összege, kaptunk egy újabb számot, annak is megnézzük, és ha előbb utóbb visszajutunk a kiindulási számhoz, akkor hurkot találtunk.

Forrás a tovább után---->>

Következő programom megadott mennyiségű elemet fog hibátlanul permutálni.

Maximum 10 elemre képes :)

#include<iostream>
#include<cstdlib>
#include<cstdio>
int f;
using namespace std;

int
fakt (int j)
{
  int i;
  f = 1;
  for (i = 1; i <= j; i++)
    f = f * i;
  return f;
}

int
main (void)
{
  long long int a, b, i, j, k, l, m, p, t, s, q, egyezo;
  int *tomb, *seged;

  cout << "Kérlek add meg hány elemet akarsz permutálni: ";
  cin >> a;

  tomb = (int *) malloc (a * sizeof (int));
  srand (time (NULL));
  if (a < 1)
    cout << "Nem megfelelő az érték!!!!" << endl;
  else if (a == 1)
    cout << "Azt meg minek permutálni!!" << endl;
  else if (a > 10)
    cout << "Túl magas az érték a változók kapacitásához!!" << endl;
  else
    {
      cout << "Tehát " << a << " elemű tömböt szeretnél!" << endl;
      cout << "Ennyi elemet " << fakt (a) <<
    " féle képpen lehet permutálni!!!" << endl;
      cout << "Ez egy " << a << " oszlopú és " << f <<
    " sorú két dimenzós tömbbe fér bele!" << endl;



      int **vegleges;
      vegleges = (int **) malloc (f * sizeof (int *));
      for (i = 0; i < f; i++)
    vegleges[i] = (int *) malloc (a * sizeof (int));

      for (j = 0; j < f; j++)
    for (i = 0; i < a; i++)
      vegleges[i][j] = 0;

      t = 0;
      while (t < f)        //addig meg míg nincs legenerálva az összes permutáció
    {

      m = 0;
      for (;;)        //addig meg míg minden elem nem különbözik
        {
          for (i = 0; i < a; i++)    //feltöltjük a segédtömböt véletlen számokkal
        {
          b = (rand () % a + 1);
          tomb[i] = b;
        }
          for (l = 0; l < a; l++)    //lecsekkoljuk hogy van-e egyezés
        {
          k = tomb[l];
          tomb[l] = tomb[0];
          tomb[0] = k;
          for (i = 1; i < a; i++)
            if (tomb[0] == tomb[i])
              m++;
        }
          if (m == 0)
        break;
          else
        m = 0;
        }

      if (t == 0)
        {
          for (i = 0; i < a; i++)
        {
          vegleges[0][i] = tomb[i];
          cout << vegleges[0][i] << " ";
        }
          cout << endl;
          t++;
        }
      else if (t > 0)
        {
          egyezo = 0;
          for (j = 0; j < t; j++)
        {
          p = 0;
          for (i = 0; i < a; i++)
            if (vegleges[j][i] == tomb[i])
              p++;
          if (p == a)
            egyezo++;
        }
          if (egyezo == 0)
        {
          for (i = 0; i < a; i++)
            {
              vegleges[t][i] = tomb[i];
              cout << vegleges[t][i] << " ";
            }
          cout << endl;
          t++;
        }
        }
    }
    }

  return 0;
}

Kimenete------->

3 elem esetén:

Kérlek add meg hány elemet akarsz permutálni: 3
Tehát 3 elemű tömböt szeretnél!
Ennyi elemet 6 féle képpen lehet permutálni!!!
Ez egy 3 oszlopú és 6 sorú két dimenzós tömbbe fér bele!
2 1 3
3 2 1
1 3 2
1 2 3
3 1 2
2 3 1

real    0m0.289s
user    0m0.004s
sys    0m0.000s
 

4 elem esetén:

Kérlek add meg hány elemet akarsz permutálni: 4
Tehát 4 elemű tömböt szeretnél!
Ennyi elemet 24 féle képpen lehet permutálni!!!
Ez egy 4 oszlopú és 24 sorú két dimenzós tömbbe fér bele!
1 4 3 2
3 4 2 1
1 2 3 4
2 3 4 1
1 3 4 2
1 4 2 3
4 2 3 1
1 2 4 3
4 3 1 2
4 2 1 3
2 3 1 4
2 1 3 4
4 1 3 2
4 3 2 1
3 1 2 4
3 2 1 4
3 2 4 1
2 1 4 3
2 4 3 1
3 4 1 2
4 1 2 3
3 1 4 2
2 4 1 3
1 3 2 4

real    0m0.266s
user    0m0.008s
sys    0m0.000s
 

8 elem esetén: kis idő várakozás után....

40320 eshetőség lévén.....

real    15m36.352s
user    15m32.786s
sys    0m0.264s
 

Mitől is lehet valami egyedi, miért lenne valami egyedi az amúgy is egyediek között? Ezek eléggé érdekes kérdések :) De meg válaszolásra kerülnek hamarosan, kicsit gugliztam és találtam egy nagyon jó oldalt amin rengeteg érdekes egyedi prímsorozat van, mint például a csillagprímek a biztonságos prímek stb.

Íme az oldal: http://hu.wikipedia.org/wiki/Pr%C3%ADmsz%C3%A1mok_list%C3%A1ja

biztonsagosprimek.c

#include <stdio.h>
//olyan prímek ahol a 'p' és a '(p-1)/2' is prímek
int osztokszama;
int osztok(int j)
{
    int i,osztok=0;
    for(i=1;i<=j;i++)
    {
    if((j%i)==0) osztok++;
    }
    osztokszama=osztok;
    return osztokszama;
}

int main()
{
    int j;
    for(j=2;;++j)
    {
        if (osztok(j)==2&&osztok((j-1)/2)==2) printf("%d ", j);
    }
    return 0;
}

Kép: http://imagerz.com/QFdDXAhVA1U

csillagprimek.c

#include <stdio.h>
//Olyan prímek melyek alakja 6n(n-1)
int osztok(int j)
{
    int i,oszto=0;
    for(i=1;i<j;++i)
    {
        if((j%i)==0) oszto++;
    }
    return oszto;
}
int main()
{
    int j,k;
    for(k=2;;++k)
    {
        j=(6*k)*(k-1)+1;
        if(osztok(j)<3) printf("%d ", j);
    }

    printf("Oszto %d",osztok(6));
    return 0;
}

Kép: http://imagerz.com/QFdDXAhVA1M

Rendhagyó muzsika: https://www.youtube.com/watch?v=YkYVIePty9s

Ez a témakör is megfogott nagyon, vajon van-e olyan hogy legnagyobb prímszám........ Van olyan aki szerint van és persze az ellentét mellett is állnak sokan. De ahoz hogy kiválló prímvadászok lehessünk :) nem szabad durbelebalázs módon neki esni, Adott az előző programom amit ha kicsit módosítunk akkor kaphatjuk az alábbi programot.

idoketprimkozott.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int osztokszama;
int osztok(int j)
{
    int i,osztok=0;
    for(i=1;i<=j;i++)
    {
    if((j%i)==0) osztok++;
    if(osztok==3) break;
    }
    osztokszama=osztok;
    return osztokszama;
}

int
main ()
{
    int j;
    for(j=1000000000;;++j)
    {
    clock_t start = clock ();
    osztok(j);
    if (osztokszama==2)
    {
     printf("%d\n",j);
     printf ("Ennyi idő telt el két prím között: %f\n", ((double) clock () - start) / CLOCKS_PER_SEC);
    }
    }

  return 0;
}

Ebben a programban hogy eléggé lényegre törőek legyünk már csak a prímszámokat íratjuk ki, illetve a két megtalált prímszám között eltelt időt is :) Ami egy érdekes dologra ad következtetni, mégpedig hogy, haladunk szépen a számskálán  a programunkkal és bizonyos szám intervallumokban meghatározott időközönként bukkanunk prímekre, tehát. Elég lenne egy bizonyos idő múlva elért számot illetve annak a környezetét és 1 valószínűséggel találhatnánk prímszámokat. De egyelőre ez még  a jövő zenéje.

Kép: http://imagerz.com/QFdDXAgNVQM

Kicsit mit szólnátok ha fejlesztenénk rajta? Aki futtatta egy kis idejig az biztos észre vette hogy a vizsgálás 1 és 200000 között viszonylag gyors és ez után kezd szép lassan belassulni. Sejtitek-e hogy miért van ez? Namost az osztok() az egy külső függvény aminek visszatérési értéke nem más mint az hogy a vizsgált szám hány darab osztóval rendelkezik... és ha ezek szám 2 akkor hívjuk őtet prímnek :) Ha több akkor pedig nem :) A program belassulásának legfőbb oka hogy legyen az adott számunk az 500000, ekkor a második ciklus ami ennek az osztóit vizsgálja kénytelen 1...500000-ig elbattyogni akár megvan már a 2 osztó akár már több van.  Innen jött az ötlet hogy egészítsem ki egy olyan feltétellel hogy amennyiben megvan már 3 osztó ne vizsgálja tovább az adott számot hanem menjen a következőre.

primkeresoupgrade.c

#include <stdio.h>
#include <stdlib.h>
int osztokszama;
int osztok(int j)
{
    int i,osztok=0;
    for(i=1;i<=j;i++)
    {

     if(osztok==3) break;

     if((j%i)==0) osztok++;
    }
    printf("A %d nek ennyi osztoja van: %d ",j,osztok);
    osztokszama=osztok;
    return osztokszama;
}

int
main ()
{
    int j;
    for(j=5000000;;++j)
    {
    osztok(j);
    if (osztokszama==2) printf("  PRÍMSZÁM!!!\n");
    else printf("\n");
    }
  return 0;
}

Ezzel a kis módosítással rengeteg időt spórolunk meg, de elég egy állatorvosi lovas példára gondolni, ha van egy program aminek a futási ideje 6 sec és ezt a programot 1000000 szor használják, akkor csak 1 sec-es gyorsítással 1000000 másodpercet tudunk megspórolni, ami 16666 perc, 277 óra és ez 11,57 nap. :)

Kis muzsika az olvasáshoz: https://www.youtube.com/watch?v=qwdK-rYWx3A

Jelen program a prímszámokkal foglalkozik, honnan tudjuk hogy az adott szám prímszám-e, mi is az a prím :) Az alap koncepció a programnál az volt hogy induljunk el az egytől ésmenjünk amíg el nem fáradunk... a végtelen felé, eközben unaloműzés végett vizsgáljuk meg az adott száot hogy az prím-e vagy sem. Mégpedig úgy hogy veszük az adott számot, és egy új ciklust indítunk 1-től az adottig és mindig megnézzük hogy osztható e a futóindexxel a vizsgált szám maradék nélkül, ha igen akkor a gyűjtő változót növeljük 1-el. :) Enjoy.

primkereso.c

#include <stdio.h>
#include <stdlib.h>
int osztokszama;
int osztok(int j)
{
    int i,osztok=0;
    for(i=1;i<=j;i++)
    {
    if((j%i)==0) osztok++;
    }
    printf("A %d nek ennyi osztoja van: %d ",j,osztok);
    osztokszama=osztok;
    return osztokszama;
}

int
main ()
{
    int j;
    for(j=5000000;;++j)
    {
    osztok(j);
    if (osztokszama==2) printf("  PRÍMSZÁM!!!\n");
    else printf("\n");
    }
  return 0;
}

fordítása:

gcc primkereso.c -o primkereso

./primkereso

Kép:http://imagerz.com/QFdDXAgNVgI

Sziasztok!

Ez az én legelső blogom, melyet egy egyetemi tárgy ihletett mely nem más mint a PROGRAMOZÁS. Mely egy egészen érdekes világ számomra, illetve mint nyelv is kihívások elé állítja az embert, mert ezt is csak úgy lehet megtanulni mint egy igazi nyelvet, Füli szavaival élve le kell ülni és be kell seggelni a szabályokat, illetve a szókincset. :)