Commit f0d1d2b4 authored by Paffenholz, Andreas's avatar Paffenholz, Andreas

Kapitel 7 und 8

parent a140838e
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Fibonaccizahlen rekursiv
*
* Uebersetzen mit
* gcc fibonacci.c -o fibonacci
* Aufruf mit
* ./fibonacci 10
**************************************/
#include <stdio.h>
#include <stdlib.h>
long fibonacci(int n) {
//printf("Aufruf mit %d\n",n);
if ( n <= 1) {
return 1;
} else {
return fibonacci(n-1)+fibonacci(n-2);
}
}
int main(int argc, char** argv) {
int n = atoi(argv[1]);
printf("Die %d-te Fibnaccizahl ist %ld\n",n,fibonacci(n));
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Fibonaccizahlen rekursiv, mit Dict
*
* Uebersetzen mit
* gcc fibonacci_mit_dict.c -o fibonacci_mit_dict
* Aufruf mit
* ./fibonacci_mit_dict 10
**************************************/
#include <stdio.h>
#include <stdlib.h>
#define MAX_FIB 1000
long fibonacci(int n) {
//printf("Aufruf mit %d\n",n);
static long fib[MAX_FIB] = { 1, 1};
static int max_index = 1;
if (n > max_index ) {
fib[n] = fibonacci(n-1)+fibonacci(n-2);
max_index = n;
}
return fib[n];
}
int main(int argc, char** argv) {
int n = atoi(argv[1]);
printf("Die %d-te Fibnaccizahl ist %ld\n",n,fibonacci(n));
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* groesster gemeinsamer Teiler mit dem erweiterten euklidischen Algorithmus
*
* Uebersetzen mit
* gcc ggt_erweitert.c -o ggt_erweitert
* Aufruf mit
* ./ggt_erweitert 35 63
**************************************/
#include <stdio.h>
#include <stdlib.h>
long long gcd(long long a, long long b, long long* x, long long* y) {
if (b == 0) {
return a;
}
long long g = gcd(b, a%b, x, y);
long long temp = *x;
*x = *y;
*y = temp - (a/b) * *y;
return g;
}
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long x = 1,y = 0;
long long g = gcd(a, b, &x, &y);
printf("gcd(%lld, %lld) = %lld = %lld*%lld + %lld*%lld\n", a, b, g, x, a, y, b);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Erweiterter Euklidischer Algorithmus
*
* Uebersetzen mit
* gcc ggt_erweitert_v2.c -o ggt_erweitert_v2
* Aufruf mit
* ./ggt_erweitert_v2 106 28
**************************************/
#include <stdio.h>
#include <stdlib.h>
long long ggt(long long a, long long b, long long* x, long long* y) {
if (b == 0) {
*x = 0;
*y = 1;
return a;
}
long long g = ggt(b, a%b, y, x);
*x = *x - (a/b) * *y;
return g;
}
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long x, y;
long long g = ggt(a, b, &y, &x);
printf("ggt(%lld, %lld) = %lld = %lld*%lld + %lld*%lld\n", a, b, g, x, a, y, b);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* groesster gemeinsamer Teiler ueber Teilem mit Rest
*
* Uebersetzen mit
* gcc ggt_rekursiv.c -o ggt_rekursiv
* Aufruf mit
* ./ggt_rekursiv 35 63
**************************************/
#include <stdio.h>
#include <stdlib.h>
long long gcd ( long long a, long long b) {
return b ? gcd(b,a%b) : a;
}
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long g = gcd(a,b);
printf("Der groesste gemeinsame Teiler von %lld und %lld ist %lld\n",a,b,g);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* groesster gemeinsamer Teiler ueber Durchtesten
*
* Uebersetzen mit
* gcc ggt_v1.c -o ggt_v1
* Aufruf mit
* ./ggt_v1 35 63
**************************************/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long ggt = 0;
for ( long long i = b; i > 0; --i ) {
if ( a % i == 0 && b % i == 0 ) {
ggt = i;
break;
}
}
printf("Der groesste gemeinsame Teiler von %lld und %lld ist %lld\n",a,b,ggt);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* groesster gemeinsamer Teiler uber sukzessive Subtraktion
*
* Uebersetzen mit
* gcc ggt_v2.c -o ggt_v2
* Aufruf mit
* ./ggt_v2 35 63
**************************************/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long at = a;
long long bt = b;
while ( bt != 0 ) {
long long r = at - bt;
if ( bt > r ) {
at = bt;
bt = r;
} else {
at = r;
}
}
printf("Der groesste gemeinsame Teiler von %lld und %lld ist %lld\n",a,b,at);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* groesster gemeinsamer Teiler uber sukzessive Subtraktion
*
* Uebersetzen mit
* gcc ggt_v2_zeitmessung.c -o ggt_v2_zeitmessung
* Aufruf mit
* ./ggt_v2_zeitmessung 35 63
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long at = a;
long long bt = b;
clock_t start, end;
start = clock(); // Start der Zeitmessung
while ( bt != 0 ) {
long long r = at - bt;
if ( bt > r ) {
at = bt;
bt = r;
} else {
at = r;
}
}
end = clock(); // Ende der Zeitmessung
// Gemessen werden hier Prozessortakte
// Zur Umwandlung muessen wir also noch durch die Taktrate dividieren
double time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("Der groesste gemeinsame Teiler von %lld und %lld ist %lld\n",a,b,at);
printf("Die Berechnung hat %f Sekunden benötigt\n", time_used);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* groesster gemeinsamer Teiler ueber Teilem mit Rest
*
* Uebersetzen mit
* gcc ggt_v3.c -o ggt_v3
* Aufruf mit
* ./ggt_v3 35 63
**************************************/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long at = a;
long long bt = b;
while ( bt != 0 ) {
int r = at % bt;
at = bt;
bt = r;
}
printf("Der groesste gemeinsame Teiler von %lld und %lld ist %lld\n",a,b,at);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* groesster gemeinsamer Teiler ueber Teilem mit Rest
*
* Uebersetzen mit
* gcc ggt_v3_zeitmessung.c -o ggt_v3_zeitmessung
* Aufruf mit
* ./ggt_v3_zeitmessung 35 63
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char** argv) {
long long a = atoll(argv[1]);
long long b = atoll(argv[2]);
if ( a < b ) {
long long c = a;
a = b;
b = c;
}
long long at = a;
long long bt = b;
clock_t start, end;
start = clock(); // Start der Zeitmessung
while ( bt != 0 ) {
long long r = at % bt;
at = bt;
bt = r;
}
end = clock(); // Ende der Zeitmessung
// Gemessen werden hier Prozessortakte
// Zur Umwandlung muessen wir also noch durch die Taktrate dividieren
double time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("Der groesste gemeinsame Teiler von %lld und %lld ist %lld\n",a,b,at);
printf("Die Berechnung hat %f Sekunden benötigt\n", time_used);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Ausgabe in eine Datei mit fputs
*
* Uebersetzen mit
* gcc auslesen_fputs_01.c -o auslesen_fputs_01
* Aufruf mit
* ./auslesen_fputs_01 matrix.dat matrix_out.dat
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LINE_LENGTH 100
#define MAX_DIGITS 2
int main(int argc, char** argv) {
char* fname = argv[1];
char *fname_out = argv[2];
FILE * fh = fopen(fname,"r");
if ( fh == NULL ) {
printf("Datei nicht lesbar\n");
exit(1);
}
char line[LINE_LENGTH] = "";
int zeilen = 0;
int spalten = 0;
fscanf(fh,"%d %d\n",&zeilen,&spalten);
int mat[zeilen][spalten];
char* teilkette;
char begrenzer[2] = " "; // an Leerzeichen trennen, Laenge 2 wegen \0
int s = 0;
int z = 0;
while( fgets(line,LINE_LENGTH,fh) ) {
s = 0;
teilkette = strtok(line,begrenzer);
while ( teilkette != NULL ) {
mat[z][s++] = atoi(teilkette);
teilkette = strtok(NULL,begrenzer);
}
z++;
}
fclose(fh);
fh = fopen(fname_out,"w"); // zum Schreiben oeffnen
if ( fh == NULL ) {
printf("Datei nicht schreibbar\n");
exit(1);
}
char outstring[LINE_LENGTH] = "";
sprintf(outstring,"%d %d\n", zeilen, spalten);
fputs(outstring, fh);
for (int i = 0; i < z; ++i ) {
outstring[0] = '\0';
for (int j = 0; j < s; ++j ) {
char n[MAX_DIGITS+2]; // fuer Leerzeichen zwischen Eintraegen und \0
sprintf(n,"%d ", mat[i][j]);
strcat(outstring, n);
}
strcat(outstring, "\n");
fputs(outstring, fh);
}
fclose(fh);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Ausgabe in eine Datei oder den Bildschirm mit fputs
*
* Uebersetzen mit
* gcc auslesen_fputs_02.c -o auslesen_fputs_02
* Aufruf mit
* ./auslesen_fputs_02
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void printHelp() {
printf("Variable Ausgabe\n(c) Einfuehrung in die Programmierung 1\n");
printf("\nOptionen:\n");
char* fmtString = " %-10s -- %s\n";
printf(fmtString, "-o <Datei>","Ausgabe in Datei");
printf(fmtString, "-h","diese Hilfe :)");
}
int main(int argc, char** argv) {
int option_o = 0;
FILE * fh = stdout;
for ( int i = 1; i < argc; ++i ) {
if (strcmp(argv[i],"-h") == 0) {
printHelp();
return 0;
}
if (strcmp(argv[i],"-o") == 0) {
option_o = 1;
fh = fopen(argv[++i],"w"); // zum Schreiben oeffnen
if ( fh == NULL ) {
printf("Datei nicht schreibbar\n");
exit(1);
}
}
}
fprintf(fh,"EInfuehrung in die Programmierung 1\n");
if ( option_o ) {
fclose(fh);
}
return 0;
}
Einfuehrung in die Programmierung 1
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Eingabe mit scanf
*
* Uebersetzen mit
* gcc eingabe_01.c -o eingabe_01
* Aufruf mit
* ./eingabe_01
**************************************/
#include <stdio.h>
int main() {
int n;
scanf("Geben Sie eine Zahl ein: %d",&n);
printf("Es wurde %d eingegeben\",n);
return 0;
}