Jak porównać 2 elemnty z tablicy

0

Cześć, moim zadaniem jest wyznaczenie liczb zaprzyjaźnionych i doskonałych w zakresie do 1000

Liczba doskonała – liczba naturalna, która jest sumą wszystkich swych dzielników właściwych (to znaczy od niej mniejszych). Najmniejszą liczbą doskonałą jest 6, ponieważ 6 = 3 + 2 + 1. Następną jest 28

Liczby zaprzyjaźnione to para różnych liczb naturalnych, takich że suma dzielników właściwych (mniejszych od tej liczby) każdej z tych liczb równa się drugiej
np: 220 = 1 + 2 + 4 + 71 + 142 (dzielniki 284)
284 = 1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 (dzielniki 220)

Gdzie tkwi mój problem?
Znalazłem liczby doskonałe, ale nie potrafię za pomocą zapisanych inforamcji w tablicy wyszukać liczb zaprzyjaźnionych.(jeszcze nie czuję tak dobrze tablic)

wstawiam mój kod:


#include < stdio.h > 
#include < math.h >
 #define rozmiar 1000

int main() {

  int i = 2; // zmienna sterująca 1wszą  pętlą
  int z = 1; //  dzielniki liczb y i
  int suma_dzielnikow = 0; // w domyśle bez dzielania n/n
  int tablica[rozmiar] = {
    0
  };

  for (i = 2; i <= 1000; i++) /// tutaj zmień na 1000 później
  {
    suma_dzielnikow = 0; // po to tutaj to jest by  suma nizej nie dodawala sie do poprzedniej:
    // musi sie zerować po kazdej petli
    for (z = 1; z <= i - 1; z++) {
      //printf("liczba %d jest dzielona przez %d \n", i,z); ---- > na pewno dziala

      if (i % z == 0) {

        suma_dzielnikow = suma_dzielnikow + z;

        //inicjalizowanie tablicy
        tablica[i] = suma_dzielnikow;
      }

    }

    //printf("suma dzielników %d jest równa %d\n",i,suma_dzielnikow);
    //    printf("element nr  %d =%d\n",i,tablica[i]);

  }

  int suma_liczb_doskonalych = 0;

  for (i = 2; i <= 1000; i++) {

    if (tablica[i] == i) {
      suma_liczb_doskonalych = suma_liczb_doskonalych + 1;

    }

  }

  printf("suma liczb doskonalych jest równa: %d", suma_liczb_doskonalych);

  // jeszcze to poprawić
  int suma_liczb_zaprzyjaznionych = 0;
  int m = 0;
  int n = 0;
  for (n = 2; n <= 999; n++) {
    tablica[n];
    for (m = 999; m >= 2; m--)
      if (tablica[n] = m) {
        suma_liczb_zaprzyjaznionych = suma_liczb_zaprzyjaznionych + 1;
      }
  }

  printf("suma liczb doskonalych jest równa: %d", suma_liczb_zaprzyjaznionych);

  return 0;
}

/*if(tablica[n] == m && tablica[m] == n)
         {
        suma_liczb_zaprzyjaznionych=suma_liczb_zaprzyjaznionych+1;

         } */

Tak wiem strasznie się pogubiłem w zaznaczonym fragmencie, ale już na prawdę nie mam już pomysłu na to jak to doprowadzić do porządku
# editt sformatowany kod

0

1) sformatuj kod, losowe spacje i taby nie sa mile widziane
2) wydziel kod na funkcje

Wybacz, ale tego sie nie da czytac

0

Rzeczywiście, tak z czystej dobroci serca wypadałoby ułatwić robotę ludziom, których Prosisz o pomoc:). nie dałem rady śledzić Twojego kodu, więc daje pseudokod, trochę wygląda jak python:):

def sum_of_divisors(n): # funkcja pomocnicza: suma dzielników
    if n == 0:
        return 0
    s = 0
    for k in range(1, n // 2 + 1): # od 1 do n/2,  "//" - dzielenie w integerach
        if n % k == 0:
            s += k
    return s

def find_friend(n):

    d = [0] + [x for x in range(1, n  + 1)] # składnia tego jest nieistotna, można to
                                            #  zrobić dowolną pętlą, ważne, że
                                            # tworzę tablicę liczb o rozmiarze n + 1 od 0 do n,
                                            # będziemy używać tylko elementów od 1 do n
    for x in range(n + 1): # x - sy iteruję od 0 do n, przy zero base indeks tak to wygląda (czyli prawie wszędzie:)
        d[x] = sum_of_divisors(x) # każdej liczbie przypisujemy jej sumę dzielników: 1 -> 0, 2 -> 1, ...

    out = [] # tablica do zwrócenia wyniku, narazie pusta
    for m in range(1, n + 1): #tu iterujemy od 1 do n, czyli indeks = liczba, d[indeks] = suma dzielników tej liczby
        if d[m] <= n: # musi być mniej niż n, oczywiste
            if d[d[m]] == m: # to oznacza właśnie definicję liczb zaprzyjaźnionych, Przeanalizuj uważnie
                if m != d[m]: # żeby wykluczyć liczby doskonale, bez tego zwróci również pary: (6, 6),....
                    out.append([m, d[m]]) # będzie to tablica par liczb zaprzyjaźnionych,(tablica tablic)
    return out # zwracamy wynik

print(find_friend(2000)) # -> [[220, 284], [284, 220], [1184, 1210], [1210, 1184]]

Pozostanie jedynie wyrzucić powtarzające się pary, ale to już pikuś:)

0

Ptrząc na to co jest napisane rozumiem mniej niż przedtem ;)
Nie jestem zaawansowanym programista który zna 10 języków i 10 kompilatorów ;)

Chodzi mi o ideę do rozwiązania takiego problemu masz w tablicy 998 elementów każdemu przyporządkowane są jego dzielniki
jak znaleźć takie pary w tablicach że P(n)=m i P(m)=n
gdzie p(n) dajmy na to to pozycja w tablicy a wynik równania to liczba dzielników
tyle mi potrzebne do szczęścia
Dzięki z góry za wskazówki .

0

Masz dokladnie opisane, Zrob to samo w C++. Jak nie Dasz rady, to wieczorem moge wrzucic kod w C.

0

Tyle że ja zupełnie nie znam C++ i pojęcia nie wiem co jest grane tam ;)

1

Jak powiedziałem kod w C, najtoporniejszy z możliwych:

#include <stdio.h>

int sum_divisors(int n) { // suma dzielników n
    if (n == 0)
        return 0;
    int s = 0;
    for (int i = 1; i < n / 2 + 1; i++){
        if (n % i == 0) {
            s += i;
        } 
    }
    return s;
}

int * find_friends_pairs(int n){

    int t[n + 1]; //tablica do obliczeń na stosie
    static int d[10]; // statyczna tablica do zwrócenia wyniku - rozmiar ustalany "na oko"

    for (int i = 1; i <= n; i++){
        t[i] = sum_divisors(i); // wypełnia tablicę sumami dzielników indeksu, 
                 // tworząc parę indeks - liczba, wartość dla indeksu -  suma dzielników liczby
    }

    int k = 0; // , zmienna pomocnicza do indeksowania tablicy wynikowej
    for (int i = 1 ; i <= n + 1; i++){
        if (t[i] <= n){ // żeby suma dzielników nie wyszła poza zakres, oczywiste
            if (t[t[i]] == i){ // tu sprawdza czy zaprzyjaźniona para
                if (i != t[i]){ // tu odfiltorwuje liczby doskonałe, dla nich też t[t[i]] = i !
                    d[k] = i;
                    k++;
                    d[k] == t[i];
                    k++;
                }
            }
        }
    }
    return d; 
}

int main(int argc, char **argv)
{
    int * tab;
    tab = find_friends_pairs(1000); // zaprzyjaźnione pary będą niezerowymi elementami
                                    // w tablicy tab

    return 0;
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0