Działania na stringach

Wielki Kaczor napisał(a):

Witam,
mam na celu znalezienie NWD dla dużych liczb, wykraczających poza przedział long long. Operacji dokonuje na stringach, jednak pojawia się jeden szkopuł dla dużych liczb - program się crashuje z niewiadomych dla mnie przyczyn. Kilkakrotnie analizowałem kod, ale nie widzę, że niespójności logicznych. Proszę o pomoc. Kod ma 90 linijek, stąd wiem, że jego przejrzenie może okazać się nieco trudne.```

Kopiuj

#include <iostream>
#include <cstring>
using namespace std;

inline string odejmij(string a, string b){
    //WYNIK WYJSCIOWY Z DODAWANIA
    string wynik = "";

    //DLUGOSC STRINGOW
    int strAd, strBd;

    //PRZENIESIENIE
    int p = 0;

    //WYROWNANIE LICZB
    while(a.size() - b.size() > 0) b = "0" + b;

    cout << a << ' ' << b << endl;

    strAd = a.size() - 1;
    strBd = b.size() - 1;

    while(strAd >= 0 || strBd >= 0){
        //buforA, buforB, wynik
        int bufA = 0;
        int bufB = 0;
        int w = 0;

        if(strAd >= 0) bufA = a[strAd] - 48; else bufA = 0;
        if(strBd >= 0) bufB = b[strBd] - 48; else bufB = 0;

        if((bufA - bufB - p ) < 0) { w = bufA - bufB - p + 10; p = 1; }
        else if((bufA - bufB - p) == 0) { w = 0; p = 0; }
        else {w = bufA - bufB - p; p = 0;}

        wynik = "0" + wynik;
        wynik[0] = 48 + w;

        strAd--;
        strBd--;
    }

    string wynikF = "";

    //USUNIECIE ZER Z POCZATKU
    int s = 0;
    for(int i = 0; i < wynik.size(); i++){
        if(wynik[i] == 48) s += 1;
        else break;
    }

    for(int i = s; i < wynik.size(); i++){
        wynikF += wynik[i];
    }

    if(wynikF.size() == 0) wynikF += 48;

    return wynikF;
}

inline string NWD(string, string);

inline string wiekszy(string strA, string strB){
    int dlA = strA.size();
    int dlB = strB.size();

    if(dlA > dlB) { return NWD(odejmij(strA, strB), strB); }
    else if(dlB > dlA) { return NWD(odejmij(strB, strA), strA); }
    else{
        for(int i = 0; i < dlA; i++){
            if(strA[i] > strB[i]) { return NWD(odejmij(strA, strB), strB);}
            else if(strA[i] < strB[i]) { return NWD(odejmij(strB, strA), strA);}
        }
    }
}

inline string NWD(string a, string b){
    if(a == b) return a;
    else return wiekszy(a, b);
}

int main(){
    ios_base::sync_with_stdio(NULL);
    cin.tie(nullptr);

    string strA, strB;
    cin >> strA >> strB;

    cout << NWD(strA, strB);
}

biblioteki do czego?

"biblioteki do czego?"
Na przyszłość, na komentarze Odpowiadaj w komentarzach, bo po dodaniu komentarza jeszcze nie obserwuje się wątku. A co do meritum, biblioteki do liczenia NWD dla bigintegerów, na przykład takiej jak ta. Zadałem proste pytanie, można na nie prosto odpowiedzieć, a nie odbijać piłeczkę.

lion137 napisał(a):

"biblioteki do czego?"
Na przyszłość, na komentarze Odpowiadaj w komentarzach, bo po dodaniu komentarza jeszcze nie obserwuje się wątku. A co do meritum, biblioteki do liczenia NWD dla bigintegerów, na przykład takiej jak ta. Zadałem proste pytanie, można na nie prosto odpowiedzieć, a nie odbijać piłeczkę.

Z tego, co widzę, jako użytkownik niezarejestrowany nie mogę dodawać odpowiedzi bezpośrednio pod pytanie. Złośliwości w moim pytaniu nie było, pytam do czego mogłaby się biblioteka odnosić, bo jakoś nie spotkałem się nigdy z budowanymi funkcjami bibliotecznymi dla wyznaczania NWD, operując na stringach. Mimo wszystko jednak najbardziej zależy mi na znalezieniu nieścisłości w tym, co już napisałem, dlatego założyem ten wątek. ;) Jeżeli masz jakieś uwagi i zastrzeżenia do kodu, dlaczego program się crashuje, to z wdzięcznością przeczytam.

Wielki Kaczor napisał(a):

lion137 napisał(a):

"biblioteki do czego?"
Na przyszłość, na komentarze Odpowiadaj w komentarzach, bo po dodaniu komentarza jeszcze nie obserwuje się wątku. A co do meritum, biblioteki do liczenia NWD dla bigintegerów, na przykład takiej jak ta. Zadałem proste pytanie, można na nie prosto odpowiedzieć, a nie odbijać piłeczkę.

Z tego, co widzę, jako użytkownik niezarejestrowany nie mogę dodawać odpowiedzi bezpośrednio pod pytanie. Złośliwości w moim pytaniu nie było, pytam do czego mogłaby się biblioteka odnosić, bo jakoś nie spotkałem się nigdy z budowanymi funkcjami bibliotecznymi dla wyznaczania NWD, operując na stringach. Mimo wszystko jednak najbardziej zależy mi na znalezieniu nieścisłości w tym, co już napisałem, dlatego założyem ten wątek. ;) Jeżeli masz jakieś uwagi i zastrzeżenia do kodu, dlaczego program się crashuje, to z wdzięcznością przeczytam.

Nie doszukiwałem się złosliwości, zwróciłem tylko uwagę, że zadałem proste pytanie, a Ty Odbiłeś piłeczkę. Do rzeczy.
To właśnie Spotkałeś taką bibliotekę liczacą NWD na stringach.
A co do Twojego kodu, to Przejechałęś go debugerem?

       for(int i = 0; i < dlA; i++){
            if(strA[i] > strB[i]) { return NWD(odejmij(strA, strB), strB);}
            else if(strA[i] < strB[i]) { return NWD(odejmij(strB, strA), strA);}

Ta pętla nie ma sensu, bo nigdy nie wykona się do końca, ponieważ po pierwszym przebiegu zawsze zakończy działanie funkcji i zwróci daną wartość.

Czyli zawsze i = 0.

PanRiK napisał(a):

Kopiuj

       for(int i = 0; i < dlA; i++){
            if(strA[i] > strB[i]) { return NWD(odejmij(strA, strB), strB);}
            else if(strA[i] < strB[i]) { return NWD(odejmij(strB, strA), strA);}

Ta pętla nie ma sensu, bo nigdy nie wykona się do końca, ponieważ po pierwszym przebiegu zawsze zakończy działanie funkcji i zwróci daną wartość.

Czyli zawsze i = 0.

ale przecież może zajść sytuacja strA[i] == strB[i]? wtedy w celu ustalenia, który string przechowuje większą wartość musimy dalej iterować po tablicy i przejść do jej następnej komórki?

Wygląda mi to na zadanie ze SPOJ-a, lub czegoś pokrewnego.
Najlepiej jakbyś tego nie ukrywał i pokazał link. Często są triki, które pozwalają uniknąć operacji na dużych liczbach i obliczyć coś dużo szybciej.
NWD dla dużych liczb zrobiony za pomocą jedynie odejmowania, to będzie bardzo wolne.

MarekR22 napisał(a):

Wygląda mi to na zadanie ze SPOJ-a, lub czegoś pokrewnego.
Najlepiej jakbyś tego nie ukrywał i pokazał link. Często są triki, które pozwalają uniknąć operacji na dużych liczbach i obliczyć coś dużo szybciej.
NWD dla dużych liczb zrobiony za pomocą jedynie odejmowania, to będzie bardzo wolne.

Linka nie jestem w stanie podrzucić, jedynie zdjęcie zadania.

I jeszce to:

prog.cc:47:22: warning: comparison of integers of different signs: 'int' and 'std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::size_type' (aka 'unsigned long') [-Wsign-compare]
    for(int i = 0; i < wynik.size(); i++){
                   ~ ^ ~~~~~~~~~~~~
prog.cc:52:22: warning: comparison of integers of different signs: 'int' and 'std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::size_type' (aka 'unsigned long') [-Wsign-compare]
    for(int i = s; i < wynik.size(); i++){
                   ~ ^ ~~~~~~~~~~~~
prog.cc:75:1: warning: control may reach end of non-void function [-Wreturn-type]
}
^
prog.cc:83:31: warning: implicit conversion of NULL constant to 'bool' [-Wnull-conversion]
    ios_base::sync_with_stdio(NULL);
    ~~~~~~~~                  ^~~~
                              false
4 warnings generated.

trzeci warning jest największym problemem.

MarekR22 napisał(a):

I jeszce to:

Kopiuj

prog.cc:47:22: warning: comparison of integers of different signs: 'int' and 'std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::size_type' (aka 'unsigned long') [-Wsign-compare]
    for(int i = 0; i < wynik.size(); i++){
                   ~ ^ ~~~~~~~~~~~~
prog.cc:52:22: warning: comparison of integers of different signs: 'int' and 'std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::size_type' (aka 'unsigned long') [-Wsign-compare]
    for(int i = s; i < wynik.size(); i++){
                   ~ ^ ~~~~~~~~~~~~
prog.cc:75:1: warning: control may reach end of non-void function [-Wreturn-type]
}
^
prog.cc:83:31: warning: implicit conversion of NULL constant to 'bool' [-Wnull-conversion]
    ios_base::sync_with_stdio(NULL);
    ~~~~~~~~                  ^~~~
                              false
4 warnings generated.

trzeci warning jest największym problemem.

rzeczywiście niedopuszczalny. wychodzi na to, że z funkcją inline string wiekszy(string, string) jest coś nie tak. ale co? przecież na moje oko nie pomijam żadnego przypadku i zawsze zostanie zwrócona jakiś string. można jeszcze dopuścić się dopisania po pętli for() return NWD(odejmij(strA, strB), strA) - tak dla pewności. jednak i tak nic to nie daje.

problem pojawia się także przy większych liczbach, działając na mniejszych, zwraca poprawny wynik

Mnie ciekawi skad takie zainteresowanie akurat tym tematem (patrz strona glowna). Czyzby chwytliwy tytul?

vpiotr napisał(a):

Mnie ciekawi skad takie zainteresowanie akurat tym tematem (patrz strona glowna). Czyzby chwytliwy tytul?

Zawsze mogłem dodać "odejmowanie stringów", nie mówiąc już o ich zdejmowaniu. ;)

Ogólnie problem leży po stronie kompilatora, bo jeżeli dasz NWD z cyfr np. co ma jedna ma 99znaków, a druga 10, to kompilator uznaje, że za długo będzie się to robiło i do niczego to nie dojdzie.

W odejmowaniu, przed wyświetlaniem zmiennych wstawiłem sleepa, z biblioteką:

Sleep(10);

#include "windows.h"

i to:

        wynik = "0" + wynik;
        wynik[0] = 48 + w;

zmieniłem na:

wynik = to_string(w)+ wynik;

Tak, jest to dokładnie to samo, ale działa dla większych liczb, lub przez przypadek mi zadziałało.

Sleepa dałem, bo jakoś mój kompilator nie wywalał tak szybko błędów, tylko jechał do samego końca.

Chyba gdzieś w ustawieniach kompilatora można zmienić , żeby nie wywalał tak szybko

Do testowania zadania polecam cyfry, które się od siebie różnią.

PanRiK napisał(a):

Ogólnie problem leży po stronie kompilatora, bo jeżeli dasz NWD z cyfr np. co ma jedna ma 99znaków, a druga 10, to kompilator uznaje, że za długo będzie się to robiło i do niczego to nie dojdzie.

W odejmowaniu, przed wyświetlaniem zmiennych wstawiłem sleepa, z biblioteką:

Kopiuj

Sleep(10);

Kopiuj

#include "windows.h"

i to:

Kopiuj

        wynik = "0" + wynik;
        wynik[0] = 48 + w;

zmieniłem na:

Kopiuj

wynik = to_string(w)+ wynik;

Tak, jest to dokładnie to samo, ale działa dla większych liczb, lub przez przypadek mi zadziałało.

Sleepa dałem, bo jakoś mój kompilator nie wywalał tak szybko błędów, tylko jechał do samego końca.

Chyba gdzieś w ustawieniach kompilatora można zmienić , żeby nie wywalał tak szybko

Do testowania zadania polecam cyfry, które się od siebie różnią.

Dziękuję za inicjatywę, ale to jednak nie to. Pozmieniałem tak, jak zaleciłeś, ale dla danych: 1111111 55 wciąż wywala błąd. To problem nam się trafił...

Dalej uważam, że lepiej użyć gotowej biblioteki do wielkich liczb, ale skoro Chcesz tak. Jakyś miał działające odejmowanie - znaczy takie, że przy próbie odjęcia wiekszej od mniejszej da w wyniku zero, to można by to łatwo zaimplementować.
Potrzeba tylko dwóch funkcji: <=, oraz mod.
Mniejszy lub równy mógłby wyglądać tak:

fun less_or_eq(a, b):
    if sub(a, b) == ZERO:
        return true;
    else:
        return false;

I modulo:

fun mod(a, b):
    if less_or_eq(b, a):
        return mod(sub(a, b), b);
    else:
        return a;

I finalnie GCD:

fun gcd(a, b):
    if b = 0:
        return a;
    else:
        return gcd(b, mod(a, b));

Predykat równości, jeśli wszystko działa dobrze, to powinno być sprawdzenie czy string jest postaci: "0".
A jesli odejmowanie wywala błąd przy próbie odjęcia większej od mniejszej, to albo je zmienić (tak by było najlepiej, bo Miałbys już gotowe - tylko przepisać funkcje, które Ci podałem w pseudokodzie), albo napisać porównanie:
Nie jestem tego pewien, ale algorytm mógłby być taki:

• Dłuższy string, to większa liczba;
• Gdy równej długości, to ten z pierwszą cyfrą większą (jako int, oczywiście) jest wiekszy;
• Gdy pierwsze cyfry równe, to ten z następną wiekszą cyfrą jest większy;
• I tak dalej aż do ostatniej cyferki.

EDIT:
wydaje sie, że ten sposób na zaimplementowanie <=, powinien działać:

fun less_or_eq(m, n):
    if length(m) > length(n):
        return False
    else if length(n) > length(m):
        return True
    else:
        for indeks in length(m):
            if int(m[indeks]) > int(n[indeks]):
                return False
            else if int(n[indeks]) > int(m[indeks]):
                return True
            else:
                continue
        return True

lion137 napisał(a):

Dalej uważam, że lepiej użyć gotowej biblioteki do wielkich liczb, ale skoro Chcesz tak. Jakyś miał działające odejmowanie - znaczy takie, że przy próbie odjęcia wiekszej od mniejszej da w wyniku zero, to można by to łatwo zaimplementować.
Potrzeba tylko dwóch funkcji: <=, oraz mod.
Mniejszy lub równy mógłby wyglądać tak:

Kopiuj

fun less_or_eq(a, b):
    if sub(a, b) == ZERO:
        return true;
    else:
        return false;

I modulo:

Kopiuj

fun mod(a, b):
    if less_or_eq(b, a):
        return mod(sub(a, b), b);
    else:
        return a;

I finalnie GCD:

Kopiuj

fun gcd(a, b):
    if b = 0:
        return a;
    else:
        return gcd(b, mod(a, b));

Predykat równości, jeśli wszystko działa dobrze, to powinno być sprawdzenie czy string jest postaci: "0".
A jesli odejmowanie wywala błąd przy próbie odjęcia większej od mniejszej, to albo je zmienić (tak by było najlepiej, bo Miałbys już gotowe - tylko przepisać funkcje, które Ci podałem w pseudokodzie), albo napisać porównanie:
Nie jestem tego pewien, ale algorytm mógłby być taki:

• Dłuższy string, to większa liczba;
• Gdy równej długości, to ten z pierwszą cyfrą większą (jako int, oczywiście) jest wiekszy;
• Gdy pierwsze cyfry równe, to ten z następną wiekszą cyfrą jest większy;
• I tak dalej aż do ostatniej cyferki.

EDIT:
wydaje sie, że ten sposób na zaimplementowanie <=, powinien działać:

Kopiuj

fun less_or_eq(m, n):
    if length(m) > length(n):
        return False
    else if length(n) > length(m):
        return True
    else:
        for indeks in length(m):
            if int(m[indeks]) > int(n[indeks]):
                return False
            else if int(n[indeks]) > int(m[indeks]):
                return True
            else:
                continue
        return True

czyli zakładasz, że błąd wynika z tego, iż w którymś momencie liczba w string się zeruje / staje się ujemna?

Wielki Kaczor napisał(a):

czyli zakładasz, że błąd wynika z tego, iż w którymś momencie liczba w string się zeruje / staje się ujemna?

Nie wiem, nie wiem jak ma działać Twoje gcd bez funkjcji modulo. Ja bym tego nie poprawiał tylko od nowa napisał tak jak podałem; jak będa jakies błędy będzie łatwiej debugować, bo jest podzielone na jak najmniejsze funkcje.

Napisałem kod od nowa:

#include <iostream>
#include <cstring>
#include <windows.h>
using namespace std;

inline string odejmij(string a, string b){
    //WYNIK WYJSCIOWY Z DODAWANIA
    string wynik = "";

    //DLUGOSC STRINGOW
    int strAd, strBd;

    //PRZENIESIENIE
    int p = 0;

    //WYROWNANIE LICZB
    while(a.size() - b.size() > 0) b = "0" + b;

    strAd = a.size() - 1;
    strBd = b.size() - 1;

    while(strAd >= 0 || strBd >= 0){
        //buforA, buforB, wynik
        int bufA = 0;
        int bufB = 0;
        int w = 0;

        if(strAd >= 0) bufA = a[strAd] - 48; else bufA = 0;
        if(strBd >= 0) bufB = b[strBd] - 48; else bufB = 0;

        if((bufA - bufB - p ) < 0) { w = bufA - bufB - p + 10; p = 1; }
        else if((bufA - bufB - p) == 0) { w = 0; p = 0; }
        else {w = bufA - bufB - p; p = 0;}

        wynik = to_string(w) + wynik;

        strAd--;
        strBd--;
    }

    string wynikF = "";

    //USUNIECIE ZER Z POCZATKU
    int s = 0;
    for(int i = 0; i < wynik.size(); i++){
        if(wynik[i] == 48) s += 1;
        else break;
    }

    for(int i = s; i < wynik.size(); i++){
        wynikF += wynik[i];
    }

    if(wynikF.size() == 0) wynikF += 48;

    return wynikF;
}

inline string NWD(string, string);

inline string wiekszy(string strA, string strB){
    int dlA = strA.size();
    int dlB = strB.size();


    if(dlA > dlB) { return NWD(odejmij(strA, strB), strB); }
    else if(dlA < dlB) { return NWD(odejmij(strB, strA), strA); }
    else{
        for(int i = 0; i < dlA; i++){
            if(strA[i] > strB[i]) { return NWD(odejmij(strA, strB), strB);}
            else if(strA[i] < strB[i]) { return NWD(odejmij(strB, strA), strA);}
            else continue;
        }
        return NWD(odejmij(strA, strB), strB);
    }
}

inline string NWD(string a, string b){
    if(a == b) return a;
    else return wiekszy(a, b);
}

int main(){
    ios_base::sync_with_stdio(NULL);
    cin.tie(nullptr);

    string strA, strB;
    cin >> strA;
    cin >> strB;

    cout << NWD(strA, strB);
}

problem nie zniknął, pojawia się dla tych samych par danych wejściowych. ja już niczego nie wymyślę na chwilę obecną. pozostało mi biernie poddać się wskazówkom

EDIT:
Zły kod źródłowy podałem:

#include <iostream>
#include <cstring>
using namespace std;

inline string odejmij(string a, string b){
    //WYNIK WYJSCIOWY Z DODAWANIA
    string wynik = "";

    //DLUGOSC STRINGOW
    int strAd, strBd;

    //PRZENIESIENIE
    int p = 0;

    //WYROWNANIE LICZB
    while(a.size() - b.size() > 0) b = "0" + b;

    strAd = a.size() - 1;
    strBd = b.size() - 1;

    while(strAd >= 0 || strBd >= 0){
        //buforA, buforB, wynik
        int bufA = 0;
        int bufB = 0;
        int w = 0;

        if(strAd >= 0) bufA = a[strAd] - 48; else bufA = 0;
        if(strBd >= 0) bufB = b[strBd] - 48; else bufB = 0;

        if((bufA - bufB - p ) < 0) { w = bufA - bufB - p + 10; p = 1; }
        else if((bufA - bufB - p) == 0) { w = 0; p = 0; }
        else {w = bufA - bufB - p; p = 0;}

        wynik = to_string(w) + wynik;

        strAd--;
        strBd--;
    }

    string wynikF = "";

    //USUNIECIE ZER Z POCZATKU
    int s = 0;
    for(int i = 0; i < wynik.size(); i++){
        if(wynik[i] == 48) s += 1;
        else break;
    }

    for(int i = s; i < wynik.size(); i++){
        wynikF += wynik[i];
    }

    if(wynikF.size() == 0) wynikF += 48;

    return wynikF;
}

inline bool mniejsze_rowne(string strA, string strB){
    if(strA.size() > strB.size()) return false;
    else if(strA.size() < strB.size()) return true;
    else{
        for(int i = 0; i < strA.size(); i++){
            if(strA[i] > strB[i]) return false;
            else if(strA[i] < strB[i]) return true;
            else continue;
        }
        return true;
    }
}

inline string mod(string strA, string strB){
    if(mniejsze_rowne(strB, strA))
        return mod(odejmij(strA, strB), strB);
    else
        return strA;
}

inline string nwd(string strA, string strB){
    if(strB == "0")
        return strA;
    else
        return nwd(strB, mod(strA, strB));
}

int main(){
    ios_base::sync_with_stdio(NULL);
    cin.tie(nullptr);

    string strA, strB;
    cin >> strA >> strB;

    cout << nwd(strA, strB);
}

 while(strAd >= 0 || strBd >= 0)

Zamień na:

 while(strAd > 0 || strBd > 0)

Wychodzisz po za zakres , bo w while masz odejmowanie tej wielkości

Edit: U mnie działa :D , tylko błędne wyniki są

PanRiK napisał(a):

Kopiuj

 while(strAd >= 0 || strBd >= 0)

Zamień na:

Kopiuj

 while(strAd > 0 || strBd > 0)

Wychodzisz po za zakres , bo w while masz odejmowanie tej wielkości

Edit: U mnie działa :D , tylko błędne wyniki są

no właśnie, są błędne wyniki. uwaga słuszna i rzeczywiście przez moją nieuwagę docieraliśmy do -1 elementu tablicy, co mogło być potencjalnym powodem błędu. zrobiłem jeszcze w środku while() sprawdzenie:

if(strAd == 0 || strBd == 0) break; else { strAd--; strBd--; }

bez skutku jednak :)

Już brak pomysłów, co może być problemem? Zależy mi na rozwiązaniu, stąd moje zawzięcie.

Wielki Kaczor napisał(a):

Już brak pomysłów, co może być problemem? Zależy mi na rozwiązaniu, stąd moje zawzięcie.

Czyli co, odejmowanie Nie dziala?

Panie tu dużo nie trzeba do zrobienia tego zadania.

BigInteger, musisz zrobić odejmowanie i porównywanie liczb.

czyli jak masz 24 tekst i 13 tekst to dodajesz od prawej do lewej 4+3 = 7, 0 przeniesienia. i 2+1 = 3 i 0 przeniesienia, a dalej pierwszy string się kończy i drugi tak samo.
Ewentualnie wspak możesz to zapisać to wtedy od lewej do prawej pojedziesz.

Porównywanie możesz zrobić kilku etapowo jeśli jeden string jest dłuższy od drugiego w sensie czy mają tyle samo znaków.
Jeśli nie mają to są różne (!=).

jeśli mają tyle samo znaków, to sprawdzasz od najbardziej znaczącego i dopóki najbardziej znaczący nie jest większy to przechodzisz tak aż do ostatniego.
Najbardziej znaczący to np. z 1234 to liczba 1, a najmniej znacząca, to 4, jeśli najbardziej znacząca jest większa w jednym ze stringów, to nie ma co dalej sprawdzać.

Jak odejmowanie będzie działać, bo w sumie dodawanie nie potrzebne, to wtedy implementujesz NWD algorytm na tym odejmowaniu.

Łączysz to razem i masz gotowy program.

lion137 napisał(a):

Wielki Kaczor napisał(a):

Już brak pomysłów, co może być problemem? Zależy mi na rozwiązaniu, stąd moje zawzięcie.

Czyli co, odejmowanie Nie dziala?

Na to wygląda.

https://ideone.com/cuM6DU

Bogaty Rycerz napisał(a):

https://ideone.com/cuM6DU

odejmowania na a - b, gdzie a > b raczej nie powinniśmy rozpatrywać

Wielki Kaczor napisał(a):

Bogaty Rycerz napisał(a):

https://ideone.com/cuM6DU

odejmowania na a - b, gdzie a > b raczej nie powinniśmy rozpatrywać

• b > a