Pubblicità
te l'ho detto almeno 3 volte, 9^10 dentro 32 bit non ci va ed è solo un esempio, anche 8^10 fa più di un miliardo, il che significa che qualunque numero di 10 cifre che abbia 4-5 cifre 8 fa sbagliare i calcoli
ah, ops. Non me ne ero accorto. Correggo subito
Le ho notate adesso, sistemo
#include <stdio.h>
#include <inttypes.h>
int64_t myPow(int base, int exponent) {
int64_t base2 = base;
for(int i = 0; i < exponent; i++) {
base *= base2;
}
return base;
}
int64_t isArmstrong(int64_t num) {
int64_t digit, powered_digit, num2 = num, num3 = num, exponent = 0, check_num = 0;
if(num < 10) return 1;
while(num2 != 0) {
num2 /= 10;
exponent++;
}
while(num != 0) {
digit = num % 10;
powered_digit = myPow(digit, exponent);
check_num += powered_digit;
}
return check_num == num3;
}
int main(int argc, char const *argv[]) {
for(int64_t i = 0; i < 2000000; i++) {
if(isArmstrong(i)) printf("%lld\n", i);
}
return 0;
}
printf("%" PRId64 "\n", i);check_num += myPow(num % 10, exponent);Ho dimenticato di postarlo, ma l'avevo aggiunto.
Non ho capito, puoi spiegarmi meglio?
la variabile che memorizza il prodotto deve essere inizializzata a 1 (come inizializzi a zero quella della somma)
Un codice scritto bene NON richiede nessun commento. Come dice Robert Martin (l’autore di Clean Code) sono veramente pochissimi i casi in cui i commenti siano “accettabili” (neanche “necessari”); un codice scritto bene si auto commenta da solo.
il nostro amico sta imparando a programmare, come mantra ci martellavano "date nomi significativi alle variabili, mettete dei commenti"
non mi sembra proprio, se il codice è rimasto quello di prima e non lo hai corretto il calcolo è sbagliato, fa una moltiplicazione di troppo, l'inizializzazione è errata;
Pubblica anche quello, così vediamo come l'hai scritto. Anzi, pubblicali entrambi.
Ho riso appena ho letto questo post.
public class Main {
public static long pow(long base, int exponent) {
long base2 = 1;
for (int i = 0; i < exponent; i++) {
base2 *= base;
}
return base2;
}
public static boolean isArmstrong(long num) {
long num2 = num, num3 = num, check_num = 0;
int exponent = 0;
if (num < 10) return true;
while (num2 != 0) {
num2 /= 10;
exponent++;
}
while (num != 0) {
check_num += pow(num % 10, exponent);
num /= 10;
}
return check_num == num3;
}
public static void main(String[] args) {
for (long i = 0; i < pow(2, 25); i++) {
if (isArmstrong(i)) System.out.println(i);
}
}
}#include <stdio.h>
#include <inttypes.h>
int64_t myPow(int base, int exponent) {
int64_t base2 = 1;
for(int i = 0; i < exponent; i++) {
base2 *= base;
}
return base2;
}
int64_t isArmstrong(int64_t num) {
int64_t num2 = num, num3 = num, exponent = 0, check_num = 0;
if(num < 10) return 1;
while(num2 != 0) {
num2 /= 10;
exponent++;
}
while(num != 0) {
check_num += myPow(num % 10, exponent);
num /= 10;
}
return check_num == num3;
}
int main(int argc, char const *argv[]) {
for(int64_t i = 0; i < myPow(2, 25); i++) {
if(isArmstrong(i)) printf("%" PRId64 "\n", i);
}
return 0;
}0
1
2
3
4
5
6
7
8
9
153
370
371
407
1634
8208
9474
54748
92727
93084
548834
1741725
4210818
9800817
9926315
24678050
24678051
real 0m1,435s
user 0m1,372s
sys 0m0,020s0
1
2
3
4
5
6
7
8
9
153
370
371
407
1634
8208
9474
54748
92727
93084
548834
1741725
4210818
9800817
9926315
24678050
24678051
real 0m5,460s
user 0m5,455s
sys 0m0,004sFa stranissimo anche a me, ma a quanto pare il java è quasi 5 volte più veloce
Ma lo hai compilato con l'opzione -O3 (o almeno -O2)?
