[RESOLVIDO] Cálculo fatorial de um array

Programação Java
,
#1

Pessoal, tenho um problema aqui. Eu preciso fazer um programa que armazene em um array o cálculo fatorial dos números de 20 à 80, com a exceção dos números 24 à 28, 34 à 38 e 60 à 70.

#2 
class fatorialRange {
          private static int fat(int n) {
                     if (n == 1 || n == 0) return 1;
                     return n * fat(n - 1);
          }

          int range[3][2] = new int[3][2];
          range = { {24, 28}, {34, 38}, {60, 70} };

          long int fat_list[61] = new int[61]; // 80 - 20 + 1
          public static void main(String[] args) {
                for(int i = 0; i < fat_list.length; i++) {
                       if (i >= range[0][0] && i <= range[0][1] ||
                           i >= range[1][0] && i <= range[1][1] ||
                           i >= range[2][0] && i <= range[2][1])
                                   continue;

                       int res = fat(i);
                       fat_list[i] = res;
                       System.out.println(res);
          }
  }

Olá amigo, nao sou muito bom com java e provavelmente tem uma solução melhor para fazer essa questão como usar a classes ‘java.util.List’ e ‘java.util.ArrayList’ para fazer os array e assim ocupar menos memoria, como no ‘fat_list’ que tem ao todo 61 “espaços” no array (80 - 20 + 1, da o numero de valores ente 20 e 80 incluindo o 20). Onde nem todos os “espaços” são usados.
Também nao sei se o tipo ‘long int’ vai conseguir armazena os valores do fatorial, logo que esses valores sao muito grande.

Obs.: não testei o codigo apenas fiz de cabeça aqui bem rápido.

Espero ter ajudado, vlw!

#3

Testei o código, mas não funcionou. :cry:

#4

Poste o que você já fez!

80! vai dar um valor ABSURDAMENTE grande: 71569457046263802294811533723186532165584657342365752577109445058227039255480148842668944867280814080000000000000000000

O @Edinho013 postou algo muito ineficiente para o que você precisa. Ele implementou de forma recursiva e para cada posição, o cálculo é feito novamente. Uma abordagem menos pior seria usar programação dinâmica, pois quando você for calcular o fatorial de n, vc já terá o fatorial de n-1. Outra coisa, você vai precisar usar a classe BigInteger para o seu problema, pois a função fatorial cresce MUITO rápido.

import java.math.BigInteger;

/**
 *
 * @author David
 */
public class BigFat {

    /**
     * @param args the command line arguments
     */
    public static void main( String[] args ) {
        
        BigInteger[] fat = new BigInteger[81];
        fat[0] = BigInteger.ONE;
        
        for ( int i = 1; i < fat.length; i++ ) {
            fat[i] = fat[i-1].multiply( BigInteger.valueOf( i ) );
        }
        
        for ( int i = 0; i < fat.length; i++ ) {
            System.out.printf( "%d! = %d\n", i, fat[i] );
        }
        
    }
    
}

Saída:

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800
11! = 39916800
12! = 479001600
13! = 6227020800
14! = 87178291200
15! = 1307674368000
16! = 20922789888000
17! = 355687428096000
18! = 6402373705728000
19! = 121645100408832000
20! = 2432902008176640000
21! = 51090942171709440000
22! = 1124000727777607680000
23! = 25852016738884976640000
24! = 620448401733239439360000
25! = 15511210043330985984000000
26! = 403291461126605635584000000
27! = 10888869450418352160768000000
28! = 304888344611713860501504000000
29! = 8841761993739701954543616000000
30! = 265252859812191058636308480000000
31! = 8222838654177922817725562880000000
32! = 263130836933693530167218012160000000
33! = 8683317618811886495518194401280000000
34! = 295232799039604140847618609643520000000
35! = 10333147966386144929666651337523200000000
36! = 371993326789901217467999448150835200000000
37! = 13763753091226345046315979581580902400000000
38! = 523022617466601111760007224100074291200000000
39! = 20397882081197443358640281739902897356800000000
40! = 815915283247897734345611269596115894272000000000
41! = 33452526613163807108170062053440751665152000000000
42! = 1405006117752879898543142606244511569936384000000000
43! = 60415263063373835637355132068513997507264512000000000
44! = 2658271574788448768043625811014615890319638528000000000
45! = 119622220865480194561963161495657715064383733760000000000
46! = 5502622159812088949850305428800254892961651752960000000000
47! = 258623241511168180642964355153611979969197632389120000000000
48! = 12413915592536072670862289047373375038521486354677760000000000
49! = 608281864034267560872252163321295376887552831379210240000000000
50! = 30414093201713378043612608166064768844377641568960512000000000000
51! = 1551118753287382280224243016469303211063259720016986112000000000000
52! = 80658175170943878571660636856403766975289505440883277824000000000000
53! = 4274883284060025564298013753389399649690343788366813724672000000000000
54! = 230843697339241380472092742683027581083278564571807941132288000000000000
55! = 12696403353658275925965100847566516959580321051449436762275840000000000000
56! = 710998587804863451854045647463724949736497978881168458687447040000000000000
57! = 40526919504877216755680601905432322134980384796226602145184481280000000000000
58! = 2350561331282878571829474910515074683828862318181142924420699914240000000000000
59! = 138683118545689835737939019720389406345902876772687432540821294940160000000000000
60! = 8320987112741390144276341183223364380754172606361245952449277696409600000000000000
61! = 507580213877224798800856812176625227226004528988036003099405939480985600000000000000
62! = 31469973260387937525653122354950764088012280797258232192163168247821107200000000000000
63! = 1982608315404440064116146708361898137544773690227268628106279599612729753600000000000000
64! = 126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000
65! = 8247650592082470666723170306785496252186258551345437492922123134388955774976000000000000000
66! = 544344939077443064003729240247842752644293064388798874532860126869671081148416000000000000000
67! = 36471110918188685288249859096605464427167635314049524593701628500267962436943872000000000000000
68! = 2480035542436830599600990418569171581047399201355367672371710738018221445712183296000000000000000
69! = 171122452428141311372468338881272839092270544893520369393648040923257279754140647424000000000000000
70! = 11978571669969891796072783721689098736458938142546425857555362864628009582789845319680000000000000000
71! = 850478588567862317521167644239926010288584608120796235886430763388588680378079017697280000000000000000
72! = 61234458376886086861524070385274672740778091784697328983823014963978384987221689274204160000000000000000
73! = 4470115461512684340891257138125051110076800700282905015819080092370422104067183317016903680000000000000000
74! = 330788544151938641225953028221253782145683251820934971170611926835411235700971565459250872320000000000000000
75! = 24809140811395398091946477116594033660926243886570122837795894512655842677572867409443815424000000000000000000
76! = 1885494701666050254987932260861146558230394535379329335672487982961844043495537923117729972224000000000000000000
77! = 145183092028285869634070784086308284983740379224208358846781574688061991349156420080065207861248000000000000000000
78! = 11324281178206297831457521158732046228731749579488251990048962825668835325234200766245086213177344000000000000000000
79! = 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000
80! = 71569457046263802294811533723186532165584657342365752577109445058227039255480148842668944867280814080000000000000000000
1 curtida
#5

Então, eu consigo imprimir o fatorial do número 20 ao 80, mas eu não queria que mostrasse o fatorial do 24 ao 28, do 34 ao 38 e do 60 ao 70. Eu deveria utilizar o IF?

Vocês me deram uma luz, eu incrementei o seu código, ficou assim:

    public static void main(String[] args) {

    BigInteger[] vetor = new BigInteger[81];
    vetor[0] = BigInteger.ONE;

    for ( int i = 1; i < vetor.length; i++ ) {
        vetor[i] = vetor[i-1].multiply( BigInteger.valueOf( i ) );
    }

    for ( int i = 20; i < vetor.length; i++ ) {
        System.out.printf( "%d! = %d\n", i, vetor[i] );
    }
}
#6

Isso, agora põe um if ali dentro para testar os intervalos.

#7 
public static void main(String[] args) {
    BigInteger[] vetor = new BigInteger[81];
    vetor[0] = BigInteger.ONE;
    for (int i = 1; i < vetor.length; i++) {
        vetor[i] = vetor[i - 1].multiply(BigInteger.valueOf(i));
    }
    for (int i = 20; i < vetor.length; i++) {
        if (podeMostrar(i)) {
            System.out.printf("%d! = %d\n", i, vetor[i]);
        }
    }
}

private static boolean podeMostrar(int numero) {
    if (numero >= 24 && numero <= 28) {
        return false;
    }
    if (numero >= 34 && numero <= 38) {
        return false;
    }
    if (numero >= 60 && numero <= 70) {
        return false;
    }
    return true;
}
#8

Opa, deu certo, eu não estava conseguindo utilizar o if para testar os intervalos.