Multiplisera i en for loop.

var res = 1;
for (int i = x; i > 0; i--) {
   res *= i;
}

Nåt i den stilen borde fungera

Skickades från m.sweclockers.com

Och vad är det som inte fungerar?

Klistra in all din kod i CODE-taggar så kan vi se vart felet ligger.

I din "initiering" gör du

int total = x;

Varför?

Initiera den till noll, det är mer logiskt. Om du går igenom din loop med penna och papper så kommer du se varför resultatet blir som det blir, och du hittar enkelt felet.

        int x;
	cin >> x;
	int total = x;

	for (int i = x ; i > 0; i--) {
		total = total * i;
		cout << total << endl;
        }

Det är för att

loop 1:
Total(16) = total(4) * i(4)

loop 2:
Total(48) = total(16) * i(3)
osv

Skriv ut X
sedan en loop med
(int i = x-1; i <1 ; i--)

då får du
Total (4)

första loopen
Total (12) = Total (4) * i (3)

andra loopen
Total (24) = Total (12) * i (2)

tredje loopen
Total (24) = Total (24) * i (1)

Precis, jag skulle bara se så ni var vakna

Jag är nog lite anti mot rekursiva funktioner då det ofta resulterar i stack overflow om man använder sig av det i programmering, dock beror det ju på hur stor data man jobbar på och djupet på rekursionen, så i detta fall skulle det fungera hyfsat.

Yes, Java är kanske inte det mest optimala språket att skriva rekursiva funktioner i.

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return factorial(n - 1);
    }
}

public static int factorial(int n) {
    return n == 0 ? 1 : factorial(n - 1);
}

public static int factorial(int n) {
    if (n < 0) {
        throw new IllegalArgumentException("Cannot compute factorial of "+n+" because it is negative.");
    }
    return n == 0 ? 1 : factorial(n - 1);
}

Du har ju i texten skrivit att man ska returnera n * (n-1)!, men så tycker jag inte att det ser ut i din kod?

Såhär borde det väl vara?

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

måste du va så dryg attityd? man fattar va man menar,,, va e meningen me o klaga på små detaljer,,,,

Skämt åsido. Obegripligt hur jag kunde klanta till det så. TACK för att du uppmärksammade det! Ska genast ändra.

Håller med. I vissa fall blir det väldigt mycket enklare att lösa ett problem med en rekursiv lösning, men man ska nog akta sig för att använda det som förstatanke. Framförallt när man jobbar i språk som C++, Java och C# då ingen av dessa garanterar att svansrekursion optimeras till en iterativ loop som inte äter stack.

I detta specifika fall är ju en iterativ lösning bland det enklast man kan göra och det är absolut den mest effektiva.

unsigned fac(unsigned n)
{
    if (n <= 1) {
        return 1;
    }
    return n * fac(n - 1);
}

är inte svansrekursiv, så går aldrig att optimera.

Går att skriva om så här för att göra den svansrekursiv

unsigned fac(unsigned n, unsigned acc = 1)
{
    if (n <= 1) {
        return acc;
    }
    return fac(n - 1, acc * n);
}

men är detta verkligen att föredra över en enkel "for"-loop?

Är heller ingen garanti att detta blir omskriven till en iterativ algoritm av kompilatorn, även om det i praktiken är fallet med de flesta moderna kompilatorer.

Här är en variant som använder constexpr för att om möjligt utföra beräkningen redan vid kompileringstid:

constexpr int factorial(const int n)
{
    return n <= 1 ? n : n * factorial(n - 1); 
}

Körbart demo:
https://godbolt.org/g/NizxP1

@Tunnelsork: ett lysande exempel på där C++11 är ett klart fall framåt jämfört med tidigare. Samma effekt kan uppnås med pre-C++11 så här

// Rekursiva fallet
template<int N>
struct factorial {
    enum { 
        value = N * factorial<N - 1>::value 
    };
};

// Basfallet där N==0
template<>
struct factorial<0> {
    enum { 
        value = 1 
    };
};

int main()
{
    std::cout << factorial<5>::value << std::endl;
}

Kanske lite svårare att följa

För den som absolut inte vill använda "for" i C++ finns faktiskt en del färdiga verktyg i standardbiblioteket. Detta kräver C++11

unsigned factorial(unsigned n)
{
    std::vector<unsigned> seq(n);
    std::iota(std::begin(seq), std::end(seq), 1);
    return std::accumulate(std::begin(seq), std::end(seq), 1, std::multiplies<unsigned>());
}

Svårt att se att någon skulle välja detta över en for-loop i just detta fall dock...

Det finns språk som faktiskt saknar for-loopar, ett exempel är Ruby och där skulle nog de flesta köra just varianten ovan här. Fast syntaxen för detta är lite mer lättläst i Ruby.

def factorial(n)
    n.downto(1).inject(1, &:*)
end

Detta säger: starta från n, skapa en sekvens av heltal ner till ett (inklusive). Ta denna sekvens, applicera sedan metoden "*" (multiplicera) på hela sekvensen, left-hand-side är resultatet av föregående beräkning och man startar med 1 (första argumentet till inject).

Samma sak gäller rekursion. Man ska vara försiktig med detta i språk som t.ex. C++, Java och C# då dessa har en fixerad storlek på anropsstacken och de garanterar inte att en konstant mängd stack-utrymme används för svansrekursiva funktioner.

Finns språk där optimering av svansrekursion är en del av språkdefinitionen och typisk saknas där motsvarande "for-loop". Många Lisp-dialekter och i princip alla funktionella språk fungerar så.

Finns också språk/miljöer där anropsstacken kan växa dynamisk, två sådana exempel är Erlang och Go. I det läget väljer man naturligtvis en rekursiv lösning så fort det passar.

I fall där en rekursiv lösning inte kan göras svansrekursiv men ändå är det enklaste sättet och man sitter med C++, Java eller C# så går det alltid att helt mekaniskt att översätta en rekursiv funktion till en iterativ funktion + separat stack. Kanske inte verkar som en förbättring, men det är det då stacken i detta fall ligger på heap:en så den kan växa dynamiskt!

Annars kan man ju alltid använda boost

Ruby har ju dock for-loopar:

res = 1;
for i in 1..5
  res *= i;
end

puts "result = #{res}"