HTML

Programozó Páternoszter

Ez a Programozó Páternoszter (PP) blogja, a programozásról szól. Aktualitása, hogy a Debreceni Egyetem Informatikai Kara Magasszintű programozási nyelvek 1-2, C++ esattanulmányok, Java esettanulmányok című kurzusainak blogja is egyben.

A vadászat

A Debreceni Egyetem Programozói Évkönyve: az UDPROG projekt. A szakmai fórumunk a Facebook-en. Az új előadások a prezin.
A régi előadások:
Prog1:
1. C bevezetés
2. C tárgyalás
3. C befejezés
4. C a gyakorlatban
5. C++ bevezetés
6. C++ tárgyalás
7. C++ befejezés
8. C++ a gyakorlatban
9. Java platform bevezetés
10. Kvantuminformatikai alg. bev.
Prog2:
1. Java bevezetés
2. Java tárgyalás
3. Java befejezés
4. Java a gyakorlatban
5. Software Engineering bev.
6. Java EE bevezetés
7. AspectJ bevezetés
8. BPMN-BPEL SOA programozás
9. C++ haladó
10. Tensorflow

Kövess engem!

Friss topikok

Linkblog

Játék a betűkkel: TCAG, avagy a Humán Genom Projekt

2012.03.12. 13:59 nb

Az elmúlt héten többen szóvá tették, hogy Ők nem olvasták a labor posztját, ezért nem tudták, hogy pontosan milyen olvasmányélményekkel kell, hogy a laborra rendelkezzenek. A hallgatói laborkártya kezdeményezés kb. olyan, mint amikor a magyar tanárod rákérdezett, hogy "a madáchi tragédiában Évának hányadik gyermeke volt a leány?" Amivel ugye csak arra volt kíváncsi, olvastad-e a művet? A mi analóg (így szabadon feldobott) kérdésünk az volt a struktúrás fejezet kapcsán, hogy írjuk át a szereplő struct date *dp; mutatót használó dp->year-t a . operátort felhasználva. Szerencsére jeles hallgatóim tudták a választ (az örök igazság itt is áll: nem tanulni kell, tudni). Ilyesmi ellenőrző kérdésekre is számíts, de ha olvasgatod a kiadott részeket, nem lehet gond.

Ne feledd: a kurzus szervezésének sorodvonala ez a blog!

Aki lemaradt a laboron, itt egy segítő poszt még tavalyról: Labormérés otthon, avagy hogyan dolgozok fel egy pédát (foglalkozz vele, mert a védendő C++ kb. ugyanez lesz, de itt még a C változat ketyeg). A működésben pedig hasonló a feladott kötelező olvasmány példája.

A C programzónak a bitfaragás olyan, mint a katonának a takarítás, ennek jegyében ismételjünk a labor bemelegítéseként: aki megmagyarázza először a Linux kernelbeli static inline const char *get_task_state(struct task_struct *tsk) függvény bitfaragását egy kommentben elsőként, az 2 trófeát zsebelhet be ezért! Legyél gyors, mert ugyanezzel a fóliával kezdjük holnap az előadást, addig és a kihívás :)

(Kis help a Linux kernel hacking megkezdéséhez itt.)

Jöjjön a szakma:

A UNIX típusú rendszerekben a fork() a mitózis.

Rántsuk le az emberi genom 2. kromoszómájának egy részét:

ftp.ncbi.nlm.nih.gov/genomes/H_sapiens/Assembled_chromosomes/seq/ (már az új fájlneveket használtuk az elmúlt héten). T, C, A, G betűkkel találkozunk, ahogyan hármasával egy fehérjét kódolnak. A következő kis progival (mivel nem feledhetjük, hogy kezdő programozók is vannak köztünk, ezért az ilyen egyszerűekkel is foglalkoznunk kell ter) tehát a következő kis progival átkódoljuk a sorozatot, a Javát tanítok  www.tankonyvtar.hu/informatika/javat-tanitok-1-1-1-080904 TCAG2Hexa osztályának mintájára két nukleotid bázisból egy hexadecimális betűt készítünk:

#include <stdio.h>
#include <unistd.h>

int
main (void)
{      
  char hexa_jegyek[] = {'A', 'B', 'C', 'D', 'E', 'F'};
  
  int paratlan = 0, elso=0, masodik=0, i = 0;
  
  while((i=getchar()) != EOF) {
    
    switch(i) {
      
    case 'T':
      masodik = 0;
      break;
    case 'C':
      masodik = 1;
      break;
    case 'A':
      masodik = 2;
      break;
    case 'G':
      masodik = 3;
      break;
    }
    
    if(paratlan) {
      
      int jegy = 4*elso + masodik;
      
      if(jegy<10)
	printf("%d", jegy);
      else
	printf("%c", hexa_jegyek[jegy-10]);
      
    }
    paratlan = !paratlan;
    elso = masodik;                        
  }        
} 

Az alábbi kis játék során megismerkedünk a (2. előadásban bevezetett) CompLearn csomag használatával.

  • Rántsuk le a humán genom 2. kromoszómájának első 1400 betűjét ftp.ncbi.nlm.nih.gov/genomes/H_sapiens/CHR_02/ (amit a hs_alt_Hs_Celera_chr2.fa.gz név alapján Hschr21400 néven mentünk most el, alul majd helso.human1minta)!
  • Generáljunk le 1000 hexa jegyet a Pi kifejtésének 1.000.000. jegyétől (piezer.txt, alul majd piezer.1000000)!
  • Az első előadás pszeudorandom kártyájával és a fenti tcag2hex kiírás további finomításával
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <sys/types.h>
    #include <unistd.h>
    int
    main (void)
    {
      int i, r;
      srand (time (NULL) + getpid ());
      for (i = 0; i < 2000; ++i)
        {
          r = (int) (16.0 * rand () / (RAND_MAX + 1.0));
    
          if (r < 10)
    	printf ("%d", r);
          else
    	printf ("%c", r - 10 + 'A');
    
        }
      printf ("\n");
      return 0;
    }
    
    nyomtassunk ki 2000 db véletlen jegyet (veletlen2000, alul majd rand.2000db)!
  •  Rántsunk még le a 3. emberi koromóból is 700 betűt (Hschr3700)!
  •  A C elegans fonalféreg II. kromójából is vegyünk valamekkora mintát (c2_2000) ftp.ncbi.nlm.nih.gov/genomes/Caenorhabditis_elegans/CHR_II/NC_003280.fna (ez a féreg közel áll a szívünkhöz az Orch OR tudatmodell miatt is, alul majd celeg.celegans)
  • ... s készítünk még pár mintát... a kutya (canis familiaris), a ló (equus caballus), a kakas (gallus gallus), a szarvasmarha (bos taurus) 2. kromójának elejéből, a Pi kifejtéséből, a csupa 1 jegyből, a 01-ekből álló állományokból:

batfai@kalapacs:~ $ ls -l mintak/
összesen 72
-rw-r--r-- 1 batfai batfai 2100 2011-02-27 18:49 celeg.celegans
-rw-r--r-- 1 batfai batfai  800 2011-02-27 18:20 egyes.8001es
-rw-r--r-- 1 batfai batfai 3220 2011-02-27 21:14 h11kromo.eleje
-rw-r--r-- 1 batfai batfai 3080 2011-02-27 21:17 h11kromo.kozepe
-rw-r--r-- 1 batfai batfai 3260 2011-02-27 21:16 h11kromo.vege
-rw-r--r-- 1 batfai batfai 1400 2011-02-27 17:24 helso.human1minta
-rw-r--r-- 1 batfai batfai  700 2011-02-27 17:24 hmaso.human2minta
-rw-r--r-- 1 batfai batfai 3448 2011-02-27 18:44 kakas.2k
-rw-r--r-- 1 batfai batfai 1400 2011-02-27 21:02 kutya.1400
-rw-r--r-- 1 batfai batfai 1190 2011-02-27 21:09 kutya.kozepe
-rw-r--r-- 1 batfai batfai 1127 2011-02-27 21:09 kutya.vege
-rw-r--r-- 1 batfai batfai 1190 2011-02-27 18:45 lo.2k
-rw-r--r-- 1 batfai batfai 1600 2011-02-27 18:27 nulegy.800par
-rw-r--r-- 1 batfai batfai 1000 2011-02-27 18:39 pi1000.0tol
-rw-r--r-- 1 batfai batfai 2000 2011-02-27 18:35 pi2000.0tol
-rw-r--r-- 1 batfai batfai 1000 2011-02-27 17:25 piezer.1000000
-rw-r--r-- 1 batfai batfai 2000 2011-02-27 17:24 rand.2000db
-rw-r--r-- 1 batfai batfai  700 2011-02-27 20:57 szarvasm.700
batfai@kalapacs:~ $
S lássuk, mit mutat ezekre a mintákra a CompLearn normalizált tömörítési távolsága alapján készített gráfja:

ncd -b -d mintak/ mintak/
maketree distmatrix.clb
neato -Tpng treefile.dot > tcag.png


 

A poszt elején említett kódolást a lerántott genetikai kódrészletekre alkalmazva kapjuk a .hex állományokat, ezzel így módosul a gráf:

 

3/5 trófea üti a markát aki ez iménti CompLearn-ös játékot reprodukálja.

Bajnokság van, nevezel?

Íme néhány a genetikai kóddal kapcsolatos új trófea:

  • 2 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak. A kódot bináris állományként dolgozd fel (előtte persze azért tömörítsd ki :), jöhet kommentben is a megoldás. (A szórást a Jávácska ONE-beli Hetedik Szem (javacska-one-1.0.0-projects.zip / hetedik-szem-1.0.0 / src / main / java / TudatSzamitas.java) kódja alapján fejleszd bele a korábbi kódunkba.)
  • 3 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak. A kódot tedd át 2 betűnként hexába, aztán a hexa betűkből nyomj 4 bitet betűnként, az így kapott állományt vizsgáld, jöhet kommentben is a megoldás. (A szórást a Jávácska ONE-beli Hetedik Szem (javacska-one-1.0.0-projects.zip / hetedik-szem-1.0.0 / src / main / java / TudatSzamitas.java) kódja alapján fejleszd bele a korábbi kódunkba.)
  • 4 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak. A kódot karakteresen a szereplő 5 betű alapján vizsgáld, jöhet kommentben is a megoldás. (A szórást a Jávácska ONE-beli Hetedik Szem (javacska-one-1.0.0-projects.zip / hetedik-szem-1.0.0 / src / main / java / TudatSzamitas.java) kódja alapján fejleszd bele a korábbi kódunkba. A korábbi LZW-s kódunkba ne bináris fát építs, hanem olyat, aminek egy csomópontjából 5 mutató mutat a lehetséges 5 betűvel címkézett gyerek csomópontokra.)
  • (s egy kicsit más jellegű feladat) 1 trófea annak, aki a genetikai kódot a kódnak megfelelő fehérjék sorozatává kódolja, pl.: TGT=Cys, TGG=Trp, TGA=STOP, segít a DNA codon table, jöhet kommentben a kód és egy kis rövid demó minta, hogy lássam jó-e.

Binom trófeák

  • .5 pont a készítőnek, 0.5 pont a binomjának, aki ellenőrzi a megoldást. Maga a feladat pedig tetszőlegesen választott lehet a K&R könyvből.
  • 1 pont a készítőnek, 0.5 pont a binomjának, aki ellenőrzi a megoldást. Maga a feladat pedig tetszőlegesen választott lehet a C++ tankönyvből.

Figyeld a blogot, mert minden feladatból csakis egyet fogadok el ebben a kategóriában!

g.c:

  • Beszéljük meg és teszteljük a g.c-t, itt azt kell kiemelni, hogy hármasával olvassuk a betűket a fájlból, de nagyon rossz gyakorlat, ha a ciklusban ciklusolgatni kezdünk... e helyett egyetlen ciklust használunk:
    // a betűket 3-asával "olvasom": nem kell cifrázni! egy ciklus
    // elvégzi, amiben megjegyzem, hogy melyik hányadik betű volt
    // aki ciklusban ciklusolgat, az már bénázik :)
    int
    main (void)
    {
      // hányadik betűn állok?
      int hanyadik_betu = -1;
      // azon a helyen mit olvastam?
      int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = 0;
    
      while ((i = getchar ()) != EOF)
        {
    
          switch (i)
    	{
    
    	case 'T':
    	  jegy = 0;
    	  break;
    	case 'C':
    	  jegy = 1;
    	  break;
    	case 'A':
    	  jegy = 2;
    	  break;
    	case 'G':
    	  jegy = 3;
    	  break;
    	}
    
          hanyadik_betu = (hanyadik_betu + 1) % 3;
    
          if (!hanyadik_betu)
    	elso = jegy;
          else if (!(hanyadik_betu - 1))
    	masodik = jegy;
          else
    	{
    	  harmadik = jegy;
    	  printf ("%s", genetikai_kod (elso * 16 + masodik * 4 + harmadik));
    	}
        }
    }
    
    vedd észre, hogy a kód pici továbbfejlesztése a jelen poszt bevezető progijának, csak ott kettesével olvasunk és két betűből készítettünk egy hexadecimális jegyet.
  • Feladat (kisebb sebességű): készíts "aminosav-hisztogramot", azaz a progi továbbfejlesztésével mond meg, melyik aminosav hányszor szerepel? (egy trófea, jöhet kommentben előre is)
  • Hogy változik ez a szám, ha az első kódoló betűt törlöd a bemenő fájlból (azaz a 2. betűtől méred fel a 3 betűket) (egy trófea, jöhet kommentben előre is)
  • Hogy változik ez a szám, ha az első két kódoló betűt törlöd a bemenő fájlból (azaz a 3. betűtől méred fel a 3 betűket) (egy trófea, jöhet kommentben előre is)
  • Feladat (nagyobb sebességű): módosítsd a z.c-t, hogy ne 0, 1 betűkre menjen, hanem a 4 T, C, A, G betűre és így építs fát (ez már nem bináris fa lesz persze), mennyi a 2. kromóra az LZW fa ághosszainak átlaga és sztenderd hibája? (ez 5 trófeát ér, jöhet kommentben is)
  • További két kisbajnokság, aki gyorsabbat ír:
    [norbi@sgu tcag]$ time ./g <hs_alt_Hs_Celera_chr2.fa >aminosavak

    real    0m17.428s
    user    0m16.593s
    sys     0m0.714

g.c

 

// g.c
//
// genetikai kód nyomtató
// Programozó Páternoszter
//
// Copyright (C) 2011, Bátfai Norbert, nbatfai@inf.unideb.hu, nbatfai@gmail.com
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// Ez a program szabad szoftver; terjeszthetõ illetve módosítható a
// Free Software Foundation által kiadott GNU General Public License
// dokumentumában leírtak; akár a licenc 3-as, akár (tetszõleges) késõbbi
// változata szerint.
//
// Ez a program abban a reményben kerül közreadásra, hogy hasznos lesz,
// de minden egyéb GARANCIA NÉLKÜL, az ELADHATÓSÁGRA vagy VALAMELY CÉLRA
// VALÓ ALKALMAZHATÓSÁGRA való származtatott garanciát is beleértve.
// További részleteket a GNU General Public License tartalmaz.
//
// A felhasználónak a programmal együtt meg kell kapnia a GNU General
// Public License egy példányát; ha mégsem kapta meg, akkor
// tekintse meg a <http://www.gnu.org/licenses/> oldalon.
//
// Version history: szösszenet
//
// A http://progpater.blog.hu/2011/02/27/a_human_genom_projekt poszt
// bevezető kódjának alapötletét használjuk fel, de nem kettesével,
// hanem most hármasával dolgozzuk fel az inputot
//
// Ennek a kódnak a részleteit az itteni kisbajnokikon is
// kamatoztathatod: http://progpater.blog.hu/2011/03/05/szonyegen_a_human_genom

#include <stdio.h>
#include <unistd.h>

// Egyszerűen felsorolom, pl. az alábbi alapján:
// http://en.wikipedia.org/wiki/DNA_codon_table
char *amino_sav[] = {
  "Stop",
  "Phe",
  "Leu",
  "Ile",
  "Met",
  "Val",
  "Ser",			// 6.
  "Pro",
  "Thr",
  "Ala",
  "Tyr",			// 10.
  "His",
  "Gln",
  "Asn",
  "Lys",
  "Asp",
  "Glu",
  "Cys",
  "Trp",			// 18.
  "Arg",			// 19.
  "Gly"				// 20.
};

// a 3 betű melyik aminosavat kódolja?
char *
genetikai_kod (int triplet)
{
  int index = 0;

  switch (triplet)
    {
    case 0:			// Phe
    case 1:
      index = 1;
      break;
    case 2:			// Leu
    case 3:
    case 16:			
    case 17:
    case 18:
    case 19:
      index = 2;
      break;
    case 32:			// Ile
    case 33:
    case 34:
      index = 3;
      break;
    case 35:			// Met
      index = 4;
      break;
// hogy jön ez? az 5 indexű a "Val"
// GTT-től GTG-ig van ez, jegyekben:
// 300-tól 303-ig 4-es számrendszerben
// ez van átváltva, pl.:
//      303(4) -> 3*16+0*4+3*1 = 51(10)      
    case 48:
    case 49:
    case 50:
    case 51:
      index = 5;
      break;
    case 4:
    case 5:
    case 6:
    case 7:
      index = 6;
      break;
    case 20:
    case 21:
    case 22:
    case 23:
      index = 7;
      break;
    case 36:
    case 37:
    case 38:
    case 39:
      index = 8;
      break;
    case 52:
    case 53:
    case 54:
    case 55:
      index = 9;
      break;
    case 8:
    case 9:
      index = 10;
      break;
    case 10:			// Stop
    case 11:
      index = 0;
      break;
    case 24:
    case 25:
      index = 11;
      break;
    case 26:
    case 27:
      index = 12;
      break;
    case 40:
    case 41:
      index = 13;
      break;
    case 42:
    case 43:
      index = 14;
      break;
    case 56:
    case 57:
      index = 15;
      break;
    case 58:
    case 59:
      index = 16;
      break;
    case 12:			// Cys
    case 13:
      index = 17;
      break;
    case 14:			// Stop
      index = 0;
      break;
    case 15:			// Trp
      index = 18;
      break;
    case 28:			// Arg
    case 29:
    case 30:
    case 31:
      index = 19;
      break;
    case 44:			// Ser
    case 45:
      index = 6;
      break;
    case 46:			// Arg
    case 47:
      index = 19;
      break;
    case 60:			// Gly
    case 61:
    case 62:
    case 63:
      index = 20;
      break;

    default:
      // csak tesztelesre a printf
      printf ("Zavar az eroben %d-nel", triplet);
      index = 0;
      break;
    }

  return amino_sav[index];
}

// a betűket 3-asával "olvasom": nem kell cifrázni! egy ciklus
// elvégzi, amiben megjegyzem, hogy melyik hányadik betű volt
// aki ciklusban ciklusolgat, az már bénázik :)
int
main (void)
{
  // hányadik betűn állok?
  int hanyadik_betu = -1;
  // azon a helyen mit olvastam?
  int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = 0;

  while ((i = getchar ()) != EOF)
    {

      switch (i)
	{

	case 'T':
	  jegy = 0;
	  break;
	case 'C':
	  jegy = 1;
	  break;
	case 'A':
	  jegy = 2;
	  break;
	case 'G':
	  jegy = 3;
	  break;
	}

      hanyadik_betu = (hanyadik_betu + 1) % 3;

      if (!hanyadik_betu)
	elso = jegy;
      else if (!(hanyadik_betu - 1))
	masodik = jegy;
      else
	{
	  harmadik = jegy;
	  printf ("%s", genetikai_kod (elso * 16 + masodik * 4 + harmadik));
	}
    }
}

C elegans fonalféreg

 Az iménti g.c számos hiba forrása is, hiszen a maradékos osztásos "fűrészfog" akkor is dolgozik, amikor nem kéne... addig javítsuk, amíg ez nem jön ki a C elegans fonalféreg II. kromoszómájára, természetesen paramcssorból ránsd le:

wget ftp://ftp.ncbi.nlm.nih.gov/genomes/Caenorhabditis_elegans/CHR_II/NC_003280.fnanbatfai@hallg:~/bevezetes$ ./g </home/nbatfai/NC_003280.fna |tail -n 21
Stop 267497
Phe 445827
Leu 489714
Ile 364670
Met 79613
Val 243280
Ser 450361
Pro 179453
Thr 243056
Ala 175140
Tyr 153251
His 133711
Gln 181261
Asn 275429
Lys 398344
Asp 125314
Glu 199000
Cys 142503
Trp 65033
Arg 303128
Gly 17752

Magam így módosítottam a kódot: g.c

Az aktuális immár ennek kapcsán, hogy egy ugyanazon a gépen gyorsítsd fel ezt a g.c-t további 3/2 pontért, a sebességnövekedést ezzel a paranccsal vizsgáld:

$ time ./g </home/nbatfai/NC_003280.fna |tail -n

GNU/Linux kernel hacking

Azok számára, akik a félévben önálló érdeklődésből a Linux rendszerrel kívánnak közelebbi kapcsolatba kerülni, készítettem egy VirtualBox-OSE-s képet (BatfaiProg1.ova), ahol a PP kernelmodulos példáit aktualizáltam. Az első három 6 évvel a PP születése után (persze a PCB-ből pár tagot gyomlálni kell, a printk pár formátumparaméterét hangolni stb.) is simán megy, a negyedikkel van több hiba, például a "[PATCH -mm 7/3] proc: remove proc_root from drivers" stb. miatt. Nyilván a szóban forgó virtualizált rendszeren már minden javítva van (ez azért sokat segít az előző poszt kiírt Linuxos trófeáihoz). A negyedik modult, már a hardcore programozóknak javaslom, az első három kell mindenkinek persze :) Itt a negyedikről a bizonyítékom, hogy műxik:

s itt egy kis további help ehhez.

Hallgatói laborkártyák

Természetesen a korábbiak mellett (l. a korábbi posztot)

 

85 komment

Címkék: kutya pi kakas dns fehérjék homo sapiens szarvasmarha hexa c elegans humán genom canis familiaris tcag equus caballus gallus gallus bos taurus genetikai kód prog1

A bejegyzés trackback címe:

https://progpater.blog.hu/api/trackback/id/tr444311868

Kommentek:

A hozzászólások a vonatkozó jogszabályok  értelmében felhasználói tartalomnak minősülnek, értük a szolgáltatás technikai  üzemeltetője semmilyen felelősséget nem vállal, azokat nem ellenőrzi. Kifogás esetén forduljon a blog szerkesztőjéhez. Részletek a  Felhasználási feltételekben és az adatvédelmi tájékoztatóban.

2012.03.12. 18:42:09

2 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak.

Nem tudom pontosan hogy s mint, de az elso 10 000-re ilyesmik jottek ki:

szorasosszeg = 10679.220588
szorasn = 8.731987
szoras = 2.954994

jakaba 2012.03.12. 18:55:47

2 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak.
szoras=9.495396

2012.03.12. 19:02:36

Az egesz hs_alt_HuRef_chr2.fa-nek ez jott ki:
szorasosszeg = 1098145231.280844
szorasn = 148.647149
szoras = 12.192094

KDániel 2012.03.12. 19:11:51

"Binom trófeák

5 pont a készítőnek, 0.5 pont a binomjának, aki ellenőrzi a megoldást. Maga a feladat pedig tetszőlegesen választott lehet a K&R könyvből."

Meg csináltam (tetszőleges feladat volt írva :P ):
kepfeltoltes.hu/120312/10895549521_www.kepfeltoltes.hu_.png

Na jó, csak vicceltem :D
2-őt csináltam meg:
kepfeltoltes.hu/120312/3153001803_www.kepfeltoltes.hu_.png

kepfeltoltes.hu/120312/9952627982_www.kepfeltoltes.hu_.png

KDániel 2012.03.12. 19:24:20

Hoppsz, az utolsó előtti link nem a jó megoldást tartalmazza, ez itt a jó: kepfeltoltes.hu/120312/8762765594_www.kepfeltoltes.hu_.png

2012.03.12. 19:24:38

3 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak. A kódot tedd át 2 betűnként hexába, aztán a hexa betűkből nyomj 4 bitet betűnként, az így kapott állományt vizsgáld, jöhet kommentben is a megoldás.

szorasosszeg = 329012918.366311
szoras = 4.783640

nb · http://fersml.blog.hu 2012.03.12. 20:27:24

@mamenyaka: csak pár képre kattintottam egyelőre, impozánsak egyértelműen, de a binomod rövid reakciói is kellenének, jöhetne a kommentjeidre válasznak Tőle.

Más: a képeken root-ként dolgozok, ezt a gyakorlatot kerülni kellene, általában az az ökölszabály, hogy rootként csak azt, ami másként nem megy. (De természetesen indokolt legyen a máskép nem megy :) A jelenlegi progik közül szerintem a kernel programozás példáinál lehetnek olyan részek, amihez root-kell, illetve a network programozás részben majd a nyers socketes példák lesznek ilyenek, de a mostani példákban szerintem nem indokolható.

nb · http://fersml.blog.hu 2012.03.12. 20:31:11

@mamenyaka: kicsit szofisztikáltabb válasz kellene, legalábbis a feladatot jelöljök meg pontosan, hogy melyikre küldtük, mert most több LZW fa szórásos is van. (Persze vannak egyezések, mert a bináris feldolgozás alapján épített, meg a karakteres adhat ugyanannyit, csak az utóbbit nem lehet kivárni :)

A Jávácska ONE-beli Hetedik Szemet pedig érdekességként érdemes esetleg megnézni, egyébként inkább az SVN-beli kód tanulmányozása és használata ajánlott.

2012.03.12. 20:42:27

@nb: Az, amelyiknél hiányzik a pontos leírás, az az előző hozzászólásomzoh kapcsolódik.
Tehát:
2 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak.

szorasosszeg = 1098145231.280844
szoras = 12.192094

2012.03.12. 20:52:05

@nb: A root-os dologgal teljesen tisztában vagyok. Eddig vagy 10 linux disztribuciót biztos kiprobáltam, de csak ez az egy, ami nem csináltat velem felhasználót, és alapértelmezetten csak root létezik.
Tehát nem másért, de nehezen tudnék nem root-ként tevékenykedni.

Kassen 2012.03.12. 21:04:41

Fapados verzió a +1 pontos átalakításhoz (itt a 4. feladat)

#include <stdio.h>
#include <unistd.h>

int
main (void)
{
int szamlalo=0;
unsigned char b1, b2, b3;

while (read (0, (void *) &b1, sizeof (unsigned char)))
if (b1 == '\n')
{
break;
}

while (read (0, (void *) &b1, sizeof (unsigned char)) &&
read (0, (void *) &b2, sizeof (unsigned char)) &&
read (0, (void *) &b3, sizeof (unsigned char)))
{
if (b1 == 'T' && b2 == 'T' && (b3 == 'T' || b3 == 'C'))
{
printf ("Phe ");
}
else if (b1 == 'T' && b2 == 'T' && (b3 == 'A' || b3 == 'G'))
{
printf ("Leu ");
}
else if (b1 == 'C' && b2 == 'T')
{
printf ("Leu ");
}
else if (b1 == 'A' && b2 == 'T'
&& (b3 == 'T' || b3 == 'C' || b3 == 'A'))
{
printf ("Ile ");
}
else if (b1 == 'A' && b2 == 'T' && b3 == 'G')
{
printf ("Met ");
}
else if (b1 == 'G' && b2 == 'T')
{
printf ("Val ");
}
else if (b1 == 'T' && b2 == 'C')
{
printf ("Ser ");
}
else if (b1 == 'C' && b2 == 'C')
{
printf ("Pro ");
}
else if (b1 == 'A' && b2 == 'C')
{
printf ("Thr ");
}
else if (b1 == 'G' && b2 == 'C')
{
printf ("Ala ");
}
else if (b1 == 'T' && b2 == 'A' && (b3 == 'T' || b3 == 'C'))
{
printf ("Tyr ");
}
else if (b1 == 'T' && b2 == 'A' && (b3 == 'A' || b3 == 'G'))
{
printf ("Stop");
}
else if (b1 == 'C' && b2 == 'A' && (b3 == 'T' || b3 == 'C'))
{
printf ("His ");
}
else if (b1 == 'C' && b2 == 'A' && (b3 == 'A' || b3 == 'G'))
{
printf ("Gln ");
}
else if (b1 == 'A' && b2 == 'A' && (b3 == 'T' || b3 == 'C'))
{
printf ("Asn ");
}
else if (b1 == 'A' && b2 == 'A' && (b3 == 'A' || b3 == 'G'))
{
printf ("Lys ");
}
else if (b1 == 'G' && b2 == 'A' && (b3 == 'T' || b3 == 'C'))
{
printf ("Asp ");
}
else if (b1 == 'G' && b2 == 'A' && (b3 == 'A' || b3 == 'G'))
{
printf ("Glu ");
}
else if (b1 == 'T' && b2 == 'G' && (b3 == 'T' || b3 == 'C'))
{
printf ("Cys ");
}
else if (b1 == 'T' && b2 == 'G' && b3 == 'A')
{
printf ("Stop");
}
else if (b1 == 'T' && b2 == 'G' && b3 == 'G')
{
printf ("Trp ");
}
else if (b1 == 'C' && b2 == 'G')
{
printf ("Arg ");
}
else if (b1 == 'A' && b2 == 'G' && (b3 == 'T' || b3 == 'C'))
{
printf ("Ser ");
}
else if (b1 == 'A' && b2 == 'G' && (b3 == 'A' || b3 == 'G'))
{
printf ("Arg ");
}
else if (b1 == 'G' && b2 == 'G')
{
printf ("Gly ");
}

szamlalo = szamlalo + 3;
if (szamlalo >= 10000)
break;
}

}

Pro Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu
Thr Leu Thr Leu Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro
Asn Pro Asn Pro Asn Pro Asn Pro Pro StopPro StopPro StopPro StopPro StopPro
StopPro StopPro StopPro StopPro StopPro StopPro Leu Thr Leu Thr Leu Thr Leu
Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Pro Asn Pro
Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn
Pro Pro StopPro StopPro StopPro StopPro StopPro StopPro StopPro StopPro Stop
Pro StopPro StopPro Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr
Leu Thr Leu Thr Leu Thr Leu Thr Leu Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn
Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Asn Pro Pro StopPro StopPro Stop
Pro StopPro StopPro StopPro StopPro StopPro StopPro StopPro StopPro Leu Thr
Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu Thr Leu
Thr

Kassen 2012.03.12. 21:12:16

Azért az előzőhöz pontosítok:
"1 trófea annak, aki a genetikai kódot a kódnak megfelelő fehérjék sorozatává kódolja, pl.: TGT=Cys, TGG=Trp, TGA=STOP, segít a DNA codon table, jöhet kommentben a kód és egy kis rövid demó minta, hogy lássam jó-e."

2012.03.12. 21:44:41

@nb: Egy kérdés:
Meg lesz-e tartva a szerdai labor, tekintettel arra, hogy csütörtök szabadnap?

KDániel 2012.03.12. 21:55:11

Egyébként a binomos feladatokból hányat lehet max. beküldeni?

Owert 2012.03.13. 13:03:35

A binomos feladatnál hogy, s mint kell csinálni a dolgokat? Le kell tesztelni a megírtakat?
Idézek:

"Binom trófeák

5 pont a készítőnek, 0.5 pont a binomjának, aki ellenőrzi a megoldást. Maga a feladat pedig tetszőlegesen választott lehet a K&R könyvből."

nb · http://fersml.blog.hu 2012.03.13. 13:16:11

@Owert: az például tökéletes lenne.

(de .5 pont, illetve 1, azaz a K&R-esek egy fél pont, ott van előtte a tizedespont)

2012.03.13. 18:14:01

4 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak. A kódot karakteresen a szereplő 5 betű alapján vizsgáld, jöhet kommentben is a megoldás.

Ha minden igaz, akkor az 5 betű a T C A G N, es a hs_alt_HuRef_chr2.fa tele van folos szovegekkel, melyeknek a vege "...shotgun sequence"
Ezeket kihagyva kaptam:

szorasosszeg = 262246477.876493
szoras = 3.783302

Owert 2012.03.13. 18:28:20

mamenyaka (binom) feladatainak ellenőrzése megtörtént 1-4-ig, hamarosan a többi is felkerül!

nb · http://fersml.blog.hu 2012.03.13. 18:28:42

@jakaba: minden K&R és a C++-os tankönyves feladathoz kérem a binom tesztelését, véleményét is!

Ettől föggetlenül adok +1 pontos, ha készítesz egy ugyanilyen működésű progit, de egy lexerrel (l. 1. ea.).

2012.03.13. 18:46:05

Ujraszamolva:
2 trófea annak, aki először megmondja, hogy mennyi az LZW fa ághosszainak szórása a humán 2 kromóban lévő genetikai kódnak.

szorasosszeg = 1125200138.962853
szoras = 12.344454

jakaba 2012.03.13. 19:07:24

lexes számszámláló, illetve egyéb dolgokat is számol mellékesen, tehát egy előző feladat továbbfejlesztett változata. Binomra még váratik.
kepfeltoltes.hu/view/120313/lexes_www.kepfeltoltes.hu_.png

Toma89 2012.03.13. 22:05:33

ftp://ftp.ncbi.nlm.nih.gov/genomes/H_sapiens/CHR_02/hs_alt_Hs_Celera_chr2.fa.gz

Nem tudom letölteni a linken megadott fájlt, mert a bőngésző is, meg a wget parancs is azt írja ki, hogy Nincs ilyen fájl. Nálam van a gond, vagy félre értelmeztem és másik fájlt kell letöltenem? Köszönöm a segítséget!

zacsesz 2012.03.14. 08:37:14

Volatile C-ben:

Létrehozhatunk konstansokat is szintén a prg legelején, lényegűk az állandó jelenlét memóriafoglalás, nem lassítja a programot a futásidejű deklaráció. (volatile állandóan változó). Az alaptípusok egymás között konvertálhatóak.

zacsesz 2012.03.14. 08:37:59

Egyébként van saját DNS elemző alkalmazásom anno biológia órára írtam C#-ban... Ha érdekel valakit akkor forráskóddal együtt felrakom! (lehet vannak benne hibák ezt ma már nem tudom)

zacsesz 2012.03.14. 08:48:05

C-ben inline:

A #define-nal történõ makródefiníciókkal szemben hatékony alternatívát jelentenek az ún. inline (sorok közötti) függvények. Röviden: egy inline függvény elég kis terjedelmû ahhoz, hogy helyben (in situ), a függvényhívás helyére behelyettesítve le lehessen fordítani. Ebben a tekintetben egy inline függvény olyan, mintha makró lenne, azaz a függvényhívásokkal járó adminisztrációra nincs szükség. Rövid, egy-két soros függvények esetében ez sokkal hatékonyabb, sokkal olvashatóbb megoldást jelent, mint a makró-definíció. Az ún. explicit inline függvények deklarálására szolgál a C++ inline kulcsszava. (Az implicit inline deklarációról az ún. függvénymezõk kapcsán egy késõbbi fejezetben lesz szó.)

Tehát az inline függvények a hagyományos C elõfeldolgozó #define direktívájával definiálható makrókhoz hasonlítanak. Annyival fejlettebbek a makróknál, hogy egy ilyen függvény meghívása nem pusztán szöveghelyettesítés, hanem a definíció szerint generált kód másolódik be a hívások helyére, így a makrókkal kapcsolatban említett mellékhatások jelentkezésének is kisebb a veszélye

2012.03.14. 08:51:21

Volatile:
Megakadályozza a compilert, hogy optimizálja a változóban levő kódot.
"the volatile keyword is intended to prevent the compiler from applying any optimizations on the code, that assume values of variables cannot change "on their own." "

nb · http://fersml.blog.hu 2012.03.14. 09:46:09

@zacsesz: ez nagyon "plagizálás jellegű" komment, hiszen nagy valséggel simán bemásoltad idézés vagy erre utaló forrás nélkül, pl. innen:

www.eet.bme.hu/publications/e_books/progr/cpp/node76.html

vagy innen:

codesnippet.atw.hu/?p=25

és még olvastam vagy pár helyen :)

ettől tartózkodjunk, olvassunk, értsük meg és a saját gondolatainkat írjuk, s persze egy hivatkozzuk is a forrásokat!

jakaba 2012.03.14. 10:03:56

Inline függvény esetén a híváskor fordítás közben a függvény kódja helyettesítődik be, ami hasznos lehet kis méretű függvények esetén. A függvényhívás kiesik ezesetben, míg a kód picit nagyobb lesz ténylegesen.

zacsesz 2012.03.14. 10:54:45

@nb: Rendben van, majd megfogalmazom személyesen! :)

jakaba 2012.03.14. 11:08:50

static inline const char *get_task_state(struct task_struct *tsk) magyarázat.
A függvény statikus, tehát a static deklarációval azt mondtuk, hogy az objektum érvényességi tartománya csak az éppen fordított forrásállomány fennmaradó részére legyen elérhető. Az inline jelentését fentebb kifejtettem. A const arra szolgál, hogy definiáljuk azt, hogy az utána következő változó tartalmát nem bántjuk a függvényben. A függvény visszatérési értéke karaktertömb (char *), neve get_task_state. Bemeneti paraméternek kap egy task_struct névvel definiált struct típusú pointert (*tsk), ami nagy valószínűséggel egy folyamatstruktúrára mutat.

2012.03.14. 13:41:46

+0.5: TTGGTT... -> F0F0F0

./gh <hs_alt_Hs_Celera_chr2.fa
Stop 4207582
Phe 4612957
Leu 8542876
Ile 4687211
Met 1441407
Val 3905544
Ser 6900686
Pro 3878421
Thr 3891523
Ala 3197284
Tyr 2547675
His 2580585
Gln 3009185
Asn 3132596
Lys 4611921
Asp 1757921
Glu 2819501
Cys 2685071
Trp 1392459
Arg 3761920
Gly 3883057

./gh <NC_003280.fna
Stop 267497
Phe 445827
Leu 489714
Ile 364670
Met 79613
Val 243280
Ser 450361
Pro 179453
Thr 243056
Ala 175140
Tyr 153251
His 133711
Gln 181261
Asn 275429
Lys 398344
Asp 125314
Glu 199000
Cys 142503
Trp 65033
Arg 303128
Gly 177523

www43.zippyshare.com/v/60663877/file.html

jakaba 2012.03.14. 13:43:22

KÓD (g.c)
// g.c
//
// genetikai kód nyomtató
// Programozó Páternoszter
//
// Copyright (C) 2011, Bátfai Norbert, nbatfai@inf.unideb.hu, nbatfai@gmail.com
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <www.gnu.org/licenses/&gt;.
//
// Ez a program szabad szoftver; terjeszthetõ illetve módosítható a
// Free Software Foundation által kiadott GNU General Public License
// dokumentumában leírtak; akár a licenc 3-as, akár (tetszõleges) késõbbi
// változata szerint.
//
// Ez a program abban a reményben kerül közreadásra, hogy hasznos lesz,
// de minden egyéb GARANCIA NÉLKÜL, az ELADHATÓSÁGRA vagy VALAMELY CÉLRA
// VALÓ ALKALMAZHATÓSÁGRA való származtatott garanciát is beleértve.
// További részleteket a GNU General Public License tartalmaz.
//
// A felhasználónak a programmal együtt meg kell kapnia a GNU General
// Public License egy példányát; ha mégsem kapta meg, akkor
// tekintse meg a <www.gnu.org/licenses/&gt; oldalon.
//
// Version history: szösszenet
//
// A progpater.blog.hu/2011/02/27/a_human_genom_projekt poszt
// bevezető kódjának alapötletét használjuk fel, de nem kettesével,
// hanem most hármasával dolgozzuk fel az inputot
//
// Ennek a kódnak a részleteit az itteni kisbajnokikon is
// kamatoztathatod: progpater.blog.hu/2011/03/05/szonyegen_a_human_genom

#include <stdio.h>
#include <unistd.h>

// Egyszerűen felsorolom, pl. az alábbi alapján:
// en.wikipedia.org/wiki/DNA_codon_table

int t[20];
char *amino_sav[] = {
"Stop",
"Phe",
"Leu",
"Ile",
"Met",
"Val",
"Ser", // 6.
"Pro",
"Thr",
"Ala",
"Tyr", // 10.
"His",
"Gln",
"Asn",
"Lys",
"Asp",
"Glu",
"Cys",
"Trp", // 18.
"Arg", // 19.
"Gly" // 20.
};

// a 3 betű melyik aminosavat kódolja?
int
genetikai_kod (int triplet)
{
int index = 0;

switch (triplet)
{
case 0: // Phe
case 1:
index = 1;
break;
case 2: // Leu
case 3:
case 16:
case 17:
case 18:
case 19:
index = 2;
break;
case 32: // Ile
case 33:
case 34:
index = 3;
break;
case 35: // Met
index = 4;
break;
// hogy jön ez? az 5 indexű a "Val"
// GTT-től GTG-ig van ez, jegyekben:
// 300-tól 303-ig 4-es számrendszerben
// ez van átváltva, pl.:
// 303(4) -> 3*16+0*4+3*1 = 51(10)
case 48:
case 49:
case 50:
case 51:
index = 5;
break;
case 4:
case 5:
case 6:
case 7:
index = 6;
break;
case 20:
case 21:
case 22:
case 23:
index = 7;
break;
case 36:
case 37:
case 38:
case 39:
index = 8;
break;
case 52:
case 53:
case 54:
case 55:
index = 9;
break;
case 8:
case 9:
index = 10;
break;
case 10: // Stop
case 11:
index = 0;
break;
case 24:
case 25:
index = 11;
break;
case 26:
case 27:
index = 12;
break;
case 40:
case 41:
index = 13;
break;
case 42:
case 43:
index = 14;

break;
case 56:
case 57:
index = 15;
break;
case 58:
case 59:
index = 16;
break;
case 12: // Cys
case 13:
index = 17;

break;
case 14: // Stop
index = 0;

break;
case 15: // Trp
index = 18;

break;
case 28: // Arg
case 29:
case 30:
case 31:
index = 19;

break;
case 44: // Ser
case 45:
index = 6;

break;
case 46: // Arg
case 47:
index = 19;

break;
case 60: // Gly
case 61:
case 62:
case 63:
index = 20;
break;

default:
// csak tesztelesre a printf
printf ("Zavar az eroben %d-nel", triplet);
index = 0;
break;
}
++t[triplet];
return index;
}

// a betűket 3-asával "olvasom": nem kell cifrázni! egy ciklus
// elvégzi, amiben megjegyzem, hogy melyik hányadik betű volt
// aki ciklusban ciklusolgat, az már bénázik :)
int
main (void)
{
// hányadik betűn állok?
int hanyadik_betu = -1;
// azon a helyen mit olvastam?
int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = 0;
int szamol = 0;
while ((i = getchar ()) != EOF)
{

++szamol;
if (i != '\n' && szamol>85)
{

switch (i)
{

case 'T':
jegy = 0;
break;
case 'C':
jegy = 1;
break;
case 'A':
jegy = 2;
break;
case 'G':
jegy = 3;
break;
}

hanyadik_betu = (hanyadik_betu + 1) % 3;

if (!hanyadik_betu)
elso = jegy;
else if (!(hanyadik_betu - 1))
masodik = jegy;
else
{
harmadik = jegy;
int index;
genetikai_kod (elso * 16 + masodik * 4 + harmadik);
}
}
else
++szamol;
}
for (i = 0; i < 21; ++i)
{
printf ("%s %d\n", amino_sav[i], t[i]);
}
}

FORRÁS:
ftp://ftp.ncbi.nlm.nih.gov/genomes/Caenorhabditis_elegans/CHR_II/NC_003280.fna
EREDMÉNY:
Stop 308093
Phe 137189
Leu 105797
Ile 121132
Met 92980
Val 65167
Ser 106847
Pro 57839
Thr 98491
Ala 55005
Tyr 105496
His 54347
Gln 84094
Asn 57648
Lys 107271
Asp 64420
Glu 88409
Cys 62252
Trp 54287
Arg 60113
Gly 45529

nimuss 2012.03.14. 13:45:57

hallgato@deik-admin-desktop:~/hg_prog$ ./genom <NC_003280.fna
Stop: 267838
Phe: 463183
Leu: 494987
Ile: 365167
Met: 78173
Val: 243485
Ser: 447363
Pro: 194184
Thr: 243451
Ala: 175955
Tyr: 151660
His: 131102
Gln: 183783
Asn: 281030
Lys: 415900
Asp: 123341
Glu: 201059
Cys: 140234
Trp: 68346
Arg: 304556
Gly: 191070

#include <stdio.h>
#include <unistd.h>

// Egyszerűen felsorolom, pl. az alábbi alapján:
// en.wikipedia.org/wiki/DNA_codon_table
char *amino_sav[] = {
"Stop",
"Phe",
"Leu",
"Ile",
"Met",
"Val",
"Ser", // 6.
"Pro",
"Thr",
"Ala",
"Tyr", // 10.
"His",
"Gln",
"Asn",
"Lys",
"Asp",
"Glu",
"Cys",
"Trp", // 18.
"Arg", // 19.
"Gly" // 20.
};

// a 3 betű melyik aminosavat kódolja?
char *
genetikai_kod (int triplet)
{
int index = 0;

switch (triplet)
{
case 0: // Phe
case 1:
index = 1;
break;
case 2: // Leu
case 3:
case 16:
case 17:
case 18:
case 19:
index = 2;
break;
case 32: // Ile
case 33:
case 34:
index = 3;
break;
case 35: // Met
index = 4;
break;
// hogy jön ez? az 5 indexű a "Val"
// GTT-től GTG-ig van ez, jegyekben:
// 300-tól 303-ig 4-es számrendszerben
// ez van átváltva, pl.:
// 303(4) -> 3*16+0*4+3*1 = 51(10)
case 48:
case 49:
case 50:
case 51:
index = 5;
break;
case 4:
case 5:
case 6:
case 7:
index = 6;
break;
case 20:
case 21:
case 22:
case 23:
index = 7;
break;
case 36:
case 37:
case 38:
case 39:
index = 8;
break;
case 52:
case 53:
case 54:
case 55:
index = 9;
break;
case 8:
case 9:
index = 10;
break;
case 10: // Stop
case 11:
index = 0;
break;
case 24:
case 25:
index = 11;
break;
case 26:
case 27:
index = 12;
break;
case 40:
case 41:
index = 13;
break;
case 42:
case 43:
index = 14;
break;
case 56:
case 57:
index = 15;
break;
case 58:
case 59:
index = 16;
break;
case 12: // Cys
case 13:
index = 17;
break;
case 14: // Stop
index = 0;
break;
case 15: // Trp
index = 18;
break;
case 28: // Arg
case 29:
case 30:
case 31:
index = 19;
break;
case 44: // Ser
case 45:
index = 6;
break;
case 46: // Arg
case 47:
index = 19;
break;
case 60: // Gly
case 61:
case 62:
case 63:
index = 20;
break;

default:
// csak tesztelesre a printf
printf ("Zavar az eroben %d-nel", triplet);
index = 0;
break;
}

return amino_sav[index];
}

// a betűket 3-asával "olvasom": nem kell cifrázni! egy ciklus
// elvégzi, amiben megjegyzem, hogy melyik hányadik betű volt
// aki ciklusban ciklusolgat, az már bénázik :)
int
main (void)
{
int x, mennyi[21], y = 0;

for (x = 0; x < 21; x++)
{
mennyi[x] = 0;
}

// hányadik betűn állok?
int hanyadik_betu = -1;
// azon a helyen mit olvastam?
int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = 0;

while ((i = getchar ()) != EOF)
{
if (y == 0)
{
if (i == '\n')
{
y = 1;
}
}
else
{

switch (i)
{

case 'T':
jegy = 0;
break;
case 'C':
jegy = 1;
break;
case 'A':
jegy = 2;
break;
case 'G':
jegy = 3;
break;
}

hanyadik_betu = (hanyadik_betu + 1) % 3;

if (!hanyadik_betu)
elso = jegy;
else if (!(hanyadik_betu - 1))
masodik = jegy;
else
{
harmadik = jegy;
//printf ("%s\n", genetikai_kod (elso * 16 + masodik * 4 + harmadik));
for (x = 0; x < 21; x++)
{
if (genetikai_kod (elso * 16 + masodik * 4 + harmadik) ==
amino_sav[x])
mennyi[x]++;
}
}
}
}
for (x = 0; x < 21; x++)
{
printf ("%s: %d\n", amino_sav[x], mennyi[x]);
}
}

Hypno (törölt) 2012.03.14. 13:54:25

#include <stdio.h>
#include <unistd.h>

char *amino_sav[] = {
"Stop",
"Phe",
"Leu",
"Ile",
"Met",
"Val",
"Ser",
"Pro",
"Thr",
"Ala",
"Tyr",
"His",
"Gln",
"Asn",
"Lys",
"Asp",
"Glu",
"Cys",
"Trp",
"Arg",
"Gly"
};

int genetikai_kod (int triplet)
{
int index = 0;

switch (triplet)
{
case 0:
case 1:
index = 1;
break;
case 2:
case 3:
case 16:
case 17:
case 18:
case 19:
index = 2;
break;
case 32:
case 33:
case 34:
index = 3;
break;
case 35:
index = 4;
break;
case 48:
case 49:
case 50:
case 51:
index = 5;
break;
case 4:
case 5:
case 6:
case 7:
index = 6;
break;
case 20:
case 21:
case 22:
case 23:
index = 7;
break;
case 36:
case 37:
case 38:
case 39:
index = 8;
break;
case 52:
case 53:
case 54:
case 55:
index = 9;
break;
case 8:
case 9:
index = 10;
break;
case 10:
case 11:
index = 0;
break;
case 24:
case 25:
index = 11;
break;
case 26:
case 27:
index = 12;
break;
case 40:
case 41:
index = 13;
break;
case 42:
case 43:
index = 14;
break;
case 56:
case 57:
index = 15;
break;
case 58:
case 59:
index = 16;
break;
case 12:
case 13:
index = 17;
break;
case 14:
index = 0;
break;
case 15:
index = 18;
break;
case 28:
case 29:
case 30:
case 31:
index = 19;
break;
case 44:
case 45:
index = 6;
break;
case 46:
case 47:
index = 19;
break;
case 60:
case 61:
case 62:
case 63:
index = 20;
break;

default:

printf ("Zavar az eroben %d-nel\n", triplet);
index = 0;
break;
}

return index;
}

int
main (void)
{

int l, A[20];

for (l = 0; l < 20; l++)
A[l] = 0;

int hanyadik_betu = -1;

int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = 0;

while ((i = getchar ()) != EOF)
{

switch (i)
{

case 'T':
jegy = 0;
break;
case 'C':
jegy = 1;
break;
case 'A':
jegy = 2;
break;
case 'G':
jegy = 3;
break;
}

hanyadik_betu = (hanyadik_betu + 1) % 3;

if (!hanyadik_betu)
elso = jegy;
else if (!(hanyadik_betu - 1))
masodik = jegy;
else
{
harmadik = jegy;
++A[genetikai_kod ( elso * 16 + masodik * 4 + harmadik )];
}
}

for (l = 0; l < 20; l++)
printf("%s\t%d\n", amino_sav[l], A[l]);
}

Stop: 267838
Phe: 463183
Leu: 494987
Ile: 365167
Met: 78173
Val: 243485
Ser: 447363
Pro: 194184
Thr: 243451
Ala: 175955
Tyr: 151660
His: 131102
Gln: 183783
Asn: 281030
Lys: 415900
Asp: 123341
Glu: 201059
Cys: 140234
Trp: 68346
Arg: 304556
Gly: 191070

Kassen 2012.03.14. 18:50:12

@Kassen: Akkor ez az előző nem jó? Nem kaptam semmi visszajelzést, pedig végülis hibátlanul elvégzi a dolgát.
A feladat szövege még egyszer:
"1 trófea annak, aki a genetikai kódot a kódnak megfelelő fehérjék sorozatává kódolja, pl.: TGT=Cys, TGG=Trp, TGA=STOP, segít a DNA codon table, jöhet kommentben a kód és egy kis rövid demó minta, hogy lássam jó-e."

KDániel 2012.03.14. 20:09:05

"Aki reprodukálja a kernel fordítás részt (létszámlimit nélkül) 2 trófea,"

data.hu/get/4851783/Linux_kernelforditas.doc

2012.03.15. 00:01:24

Uj, jobb valtozat, opcionalis tesztelo resszel:
www33.zippyshare.com/v/20922951/file.html

Eredmenyek:
./gh <hs_alt_HuRef_chr2.fa
Stop 4231151
Phe 4618214
Leu 8569550
Ile 4712323
Met 1451053
Val 3918718
Ser 6925936
Pro 3891228
Thr 3913828
Ala 3210576
Tyr 2560854
His 2592551
Gln 3028269
Asn 3155479
Lys 4641801
Asp 1769058
Glu 2836049
Cys 2690203
Trp 1396226
Arg 3780243
Gly 3901759

./gh <NC_003280.fna
Stop 267497
Phe 445827
Leu 489714
Ile 364670
Met 79613
Val 243280
Ser 450361
Pro 179453
Thr 243056
Ala 175140
Tyr 153251
His 133711
Gln 181261
Asn 275429
Lys 398344
Asp 125314
Glu 199000
Cys 142503
Trp 65033
Arg 303128
Gly 177523

jakaba 2012.03.15. 14:18:07

Magam így módosítottam a kódot: g.c
A link egyenlőre egyenlőre Forbidden.

nb · http://fersml.blog.hu 2012.03.17. 13:30:42

@KDániel: az összeset :) de éljetek együtt a játékkal és (visszaolvasva a kommenteket) arra figyeljetek, hogy egy feladat csak egyszer jöjjön be.

mamenyaka (törölt) 2012.03.17. 14:00:02

@nb: Ki lehetne törölni a fenti ezer kommentemet? Úgy 5 nappal ezelőtt írtam őket és csodálkoztam, hogy egyik se jelent meg a blogon...Ezért persze újra meg újra írtam őket. Most meg mind egyszerre feltámadt...

KDániel 2012.03.17. 21:26:08

@nb: Köszönöm a választ. :)

Viszont ha lehetek olyan pofátlan, megkérhetném a feladat beküldőket, hogy jelöljék melyik feladatot is küldték? Mert így elég nehéz kiválogatni, hogy melyik nem volt még.

Toma89 2012.03.18. 16:42:17

www.inf.unideb.hu/~nbatfai/l/
Linux-kernel fordítás:

3.2.9.kernel: kepfeltoltes.hu/120318/linux-3.2.9_www.kepfeltoltes.hu_.png

3.2.10.kernel: kepfeltoltes.hu/120318/linux-3.2.9_www.kepfeltoltes.hu_.png

Következő kommentben a kernelmodulos feladatot is feltöltöm. Esetleg tudna nekem valaki ajánlani egy video rögzítő programot Fedora-ra amivel tudom tudom rögzíteni az asztali tevékenységeimet? Köszönöm! :)

Toma89 2012.03.18. 16:43:20

@Toma89: Elnézést a második kép rosszul lett felötltve. Itt a javítás:

3.2.10: kepfeltoltes.hu/120318/linux-3.2.10_www.kepfeltoltes.hu_.png

Toma89 2012.03.18. 17:40:36

Kettesével töltöm fel a kernel modulos képeket, mert nem hajlandó egyben befűzni a többi kommenthez:

1: kepfeltoltes.hu/120318/5810997501_www.kepfeltoltes.hu_.png

2: kepfeltoltes.hu/120318/7387504752_www.kepfeltoltes.hu_.png

Toma89 2012.03.18. 17:45:19

@Toma89: Közben ha még is megjelenne az előző kommentjeim akkor elnézést érte. Egyszerre a hét képet nem volt hajlandó belinkelni egy kommentben, ezért muszáj voltam széttördelni.

nb · http://fersml.blog.hu 2012.03.18. 19:22:47

@Toma89: legtöbb esetben magam a recordmydesktop-ot szoktam parancssorból felparaméterezve használni.

nb · http://fersml.blog.hu 2012.03.18. 19:36:10

@Toma89: jól látom, hogy Te a saját gépen dolgoztál ugye? (úgy értem, hogy nem simán a "BatfaiProg1"-en a Vboxban)

Toma89 2012.03.18. 19:58:13

@nb: Igen a saját gépemen dolgoztam végig. Nem mondom, hogy minden zökkenő mentes zajlott le, de legtöbbször sikerült orvosolni időben a hibákat így nem omlott össze a rendszer se a kernel fordításnál, sem a kernel moduloknál.

Toma89 2012.03.18. 23:01:25

Feladat (kisebb sebességű): készíts "aminosav-hisztogramot", azaz a progi továbbfejlesztésével mond meg, melyik aminosav hányszor szerepel? (egy trófea, jöhet kommentben előre is)

#include <stdio.h>
#include <unistd.h>

struct amino_sav
{
char *ams;
int db;
}
amino_tab[] = {
{"Stop", 0 },
{"Phe", 0 },
{"Leu", 0 },
{"Ile", 0 },
{"Met", 0 },
{"Val", 0 },
{"Ser", 0 },
{"Pro", 0 },
{"Thr", 0 },
{"Ala", 0 },
{"Tyr", 0 },
{"His", 0 },
{"Gln", 0 },
{"Asn", 0 },
{"Lys", 0 },
{"Asp", 0 },
{"Glu", 0 },
{"Cys", 0 },
{"Trp", 0 },
{"Arg", 0 },
{"Gly", 0 }
};

void
genetikai_kod (int triplet)
{
int index = 0;

switch (triplet)
{
case 0:
case 1:
index = 1;
break;
case 2: // Leu
case 3:
case 16:
case 17:
case 18:
case 19:
index = 2;
break;
case 32: // Ile
case 33:
case 34:
index = 3;
break;
case 35: // Met
index = 4;
break;
case 48:
case 49:
case 50:
case 51:
index = 5;
break;
case 4:
case 5:
case 6:
case 7:
case 44:
case 45:
index = 6;
break;
case 20:
case 21:
case 22:
case 23:
index = 7;
break;
case 36:
case 37:
case 38:
case 39:
index = 8;
break;
case 52:
case 53:
case 54:
case 55:
index = 9;
break;
case 8:
case 9:
index = 10;
break;
case 10: // Stop
case 11:
case 14:
index = 0;
break;
case 24:
case 25:
index = 11;
break;
case 26:
case 27:
index = 12;
break;
case 40:
case 41:
index = 13;
break;
case 42:
case 43:
index = 14;
break;
case 56:
case 57:
index = 15;
break;
case 58:
case 59:
index = 16;
break;
case 12: // Cys
case 13:
index = 17;
break;
case 15: // Trp
index = 18;
break;
case 28: // Arg
case 29:
case 30:
case 31:
case 46:
case 47:
index = 19;
break;
case 60: // Gly
case 61:
case 62:
case 63:
index = 20;
break;
default:
printf ("Zavar az eroben %d-nel", triplet);
break;
}
++amino_tab[index].db;
printf ("%s", amino_tab[index].ams);
}
int
main (void)
{

int hanyadik_betu = -1;

int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = -1;

while ((i = getchar ()) != EOF)
if (i == '\n')
break;

while ((i = getchar ()) != EOF )
{

jegy = -1;

switch (i)
{

case 'T':
jegy = 0;
break;
case 'C':
jegy = 1;
break;
case 'A':
jegy = 2;
break;
case 'G':
jegy = 3;
break;
}
if (jegy >= 0)
{

hanyadik_betu = (hanyadik_betu + 1) % 3;

if (!hanyadik_betu)
elso = jegy;
else if (!(hanyadik_betu - 1))
masodik = jegy;
else
{
harmadik = jegy;
genetikai_kod (elso * 16 + masodik * 4 + harmadik);
}

}

}
for (int i = 0; i <= 20; ++i)
printf ("\n%s\t%6d", amino_tab[i].ams, amino_tab[i].db);
printf ("\n");
}

Annyiban különbözik az eredeti kódtól, hogy struktúrát használ a program az aminosavak darabszámainak tárolásához és eljárással tölti fel a struktúra aminosav darabszámait és nem fügvénnyel. Ezzel a módszerrel pár tized másodpercet meg lehet spórolni. Videot is készítek igazolás képpen!

Toma89 2012.03.18. 23:26:18

További két kisbajnokság, aki gyorsabbat ír:

www.youtube.com/watch?v=xT2gBDxhz5k

Elkészült a video is. Mint mondtam nem függvényt, hanem eljárást használ a program az aminosav hisztogram feltöltésére és struktúrával van megvalósítva az aminosav nevének és db számának eltárolása.

Több féle módszerre próbáltam hangsúlyozni a program sebességét. Kommentbe helyeztem a printf ("%s", amino_tab[index].ams); részt, hogy csak is az aminosav nevét és annak db számát írja ki a program. Ezzel is lehet nyerni egy kis időt és azzal is, ha a tail -n 0 használva csak az időtartamot iratom ki.

csigusz600 2012.03.19. 18:36:34

Tudom hogy nem ide tartozik....mármint a blogra ,de nem a feladathoz hogy a zh vagy ez a feladat védés mikor is lesz és ha lezs zh miből????

nb · http://fersml.blog.hu 2012.03.19. 19:35:48

@csigusz600: előadásra el kell kezdened járni! Programozásról lévén szó még a vizsgán sem lesz olyan szituáció, amely egy klasszikus ZH-ra emlékeztetne... sokkal inkább valódi gépnél, természetesen akár hálózattal is felszerelt gépnél kell programot írnod. Az egyik védés a félév közepén lesz, de mivel a múlt héten is elmaradt labor, s a jövő héten is ez lesz a helyzet a szakmai nap miatt, ha jól számolok, így utána lesz szerencsés, de a blogon minden időben kint lesz, illetve elég sok infó megy Neptunon is :)

De kérdésedet tartalmi szempontból tekintve, a valódi szűrő a védés, de ha visszagondolsz az eddigi laborokra, a celebrálásnak már van hagyománya, ilyesmi a védés is, csak sokkal kukacoskodóbb :)

Egyébként szerintem simán a blogra tartozhat a kérdés. A védés azzal kezdődik, hogy a hallgató demonstrálja a várt működést, majd elkápráztatja a laborközösséget a programja ismeretével, jó esetben :)

nb · http://fersml.blog.hu 2012.03.19. 19:40:42

@nb: ha az elkápráztatás nem jön össze, akkor kérdést kap a hallgató, amelyet meg kell világítania, vagy módosítania kell a programján stb. Súlyozzuk majd a két védést, de mindkét esetben igaz, hogy alapdolgok nem értése a labor nem teljesítéséhez vezet, az alap pedig a program kódjának olvasása, értése, a program módosítani tudása, használata. Aki a félévben együtt él a játékkal, annak játék szokott lenni, a többieknek meggyűlhet a baja a teljesítéssel. (Tavaly a prog2-nél már elég nagy számban nem tudták megvédeni a saját Java/Atan alapú focicsapatukat... )

KDániel 2012.03.19. 20:13:31

A program, amit majd védeni kell saját ötlet alapján írt lesz vagy előre meghatározott?

szajbergyerek 2012.03.19. 23:37:22

@KDániel: Üdv!

KDániel binomja vagyok. Ellenőriztem az általa beküldött programokat, és itt vannak a kódok, valamint a képernyőmentések is:

---

1.12. gyakorlat - Írjunk programot, ami a bemenetére adott szöveg minden szavát új sorba írja ki!

#include <stdio.h>
int main()
{
int i=0,k;
char s[80];
printf("Kerem a szoveget: ");
while((s[i]=getchar())!='\n')
i++;
for(k=i;k<80;k++)
s[k]='\0';
for(k=0;k<i;k++)
if(s[k]==' ') printf("\n");
else printf("%c",s[k]);
printf("\n");
return 0;
}

kepfeltoltes.hu/view/120319/screenshot_exercise_1-12_www.kepfeltoltes.hu_.png

---

1.17. gyakorlat - Írjunk programot, ami kiírja az összes, 80 karakternél hosszabb bemeneti sort!

#include <stdio.h>
#include <string.h>
#define MAX_SOR 1000
int main ()
{
char sor[MAX_SOR]={'\0'};
int i=0,k;
while((sor[i]=getchar())!=EOF)
{
if(sor[i]=='\n')
{
if(strlen(sor)>81)
printf("%s\n",sor);
for(k=0;k<i; k++)
sor[k]='\0';
i=-1;
}
i++;
}
return 0;
}

kepfeltoltes.hu/view/120319/screenshot_exercise_1-17_www.kepfeltoltes.hu_.png

---

4.1. gyakorlat - Írjuk meg az 'strindex(s, t)' függvénynek azt a változatát, amely a 't' minta 's'-beli legutolsó előfordulásának indexével, vagy ha 't' nem található meg 's'-ben, akkor -1-gyel tér vissza!

#include <stdio.h>
#include <string.h>
int strindex(char *miben, char *mit)
{
int i=0,van=1,j=0,l;
while (i<strlen(miben))
{
van=1;
if(miben[i]==mit[0])
{
j=i+1;
for(l=1;l<strlen(mit); l++)
{
if(miben[j]==mit[l]) van++;
j++;
}
if(van==strlen(mit)) return i+1;
}
i++;
}
return -1;
}

main () {
char s[80],t[80]; int i=0,k;
printf("Kerem a szoveget: ");
while((s[i]=getchar())!='\n') i++;
for(k=i;k<80; k++) s[k]='\0';
printf("Kerem a keresett szovegreszt: ");
i=0;
while((t[i]=getchar())!='\n') i++;
for(k=i;k<80; k++) t[k]='\0';
printf("Az eredmeny (ha szam, akkor onnantol kezdodik a szovegben, ha -1 akkor nincs meg): %d\n",strindex(s,t));

return 0;
}

kepfeltoltes.hu/view/120319/screenshot_exercise_4-1_www.kepfeltoltes.hu_.png

szajbergyerek 2012.03.19. 23:38:11

@szajbergyerek:

4.13. gyakorlat - Írjuk meg az 's' karaktersorozatot helyben megfordító 'reverse(s)' függvény rekurzív változatát!

#include <stdio.h>
#include <string.h>
#define MAX_ 120

int reverse_recursive(char *mit,int hossz)
{
printf("%c",mit[hossz]);
if(hossz>=0)
printf("%c",reverse_recursive(mit,hossz-1));
else
return;
}

int main(void)
{
char s[MAX_]={'\0'};
int i=0,k;

printf("Kerem a szoveget: ");
while((s[i]=getchar())!='\n')
i++;
for(k=i;k<MAX_; k++)
s[k]='\0';
reverse_recursive(s,strlen(s));
printf("\n");

return 0;
}

kepfeltoltes.hu/view/120319/screenshot_exercise_4-13_www.kepfeltoltes.hu_.png

---

5.4. gyakorlat - Írjon 'strend(s, t)' néven függvényt, amely 1 értékkel tér vissza, ha a 't' karaktersorozat megtalálható az 's' karaktersorozat végén, és 0 értékkel, ha nem!

#include <stdio.h>
#include <string.h>
#define MAX_ 100

int strend(char *miben, char *mit)
{
int i,j,l,van=1;
for(i=(strlen(miben)-strlen(mit)); i<strlen(miben); i++)
{
if(miben[i]==mit[0])
{
l=i+1;
for(j=1;j<strlen(mit); j++)
{
if(miben[l]==mit[j])
van++;
else break;
l++;
}
if(van==strlen(mit))
return 1;
}
van=1;
}
return 0;
}

int main(void)
{
char s[MAX_],t[MAX_];
int i=0,k;
printf("Kerem a szoveget: ");

while((s[i]=getchar())!='\n')
i++;

for(k=i;k<MAX_; k++)
s[k]='\0';

printf("Kerem a keresett szovegreszt: ");
i=0;

while((t[i]=getchar())!='\n')
i++;

for(k=i;k<MAX_;k++)
t[k]='\0';

printf("Az eredmeny: %d \n(- 1 benne van a vegen\n - 0 nincs benne a vegen)\n",strend(s,t));
return 0;
}

kepfeltoltes.hu/view/120319/screenshot_exercise_5-4_www.kepfeltoltes.hu_.png

---

5.13. gyakorlat - Írjuk meg a 'tail' programot, amely kinyomtatja az utolsó 'n' bemeneti sort! Alapfeltételezés szerint legyen n=10, de tegyük lehetővé 'n' változtatását egy opcionális argumentummal pl. a

tail -n

formában. (Ennek hatására az utolsón sor íródjon ki.) A program viselkedjen ésszerűen akkor is, ha a bemenet vagy az 'n' értéke ésszerűtlen. A programot úgy írjuk meg, hogy a lehető legjobban használja a rendelkezésére álló tárterületet: a szövegsorokat a rendezőprogramnál leírt módon tároljuk és ne rögzített méretű kétdimenziós tömbként.

#include <stdio.h>
#include <string.h>
#define MAX_ 1000

main(int argc, char *argv[])
{
char s[MAX_]={'\0'}, sorok[MAX_][MAX_]={'\0'};
int n=23,i=0,sor=0,k;

if(argc==1) n=10;

else n=*argv[1]-'0';

while((s[i]=getchar())!=EOF)
{
if(s[i]=='\n')
{
strcpy(sorok[sor],s);
for(k=0;k<i; k++) s[k]='\0';
i=-1;
sor++;
}
i++;
}

if(n>sor)
{
printf("Nincs annyi bejovo adat\n");
return 1;
}
else for(i=sor-n;i<sor;i++)
printf("%s",sorok[i]);
return 0;
}

kepfeltoltes.hu/view/120319/screenshot_exercise_5-13_www.kepfeltoltes.hu_.png

---

7.1. gyakorlat - Írjunk programot, amely a hívásakor az argv[0]-ban elhelyezett paramétertől függően a nagybetűket kisbetűvé vagy a kisbetűket nagybetűvé alakítja!

#include <stdio.h>
#include <ctype.h>
#include <string.h>

int strend(char *miben, char *mit)
{int i,j,l,van=1;
for(i=(strlen(miben)-strlen(mit)); i<strlen(miben); i++)
{
if(miben[i]==mit[0])
{
l=i+1;
for(j=1;j<strlen(mit); j++)
{
if(miben[l]==mit[j]) van++;
else break;
l++;
}
if(van==strlen(mit)) return 1;
}
van=1;
}
return 0;
}
main(int argc,char *argv[])
{
char s;
printf("* vegjelig atalakitja a bemenetet a hivasnak megfeleloen\n");
if (strend(argv[0],"lower"))
while((s=getchar())!=EOF)
{
putchar(tolower(s));
if(s=='*') break;
}
else if(strend(argv[0],"upper"))
while((s=getchar())!=EOF)
{
putchar(toupper(s));
if(s=='*') break;
}
else
{
printf("Hibas hivas\n");
return 1;
}
return 0;
}

kepfeltoltes.hu/view/120319/screenshot_exercise_7-1_www.kepfeltoltes.hu_.png

KDániel 2012.03.21. 13:38:02

Hiba javítás v2
Ha az egyik fájl hosszabb volt, mint a másik, akkor hibát írt, javítottam.

kepfeltoltes.hu/120321/p7_www.kepfeltoltes.hu_.png

KDániel 2012.03.27. 22:16:05

K&R feladat
6.5 Self-referential Structures
Exercise 6-3.
Write a cross-referencer that prints a list of all words in a document, and for each word a list of the line numbers on which it occurs. Remove noise words like "the", "and", and so on.

forrás (túl nagy, hogy képernyőképbe beleférjen):
www.4shared.com/get/uNhGaRNC/exercise63-undone.html

és kép a futásról:
kepfeltoltes.hu/120327/1287208323p8_www.kepfeltoltes.hu_.png
süti beállítások módosítása