Useful Programs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

//Palindrome Number Check Program in C


#include <stdio.h>

int main() {
    int n, n1, rev = 0, rem;
    
    printf("Enter any number: ");
    scanf("%d", &n);    
    n1 = n;
    
    /* logic */    while (n > 0){
        rem = n % 10;
        rev = rev * 10 + rem;
        n = n / 10;
    }
    
    if (n1 == rev){
        printf("Given number is a palindromic number"); 
    }
    else{
        printf("Given number is not a palindromic number"); 
    }    
    return 0; 
}

Last edited on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

//Program : Reverse String Without Using Library Function

#include<stdio.h>
#include<string.h>
 
int main() {
   char str[100], temp;
   int i, j = 0;
 
   printf("\nEnter the string :");
   gets(str);
 
   i = 0;
   j = strlen(str) - 1;
 
   while (i < j) {
      temp = str[i];
      str[i] = str[j];
      str[j] = temp;
      i++;
      j--;
   }
 
   printf("\nReverse string is :%s", str);
   return (0);
}

Last edited on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

//BubbleSort

#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>


void bubbleMusterloesung (uint8_t A[], uint16_t N) {

    uint8_t buffer;

    for (int i=0; i<N; i++)
        for (int j=0; j<N-1-i; j++)
            if (A[j] > A[j+1]) {
                // beide Elemente vertauschen
                buffer = A[j];
                A[j] = A[j+1];
                A[j+1] = buffer;
            }

    return;
}


void check (int (*fun)(uint8_t[],uint16_t), uint8_t A[], uint16_t N) {

    // Kopie des Eingabearrays erstellen
    uint8_t B[N];
    memcpy(B, A, N);

    // Studentenloesung aufrufen
    fun(A,N);

    // Musterloesung aufrufen
    bubbleMusterloesung(B,N);

    // Ergebnis des Vergleichs ausgeben
    printf ("Pruefe Array mit %d Elementen...%s\n", N, (0 == memcmp(A,B,N)) ? "korrekt" : "nicht korrekt");

    return;
}


void verify(int (*fun)(uint8_t[], uint16_t)) {

    uint8_t A[] = { 4,3,5,4,6,7,1,9 };
    check (fun, A, 8);

    uint8_t B[] = { 4,3,5,4,6,7,1 };
    check (fun, B, 7);

    uint8_t C[] = { 4 };
    check (fun, C, 1);

    uint8_t D[] = { };
    check (fun, D, 0);

    // Array zufälliger Länge basteln
    srand (time(NULL));
    uint16_t N = rand() % 1000 + 1;
    uint8_t E[N];
    for (int i=0; i<N; i++) {
        E[i] = rand() % 255;
        printf("%d ", E[i]);
    }

    check (fun, E, N);

    return;
}

Last edited on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

//PlatonischerKoerper

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "koerper.h"

void einlesen(PlatonischerKoerper * const d) {

    printf("Bitte geben Sie die Seitenlänge ein: ");
    scanf("%hi", &(d->a));

    printf("Bitte geben Sie die Koerperform ein: ");
    char * puffer = (char*)calloc(60, sizeof(char));
    scanf("%s", puffer);
    d->form = puffer;

    return;
}

double volumen(PlatonischerKoerper * const p) {

    if (0 == strcmp("tetraeder", p->form))
        return pow(p->a, 3.f) / 12.f * sqrt(2.f);

    if (0 == strcmp("dodekaeder", p->form))
        return pow(p->a, 3.f) / 4.f * (15.f + 7.f * sqrt(5));

    return 0.f;
}

int main() {

    PlatonischerKoerper p = {0};

    einlesen(&p);
    printf ("Seite: %hi\n", p.a);
    printf ("Form:  %s\n", p.form);

    double V = volumen(&p);
    printf("Fläche: %f\n", V);

    return 0;
}

Last edited on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//ArraySuche
#include <stdlib.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>

bool contains (int value, int *B, int N) {
	
    for (int i=0; i<N; i++)
        if (value == B[i])
            return true;

    return false;
}

int solution(int A[], int M, int B[], int N) {

    int erg = 3001;

    for (int i=0; i<M; i++)
        if (contains(A[i], B, N) && erg > A[i])
            erg = A[i];

    return erg != 3001 ? erg : -1;
}

Last edited on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//kleinste positive ganze Zahl n berechnen


const char * fun2017_gut (unsigned int divisor) {

    char * buffer = (char*) calloc(1024,sizeof(char));
    long long unsigned int n = 0;

    do {
        n+=divisor;
        sprintf(buffer, "%llu", n);
    } while(false == check(buffer));


    return buffer;
}



int main()
{
    verify(fun2017, 17);

     return 0;
}

Last edited on
//Kleinbuchstaben
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>


void upperCase(char const * const fname)
{
    // Nachschauen, wie gross die Datei ist.

    FILE * fileHandle = fopen(fname, "r");

    if (NULL == fileHandle)
    {
        fprintf(stderr, "FEHLER! Konnte Datei '%s' nicht oeffnen.\n", fname);
        return;
    }

    fseek(fileHandle, 0, SEEK_END);     // Wenn man fseek nicht kennt, kann man mit fgetc() auch durchzaehlen, wie lang die
                                        // Datei ist. Oder man liest die Datei nicht erst in einen Puffer, sondern liest weiter
                                        // unten immer nur Zeichenweise aus der Datei und wandelt ggf. in Grossbuchstaben.
                                        // Viele Wege fuehren nach Rom!
    int fileSize = ftell(fileHandle);
    rewind(fileHandle);

    // Eingabedatei komplett in einen Puffer einlesen.

    char * buffer = (char*) calloc(1+fileSize, sizeof(char));

    int n = fread(buffer, sizeof(char), fileSize, fileHandle);
    fclose(fileHandle);

    if (n != fileSize)
        fprintf(stderr, "FEHLER! Konnte nur %d von %d Zeichen lesen.", n, fileSize);

    // Anfangsbuchstaben veraendern.

    char *p = buffer;

    // Fuer alle eingelesenen Zeichen bis zur terminierenden Null:
    while(*p)
    {
        // Begonnen wird mit dem Anfang eines Wortes. Das Zeichen soll immer ein Grossbuchstabe sein.
        *p = toupper(*p);
        p++;

        // Vorspulen zum Anfang des naechsten Wortes:
        // erst alle Buchstaben ueberspringen
        while (*p && !isspace(*p))
            p++;
        // dann alle Leerzeichen ueberspringen
        while (*p && isspace(*p))
            p++;
    }

    // Puffer komplett in Datei schreiben

    fileHandle = fopen(fname, "w");

    if (NULL == fileHandle)
    {
        fprintf(stderr, "FEHLER! Konnte Datei '%s' nicht oeffnen.\n", fname);
        return;
    }

    n = fwrite(buffer, sizeof(char), fileSize, fileHandle);

    if (n != fileSize)
        fprintf(stderr, "FEHLER! Konnte nur %d von %d Zeichen schreiben.", n, fileSize);

    fclose(fileHandle);
    return;
}

int main()
{
    char const * const fname = "lipsum.txt";
    upperCase(fname);

    return EXIT_SUCCESS;
}

Last edited on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

/**
 * Beispielcode zu Lektion 10: Strukturen
 *
 * Einfach eine der 4 Varianten auswählen und die Kommentarzeichen vor dem entsprechenden
 * #define entfernen.
 *
 */
#include <stdio.h>
#include <stdlib.h>

//#define VARIANTE_A
#ifdef VARIANTE_A

struct auslauf {
    char *	beschreibung;
    float	dauer;
};

struct speise {
    char *	zutaten;
    float	menge;
};

struct vorlieben {
    struct speise	nahrung;
    struct auslauf	workout;
};

struct fisch {
    char * 			name;
    char * 			art;
    int 			zaehne;
    int 			alter;
    struct vorlieben	pflege;
};

void katalogAusgeben (struct fisch f) {
    printf("%s ist ein %s mit %d Zaehnen. Er ist %d Jahre alt.\n",
           f.name, f.art, f.zaehne, f.alter);
    return;
}

void schildAusgeben (struct fisch f) {
    printf("Name: %s\nArt: %s\n%d Jahre alt, %d Zaehne\n",
           f.name, f.art, f.alter, f.zaehne);
    return;
}

int main () {

    struct fisch snappy = { "Snappy", "Piranha", 69, 4 };

    katalogAusgeben (snappy);
    schildAusgeben  (snappy);
    return 0;
}

#endif // VARIANTE_A

//#define VARIANTE_B
#ifdef VARIANTE_B

struct auslauf {
    char *	beschreibung;
    float	dauer;
};

struct speise {
    char *	zutaten;
    float	menge;
};

struct vorlieben {
    struct speise	nahrung;
    struct auslauf	workout;
};

struct fisch {
    char * 			name;
    char * 			art;
    int 			zaehne;
    int 			alter;
    struct vorlieben	pflege;
};

void katalogAusgeben (struct fisch f) {
    printf("%s ist ein %s mit %d Zaehnen. Er ist %d Jahre alt.\n%s braucht jeden Tag %.1fg %s um %.1f Stunden %s zu koennen.\n\n",
           f.name, f.art, f.zaehne, f.alter,
           f.name, f.pflege.nahrung.menge, f.pflege.nahrung.zutaten,
           f.pflege.workout.dauer, f.pflege.workout.beschreibung);
    return;
}

void schildAusgeben (struct fisch f) {
    printf("Name: %s\nArt: %s\n%d Jahre alt, %d Zaehne\n",
           f.name, f.art, f.alter, f.zaehne);
    return;
}

int main () {

    //struct auslauf snappyWorkout = ;
    //struct speise nahrung = ;
    //struct vorlieben pflege = ;
    struct fisch snappy = { .name="Snappy", .art="Piranha", .zaehne=69, .alter=4,
        .pflege= {  .nahrung= { .zutaten="Fleisch", .menge=100.f },
                    .workout= { .beschreibung="schwimmen", .dauer=7.5 }
                 }
    };

    katalogAusgeben (snappy);
    schildAusgeben  (snappy);
    return 0;
}

#endif // VARIANTE_B

//#define VARIANTE_C
#ifdef VARIANTE_C

struct fisch {
    char * 	name;
    char * 	art;
    int 	zaehne;
    int 	alter;
};

void zahnarzt (struct fisch * f) {
    (*f).zaehne -= 1;
    return;
}

int main () {

    struct fisch blinky = { "Blinky", "Mutant", 23, 2 };

    printf ("%s hat %d Zaehne.\n", blinky.name, blinky.zaehne);
    zahnarzt (&blinky);
    printf ("%s hat %d Zaehne.\n", blinky.name, blinky.zaehne);

    return 0;
}

#endif // VARIANTE_C

//#define VARIANTE_D
#ifdef VARIANTE_D

struct fisch {
    char * 	name;
    char * 	art;
    int 	zaehne;
    int 	alter;
};

const static struct fisch DEFAULT_FISCH = {"Anonym", "Unbekannt", -1, -1 };

void katalogAusgeben (const struct fisch * f) {
    printf("%s ist ein %s mit %d Zaehnen. Er ist %d Jahre alt.\n",
           f->name, f->art, f->zaehne, f->alter);
    return;
}

int main () {
    struct fisch * blinky = calloc (sizeof(struct fisch), 1);

    *blinky = DEFAULT_FISCH;

    printf("Address of Default Fisch: %p\n", &DEFAULT_FISCH);
    printf("Address of Blinky       : %p\n", blinky);

    katalogAusgeben(blinky);
    free (blinky);

    return 0;
}
#endif // VARIANTE_D 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// multiplication by recursively adding
#include <stdio.h>

unsigned int multiply(unsigned int x, unsigned int y)
{
    if (x == 1)
    {
        /* Terminating case */
        return y;
    }
    else if (x > 1)
    {
        /* Recursive step */
        return y + multiply(x-1, y);
    }

    /* Catch scenario when x is zero */
    return 0;
}

int main() {
    printf("3 times 5 is %d", multiply(3, 5));
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//Dynamic Memory Allocation for Arrays

int nrows = 2;
int ncols = 5;
int i, j;

// Allocate memory for nrows pointers
char **pvowels = (char **) malloc(nrows * sizeof(char *));

// For each row, allocate memory for ncols elements
pvowels[0] = (char *) malloc(ncols * sizeof(char));
pvowels[1] = (char *) malloc(ncols * sizeof(char));

pvowels[0][0] = 'A';
pvowels[0][1] = 'E';
pvowels[0][2] = 'I';
pvowels[0][3] = 'O';
pvowels[0][4] = 'U';

pvowels[1][0] = 'a';
pvowels[1][1] = 'e';
pvowels[1][2] = 'i';
pvowels[1][3] = 'o';
pvowels[1][4] = 'u';

for (i = 0; i < nrows; i++) {
    for(j = 0; j < ncols; j++) {
        printf("%c ", pvowels[i][j]);
    }

    printf("\n");
}

// Free individual rows
free(pvowels[0]);
free(pvowels[1]);

// Free the top-level pointer
free(pvowels);
Cool! This looks like C though. Not even a single C++ header included :(
Topic archived. No new replies allowed.