main int main(int argc, char* argv[]) { return 0; } main return 0; (int argc, char* argv[]) main int int int main main main

Hasonló dokumentumok
Programozás alapjai C nyelv 10. gyakorlat. Standard függvények. Union

Programozás I. 5. Előadás: Függvények

Programozás 6. Dr. Iványi Péter

Programozás I. gyakorlat

Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás

/* Az iter függvény meghívása és a visszatérő érték átadása a gyok változóba */ gyok = iter( n, a, e ) ;

Függvény pointer. Feladat: Egy tömbben soroljunk fel függvényeket, és hívjuk meg valahányszor.

Minimum feladat: Teljes feladat: Minimum feladat: Teljes feladat: Minimum feladat:

Programozás C nyelven FELÜLNÉZETBŐL elhullatott MORZSÁK. Sapientia EMTE

Országzászlók (2015. május 27., Sz14)

10. gyakorlat Tömb, mint függvény argumentum

Programozási alapismeretek :: beadandó feladat. Felhasználói dokumentáció. Molnár Tamás MOTIABT.ELTE

Programozás alapjai 9.Gy: Struktúra 2.

C++ programozási nyelv Struktúrák a C++ nyelvben Gyakorlat

Megoldott programozási feladatok standard C-ben

Párhuzamos genetikus algoritmus

Információs Technológia

Programozás C- és Matlab nyelven C programozás kurzus BMEKOKAM603 Függvények. Dr. Bécsi Tamás 6. Előadás

Programozás alapjai 5. gyakorlat Vezérlési szerkezetek egymásba ágyazása

11. gyakorlat Sturktúrák használata. 1. Definiáljon dátum típust. Olvasson be két dátumot, és határozza meg melyik a régebbi.

Programozás alapjai 1. (BMEVIEEA100)

Programozás alapjai 8.Gy: Program struktúra

Programozás C nyelven (3. ELŐADÁS) Sapientia EMTE

Programozás alapjai C nyelv 4. gyakorlat. Mit tudunk már? Feltételes operátor (?:) Típus fogalma char, int, float, double

C programozás. { Márton Gyöngyvér, 2009 } { Sapientia, Erdélyi Magyar Tudományegyetem }

Programozás I. gyakorlat

6. gyakorlat Egydimenziós numerikus tömbök kezelése, tömbi algoritmusok

Megoldott programozási feladatok standard C-ben

Emlékeztetők. Számítástechnika 10.

Szövegek C++ -ban, a string osztály

Adatszerkezetek és algoritmusok

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

Programozás. (GKxB_INTM021) Dr. Hatwágner F. Miklós május 6. Széchenyi István Egyetem, Gy r

Programozás alapjai 2.Gy: A C nyelv alapjai P R O

INFORMATIKA tétel 2018

Programozás C- és Matlab nyelven C programozás kurzus BMEKOKAM603 Mutatók. Dr. Bécsi Tamás 7. Előadás

Programozási Nyelvek (C++) Gyakorlat

1. Írjunk programot mely beolvas két számot és ellenőrzi hogy mindkét szám zérus-e:

Óbudai Egyetem. C programozási nyelv

B I T M A N B I v: T M A N

Internet programozása. 3. előadás

C változók. Feladat: Deklaralj egy valos, egy karakter es ket egesz tipusu valtozot! int main() {

Mutatók. Programozás II. Hatwágner F. Miklós március 4. Széchenyi István Egyetem, Gy r

7/8. gyakorlat Karaktertömbök és sztringkezelés

III. Adatszerkezetek és algoritmusok

2.3. A C nyelv utasításai

Programozás C++ -ban 2007/4

A C programozási nyelv V. Struktúra Dinamikus memóriakezelés

12. gyakorlat Enum; Tárolási osztályok Preprocesszor utasítások; Moduláris programozás

Bevezetés a programozásba I 10. gyakorlat. C++: alprogramok deklarációja és paraméterátadása

Emlékeztet! matematikából

Programozás C nyelven (13. ELŐADÁS) Sapientia EMTE

Mérnöki programozás 7. Szerkesztette: dr. Vass Péter Tamás

Hardver modellezés SystemC-vel és SDL grafikus könyvtárral Visual Stúdió alatt

Számítógépes grafika

Programozás alapjai 3.Gy: C elágazások, ciklusok P R O

tétel: különböző típusú adatokat csoportosít, ezeket egyetlen adatként kezeli, de hozzáférhetünk az elemeihez is

Programozás 5. Dr. Iványi Péter

Elemi alkalmazások fejlesztése I. Olvassunk be egy fájlból egész számokat egy tömbbe. Keressük meg a tömb valamely

Függvények. Programozás I. Hatwágner F. Miklós november 16. Széchenyi István Egyetem, Gy r

Preprocesszor. Programozás alapjai C nyelv 11. gyakorlat. Makrók (2) Makrók (#define) Makrók (3) #include

Programozás alapjai C nyelv 11. gyakorlat. Preprocesszor. Makrók (#define)

Szerző Lővei Péter LOPSAAI.ELTE IP-08PAEG/25 Daiki Tennó

C# nyelv alapjai. Krizsán Zoltán 1. Objektumorientált programozás C# alapokon tananyag. Általános Informatikai Tanszék Miskolci Egyetem

Szoftverminőségbiztosítás

Járműfedélzeti rendszerek II. 2. előadás Dr. Bécsi Tamás

Programozás I gyakorlat. 10. Stringek, mutatók

Dinamikus csatolású függvénykönyvtár készítése és használata Plugin-szerű betöltés Egyszeű C++ osztályok készítése

Vezérlési szerkezetek

Miről lesz ma szó? A PROGAMOZÁS ALAPJAI 1. Dinamikus változók. Dinamikus változók. Dinamikus változók. Dinamikus változók. 7.

Algoritmusok raszteres grafikához

Körkörös listák. fej. utolsó. utolsó. fej

Mit tudunk már? Programozás alapjai C nyelv 4. gyakorlat. Legnagyobb elem keresése. Feltételes operátor (?:) Legnagyobb elem keresése (3)

Egységes és objektumközpontú adatbázis-kezelés (2. rész)

Tervminták a valósidejű gyakorlatban

Szerző. Varga Péter ETR azonosító: VAPQAAI.ELTE cím: Név: Kurzuskód:

Struktúrák (struct) A struktúra szerkezetét meghatározó deklaráció általános formája:

Maximum kiválasztás tömbben

C programozás. 6 óra Függvények, függvényszerű makrók, globális és

INFORMATIKA tétel 2017

Programozás alapjai C nyelv 5. gyakorlat. Írjunk ki fordítva! Írjunk ki fordítva! (3)

Algoritmizálás + kódolás C++ nyelven és Pascalban

Párhuzamos és Grid rendszerek

Párhuzamos és Grid rendszerek. Áttekintés. Szálak. Eddig általános eszközöket láttunk, melyek

e) Írj kódrészletet, mely az int d változó utolsó előtti bitjét 1-re állítja.

Bevezetés a C++ programozási nyelvbe

Példák tematikus csoportosításban

M veletek és kifejezések

Programozás alapjai C nyelv 9. gyakorlat. Rekurzió. Rekurzív algoritmus

Bevezetés a C programozási nyelvbe. Az Általános Informatikai Tanszék C nyelvi kódolási szabványa

Objektumorientált Programozás III.

Adminisztrációs feladatok Strukturált programok A C programnyelv elemei

Mutatók és címek (ism.) Programozás alapjai C nyelv 8. gyakorlat. Indirekció (ism) Néhány dolog érthetőbb (ism.) Változók a memóriában

A C programozási nyelv VI. Parancssori argumentumok File kezelés

Programozás alapjai C nyelv 8. gyakorlat. Mutatók és címek (ism.) Indirekció (ism)

Matematikai alapok. Dr. Iványi Péter

Programozás 1. Dr. Iványi Péter

Járműfedélzeti rendszerek II. 4. előadás Dr. Bécsi Tamás

malloc free malloc free int sum(int a[4]) { return a[0] + a[1] + a[2] + a[3]; }

Németh Levente Gyorstalpaló C programozás ÓE-KVK. Bevezető

Átírás:

main int main(int argc, char* argv[]) { return 0; main main int int main int return 0; main (int argc, char* argv[]) main

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0;

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; double

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; double

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; double

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; double

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; double

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; sqrt printf

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a, b, c; double d, r1, r2; a = 1.0; b = 3.0; c = 2.0; d = b * b - 4 * a * c; d = sqrt(d); r1 = (-b + d) / (2 * a); r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; sqrt printf #include

roots.c gcc -lm -o roots roots.c $ ls -la total 3 drwxrwxrwx 1 dobos dobos 512 Sep 1 16:47. drwxrwxrwx 1 dobos dobos 512 Sep 1 15:24.. -rw-r--r-- 1 dobos dobos 740 Sep 1 16:47 roots.c $ gcc -lm -o roots roots.c roots $ ls -la total 4 drwxrwxrwx 1 dobos dobos 512 Sep 1 16:47. drwxrwxrwx 1 dobos dobos 512 Sep 1 15:24.. -rw-r--r-- 1 dobos dobos 740 Sep 1 16:47 roots.c -rwxr-xr-x 1 dobos dobos 1798 Sep 1 16:52 roots $./roots r1 = -1.000000, r2 = -2.000000

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a = 1.0; double b = 3.0; double c = 2.0; double d = sqrt(b * b - 4 * a * c); double r1 = (-b + d) / (2 * a); double r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0;

#include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a = 1.0; double b = 3.0; double c = 2.0; double d = sqrt(b * b - 4 * a * c); double r1 = (-b + d) / (2 * a); double r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0;

$./roots 1 3 2

$./roots 1 3 2 main atof

$./roots 1 3 2 main atof #include <stdlib.h> #include <stdio.h> #include <math.h> int main(int argc, char* argv[]) { double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); double d = sqrt(b * b - 4 * a * c); double r1 = (-b + d) / (2 * a); double r2 = (-b - d) / (2 * a); printf("r1 = %f, r2 = %f\n", r1, r2); return 0; argc argv

if #include <stdio.h> #include <stdlib.h> #include <math.h> int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); double d = b * b - 4 * a * c; if (d < 0) { printf("no real solution.\n"); exit(-1); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); return 0; if

if #include <stdio.h> #include <stdlib.h> #include <math.h> int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); double d = b * b - 4 * a * c; if (d < 0) { printf("no real solution.\n"); exit(-1); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); return 0; if

if #include <stdio.h> #include <stdlib.h> #include <math.h> int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); double d = b * b - 4 * a * c; if (d < 0) { printf("no real solution.\n"); exit(-1); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); return 0; if else else

main argv if else else if if exit(0);

if #include <stdio.h> #include <stdlib.h> #include <math.h> int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); return -1; double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); double d = b * b - 4 * a * c; if (d < 0) { printf("no real solution.\n"); return -1; else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); return 0; if(...) else {... }

if #include <stdio.h> #include <stdlib.h> #include <math.h> int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); return -1; double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); double d = b * b - 4 * a * c; if (d < 0) { printf("no real solution.\n"); return -1; else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); return 0; if(...) else {... } if

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0;

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0;

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; main

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; main {... } return exit

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; main {... } return exit

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; függvénynév(...)

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; függvénynév(...)

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c) { return b * b - 4 * a * c; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; return return return

1,2 = ± 2 4 2 + - + - * / % ==!= < > <= >=

1 = + 2 4 2 (-b + sqrt(b * b - 4 * a * c)) / 2 * a (-b + sqrt(b * b - 4 * a * c)) / 2 / a -b + sqrt(b * b - 4 * a * c) / (2 * a) -(b + sqrt(b * b - 4 * a * c)) / (2 * a) -(b - sqrt(b * b - 4 * a * c)) / (2 * a) (-b + sqrt((b * b) - (4 * a * c))) / (2 * a) -b / 2 / a + sqrt(b * b - 4 * a * c) / 2 / a

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c); void roots(double a, double b, double c); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); double discr(double a, double b, double c) { return b * b - 4 * a * c; ;

#include <stdio.h> #include <stdlib.h> #include <math.h> double discr(double a, double b, double c); void roots(double a, double b, double c); int main(int argc, char* argv[]) { if (argc < 4) { printf("not enough arguments.\n"); exit(-1); double a = atof(argv[1]); double b = atof(argv[2]); double c = atof(argv[3]); roots(a, b, c); return 0; void roots(double a, double b, double c) { double d = discr(a, b, c); if (d < 0) { printf("no real solution.\n"); exit(-1); else if (d == 0) { double r = -b / 2 / a; printf("r = %f\n", r); else { d = sqrt(d); double r1 = (-b - d) / 2 / a; double r2 = (-b + d) / 2 / a; printf("r1 = %f, r2 = %f\n", r1, r2); double discr(double a, double b, double c) { return b * b - 4 * a * c; ;

1 = 1 2 = 1 = 2 + 1 int

#include <stdio.h> #include <stdlib.h> void fibo(int n) { int a = 0, b = 1; int i = 0; while (i < n) { int c = a + b; a = b; b = c; printf("%d\n", a); i++; int main(int argc, char* argv[]) { // Process command-line arguments if (argc < 2) { printf("missing argument.\n"); exit(-1); int n = atoi(argv[1]); fibo(n); return 0; main

#include <stdio.h> #include <stdlib.h> void fibo(int n) { int a = 0, b = 1; int i = 0; while (i < n) { int c = a + b; a = b; b = c; printf("%d\n", a); i++; int main(int argc, char* argv[]) { // Process command-line arguments if (argc < 2) { printf("missing argument.\n"); exit(-1); int n = atoi(argv[1]); fibo(n); return 0; main fibo n main a b i

#include <stdio.h> #include <stdlib.h> void fibo(int n) { int a = 0, b = 1; int i = 0; while (i < n) { int c = a + b; a = b; b = c; printf("%d\n", a); i++; int main(int argc, char* argv[]) { // Process command-line arguments if (argc < 2) { printf("missing argument.\n"); exit(-1); int n = atoi(argv[1]); fibo(n); return 0; main fibo n main a b i

#include <stdio.h> #include <stdlib.h> void fibo(int n) { int a = 0, b = 1; int i = 0; while (i < n) { int c = a + b; a = b; b = c; printf("%d\n", a); i++; int main(int argc, char* argv[]) { // Process command-line arguments if (argc < 2) { printf("missing argument.\n"); exit(-1); int n = atoi(argv[1]); fibo(n); return 0; main fibo n main a b i while(...)

while(i < n) { } do { } while (i < n); ; for (...) { }

int i = 0; while (i < 100) { // do something i++; for (int i = 0; i < 100; i++) { // do something

for ( [init] ; [condition] ; [increment] ) { // do something

for ( [init] ; [condition] ; [increment] ) { // do something while

for ( [init] ; [condition] ; [increment] ) { // do something while

for (int i = 0; i < 100; i++) { for (int j = 0; j < 20; j++) { // do something for (int i = 0; i < 100; i++) { for (int j = 0; j < i; j ++) { // do something for (int i = 99; i >= 0; i--) { // do something

1 i + 1 i - 1 for do while

break break for while while (hasnext()) { // do something // exit loop if escape key is hit if (isescape()) { break; // do something else

continue continue for i++ while for (int i = 0; i < 100; i++) { if (i % 7!= 0) continue; printf("%d\n", i);