Useful Programs

[barracuda]

//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; 
}

[barracuda]

//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);
}

[barracuda]

//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;
}

[barracuda]

//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;
}

[barracuda]

//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;
}

[barracuda]

//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;
}

[barracuda]

//Kleinbuchstaben

#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;
}

[barracuda]

/**
 * 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 

[barracuda]

// 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;
}

[barracuda]

//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);

[icy1]

Cool! This looks like C though. Not even a single C++ header included :(