C_Kurs_8Blatt

/*
Willkommen zum achten Aufgabenblatt vom Programmierkurs. Auf diesem Aufabenblatt geht es um Pointer und Arrays.

Um die Tests für dieses Blatt zu kompilieren und zu starten, führen Sie den folgenden Befehl aus:
cc -std=c11 -g -Wall 08ex_test.c -o 08ex_test.o -lm && ./08ex_test.o
*/

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include "turtlecanvas.h"

/*
Aufgabe 1a:
Lesen Sie das Headerfile `turtlecanvas.h`. Diese Funktion soll die Turtle `d` Schritte vorwärts machen lassen.
*/
void turtle_advance_by(TurtleCanvas *c, uint32_t d) {

    for(int i=0; i<d; i++) turtle_advance(c);
    return;
}

/*
Aufgabe 1b:
Füllen Sie die Turtlecanvas mit horizontalen, abwechselnd schwarzen und weißen Linien (die unterste Zeile soll
schwarz gefärbt werden). Die Turtle ist anfangs an Position (0, 0), ist nach rechts orientiert, und zeichnet schwarz.
*/
void turtle_stripes(TurtleCanvas *c) {

    int width = canvas_width(c->canvas);
    int height = canvas_height(c->canvas);

    if(height==1) turtle_advance_by(c,width); //wenn canvas 1 zeile hat

    for(int i=0; i<height; i++){

        turtle_advance_by(c,width+1); //faerben die zeile komplett unk kommen links raus
        turtle_rotate_left(c); // position nach oben
        turtle_toggle_color(c); //farbe aendern - zu weiss
        turtle_advance_by(c, 2); //2schritte nach oben - eine weisse zeile damit gemacht
        turtle_rotate_right(c); //guckt jz nach rechts
        turtle_toggle_color(c); //farbe aendern zu schwarz
    }
    return;
}

/*
Aufgabe 1c:
Lesen Sie die Implementierungen der Turtlecanvas-Funktionen weiter unten in der "turtlecanvas.h".
Der Quellcode sollte vollständig verständlich und unüberraschend sein.
Hinweis: Diese Aufgabe wird nicht bewertet.
*/

/*
Aufgabe 2a:
Geben Sie einen Pointer auf das erste Vorkommen der größten Zahl im Eingabearray zurück.
*/
uint16_t *find_maximal_number(uint16_t numbers[], size_t numbers_len) {

    uint16_t maxx = 0;
    uint16_t* ptr;

    for(int i=0; i<numbers_len;i++){
        if (numbers[i] > maxx){
            maxx=numbers[i];
            ptr = &numbers[i];
        }
    }
    return ptr;
}

/*
Aufgabe 2b:
Geben Sie (einen Pointer auf) das Teilarray zurück, welches ab dem ersten Vorkommen der größten Zahl im Eingabearray beginnt.
*/
uint16_t *find_subarray_starting_at_maximal_number(uint16_t numbers[], size_t numbers_len) {

    return find_maximal_number(numbers, numbers_len);
}

/*
Aufgabe 2c:
Geben Sie die größtmögliche Distanz zwischen zwei Zahlenwerten aus dem Array `numbers` zurück.
Beispiel: Im Array {1, 3, 7, 4} ist die größte Distanz die zwischen 1 und 7, und beträgt damit `6`.
*/
uint16_t find_maximum_distance(uint16_t numbers[], size_t numbers_len) {

    int res = 0;

    for(int i=0; i<numbers_len; i++){
        for(int j=i+1; j<numbers_len; j++){
            int current_distance = abs(numbers[j]-numbers[i]);
            if(current_distance > res) res = current_distance;
        }
    }


    return res;
}

/*
Aufgabe 2d:
Geben Sie die kleinstmögliche Distanz zwischen zwei Zahlenwerten aus dem Array `numbers` zurück.
Beispiel: Im Array {1, 3, 7, 4} ist die kleinste Distanz die zwischen 3 und 4, und beträgt damit `1`.
*/
uint16_t find_minimum_distance(uint16_t numbers[], size_t numbers_len) {

    int res = 10000;

    for(int i=0; i<numbers_len; i++){
        for(int j=i+1; j<numbers_len; j++){
            int current_distance = abs(numbers[j]-numbers[i]);
            if(current_distance < res) res = current_distance;
        }
    }

    return res;
}

/*
Aufgabe 2e:
Schreiben Sie die ersten `numbers_len` Quadratzahlen aufsteigend in das gegebene Array `numbers`.
Hinweis: Wir starten bei `1`. Sollte numbers_len also `5` sein, sind die ersten 5 Quadratzahlen bis
einschließlich die von 5 gemeint: 1, 4, 9, 16, 25.
*/
void square_ascending(uint16_t numbers[], size_t numbers_len) {

    for(int i=1; i<=numbers_len; i++){
        //printf("wir sind bei i=%d\n",i);
        numbers[i-1] = i*i;
        //printf("in array schreiben - %d\n", numbers[i-1]);
    }
    return;
}
//meine Funktion fuer debbuging
/*void print_array(uint16_t arrray[], uint16_t len){

    for(int i=0; i<len; i++){
        printf("array[%d] = %d\n", i, arrray[i]);
    }
    return;
}
*/

/*
Aufgabe 2f:
Füllen Sie das Array `out` mit den aufsteigend sortierten Zahlen aus dem `in` Array. Beide Arrays haben die Länge `len`.
Beispiel: Ist `in` {1, 4, 3, 7, 4}, so soll `out` am Ende {1, 3, 4, 4, 7} sein.
*/
void sort_ascending(uint16_t in[], uint16_t out[], size_t len) {

    for(int count=0; count<len; count++){

        //printf("gang nummer %d\n", count);

        int current_min = 1000; //augenblickliches min
        int current_min_pos = len+1; //position vom current min (erstmal nicht definiert deswegen len+1 also ungueltige position

        for(int i=0; i<len; i++){ //die kleinste zahl im array suchen
            if(in[i]<current_min && in[i]!=0){ //betrachtete zahl kleiner als min und wurde nicht ueberschrieben

                current_min = in[i];
                current_min_pos = i;
            }
        } //minimum und seine position gefunden
        //printf("minimum gefunden! und zwar = %d an der position %d\n",current_min, current_min_pos);
        in[current_min_pos] = 0; //mit 0 unseren min ueberschreiben
        //printf("in array now: \n");
        //print_array(in, len);
        out[count] = current_min; //naechste minimale zahl in den output array
        //printf("out array now: \n");
        //print_array(out, len);
    }

    return;
}