Υπολογισμός μορίων - C  Το θέμα επιλύθηκε

...του ubuntu και έργων ΕΛ/ΛΑΚ (Έργα-Οδηγοί-Προτάσεις)

Συντονιστής: konnn

Υπολογισμός μορίων - C

Δημοσίευσηαπό UnKnown96 » 24 Δεκ 2012, 18:32

Γεια σας παίδες!

Λοιπόν έφτιαξα ένα πρόγραμμα στην C το οποίο αν και δεν είναι τέλεια γραμμένο, υπολογίζει τα μόρια που έχει βγάλει κάποιος στην πανελλήνιες.
Υπάρχει όμως ένα προβληματάκι, στις οδηγίες που διάβασα πως τα υπολογίζουμε μπόρεσα να τα <<μεταφράσω>> σε κώδικα στην C σχεδόν τα πάντα...
Αυτό που δεν μπόρεσα είναι το εξής: Πρέπει να στρογγυλοποιώ μερικά νούμερα σε ένα ή δύο δεκαδικά ψηφία.
Επειδή δεν ήξερα πως να το κάνω, έκανα κάτι άλλο το οποίο πέφτει πολύ κοντά (κρατάει μόνο το πρώτο ή τα δύο πρώτα δεκαδικά ψηφία) αλλά και πάλι όχι ακριβώς...
Αν μπορεί κάποιος να μου δώσει μία έτοιμη συνάρτηση που να δέχεται double και να κάνει αυτή την δουλεία ή να μου δώσουν μερικά tips που να με βοηθήσουν να την φτιάξω μόνος μου, θα μου ήταν πολύ χρήσιμο.

Εδώ είναι ο κώδικας με ότι έχω κάνει μέχρι τώρα:

Edit: Με λυμένο το πρόβλημα.

Κώδικας: Επιλογή όλων

#include <stdio.h>
#include <math.h>

struct
{
int arx, ist, logot, lat;
int math, fis, xim, vio, aexv, dei;
int glo, epi, mathg, viog, ikon, istg;
} p1, p2;

struct
{
double arx, ist, logot, lat;
double math, fis, xim, vio, aexv, dei;
double glo, epi, mathg, viog, ikon, istg;
} g, d, pb, bp;

struct idmath { double id; } b;

int idm, syn;
double gbp;
int mor;

int theor (void)
{
printf ("Αρχαία Ελληνικά: ");
scanf ("%d, %d, %lf", &p1.arx, &p2.arx, &g.arx);

printf ("Ιστορία: ");
scanf ("%d, %d, %lf", &p1.ist, &p2.ist, &g.ist);

printf ("Νεοελ. Λογοτεχνία: ");
scanf ("%d, %d, %lf", &p1.logot, &p2.logot, &g.logot);

printf ("Λατινικά: ");
scanf ("%d, %d, %lf", &p1.lat, &p2.lat, &g.lat);

printf ("Νεοελ. Γλώσσα: ");
scanf ("%d, %d, %lf", &p1.glo, &p2.glo, &g.glo);

return 0;
}

int thet (void)
{
printf ("Χημεία: ");
scanf ("%d, %d, %lf", &p1.xim, &p2.xim, &g.xim);

printf ("Βιολογία: ");
scanf ("%d, %d, %lf", &p1.vio, &p2.vio, &g.vio);

return 0;
}

int texn (void)
{
printf ("Ανάπτυξη Εφαρμογών / Χημεία-Βιοχημεία: ");
scanf ("%d, %d, %lf", &p1.aexv, &p2.aexv, &g.aexv);

printf ("Διοίκηση Επιχειρήσεων / Ηλεκτρολογία: ");
scanf ("%d, %d, %lf", &p1.dei, &p2.dei, &g.dei);

return 0;
}

int thetexn (void)
{
printf ("Μαθηματικά: ");
scanf ("%d, %d, %lf", &p1.math, &p2.math, &g.math);

printf ("Φυσική: ");
scanf ("%d, %d, %lf", &p1.fis, &p2.fis, &g.fis);

printf ("Νεοελ. Γλώσσα: ");
scanf ("%d, %d, %lf", &p1.glo, &p2.glo, &g.glo);

return 0;
}

int pediop (void)
{
printf ("Οικονομία: ");
scanf ("%d, %d, %lf", &p1.ikon, &p2.ikon, &g.ikon);

printf ("Μαθηματικά Γενικής: ");
scanf ("%d, %d, %lf", &p1.mathg, &p2.mathg, &g.mathg);

return 0;
}

int ist (void)
{
printf ("Ιστορία: ");
scanf ("%d, %d, %lf", &p1.istg, &p2.istg, &g.istg);

return 0;
}

int epil (void)
{
printf ("Επιλογής: ");
scanf ("%d, %d, %lf", &p1.epi, &p2.epi, &g.epi);

return 0;
}

int vio (void)
{
printf ("Βιολογία Γενικής: ");
scanf ("%d, %d, %lf", &p1.viog, &p2.viog, &g.viog);

return 0;
}

int lpedio (void)
{
printf ("Εσφαλμένη επιλογή πεδίου.");

return 0;
}

int lid (void)
{
printf ("Εσφαλμένη επιλογή ειδικού μαθήματος / ειδικών μαθημάτων.");

return 0;
}

int wtf (void)
{
printf ("Κάτι πήγε στραβά... WTF.");

return 0;
}

int ksthetexnpe (void)
{
if (idm == 0) mor = ( (8 * gbp) + (0.9 * bp.glo) + (0.4 * bp.ist) ) * 100;
else mor = ( (8 * gbp) + (0.9 * bp.glo) + (0.4 * bp.ist) + (syn * b.id) ) * 100;

return 0;
}

int ksthetexnpdt (void)
{
if (idm == 0) mor = ( (8 * gbp) + (1.3 * bp.math) + (0.7 * bp.fis) ) * 100;
else mor = ( (8 * gbp) + (1.3 * bp.math) + (0.7 * bp.fis) + (syn * b.id) ) * 100;

return 0;
}

int kstheortexn (void)
{
if (idm == 0) mor = ( (8 * gbp) + (0.9 * bp.viog) + (0.4 * bp.glo) ) * 100;
else mor = ( (8 * gbp) + (0.9 * bp.viog) + (0.4 * bp.glo) + (syn * b.id) ) * 100;

return 0;
}

int kskatpp (void)
{
if (idm == 0) mor = ( (8 * gbp) + (1.3 * bp.ikon) + (0.7 * bp.mathg) ) * 100;
else mor = ( (8 * gbp) + (1.3 * bp.ikon) + (0.7 * bp.mathg) + (syn * b.id) ) * 100;

return 0;
}

double stredp (double x)
{
return floor (x * 10 + 0.5) / 10;
}

double strddp (double x)
{
return floor (x * 100 + 0.5) / 100;
}

int prva (void)
{
pb.arx = (p1.arx + p2.arx) / 2;
pb.ist = (p1.ist + p2.ist) / 2;
pb.logot = (p1.logot + p2.logot) / 2;
pb.lat = (p1.lat + p2.lat) / 2;

pb.math = (p1.math + p2.math) / 2;
pb.fis = (p1.fis + p2.fis) / 2;

pb.xim = (p1.xim + p2.xim) / 2;
pb.vio = (p1.vio + p2.vio) / 2;

pb.aexv = (p1.aexv + p2.aexv) / 2;
pb.dei = (p1.dei + p2.dei) / 2;

pb.glo = (p1.glo + p2.glo) / 2;
pb.epi = (p1.epi + p2.epi) / 2;
pb.mathg = (p1.mathg + p2.mathg) / 2;
pb.viog = (p1.viog + p2.viog) / 2;
pb.ikon = (p1.ikon + p2.ikon) / 2;
pb.istg = (p1.istg + p2.istg) / 2;

if (pb.arx < g.arx - 2)
{
d.arx = g.arx - 2 - pb.arx;
pb.arx += d.arx;
}

if (pb.arx > g.arx + 2)
{
d.arx = g.arx + 2 - pb.arx;
pb.arx += d.arx;
}

if (pb.ist < g.ist - 2)
{
d.ist = g.ist - 2 - pb.ist;
pb.ist += d.ist;
}

if (pb.ist > g.ist + 2)
{
d.ist = g.ist + 2 - pb.ist;
pb.ist += d.ist;
}

if (pb.logot < g.logot - 2)
{
d.logot = g.logot - 2 - pb.logot;
pb.logot += d.logot;
}

if (pb.logot > g.logot + 2)
{
d.logot = g.logot + 2 - pb.logot;
pb.logot += d.logot;
}

if (pb.lat < g.lat - 2)
{
d.lat = g.lat - 2 - pb.lat;
pb.lat += d.lat;
}

if (pb.lat > g.lat + 2)
{
d.lat = g.lat + 2 - pb.lat;
pb.lat += d.lat;
}

if (pb.math < g.math - 2)
{
d.math = g.math - 2 - pb.math;
pb.math += d.math;
}

if (pb.math > g.math + 2)
{
d.math = g.math + 2 - pb.math;
pb.math += d.math;
}

if (pb.fis < g.fis - 2)
{
d.fis = g.fis - 2 - pb.fis;
pb.fis += d.fis;
}

if (pb.fis > g.fis + 2)
{
d.fis = g.fis + 2 - pb.fis;
pb.fis += d.fis;
}

if (pb.xim < g.xim - 2)
{
d.xim = g.xim - 2 - pb.xim;
pb.xim += d.xim;
}

if (pb.xim > g.xim + 2)
{
d.xim = g.xim + 2 - pb.xim;
pb.xim += d.xim;
}

if (pb.vio < g.vio - 2)
{
d.vio = g.vio - 2 - pb.vio;
pb.vio += d.vio;
}

if (pb.vio > g.vio + 2)
{
d.vio = g.vio + 2 - pb.vio;
pb.vio += d.vio;
}

if (pb.aexv < g.aexv - 2)
{
d.aexv = g.aexv - 2 - pb.aexv;
pb.aexv += d.aexv;
}

if (pb.aexv > g.aexv + 2)
{
d.aexv = g.aexv + 2 - pb.aexv;
pb.aexv += d.aexv;
}

if (pb.dei < g.dei - 2)
{
d.dei = g.dei - 2 - pb.dei;
pb.dei += d.dei;
}

if (pb.dei > g.dei + 2)
{
d.dei = g.dei + 2 - pb.dei;
pb.dei += d.dei;
}

if (pb.glo < g.glo - 2)
{
d.glo = g.glo - 2 - pb.glo;
pb.glo += d.glo;
}

if (pb.glo > g.glo + 2)
{
d.glo = g.glo + 2 - pb.glo;
pb.glo += d.glo;
}

if (pb.epi < g.epi - 2)
{
d.epi = g.epi - 2 - pb.epi;
pb.epi += d.epi;
}

if (pb.epi > g.epi + 2)
{
d.epi = g.epi + 2 - pb.epi;
pb.epi += d.epi;
}

if (pb.mathg < g.mathg - 2)
{
d.mathg = g.mathg - 2 - pb.mathg;
pb.mathg += d.mathg;
}

if (pb.mathg > g.mathg + 2)
{
d.mathg = g.mathg + 2 - pb.mathg;
pb.mathg += d.mathg;
}

if (pb.viog < g.viog - 2)
{
d.viog = g.viog - 2 - pb.viog;
pb.viog += d.viog;
}

if (pb.viog > g.viog + 2)
{
d.viog = g.viog + 2 - pb.viog;
pb.viog += d.viog;
}

if (pb.ikon < g.ikon - 2)
{
d.ikon = g.ikon - 2 - pb.ikon;
pb.ikon += d.ikon;
}

if (pb.ikon > g.ikon + 2)
{
d.ikon = g.ikon + 2 - pb.ikon;
pb.ikon += d.ikon;
}

if (pb.istg < g.istg - 2)
{
d.istg = g.istg - 2 - pb.istg;
pb.istg += d.istg;
}

if (pb.istg > g.istg + 2)
{
d.istg = g.istg + 2 - pb.istg;
pb.istg += d.istg;
}

return 0;
}

int vapr (void)
{
bp.arx = (0.3 * pb.arx) + (0.7 * g.arx);
bp.ist = (0.3 * pb.ist) + (0.7 * g.ist);
bp.lat = (0.3 * pb.lat) + (0.7 * g.lat);
bp.logot = (0.3 * pb.logot) + (0.7 * g.logot);

bp.xim = (0.3 * pb.xim) + (0.7 * g.xim);
bp.vio = (0.3 * pb.vio) + (0.7 * g.vio);

bp.aexv = (0.3 * pb.aexv) + (0.7 * g.aexv);
bp.dei = (0.3 * pb.dei) + (0.7 * g.dei);

bp.math = (0.3 * pb.math) + (0.7 * g.math);
bp.fis = (0.3 * pb.fis) + (0.7 * g.fis);

bp.glo = (0.3 * pb.glo) + (0.7 * g.glo);
bp.epi = (0.3 * pb.epi) + (0.7 * g.epi);
bp.ikon = (0.3 * pb.ikon) + (0.7 * g.ikon);
bp.viog = (0.3 * pb.viog) + (0.7 * g.viog);
bp.istg = (0.3 * pb.istg) + (0.7 * g.istg);
bp.mathg = (0.3 * pb.mathg) + (0.7 * g.mathg);

bp.arx = stredp(bp.arx);
bp.ist = stredp(bp.ist);
bp.lat = stredp(bp.lat);
bp.logot = stredp(bp.logot);

bp.xim = stredp(bp.xim);
bp.vio = stredp(bp.vio);

bp.aexv = stredp(bp.aexv);
bp.dei = stredp(bp.dei);

bp.math = stredp(bp.math);
bp.fis = stredp(bp.fis);

bp.glo = stredp(bp.glo);
bp.epi = stredp(bp.epi);
bp.ikon = stredp(bp.ikon);
bp.viog = stredp(bp.viog);
bp.istg = stredp(bp.istg);
bp.mathg = stredp(bp.mathg);

return 0;
}

int main (void)
{
int theor (void);
int thet (void);
int texn (void);
int thetexn (void);
int pediop (void);
int ist (void);
int epil (void);
int vio (void);
int lpedio (void);
int prva (void);
int vapr (void);
int wtf (void);
int lid (void);
int ksthetexnpe (void);
int ksthetexnpdt (void);
int kstheortexn (void);
double stredp (double x);
double strddp (double x);

struct idmath b1, b2;

int kat, ped;

printf ("Κατεύθυνση: (1, 2 ή 3);\nΘεωρητική -> 1\nΘετική -> 2\nΤεχνολογική -> 3\nΑπάντηση: ");
scanf ("%d", &kat);

printf ("Πεδίο: (1, 2, 3, 4 ή 5);\nΑπάντηση: ");
scanf ("%d", &ped);

printf ("Ειδικά μαθήματα: (0, 1 ή 2); ");
scanf ("%d", &idm);

switch (idm)
{
case 0:
break;

case 1:
printf ("Βαθμός ειδικού μαθήματος: ");
scanf ("%lf", &b.id);
break;

case 2:
printf ("Βαθμός ειδικού μαθήματος 1: ");
scanf ("%lf", &b1.id);

printf ("Βαθμός ειδικού μαθήματος 2: ");
scanf ("%lf", &b2.id);

b.id = (b1.id + b2.id) / 2;
break;

default:
lid();
break;
}

if (idm != 0)
{
printf ("Συντελεστής μαθήματος / μαθημάτων: (1 ή 2);\nΑπάντηση: ");
scanf ("%d", &syn);
}

printf ("Οι βαθμολογίες να εισάγονται με την μορφή:\nΠροφορικός1, Προφορικός2, Γραπτός\n");

switch (kat)
{
case 1:
switch (ped)
{
case 1:
theor();
epil();
break;

case 2:
case 4:
theor();
printf ("Μαθηματικά Γενικής: ");
scanf ("%d, %d, %lf", &p1.mathg, &p2.mathg, &g.mathg);
break;

case 3:
theor();
vio();
break;

case 5:
theor();
pediop();
break;

default:
lpedio();
break;
}
break;

case 2:
switch (ped)
{
case 1:
thetexn();
thet();
ist();
break;

case 2:
case 3:
case 4:
thetexn();
thet();
epil();
break;

case 5:
thetexn();
thet();
pediop();
break;

default:
lpedio();
break;
}
break;

case 3:
switch (ped)
{
case 1:
thetexn();
texn();
ist();
break;

case 2:
case 4:
thetexn();
texn();
epil();
break;

case 3:
thetexn();
texn();
vio();
break;

case 5:
thetexn();
texn();
pediop();
break;

default:
lpedio();
break;
}
break;

default:
printf ("Εσφαλμένη επιλογή κατεύθυνσης.");
break;
}

prva();
vapr();

switch (kat)
{
case 1:
switch (ped)
{
case 1:
gbp = (bp.arx + bp.ist + bp.logot + bp.lat + bp.glo + bp.epi) / 6;
gbp = strddp (gbp);
break;

case 2:
case 4:
gbp = (bp.arx + bp.ist + bp.logot + bp.lat + bp.mathg + bp.glo) / 6;
gbp = strddp (gbp);
break;

case 3:
gbp = (bp.arx + bp.ist + bp.logot + bp.lat + bp.viog + bp.glo) / 6;
gbp = strddp (gbp);
break;

case 5:
gbp = (bp.arx + bp.ist + bp.logot + bp.lat + bp.glo + bp.mathg + bp.ikon) / 7;
gbp = strddp (gbp);
break;

default:
wtf();
break;
}
break;

case 2:
switch (ped)
{
case 1:
gbp = (bp.math + bp.fis + bp.xim + bp.vio + bp.glo + bp.istg) / 6;
gbp = strddp (gbp);
break;

case 2:
case 3:
case 4:
gbp = (bp.math + bp.fis + bp.xim + bp.vio + bp.glo + bp.epi) / 6;
gbp = strddp (gbp);
break;

case 5:
gbp = (bp.math + bp.fis + bp.xim + bp.vio + bp.glo + bp.ikon + bp.mathg) / 7;
gbp = strddp (gbp);
break;

default:
wtf();
break;
}
break;

case 3:
switch (ped)
{
case 1:
gbp = (bp.math + bp.fis + bp.aexv + bp.dei + bp.glo + bp.istg) / 6;
gbp = strddp (gbp);
break;

case 2:
case 4:
gbp = (bp.math + bp.fis + bp.aexv + bp.dei + bp.glo + bp.epi) / 6;
gbp = strddp (gbp);
break;

case 3:
gbp = (bp.math + bp.fis + bp.aexv + bp.dei + bp.viog + bp.glo) / 6;
gbp = strddp (gbp);
break;

case 5:
gbp = (bp.math + bp.fis + bp.aexv + bp.dei + bp.glo + bp.ikon + bp.mathg) / 7;
gbp = strddp (gbp);
break;

default:
wtf();
break;
}
break;

default:
wtf();
break;
}

switch (kat)
{
case 1:
switch (ped)
{
case 1:
if (idm == 0) mor = ( (8 * gbp) + (1.3 * bp.arx) + (0.7 * bp.ist) ) * 100;
else mor = ( (8 * gbp) + (1.3 * bp.arx) + (0.7 * bp.ist) + (syn * b.id) ) * 100;
break;

case 2:
case 4:
if (idm == 0) mor = ( (8 * gbp) + (0.9 * bp.mathg) + (0.4 * bp.glo) ) * 100;
else mor = ( (8 * gbp) + (0.9 * bp.mathg) + (0.4 * bp.glo) + (syn * b.id) ) * 100;
break;

case 3:
kstheortexn();
break;

case 5:
kskatpp();
break;

default:
wtf();
break;
}
break;

case 2:
switch (ped)
{
case 1:
ksthetexnpe();
break;

case 2:
case 4:
ksthetexnpdt();
break;

case 3:
if (idm == 0) mor = ( (8 * gbp) + (1.3 * bp.vio) + (0.7 * bp.xim) ) * 100;
else mor = ( (8 * gbp) + (1.3 * bp.vio) + (0.7 * bp.xim) + (syn * b.id) ) * 100;
break;

case 5:
kskatpp();
break;

default:
wtf();
break;
}
break;

case 3:
switch (ped)
{
case 1:
ksthetexnpe();
break;

case 2:
case 4:
ksthetexnpdt();
break;

case 3:
kstheortexn();
break;

case 5:
kskatpp();
break;

default:
wtf();
break;
}
break;

default:
wtf();
break;
}

printf ("Μόρια: %d\n", mor);

return 0;
}
Τελευταία επεξεργασία από UnKnown96 και 25 Δεκ 2012, 12:37, έχει επεξεργασθεί 2 φορά/ες συνολικά
Άβαταρ μέλους
UnKnown96
dudeTUX
dudeTUX
 
Δημοσιεύσεις: 370
Εγγραφή: 08 Ιουν 2010, 15:23
Τοποθεσία: Ρόδος
Εκτύπωση

Re: Υπολογισμός μορίων - C

Δημοσίευσηαπό parenthesis » 24 Δεκ 2012, 18:58

Βλέπω ότι εδώ έχουν δώσει μια πολύ καλή λύση για στρογγυλοποίηση στο δεύτερο δεκαδικό ψηφίο. Σε βοηθάει καθόλου;
1 Γνώσεις Linux: Πρώτα βήματα ┃ Προγραμματισμού: Ικανοποιητικό ┃ Αγγλικών: Πολύ καλό
2 Dual boot:
  • Ubuntu 13.04 raring 3.8.0-34-generic 64bit (el_GR.UTF-8, Unity ubuntu), Ubuntu 3.8.0-19-generic
  • Fedora 19 Schrödinger’s Cat 3.13.5-101.fc19.x86_64 64bit (el_GR.utf8, gnome)
3 Intel Core i5-3337U CPU @ 1.80GHz ‖ RAM 3844 MiB ‖ TOSHIBA VCUAA - TOSHIBA SATELLITE U940
4 Intel 3rd Gen Core processor Graphics Controller [8086:0166] {i915}
5 eth0: Realtek RTL8101E/RTL8102E Ethernet [10ec:8136] (rev 05) ⋮ wlan0: Intel Centrino Wireless-N 2230 [8086:0887] (rev c4)
Άβαταρ μέλους
parenthesis
punkTUX
punkTUX
 
Δημοσιεύσεις: 150
Εγγραφή: 06 Οκτ 2009, 22:47
Launchpad: mara_sdr
Εκτύπωση

Re: Υπολογισμός μορίων - C

Δημοσίευσηαπό UnKnown96 » 24 Δεκ 2012, 19:01

Είναι αυτό που χρησιμοποίησα αλλά δεν βγαίνει ακριβώς με αυτόν το τρόπο.
Για παράδειγμα με αυτόν τον τρόπο αν <<στρογγυλοποιήσω>> το 1.89 στο 1 δεκαδικό ψηφίο θα γίνει 1.8.
Ενώ μια κανονική στρογγυλοποίηση θα έβγαζε 1.9.
Άβαταρ μέλους
UnKnown96
dudeTUX
dudeTUX
 
Δημοσιεύσεις: 370
Εγγραφή: 08 Ιουν 2010, 15:23
Τοποθεσία: Ρόδος
Εκτύπωση

Re: Υπολογισμός μορίων - C

Δημοσίευσηαπό clepto » 24 Δεκ 2012, 19:33

μπορείς να σπας τον αριθμό σε 3 ψηφία πχ 1 - 8 - 9 και μετά να ελέγχεις αν το τρίτο είναι μεγαλύτερο του 5, αν είναι τότε να αυξάνεις το δεύτερο κατά 1 αλλά να ελέγχεις αν γίνεται 10 ώστε να αυξάνεις και το πρώτο, αν δεν είναι μεγαλύτερο του 5 τότε να το μειώνεις κατά 1
1 Γνώσεις Linux: Ικανοποιητικό ┃ Προγραμματισμού: Ικανοποιητικό ┃ Αγγλικών: Ικανοποιητικό
2 Ubuntu 13.04 raring 3.8.0-30-generic 64bit (en_US.UTF-8, Unity ubuntu), Ubuntu 3.8.0-19-generic, Windows 7
3 Intel Core i7-3537U CPU @ 2.00GHz ‖ RAM 3840 MiB ‖ ASUS K56CB
4 Intel 3rd Gen Core processor Graphics Controller [8086:0166] {i915}
5 wlan0: Atheros Inc. AR9485 Wireless Network Adapter [168c:0032] (rev 01) ⋮ eth0: Realtek RTL8111/8168 PCI Express Gigabit Ethernet controller [10ec:8168] (rev 0a)
clepto
antiwinTUX
antiwinTUX
 
Δημοσιεύσεις: 4102
Εγγραφή: 07 Ιαν 2010, 16:27
Τοποθεσία: Πάτρα
Launchpad: christriant
IRC: Clepto
Εκτύπωση

Re: Υπολογισμός μορίων - C

Δημοσίευσηαπό UnKnown96 » 24 Δεκ 2012, 19:40

Δεν ξέρω πόσα ψηφία είναι κάθε φορά, λογικά όμως, η γλώσσα θα έχει κάποιο όριο στα δεκαδικά ψηφία που θα δέχεται.
Από την άλλη πάλι, ακόμα και να ξέρω το όριο πως θα σπάσω τον αριθμό; Στην C δεν νομίζω να υπάρχει κάποιος απλός τρόπος...
Άβαταρ μέλους
UnKnown96
dudeTUX
dudeTUX
 
Δημοσιεύσεις: 370
Εγγραφή: 08 Ιουν 2010, 15:23
Τοποθεσία: Ρόδος
Εκτύπωση

Re: Υπολογισμός μορίων - C

Δημοσίευσηαπό simosx » 24 Δεκ 2012, 20:10

UnKnown96 έγραψε:Αυτό που δεν μπόρεσα είναι το εξής: Πρέπει να στρογγυλοποιώ μερικά νούμερα σε ένα ή δύο δεκαδικά ψηφία.
Επειδή δεν ήξερα πως να το κάνω, έκανα κάτι άλλο το οποίο πέφτει πολύ κοντά (κρατάει μόνο το πρώτο ή τα δύο πρώτα δεκαδικά ψηφία) αλλά και πάλι όχι ακριβώς...
Αν μπορεί κάποιος να μου δώσει μία έτοιμη συνάρτηση που να δέχεται double και να κάνει αυτή την δουλεία ή να μου δώσουν μερικά tips που να με βοηθήσουν να την φτιάξω μόνος μου, θα μου ήταν πολύ χρήσιμο.


Το τυπικό είναι να διατηρείς όσο πιο μεγάλη ακρίβεια εσωτερικά στο πρόγραμμά σου, και κατά την εμφάνιση των δεδομένων να στρογγυλοποιείς ανάλογα με τις ανάγκες.
Έτσι, δες
Κώδικας: Επιλογή όλων
#include <stdio.h>

int main(void)
{
printf("Αποτέλεσμα: %.1f\n", 1.89);

return 0;
}


Δηλαδή, μπορείς να χρησιμοποιήσεις επιλογές που δίνει η printf() για να κάνεις την τελική στρογγυλοποίηση για τις ανάγκες της εμφάνισης των δεδομένων.
Με man printf πρέπει να μπορείς να δεις περισσότερα για τις παραμέτρους που μπορούν να μπουν στο %f.
Σε C++ αυτό γίνεται με <iomanip>.
προσωπικό ιστολόγιο ϗ πλανήτης Ubuntu-gr
Συμβάλετε και εσείς στο ελληνικό βιβλίο Ubuntu!
1 Γνώσεις Linux: Πολύ καλό ┃ Προγραμματισμού: Πολύ καλό ┃ Αγγλικών: Πολύ καλό
2 Ubuntu 13.10 saucy 3.11.0-031100rc1-generic 64bit (el_GR.UTF-8, Unity ubuntu)
3 AMD E-450 APU with Radeon HD Graphics ‖ RAM 3555 MiB ‖ Sony Corporation VAIO
4 AMD nee ATI Wrestler [Radeon HD 6320] [1002:9806] {fglrx_pci}
5 eth0: Atheros Inc. AR8151 v2.0 Gigabit Ethernet [1969:1083] (rev c0) ⋮ wlan0: Atheros Inc. AR9285 [168c:002b] (rev 01)
Φτιάξτε και εσείς τη δική σας υπογραφή (παραπάνω κείμενο) αυτόματα με κλικ εδώ!
simosx
Επίτιμο μέλος
Επίτιμο μέλος
 
Δημοσιεύσεις: 10334
Εγγραφή: 11 Μάιος 2008, 18:52
Launchpad: simosx
IRC: simosx
Εκτύπωση

Re: Υπολογισμός μορίων - C

Δημοσίευσηαπό UnKnown96 » 24 Δεκ 2012, 20:17

Ναι, το θέμα είναι ότι κάποιοι μπορούν και το βγάζουν ακριβώς.* Αυτό σημαίνει ότι υπάρχει τρόπος να στρογγυλοποιείς ορισμένο αριθμό δεκαδικών ψηφίων ή ακολούθησαν διαφορετική τακτική...

* Παράδειγμα: http://www.methodiko-frontistirio.gr/ex ... /marks.htm
Άβαταρ μέλους
UnKnown96
dudeTUX
dudeTUX
 
Δημοσιεύσεις: 370
Εγγραφή: 08 Ιουν 2010, 15:23
Τοποθεσία: Ρόδος
Εκτύπωση

Re: Υπολογισμός μορίων - C  Το θέμα επιλύθηκε

Δημοσίευσηαπό parenthesis » 24 Δεκ 2012, 22:34

Νομίζω ότι αυτός ο κώδικας κάνει τη δουλειά που θες.
Στρογγυλοποιώ στο πρώτο, δεύτερο και τρίτο ψηφίο αντίστοιχα...

Κώδικας: Επιλογή όλων
#include <stdio.h>
#include <math.h>

int main (void) {
double a = 1.72931;

double nearest = floor(a * 10 + 0.5) / 10;
printf("%f\n", nearest);

nearest = floor(a * 100 + 0.5) / 100;
printf("%f\n", nearest);

nearest = floor(a * 1000 + 0.5) / 1000;
printf("%f\n", nearest);

return 0;
}
1 Γνώσεις Linux: Πρώτα βήματα ┃ Προγραμματισμού: Ικανοποιητικό ┃ Αγγλικών: Πολύ καλό
2 Dual boot:
  • Ubuntu 13.04 raring 3.8.0-34-generic 64bit (el_GR.UTF-8, Unity ubuntu), Ubuntu 3.8.0-19-generic
  • Fedora 19 Schrödinger’s Cat 3.13.5-101.fc19.x86_64 64bit (el_GR.utf8, gnome)
3 Intel Core i5-3337U CPU @ 1.80GHz ‖ RAM 3844 MiB ‖ TOSHIBA VCUAA - TOSHIBA SATELLITE U940
4 Intel 3rd Gen Core processor Graphics Controller [8086:0166] {i915}
5 eth0: Realtek RTL8101E/RTL8102E Ethernet [10ec:8136] (rev 05) ⋮ wlan0: Intel Centrino Wireless-N 2230 [8086:0887] (rev c4)
Άβαταρ μέλους
parenthesis
punkTUX
punkTUX
 
Δημοσιεύσεις: 150
Εγγραφή: 06 Οκτ 2009, 22:47
Launchpad: mara_sdr
Εκτύπωση

Re: Υπολογισμός μορίων - C

Δημοσίευσηαπό UnKnown96 » 24 Δεκ 2012, 23:23

parenthesis έγραψε:Βλέπω ότι εδώ έχουν δώσει μια πολύ καλή λύση για στρογγυλοποίηση στο δεύτερο δεκαδικό ψηφίο. Σε βοηθάει καθόλου;

parenthesis έγραψε:Νομίζω ότι αυτός ο κώδικας κάνει τη δουλειά που θες.
Στρογγυλοποιώ στο πρώτο, δεύτερο και τρίτο ψηφίο αντίστοιχα...

Κώδικας: Επιλογή όλων
#include <stdio.h>
#include <math.h>

int main (void) {
double a = 1.72931;

double nearest = floor(a * 10 + 0.5) / 10;
printf("%f\n", nearest);

nearest = floor(a * 100 + 0.5) / 100;
printf("%f\n", nearest);

nearest = floor(a * 1000 + 0.5) / 1000;
printf("%f\n", nearest);

return 0;
}


Όντως. Μέχρι που το έκανα με το χέρι, δεν καταλάβαινα πως δουλεύει.
Ευχαριστώ πολύ.
Άβαταρ μέλους
UnKnown96
dudeTUX
dudeTUX
 
Δημοσιεύσεις: 370
Εγγραφή: 08 Ιουν 2010, 15:23
Τοποθεσία: Ρόδος
Εκτύπωση


Επιστροφή στο Ανάπτυξη Λογισμικού / Αλγόριθμοι