Skip to content

Instantly share code, notes, and snippets.

@apertureless

apertureless/ulam.c

Created February 27, 2021 17:45
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save apertureless/3f8b875ab8aaad5aefee4dcfb0d4c4ce to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save apertureless/3f8b875ab8aaad5aefee4dcfb0d4c4ce to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. apertureless created this gist Feb 27, 2021.
    143 changes: 143 additions & 0 deletions ulam.c
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,143 @@

    #include <stdio.h>

    int ulam_max(int a0);
    int ulam_twins(int limit);
    int ulam_twins_s(int limit);
    int ulam_twins_i(int limit);
    int ulam_multiples(int limit, int number);

    int main()
    {
    // printf("Ulam_max: %d\n", ulam_max(5));
    // printf("Ulam_max: %d\n", ulam_max(7));

    // printf("Ulam_twins: %d\n", ulam_twins(5));
    // printf("Ulam_twins_sarah: %d\n", ulam_twins_s(7));
    // printf("Ulam_twins_internet: %d\n", ulam_twins_i(5));

    // printf("Ulam_twins: %d\n", ulam_twins(10));
    // printf("Ulam_twins_sarah: %d\n", ulam_twins_s(10));
    // printf("Ulam_twins_internet: %d\n", ulam_twins_i(10));
    // printf("Ulam_twins: %d\n", ulam_twins(6));
    // printf("Ulam_twins: %d\n", ulam_twins_two(6));

    printf("Ulam_multiples: %d\n", ulam_multiples(10, 2)); // 5
    printf("Ulam_multiples: %d\n", ulam_multiples(1000, 3)); // 972
    printf("Ulam_multiples: %d\n", ulam_multiples(108, 3)); // -1
    printf("Ulam_multiples: %d\n", ulam_multiples(391, 6)); // 386
    printf("Ulam_multiples: %d\n", ulam_multiples(391, 6)); // 386

    return 0;
    }

    int ulam_max(int a0)
    {
    int max = a0;
    int an = a0;

    while (an > 1)
    {
    an = (an % 2 == 0) ? an / 2 : 3 * an + 1;
    max = (max > an) ? max : an;
    }
    return (a0 < 1 ? -1 : max);
    }

    int ulam_twins_i(int limit) {
    int ergebnis;
    int i;

    for (i = 1; i < limit; i++) {
    if (ulam_max(i) == ulam_max(i + 1)) {
    ergebnis = i;
    } else {
    ergebnis = -1;
    }
    }
    return ergebnis;
    }

    // Sarahs implementierung
    // Problem ist, dass schleife nicht abgebrochen wird
    // ergebnis wird überschrieben
    int ulam_twins_s(int limit)
    {
    int i = 0;
    int ergebnis = -1;

    while (i < limit) {
    // printf(" i: %d\n", i);
    // printf("Ulam_max i: %d\n", ulam_max(i));
    // printf("Ulam_max i + 1: %d\n", ulam_max(i + 1 ));
    // printf("=========\n");
    if (ulam_max(i) == ulam_max(i + 1)) {
    ergebnis = i;
    }
    i++;
    }
    return ergebnis;
    }

    // Keine Ideale lösung da zwei return werte. glaube grifi mag das nich
    int ulam_twins(int limit) {
    int ergebnis;
    int i;

    for (i = 1; i < limit; i++) {
    if (ulam_max(i) == ulam_max(i + 1)) {
    return i;
    }
    }
    return ergebnis;
    }

    // Findet ulam_twins basierend auf number
    // number = 3 heißt drillinge
    // number = 4 heißt vierlinge
    // gibt a0 zurück,
    // wenn mehrlinge gefunden wurden und a0 kleinster wert
    // wenn mehr mehrlinge im intervall, dann kleinster wert der letzten gruppe
    // gibt -1 zurück wenn parameter kacke oder keine mehrlinge gefunden
    int ulam_multiples(int limit, int number) {
    // Ergebnis mit -1 initialisieren
    // Ergebnis is a0, kleinster wert
    int ergebnis = -1;

    // Zwischenspeicher für mehrlinge
    int max;

    // Laufvariable
    int i;
    int j;

    // 1. Überprüfen ob Parameter sinn ergeben.
    // - limit > 1: Intervall 1 bis limit, darum muss limit größer sein als 1
    // - number > 1: Number muss größer 1 sein, da es keine 1-max gibt.
    // - number < limit Die anzahl der max muss kleiner sein als das limit.

    if (limit > 1 && number > 1 && number < limit) {
    // Einfachster Fall: Number = 2, da es direkt ulam_twins ist.
    if (number == 2) {
    ergebnis = ulam_twins(limit);
    } else {
    // Schleife, die hinten anfängt
    for (i = limit; i >= number; i-- ) {
    // Gibt maximalen wert zurück
    max = ulam_max(i);

    // Innere schleife
    for (j = 1; j <= number - 1; j++ ) {
    max = (max == ulam_max(i-j)) ? max : -1;
    }

    if (max != -1) {
    ergebnis = i - number + 1;
    }
    }
    }
    }


    return ergebnis;
    }