ulam.c

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