Linux.by

class Fact { // факториал на Java
  public static void main(String[] args){
     System.out.println(getFactorial(6));
  }

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

#!/bin/sh

# Шелл - это еще и язык программирования )

function factorial(){
  if test $1 = "0"
  then
     echo 1
  else
     echo $(($1*`factorial $(($1-1))`))
  fi
}

factorial 6

#!/usr/bin/perl

sub factorial {
  my $n = shift ; # ну шо ета за argument passing?

  if ($n==0){
     1
  }else{
     $n * factorial($n-1)
  }
}

print factorial(6), "\n";

-- 3 способы на Haskell

-- самый неэффективный однако
fac1 :: Int -> Int
fac1 n = product[1..n]

fac2 :: Int -> Int
fac2 0 = 1
fac2 (n+1) = (n+1) * fac3 n

-- самый эффективный
fac3 :: Int -> Int
fac3 0 = 1
fac3 n = n * fac2 (n-1)

;; вариант на Scheme

(define factorial
  (lambda    
     (a)
     (if
        (<= a 0)  
           1
           (* a (factorial (- a 1)))
     )
  )
)

(display  (factorial 6))
(newline)

;; Cxема еще раз - в прошлом посте смайлик сработал

(define factorial
  (lambda    
     (a)
     (if
        (<= a 0)  
           1
           (* a (factorial (- a 1)))
     )
  )
)


(display "factorial of 4: ")
(display  (factorial 4))
(newline)

WANTED:
Python
tcl
OCaml
php
Prolog

Та же хвостовая рекурсия, как и в случае с Haskel, но на Ruby:
# Tail recursion version                                                                                    
# Reference: http://www.shugo.net/article/cmagazine/3rd/   (Japanese)                                      
def fact_(prod, count, max)                                                                                
 if( count > max )                                                                                        
   prod                                                                                                    
 else                                                                                                      
   fact_(count * prod, count + 1, max)                                                                    
 end                                                                                                      
end                                                                                                        
                                                                                                           
def fact(n)                                                                                                
 fact_(1,1,n)                                                                                            
end                                                                                                        

Млин, маньяки! А где факториал на Асме?

напиши...
времени с nasm'ом разбираться нет...

;; чисто логическая реализация - должна работать везде
;; т.к. мы пользуемся только логическими структурами
;;

;; определим предикат для натуральных чисел n (X)
;; 0 -> 0
;; s(0) -> 1
;; ... (число может выражаться не только цифрами)
n (0).
n (s(X)) -> n (X).

;; определим предикат сложения для plus X + Y==Z
;; (он же предикат вычитания)
plus (0,Y,Y) .
plus (s(X), Y, s (Z)) -> plus (X,Y,Z).

;; теперь умножение (оно же деление)
mult (0,X,0).
mult (s(X),Y,Z) -> mult (X,Y,W), plus (W,Y,Z).

;; ну все теперь долгожданный
factorial (0, s(0)).
factorial (s(N), F) -> factorial (N, F1), mult (s(N), F1, F).



думаю на турбо прологе можно реализовать что-то поэффективнее,
но это не относится к языку в целом


2ab а в Ruby, что есть оптимизация хвостовой рекурсии?

надеюсь вы догадались, что это на Прологе

для тех кого заинтересовало см. Стерлиг и Шапиро Искусство Программирования на языке Пролог

;0

Пипл, судорожно вспоминнаю PL/1... К утру будет.

А вот и Сергей с Прологом.
Реализации на других языках понятны, имхо,
даже для тех, кто не знает их. А вот Пролог.......

# tcl версия предоставлена  tren

proc factorial {a} {
   if {$a == 0} {
return 1
   } else {
return [expr $a * [factorial [expr $a - 1]]]
   }
}
puts [factorial 4]