6.5.2 Ćwiczenie - Który kod wydajniejszy?
Logowanie
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zapomniałem hasła
» Forum » Programowanie » [C, C++] Szukam pomocy

6.5.2 Ćwiczenie - Który kod wydajniejszy?

Ostatnio zmodyfikowano 2010-04-08 12:13
Autor Wiadomość
Steryd9339
Temat założony przez niniejszego użytkownika
6.5.2 Ćwiczenie - Który kod wydajniejszy?
» 2010-04-07 18:21:53
Witam!
Otóż napisałem parę kodów do tego zadania(6.5.2) i chciałbym się was zapytać który kod jest wydajniejszy. I żebyście to uzasadnili ponieważ jestem początkujący i chciałbym się dowiedzieć czym się kierować itd. według doświadczonych formułowiczów.

Treść:
C/C++
/*6.5 Ćwiczenia
1. Napisz program, który wykona poniższe zadania:
-> 2 + 7 * 16 - 8
-> 22 * 2 : 11
-> 8383 - 222 + 292 * 8
-> 5 * 2 * 4
Wyniki zapisz do tabeli, a następnie wyświetl je na ekranie.

2. Używając tabeli z pierwszego zadania napisz program, który wyniki z pierwszego zadania przekaże do drugiej tabeli następnie wykona dodatkowe obliczenia odpowiednio:
-> wynik * 2 - 13
-> wynik - 4 + 1
-> wynik + 88 - 250
-> wynik + (doda wyniki jakie zostaną uzyskane z 3 poprzednich wyrażeń).
Najlepiej napisać program do pierwszego zadania a potem rozszerzyć go by wykonywał podane przykład.
*/

Sposób 1: ( 8 zmiennych)
C/C++
#include <iostream>
#include <conio.h>

using namespace std;

int main()
{
    short a, b, c, d, a1, b1, c1, d1;
   
    a = 2 + 7 * 16 - 8;
    b = 22 * 2 / 11;
    c = 8383 - 222 + 292 * 8;
    d = 5 * 2 * 4;
   
    a1 = a * 2 - 13;
    b1 = b - 4 + 1;
    c1 = c + 88 - 250;
    d1 = d + a1 + b1 + c1;
   
    short Tab[ 2 ][ 4 ] = {
        { a, b, c, d },
        { a1, b1, c1, d1 },
    };
   
    cout
    << "a= " << Tab[ 0 ][ 0 ]
    << "\nb= " << Tab[ 0 ][ 1 ]
    << "\nc= " << Tab[ 0 ][ 2 ]
    << "\nd= " << Tab[ 0 ][ 3 ]
    << "\n\na1(a * 2 - 13)= " << Tab[ 1 ][ 0 ]
    << "\nb1(b - 4 + 1)= " << Tab[ 1 ][ 1 ]
    << "\nc1(c + 88 - 250)= " << Tab[ 1 ][ 2 ]
    << "\nd1(d + a1 + b1 + c1)= " << Tab[ 1 ][ 3 ] << endl;
}

Sposób 1a: ( Tylko sama tablica 1 wymiarowa i 2 wymiarowa)
C/C++
#include <iostream>
#include <conio.h>

using namespace std;

int main() {
   
    /*
        short Tab[2][4] = {
            {
            2 + 7 * 16 - 8,         //Tab[0][0]
            22 * 2 / 11,            //Tab[0][1]
            8383 - 222 + 292 * 8,   //Tab[0][2]
            5 * 2 *4                //Tab[0][3]
            },
            {
            Tab[0][0] * 2 - 13,                             //Tab[1][0]
            Tab[0][1] - 4 + 1,                              //Tab[1][1]
            Tab[0][2] + 88 - 250,                           //Tab[1][2]
            Tab[0][3] + Tab[1][0]+ Tab[1][1] + Tab[1][2]    //Tab[1][3]
            },
        };
        */
   
    short Tab[ 8 ] = {
        2 + 7 * 16 - 8, //Tab[0]
        22 * 2 / 11, //Tab[1]
        8383 - 222 + 292 * 8, //Tab[2]
        5 * 2 * 4, //Tab[3]
        Tab[ 0 ] * 2 - 13, //Tab[4]
        Tab[ 1 ] - 4 + 1, //Tab[5]
        Tab[ 2 ] + 88 - 250, //Tab[6]
        Tab[ 3 ] + Tab[ 4 ] + Tab[ 5 ] + Tab[ 6 ] //Tab[7]
    };
   
    cout
    << "a= " << Tab[ 0 ] //Tab[0][0]
    << "\nb= " << Tab[ 1 ] //Tab[0][1]
    << "\nc= " << Tab[ 2 ] //Tab[0][2]
    << "\nd= " << Tab[ 3 ] //Tab[0][3
    << "\n\na1(a * 2 - 13)= " << Tab[ 4 ] //Tab[1][0]
    << "\nb1(b - 4 + 1)= " << Tab[ 5 ] //Tab[1][1]
    << "\nc1(c + 88 - 250)= " << Tab[ 6 ] //Tab[1][2]
    << "\nd1(d + a1 + b1 + c1)= " << Tab[ 7 ] //Tab[1][3]
    << endl;
}

Sposób 2a: ( 2x jednowymiarowa tablica, 4 zmienne)
C/C++
#include <iostream>
#include <conio.h>

using namespace std;

int main()
{
    short a, b, c, d;
   
    a = 2 + 7 * 16 - 8;
    b = 22 * 2 / 11;
    c = 8383 - 222 + 292 * 8;
    d = 5 * 2 * 4;
   
    short Tab[ 4 ] = { a, b, c, d };
   
    cout
    << "a= " << Tab[ 0 ]
    << "\nb= " << Tab[ 1 ]
    << "\nc= " << Tab[ 2 ]
    << "\nd= " << Tab[ 3 ] << endl;
   
    ( a *= 2 ) -= 13;
    ( b -= 4 ) += 1;
    ( c += 88 ) -= 250;
    ( d += a ) += b + c;
   
    /* też
            a = a * 2 - 13;
            b = b - 4 + 1;
            c = c + 88 - 250;
            d = d + a + b + c; */
   
   
    short Tab1[ 4 ] = { a, b, c, d };
   
    cout
    << "\na1(a * 2 - 13)= " << Tab1[ 0 ]
    << "\nb1(b - 4 + 1)= " << Tab1[ 1 ]
    << "\nc1(c + 88 - 250)= " << Tab1[ 2 ]
    << "\nd1(d + a1 + b1 + c1)= " << Tab1[ 3 ] << endl;

}
Oraz który algorytm jest lepszy:
2aa
C/C++
( a *= 2 ) -= 13;
( b -= 4 ) += 1;
( c += 88 ) -= 250;
( d += a ) += b + c;
2ab
C/C++
a = a * 2 - 13;
b = b - 4 + 1;
c = c + 88 - 250;
d = d + a + b + c;
Sposób 2b: ( 2x jednowymiarowa tablica)

C/C++
#include <iostream>
#include <conio.h>

using namespace std;

int main()
{
    short Tab[ 4 ] = {
        2 + 7 * 16 - 8,
        22 * 2 / 11,
        8383 - 222 + 292 * 8,
        5 * 2 * 4
    };
   
    cout
    << "a= " << Tab[ 0 ]
    << "\nb= " << Tab[ 1 ]
    << "\nc= " << Tab[ 2 ]
    << "\nd= " << Tab[ 3 ] << endl;
   
    /*
        short Tab1[4] = {
            Tab[0] = Tab[0]* 2 - 13;
            Tab[1] = Tab[1]- 4 + 1;
            Tab[2] = Tab[2] + 88 - 250;
            Tab[3] = Tab[3] + Tab[0] + Tab[1] + Tab[2];
        };
        */
   
    short Tab1[ 4 ] = {
        ( Tab[ 0 ] *= 2 ) -= 13,
        ( Tab[ 1 ] -= 4 ) += 1,
        ( Tab[ 2 ] += 88 ) -= 250,
        ( Tab[ 3 ] += Tab[ 0 ] ) += Tab[ 1 ] + Tab[ 2 ]
    };
   
    cout
    << "\na1(a * 2 - 13)= " << Tab1[ 0 ]
    << "\nb1(b - 4 + 1)= " << Tab1[ 1 ]
    << "\nc1(c + 88 - 250)= " << Tab1[ 2 ]
    << "\nd1(d + a1 + b1 + c1)= " << Tab1[ 3 ]
   
}
I który algorytm jest lepszy
2aa
C/C++
short Tab1[ 4 ] = {
    Tab[ 0 ] = Tab[ 0 ] * 2 - 13;
    Tab[ 1 ] = Tab[ 1 ] - 4 + 1;
    Tab[ 2 ] = Tab[ 2 ] + 88 - 250;
    Tab[ 3 ] = Tab[ 3 ] + Tab[ 0 ] + Tab[ 1 ] + Tab[ 2 ];
};
2ab
C/C++
short Tab1[ 4 ] = {
    ( Tab[ 0 ] *= 2 ) -= 13,
    ( Tab[ 1 ] -= 4 ) += 1,
    ( Tab[ 2 ] += 88 ) -= 250,
    ( Tab[ 3 ] += Tab[ 0 ] ) += Tab[ 1 ] + Tab[ 2 ]
};

@Chyba to wszystko jak nie to szybko z edytuje
@Down
Ok. Dzięki :)
P-15902
GoldWolf
» 2010-04-08 12:13:51
Generalnie chodzi o to by było jak najmniej obliczeń, tym mniej obliczeń tym wydajniejszy algorytm. Dodatkowo zminimalizować liczbę zmiennych.
Sposób 2b: - jest dobry, najlepiej tak to wykonać.
Właśnie w C++ wprowadzono możliwość taką jak prezentujesz 2ab. Jednak akurat Twoje zastosowanie jest dość oryginalne.

Gdybyś nie musiał wykonywać poleceń z ćw. to np.
C/C++
#include <conio.h>
#include <iostream>
int main() {
    using std::cout; using std::endl; const short INDEX = 10; short Tab[ INDEX ] = { 2 + 7 * 16 - 8,
        22 * 2 / 11,
        8383 - 222 + 292 * 8,
        5 * 2 * 4,
        Tab[ 0 ] * 2 - 13,
        Tab[ 1 ] - 4 + 1,
        Tab[ 2 ] + 88 - 250,
        Tab[ 3 ] + Tab[ 4 ] + Tab[ 5 ] + Tab[ 6 ], 0, 0 };
   
    cout << "a= " << Tab[ 0 ]
    << "\nb= " << Tab[ 1 ] << "\nc= " << Tab[ 2 ] << "\nd= " << Tab[ 3 ] << "\n\na1(a * 2 - 13)= " << Tab[ 4 ]
    << "\nb1(b - 4 + 1)= " << Tab[ 5 ]
    << "\nc1(c + 88 - 250)= " << Tab[ 6 ]
    << "\nd1(d + a1 + b1 + c1)= " << Tab[ 7 ] << endl;
    getch();
}
P-15923
« 1 »
  Strona 1 z 1  
» Forum » Programowanie » [C, C++] Szukam pomocy
© Wszelkie prawa zastrzeżone 2005-2024