Nagy ZH

Ez az oldal minta NZH-kat tartalmaz, a 2011-es őszi félév alapján.

1. Beugró

Írj olyan függvényt, ami paraméterül kap egy pozitív egész számot, s paramétersoron visszaadja a kapott szám osztóinak számát!

Add meg a 73&96 értékét 2-es, 10-es és 16-os számrendszerben!

Generálj egy véletlenszámot 5 és 100 között!

Mit ír ki a következő programrészlet?

int tomb[100]={0,1,2};
int osszeg=0;
int i=0;
for (i=2;i<100;i++)
   osszeg+=tomb[i];
printf("%d\n", osszeg);

Írj olyan C függvényt, ami visszatérési értékként megadja a legnagyobb 4 jegyű prímszámot!

2. Parancssori

Írj olyan C programot, ami a 3. parancssori paraméterben megadott szöveges fájlba írja a parancssori argumentumokat! (Feltételezhető, hogy a felhasználó elegendő paramétert ad meg.)

3. Pénztár

Egy áruházban 32 pénztár van. A tulajdonos nyomon szeretné követni egy napi forgalom adatait az egyes kasszáknál. Így minden vásárláskor egy központi gépen megjelenik a kassza sorszáma és a fizetett összeg a következő alakban:
11 : 33800     (szám szóköz karakter szóköz szám) 11-es kassza, 33800 Ft
Záráskor 0 : 0 adattal zárul az aznapi forgalom figyelése.

1. Írj olyan programot, ami a standard outputra a nap végén kiírja, hogy melyik kasszánál mekkora volt a bevétel. Ha egy kassza az adott napon nem üzemelt, akkor az ne jelenjen meg.
2. A kimeneten jelenjen meg annak a kasszának a sorszáma is, ahol a legnagyobb összbevételt regisztrálták az adott napon.

4. Sztringes

Készíts függvényt, mely paraméterként kap három karaktertömböt, és az első kettőben lévő sztringet először rendezi, majd összefésülve, azaz betűnként felváltva átmásolja a harmadikba. Pl.: s1=„ebadc”, s2=„1426375”, az eredmény: s3=„a1b2c3d4e567”.

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

void rendez(char *s) {
    int hossz = strlen(s);
    int i;
    
    /* szelsoertek kereseses rendezes */
    for (i=0; i<hossz-1; ++i) {
        int minindex, j;
        char temp;

        /* minkeres */
        minindex=i;
        for (j=i+1; j<hossz; ++j)
            if (s[j]<s[minindex])
                minindex=j;
        
        /* csere */
        temp=s[i];
        s[i]=s[minindex];
        s[minindex]=temp;
    }
}

void osszefesul(char *s1, char *s2, char *s3) {
    int i, j, cel;
    
    i = j = cel = 0;
    /* amig nem fogyott el mindket sztring, azaz
     * amig barmelyikben van meg karakter, azaz
     * ha az egyikben van karakter VAGY a masikban van karakter */
    while (s1[i]!='\0' || s2[j]!='\0') {
        if (s1[i]!='\0')
            s3[cel++]=s1[i++];
        if (s2[j]!='\0')
            s3[cel++]=s2[j++];
    }
    /* lezaro nulla a cel vegere */
    s3[cel]='\0';
}

/* topdown, hogy ne kelljen omlesztett kodot irni, es
 * hogy ne kelljen a rendezest ketszer leirni */
void rendez_es_osszefesul(char *s1, char *s2, char *s3) {
    rendez(s1);
    rendez(s2);
    osszefesul(s1, s2, s3);
}

int main() {
    char s1[]="fghjsnvcx";
    char s2[]="98712357348371";
    char s3[50];
    
    rendez_es_osszefesul(s1, s2, s3);
    
    printf("s1 rendezve: %s\ns2 rendezve: %s\nosszefesulve: %s\n", s1, s2, s3);
    
    return 0;
}

1. Beugró

Írj C programot, amely a „welcome.txt” nevű szöveges fájlba írja a „Welcome to the real world!” szöveget és egy újsor karaktert!

#include <stdio.h>

int main() {
    FILE *fp;
    fp=fopen("welcome.txt", "wt");
    fprintf(fp, "Welcome to the real world!\n");
    fclose(fp);
    return 0;
}

Írj C függvényt, amely átvesz két egész típusú mutatót, és felcseréli a mutatott értékeket!

void csere(int *pa, int *pb) {
    int temp=*pa;
    *pa=*pb;
    *pb=temp;
}

Írj C függvényt, amely átvesz egy egészekből álló tömböt, és kiírja a tömb utolsó elemét! Írj kódrészletet, amely definiál egy tömböt, és meghívja vele a függvényt!

void utolso(int tomb[], int meret) {
    printf("%d", tomb[meret-1]);
}

int t[5]={1, 2, 3, 4, 5};
utolso(t, 5);

Mennyi d értéke? double d = 3 / 4; Mennyi d értéke? float d = 9 / 2;

0 és 4 /* egész osztás! */

Írj C függvényt, amely egy előjel nélküli egész értéket vesz át, és logikai IGAZ értéket ad vissza, ha a szám 1, és logikai HAMIS értéket, ha a szám nem 1!

int egy_e(unsigned szam) {
    return szam==1;
}

Írj C programot, amely kiírja az összes parancssori paraméterét (a program nevét ne írja ki)!

int main(int argc, char *argv[]) {
    int i;
    for (i=1; i<argc; ++i)
        printf("%s\n", argv[i]);
    return 0;
}

Írj C függvényt, amely átveszi egy kocka oldalhosszát (valós érték), és két, paraméterként átvett valós típusú pointer által mutatott változóban visszaadja a kocka felszínét és térfogatát!

void kocka(double a, double *pA, double *pV) {
    *pA=6*a*a;
    *pV=a*a*a;
}

Írj C függvényt, amely átvesz két sztringet, és a második sztring első karakterét úgy teszi át az elsőbe, hogy az első egy egybetűs C sztringet alkosson (pl. „példa” -> „p”)! Írj kódrészletet, amely definiálja a szükséges változókat, és meghívja velük a függvényt!

void elsobetu(char ide[], char ebbol[]) {
    ide[0]=ebbol[0];
    ide[1]='\0';
}

Definiálj struktúratípust típusdefinícióval, amely alkalmas egy gömb méretének és térbeli helyének tárolására!

typedef struct Gomb {
    double x, y, z; /* kozeppont */
    double r;       /* sugar */
} Gomb;

2a. Egyszer szerepel

Írj egy olyan C függvényt, amely paraméterként kap két, egész számokat tartalmazó tömböt, valamint a első tömb elemszámát, és átmásolja a második tömbbe azokat az értékeket, amelyek csak egyszer fordulnak elő az elsőben (biztosan beleférnek)! Visszatérési értékként adja a második tömbbe betett elemek számát! Az első tömb nem módosítható! (Írhatsz segédfüggvényt is.) Pl. be: {-5,9,2,-5,3,-1,7,2,2,4}, ki: {9,3,-1,7,4}

int hanyszor(int forras[], int meret, int mit) {
    int i, db=0;
    for (i=0; i<meret; i++)
        if (forras[i]==mit) db++;
    return db;
}

int masol(int forras[], int meret, int cel[]) {
    int i1, i2;
    for (i1=i2=0; i1<meret; i1++)
        if (hanyszor(forras,meret,forras[i1])==1)
            cel[i2++] = forras[i1];
    return i2;
}

2b. Egyszer szerepel (sztringen)

Írj egy olyan C függvényt, mely két, az angol abc kisbetűiből álló sztringet vesz át, és átmásolja az első sztringbe azokat a karaktereket, amelyek csak egyszer fordulnak elő a másodikban (biztosan beleférnek)! (Írhatsz segédfüggvényt is.) Írj main() függvényt, melyből meghívod a másoló függvényt! Pl. „madarnyelven” => „mdrylv”

int hanyszor(char forras[], char mit) {
    int i, db=0;
    for (i=0; forras[i]!=0; i++)
        if (forras[i]==mit) db++;
    return db;
}

void masol(char forras[], char cel[]) {
    int i1, i2;
    for (i1=i2=0; forras[i1]!=0; i1++)
        if (hanyszor(forras,forras[i1])==1)
            cel[i2++] = forras[i1];
    cel[i2]=0;
}

int main() {
    char forras[]="Hello", cel[20];
    masol(forras, cel);
    puts(cel);
    return 0;
}

3a. Mavadávárnyevelv

Írj C függvényt, mely két sztringet vesz át paraméterként, amelyekből a második az angol abc kisbetűiből álló szöveget tartalmaz! A függvény az elsőbe írja be a második "madárnyelvű" változatát, azaz a magánhangzókat megkétszerezi, és közéjük egy 'v' betűt rak. Felteheted, hogy az első sztring elég nagy, hogy elférjen benne az új érték! Írj main() függvényt, melyből meghívod a madárnyelv függvényt! Pl. „madarnyelven” => „mavadavarnyevelveven”

#include <stdio.h>

int maganhangzo(char c) {
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}

void madar(char *cel, char *forras) {
    int icel, iforr;

    icel = iforr = 0;

    while (forras[iforr]!='\0') {
        cel[icel++] = forras[iforr];

        if (maganhangzo(forras[iforr])) {
            cel[icel++] = 'v';
            cel[icel++] = forras[iforr];
        }

        ++iforr;
    }

    cel[icel] = '\0';
}

int main() {
    char ezt[] = "madarnyelven";
    char madarul[50];

    madar(madarul, ezt);

    printf("%s\n", madarul);

    return 0;
}

3b. Kettőnullakettő (madárnyelv számokon)

Írj C függvényt, amely paraméterként kap két, egész számokat tartalmazó tömböt, valamint az első tömb elemszámát, és a másodikba beírja az első olyan változatát, amely a páros számokat két példányban teszi bele, és közéjük egy 0 értéket rak! Felteheted, hogy a második tömb elég nagy, hogy elférjenek benne az új értékek! Visszatérési értékként adja a második tömb elemszámát! Az első tömb nem módosítható! Pl. be: {-5,9,2,-5,3,-1,7,2,2,4}, ki: {-5,9,2,0,2,-5,3,-1,7,2,0,2,2,0,2,4,0,4}

#include <stdio.h>

int tomb(int *forras, int *cel, int forras_meret) {
    int iforr, icel;

    icel = 0;
    for (iforr = 0; iforr < forras_meret; ++iforr) {
        if (forras[iforr] % 2 == 0) { 
            cel[icel++] = forras[iforr];
            cel[icel++] = 0;
            cel[icel++] = forras[iforr];
        }
        else cel[icel++] = forras[iforr];
    }

    return icel;
}

int main() {
    int forras[] = {-5,9,2,-5,3,-1,7,2,2,4}; 
    int cel[50], cel_db, i;

    cel_db = tomb(forras, cel, 10);

    for (i = 0; i < cel_db; ++i) printf("%d ", cel[i]);

    return 0;
}

4a. Prímszámos

Írj C programot, amely pozitív egész számokat kér be a felhasználótól! A számsorozat végét 0 jelzi. (A 0 után még érkezhet egyéb adat a bemeneten, de ezt a program már ne dolgozza fel!) Garantált, hogy a felhasználó maximum ezer darab számot ad meg a 0 előtt. A program írja ki az összes, a számok átlagánál kisebb beolvasott prímszámot a beolvasás sorrendjével ellentétes sorrendben! Az átlagszámításba a sorozat végét jelző 0 ne számítson bele!

#include <stdio.h>

int prim(unsigned szam) {
    unsigned oszto;
    for (oszto=2; oszto<szam; oszto++) {
        if (szam % oszto == 0)
            return 0;
    }
    return 1;
}

double atlag(unsigned *tomb, int meret) {
    double sum=0.0;
    int i;
    for (i=0; i<meret; i++)
        sum += tomb[i];
    return sum/meret;
}

int main() {
    unsigned tomb[1000], szam;
    int db, i;
    double atl;

    db=0;
    scanf("%u", &szam);
    while (szam!=0) {
        tomb[db++]=szam;
        scanf("%u", &szam);
    }
    atl=atlag(tomb,db);
    for (i=db-1; i>=0; i--)
        if (tomb[i]<atl && prim(tomb[i]))
            printf("%u\n",tomb[i]);
    return 0;
}

4b. Négyosztós

Írj C programot, amely pozitív egész számokat kér be a felhasználótól! A számsorozat végét 0 jelzi. (A 0 után még érkezhet egyéb adat a bemeneten, de ezt a program már ne dolgozza fel!) Garantált, hogy a felhasználó maximum tízezer darab számot ad meg a 0 előtt. A program írja ki az összes, a legkisebb beolvasott szám tízszeresénél nagyobb olyan beolvasott számot, amelynek pontosan négy osztója van, a beolvasás sorrendjével azonos sorrendben! A legkisebb szám meghatározásánál a 0-t ne vegye figyelembe!

#include <stdio.h>

int oszto(unsigned szam) {
    unsigned i, db=0;
    for (i=1; i<=szam; i++)
        if (szam%i==0)db++;
    return db;
}

unsigned legkisebb(unsigned *tomb, int meret) {
    int i, min=tomb[0];
    for (i=1; i<meret; i++)
        if (tomb[i]<min)min=tomb[i];
    return min;
}

int main() {
    unsigned tomb[10000], szam, min10;
    int db, i;

    db=0;
    scanf("%u", &szam);
    while (szam!=0) {
        tomb[db++]=szam;
        scanf("%u", &szam);
    }
    min10=legkisebb(tomb,db)*10;
    for (i=0; i<db; i++)
        if (tomb[i]>min10 && oszto(tomb[i])==4)
            printf("%u\n",tomb[i]);
    return 0;
}

1. Beugró

Írj egy függvényt, amely kap paraméterként egy egészekből álló tömböt, és visszatér egy véletlenszerűen választott elemével.

int veletlen(int tomb[], int meret) {
   return tomb[rand()%meret];
}

Írj függvényt, amely megmondja egy karakterről, hogy az angol ábécé kisbetűje-e.

int karakter(char c) {
   return c>='a' && c<='z';
}
/* VAGY */
int karakter(char c) {
   return islower(c);
}

Adott egy struct Pont { int x, y; } struktúra. Definiálj ilyenből 150 elemű tömböt! Nyisd meg a „pontok.dat” nevű bináris fájlt, és írd bele a tömb tartalmát! (Elég egy kódrészlet, nem kell teljes program.)

struct Pont csucsok[150];
FILE *fp=fopen("pontok.dat", "wb");
fwrite(csucsok, sizeof(struct Pont), 150, fp);
fclose(fp);

Mennyi 23^25? Írd le a számokat és az eredményt is kettes és tízes számrendszerben!

10111 23
11001 25
-----
01110 14

Definiálj felsorolt típust, és annak segítségével adatszerkezetet, amely 3x3-as amőba játék pályáját tudja tárolni.

typedef enum Cella { ures, kor, iksz } Cella;
Cella palya[3][3];   

2. Medián

Írj programot, amely fájl vége jelig olvas a szabványos bemenetről valós számokat, amelyek egy rendezetlen számsort alkotnak. A felhasználó helyes bemenetet ad meg, és legfeljebb 1000 darab beolvasott szám lesz. Írja ki a program a rendezett számsor mediánját. Ha a számsorban páratlan számú elem van, akkor ez a középső; ha páros számú, akkor a két középső számtani közepe. (A rendezés legyen algoritmikusan helyes és indokolható! A „százezerszer végigmegyünk a tömbön és addigra talán rendezett lesz” jellegű megoldások nem érnek pontot.) A program működjön helyesen akkor is, ha nem volt beírt szám! Ilyenkor 0-t írjon ki.

#include <stdio.h>

void rendez(double tomb[], int meret) {
   int i;
   
   for (i=0; i<meret; ++i) {
      int minindex, j;
      double temp;
      
      minindex=i;
      for (j=i+1; j<meret; ++j)
         if (tomb[j]<tomb[minindex])
            minindex=j;
            
      temp=tomb[i];
      tomb[i]=tomb[minindex];
      tomb[minindex]=temp;
   }
}

int main() {
   double tomb[1000], be;
   int db;
   
   db=0;
   
   while (scanf("%lf", &be)==1)
      tomb[db++]=be;
   
   rendez(tomb, db);
   
   if (db==0)
      printf("%f", 0.0);
   else {
      if (db%2==0)
         printf("%f", (tomb[db/2-1]+tomb[db/2])/2);
      else
         printf("%f", tomb[db/2]);
   }
   
   return 0;
}

3. Sztring másolása

Írj függvényt, amely átvesz paraméterként egy karaktertömböt és annak méretét; továbbá egy sztringet. Másolja ez az utóbbi sztringet az előbbi karaktertömbbe! Ha nem fér bele, akkor a forrás sztring végét el kell hagyni. A keletkező karaktertömbbe tehát olyan sztringet kell írni, amely a lehető legnagyobb részét tartalmazza az eredetinek. Térjen vissza logikai igazzal, ha a teljes sztring másolódott, és hamissal, ha le kellett vágni a végét a másoláskor. (Az eredeti sztring nem módosítható.) Írj egy main függvényt, amelyben példát mutatsz a függvény meghívására, olyat is, amelyben a teljes sztring másolódik, és olyat is, amelyben nem. Mindkét esetben jelenjen meg egy üzenet is, hogy teljes volt a másolás vagy hiányzik a sztring vége.

#include <stdio.h>

int sztringmasol(char *ide, int meret, char const *ezt) {
   int i;
   
   for (i=0; i<meret-1 && ezt[i]!='\0'; ++i)
      ide[i]=ezt[i];
   
   ide[i]='\0';
   
   return ezt[i]=='\0';
}

int main() {
   char ide[10];
   int sikerult;
   
   sikerult=sztringmasol(ide, 10, "hello");
   printf("%s: ", sikerult? "befert":"nem fert be");
   printf("[%s]\n", ide);

   sikerult=sztringmasol(ide, 10, "0123456789");
   printf("%s: ", sikerult? "befert":"nem fert be");
   printf("[%s]\n", ide);
   
   return 0;
}

4. Mondatok számolása

Add meg egy tetszőleges, standard bemenetről érkező, tetszőleges hosszúságú szövegről, hogy hány teljes mondat van benne! A bemenetnek fájlvége jelnél van vége. Mondatnak tekintünk minden olyan karaktersorozatot, amelyik nagybetűvel kezdődik, és egy vagy több ponttal, kérdőjellel vagy felkiáltójellel végződik. Pl. „Helló, Dolly!!! Hogy vagy?! Jól, köszönöm.” – 3 mondat.

#include <stdio.h>

/*
           nagybetű       ?!.              többi
      
start      mondatban      -                -
mondatban  -              sz++, start      -
*/

int nagybetu(char c) {
   return c>='A' && c<='Z';
}

int irasjel(char c) {
   return c=='?' || c=='!' || c=='.';
}

int main() {
   enum Allapot { start, mondatban } all;
   
   int c, sz;
   
   sz=0;
   all=start;
   
   while ((c=getchar())!=EOF) {
      switch (all) {
         case start:
            if (nagybetu(c))
               all=mondatban;
            break;
         case mondatban:
            if (irasjel(c)) {
               sz++;
               all=start;
            }
            break;
      }
   }
   printf("%d mondat.\n", sz);
   
   return 0;
}

1. Beugró

Adott n egy egész típusú változó, melynek értéke egy háromjegyű szám. Add meg azt a kifejezést, amely az n szám középső számjegyét szolgáltatja!

n/10%10

Definiálj struktúratípust targy típusnévvel, amellyel tantárgyakat lehet reprezentálni a következő adataival: tárgy neve, kódja (max 30 ill. 10 karakteres szöveg), szemesztere, kreditje (egész)! Definiálj egy ilyen típusú változót, és adj neki kezdőértéket! Pl. Programozás (VIEEA100) 1. szemeszter, 5 kredit.

typedef struct targy {
   char nev[31];
   char kod[11];
   int szemeszter;
   int kredit;
} targy;

targy prog1={"Programozas", "VIEEA100", 1, 5};

Írj C programot, amely a „valami.txt” nevű szöveges fájl tartalmát a szabványos kimenetre írja! A program adjon hibaüzenetet a szabványos hibakimenetre, ha a fájl nem nyitható meg!

#include <stdio.h>

int main() {
   FILE *fp=fopen("valami.txt", "rt");
   
   if (fp==NULL) {
      fprintf(stderr, "nem tudom megnyitni\n");
   } else {
      int c;
      while ((c=fgetc(fp))!=EOF)
         putchar(c);
      fclose(fp);
   }
   return 0;
}

Mit ír ki az alábbi kódrészlet?

int a=30, b=12;
while (a!=0 && b!=0) { if(a>b) a-=b; else b-=a; }
printf("%d", a+b);

6

Írj C programot, amely kiírja két, parancssori paraméterként átvett egész szám összegét! (A parancssori paraméterek mindig sztringek, az egész számokat ezekből kell kinyerni.)

#include <stdio.h>

int main(int argc, char *argv[]) {
   printf("%d", atoi(argv[1]) + atoi(argv[2]));
}

2. C++ kommentek tartalma

// mint ez itt

3. Túrázó

A Mátrában túráztunk. Utunk során a pillanatnyi helyzetünket egy GPS egység percenként rögzítette. A túra után a GPS egységből az alábbi formátumban kapjuk meg az adatokat: először egy egész szám, az adatpontok darabszáma (gyakorlatilag a túra hossza percben, plusz 1), majd ezt követően éppen ennyi darab számhármas, az egyes pontok x, y és z koordinátái, ahol z a magasság. (Ezeket nyugodtan tekinthetjük derékszögű koordinátarendszerbeli adatoknak, hisz a bejárt terület igen kicsi a Föld felszínéhez viszonyítva.) Ezt a GPS-ből származó adatsorozatot kapja majd a programunk a szabványos bemenetén, az utolsó adat után még egy valós számhármasban pedig a Kékestető pozícióját. Írj egy olyan C nyelvű teljes programot, amely meghatározza és a szabványos kimenetre írja a szabványos bemenetről olvasott adatok ismeretében

1. a túra hányadik percében jártunk legközelebb a Kékestetőhöz, és mennyi ez a távolság,
2. utunk két legtávolabbi pontjának a távolságát, azaz az összes lehetséges pontpár térbeli távolságának a maximumát.

A túra biztosan nem tart tovább 20 óránál. (Két pont távolsága a Pitagorasz-tétellel számolható.)

4. Bites

Írj függvényt, amely paraméterként vesz át egy pozitív egész számot, és a szám kettes számrendszerbeli alakját a szintén paraméterként álvett karaktertömbbe írja sztringként! Nem használhatsz könyvtári függvényt a megvalósításhoz.