Faktoriál

Faktoriál je funkcia, ktorá priradí každému kladnému celému číslu x také číslo, ktoré sa rovná súčinu všetkých čísel menších alebo rovných x.

Napríklad teda: 5! = 5 * 4 * 3 * 2 * 1 = 120

Faktoriál má jeden špeciálny prípad, s ktorým musíme počítať, a to: 0! = 1

Samotný algoritmus je veľmi jednoduchý a možno ho napísať s rekurzia či bez rekurzia.

Ako prvý si uvedieme verziu bez rekurzia.

Do premennej s výsledkom si dosadíme číslo 1. Výpočet vykonáme jednoducho cyklom od 2 do x, pričom v každom kroku výsledok pronásobíme hodnotou premennej cyklu. Cyklus by mohol bežať aj od 1 do x, ale násobiť niečo jednotkou nedáva úplne zmysel Tiež by mohol bežať pospiatky, ako je faktoriál definovaný vyššie, ale popredu je to prirodzenejšie a pri násobenie nezáleží na poradí čísel. Keď sa zamyslíte, ľahko uhádnete, že tento postup bude fungovať aj pre x = 0, pretože na začiatku sa do výsledku dosadí jednotka a cyklus sa potom už nevykoná.

Poznámka: Jedná sa o veľmi rýchlo rastúci funkciu, teda si dávajte pozor na výpočet faktoriálov vysokých čísel. (5! = 120, ale 10! Je už v poriadku miliónov). Je teda potrebné rozmyslieť si výber dátového typu podľa hodnôt, ktoré bude funkcia spracovávať.

Funkcia tiež musí byť obmedzená len pre kladné čísla vrátane nuly, pretože sa záporným argumentom nemá zmysel. Je veľmi vhodné funkciu faktoriál obmedziť na nejakú maximálnu hodnotu (tu 10), aby výpočet nezasekol program alebo nezavinil výnimku pretečeniu pamäte. Ak budete chcieť počítať vyšší Faktoriál, je to s týmto algoritmom samozrejme možné, len budete potrebovať nejakú knižnicu, ktorá umožní prácu s veľkými číslami.

Zdrojový kód - bez rekurzia

public static int factorial(int x) {
  if (x < 0) throw new IllegalArgumentException("Argument je zaporny");
  if (x > 10) throw new IllegalArgumentException("Prilis vysoka hodnota");
  int result = 1;
  for (int i = 2; i <= x; i++) {
    result *= i;
  }
  return result;
}

public static int factorial(int x) {
  if (x < 0) throw new System.ArgumentException("Argument je zaporny", "x");
  if (x > 10) throw new System.ArgumentException("Prilis vysoka hodnota", "x");
  int result = 1;
  for (int i = 2; i <= x; i++) {
    result *= i;
  }
  return result;
}

function factorial(x: integer): longint;
var vysledek, i: integer;
begin
  if (x < 0) then Raise Exception.Create('Argument je zaporny');
  if (x > 10) then Raise Exception.Create('Prilis vysoka hodnota');
  vysledek:=1;
  for i:=2 to x do begin
    vysledek:=vysledek * i;
  end;
  result:=vysledek
end;

def factorial(x)
  raise "Argument je zaporny" if (x < 0)
  raise "Prilis vysoka hodnota" if (x > 10)
  result = 1
  2.upto(x) do |i|
    result *= i
  end
  return result
end

Rekurzívne faktoriál naprogramujeme tak, že budeme vždy vracať parameter x a tým vynásobený výsledok funkcie s parametrom o jednu menšiu. Keď si rozmyslíme, kedy by sa mala rekurzia zastaviť, dospejeme k podmienke x = 1. Ak budeme chcieť, aby nám funkcie správe počítala aj 0 !, bude podmienka (x <2).

Zdrojový kód - s rekurziu

public static int factorial(int x) {
  if (x < 0) throw new IllegalArgumentException("Argument je zaporny");
  if (x > 10) throw new IllegalArgumentException("Prilis vysoka hodnota");
  if (x < 2) return 1;
  return x * factorial(x - 1);
}

public static int factorial(int x) {
  if (x < 0) throw new System.ArgumentException("Argument je zaporny", "x");
  if (x > 10) throw new System.ArgumentException("Prilis vysoka hodnota", "x");
  if (x < 2) return 1;
  return x * factorial(x - 1);
}

function factorial(x: integer): longint;
var i: integer;
begin
  if (x < 0) then Raise Exception.Create('Argument je zaporny');
  if (x > 10) then Raise Exception.Create('Prilis vysoka hodnota');
  if (x < 2) then result:=1 else
  result:=x * factorial(x - 1);
end;

def factorial(x)
  raise "Argument je zaporny" if (x < 0)
  raise "Prilis vysoka hodnota" if (x > 10)
  return 1 if (x < 2)
  return x * factorial(x - 1)
end

V ďalšej lekcii, Matice a základné operácie s nimi, nielen v kóde , sa zoznámime s pojmom matice a naučíme sa základné matematické operácie, ktoré na ne možno aplikovať.