Полиглот: 5 языков, все через работу со сверхбольшими числами

Итак, я написал полиглот, который работает на трех языках, на которых я часто пишу, а также на одном из моих других ответов на этот вопрос, который я только сегодня узнал. Это автономная программа, которая считывает одну строку, содержащую неотрицательное целое число, и печатает одну строку, содержащую его факториал. Бигны используются во всех языках, поэтому максимальный вычисляемый факториал зависит только от ресурсов Вашего компьютера.

• Perl: использует встроенный пакет bignum. Работать с perl FILENAME .
• Haskell : использует встроенные работу со сверхбольшими числами. Запуск с runhugs FILENAME или эквивалентом вашего любимого компилятора.
• C++: требуется GMP для поддержки bignum. Для компиляции с помощью g++ используйте g++ -lgmpxx -lgmp -x c++ FILENAME для связи с нужными библиотеками. После компиляции запустите ./a.out . Или используйте эквивалент вашего любимого компилятора.
• brainf*ck : я написал некоторую поддержку bignum в этом посте . Используя классическое распределение Мюллера, компилируйте с bf < FILENAME > EXECUTABLE . Сделайте вывод исполняемым и запустите его. Или используйте свой любимый дистрибутив.
• Whitespace: использует встроенную поддержку bignum. Работать с wspace FILENAME .

Edit: добавлен Whitespace в качестве пятого языка. Кстати, не обертывайте код тегами <code> ; он нарушает Whitespace. Кроме того, код выглядит гораздо лучше в фиксированной ширине.

char //# b=0+0{- |0*/; #>>>>,----------[>>>>,--------
#define	a/*#--]>>>>++<<<<<<<<[>++++++[<------>-]<-<<<
#Perl	><><><>	 <> <> <<]>>>>[[>>+<<-]>>[<<+>+>-]<->
#C++	--><><>	<><><><	> < > <	+<[>>>>+<<<-<[-]]>[-]
#Haskell >>]>[-<<<<<[<<<<]>>>>[[>>+<<-]>>[<<+>+>-]>>]
#Whitespace	>>>>[-[>+<-]+>>>>]<<<<[<<<<]<<<<[<<<<
#brainf*ck > < ]>>>>>[>>>[>>>>]>>>>[>>>>]<<<<[[>>>>*/
exp; ;//;#+<<<<-]<<<<]>>>>+<<<<<<<[<<<<][.POLYGLOT^5.
#include <gmpxx.h>//]>>>>-[>>>[>>>>]>>>>[>>>>]<<<<[>>
#define	eval int	main()//>+<<<-]>>>[<<<+>>+>->
#include <iostream>//<]<-[>>+<<[-]]<<[<<<<]>>>>[>[>>>
#define	print std::cout	<< // >	<+<-]>[<<+>+>-]<<[>>>
#define	z std::cin>>//<< +<<<-]>>>[<<<+>>+>-]<->+++++
#define c/*++++[-<[-[>>>>+<<<<-]]>>>>[<<<<+>>>>-]<<*/
#define	abs int $n //><	<]<[>>+<<<<[-]>>[<<+>>-]]>>]<
#define	uc mpz_class fact(int	$n){/*<<<[<<<<]<<<[<<
use bignum;sub#<<]>>>>-]>>>>]>>>[>[-]>>>]<<<<[>>+<<-]
z{$_[0+0]=readline(*STDIN);}sub fact{my($n)=shift;#>>
#[<<+>+>-]<->+<[>-<[-]]>[-<<-<<<<[>>+<<-]>>[<<+>+>+*/
uc;if($n==0){return 1;}return $n*fact($n-1);	}//;#
eval{abs;z($n);print fact($n);print("\n")/*2;};#-]<->
'+<[>-<[-]]>]<<[<<<<]<<<<-[>>+<<-]>>[<<+>+>-]+<[>-+++
-}--	<[-]]>[-<<++++++++++<<<<-[>>+<<-]>>[<<+>+>-++
fact 0	= 1 -- ><><><><	> <><><	]+<[>-<[-]]>]<<[<<+ +
fact	n=n*fact(n-1){-<<]>>>>[[>>+<<-]>>[<<+>+++>+-}
main=do{n<-readLn;print(fact n)}-- +>-]<->+<[>>>>+<<+
{-x<-<[-]]>[-]>>]>]>>>[>>>>]<<<<[>+++++++[<+++++++>-]
<--.<<<<]+written+by+++A+Rex+++2009+.';#+++x-}--x*/;}

lolcode:

прости я не смог устоять xD

HAI
CAN HAS STDIO?
I HAS A VAR
I HAS A INT
I HAS A CHEEZBURGER
I HAS A FACTORIALNUM
IM IN YR LOOP
    UP VAR!!1
    TIEMZD INT!![CHEEZBURGER]
    UP FACTORIALNUM!!1
    IZ VAR BIGGER THAN FACTORIALNUM? GTFO
IM OUTTA YR LOOP
U SEEZ INT
KTHXBYE    

Это один из самых быстрых алгоритмов, до 170! . Он необъяснимо терпит неудачу за пределами 170!, и это относительно медленно для небольших факториалов, но для факториалов между 80 и 170 это невероятно быстро по сравнению со многими алгоритмами.

curl http://www.google.com/search?q=170!

Есть также онлайн-интерфейс, попробуйте его прямо сейчас!

Дайте мне знать, если вы обнаружите ошибку или более быструю реализацию для больших факториалов.

---

EDIT:

Этот алгоритм немного медленнее, но дает результаты выше 170:

curl http://www58.wolframalpha.com/input/?i=171!

Это также упрощает их в различные другие представления.

C++: Метапрограммирование Шаблонов

Использует классический Хак перечисления.

template<unsigned int n>
struct factorial {
    enum { result = n * factorial<n - 1>::result };
};

template<>
struct factorial<0> {
    enum { result = 1 };
};

Использование.

const unsigned int x = factorial<4>::result;

Факториал полностью вычисляется во время компиляции на основе параметра шаблона n. таким образом, factorial<4>::result является константой после выполнения компилятором своей работы.

Whitespace

   	.
 .
 	.
		.
  	.
   	.
			 .
 .
	 	 .
	  .
   	.
 .
  .
 			 .
		  			 .
 .
	.
.
  	 .
 .
.
	.
 	.
.
.
.

Было трудно заставить его показать здесь должным образом, но теперь я попробовал скопировать его из предварительного просмотра, и он работает. Вам нужно ввести номер и нажать enter.

Я нахожу следующие реализации просто уморительными:

Эволюция программиста Haskell

Эволюция программиста Python

Наслаждайтесь!

C# Поиск:

На самом деле ничего не нужно вычислять, просто посмотрите его. Чтобы расширить его, добавьте еще 8 чисел в таблицу, и 64-битные целые числа будут на пределе. Кроме того, вызывается класс BigNum.

public static int Factorial(int f)
{ 
    if (f<0 || f>12)
    {
        throw new ArgumentException("Out of range for integer factorial");
    }
    int [] fact={1,1,2,6,24,120,720,5040,40320,362880,3628800,
                 39916800,479001600};
    return fact[f];
}

Ленивый К

Ваши чисто функциональные кошмары программирования сбываются!

Единственный эзотерический Тьюринг-полный язык программирования , который имеет:

• Чисто функциональная основа, ядро и библиотеки-на самом деле, вот полный API: S K I
• Даже лямбды нет!
• Никакие номера или списки не нужны и не разрешены
• Нет явной рекурсии, но все же, позволяет рекурсию
• Простой бесконечный ленивый потоковый механизм ввода-вывода

Вот Факториальный код во всей его парентетической красе:

K(SII(S(K(S(S(KS)(S(K(S(KS)))(S(K(S(KK)))(S(K(S(K(S(K(S(K(S(SI(K(S(K(S(S(KS)K)I))
 (S(S(KS)K)(SII(S(S(KS)K)I))))))))K))))))(S(K(S(K(S(SI(K(S(K(S(SI(K(S(K(S(S(KS)K)I))
 (S(S(KS)K)(SII(S(S(KS)K)I))(S(S(KS)K))(S(SII)I(S(S(KS)K)I))))))))K)))))))
 (S(S(KS)K)(K(S(S(KS)K)))))))))(K(S(K(S(S(KS)K)))K))))(SII))II)

Особенности:

• Нет вычитания или условных выражений
• Печатает все факториалы (если вы ждете достаточно долго)
• Использует второй слой церковных цифр для преобразования N-го факториала в N! звездочки следуют за новой строкой
• Использует комбинатор Y для рекурсии

В случае, если вы заинтересованы в попытке понять его, вот схема исходного кода для запуска через более ленивый компилятор:

(lazy-def '(fac input)
   '((Y (lambda (f n a) ((lambda (b) ((cons 10) ((b (cons 42)) (f (1+ n) b))))
       (* a n)))) 1 1))

(для подходящих определений Y, минусы, 1, 10, 42, 1+, и *).

EDIT:

Ленивый K Факториал в десятичной системе счисления

( 10 КБ тарабарщины , иначе я бы ее вставил). Например, в строке Unix:

    $ echo "4" | ./lazy facdec.lazy
    24
    $ echo "5" | ./lazy facdec.lazy
    120

Довольно медленно для чисел выше, скажем, 5.

Код немного раздут, потому что мы должны включить библиотечный код для всех наших собственных примитивов (код , написанный на языке Hazy, интерпретатор исчисления lambda и компилятор LC-to-Lazy K, написанный на языке Haskell).

XSLT 1.0

Входной файл, factorial.xml :

<?xml version="1.0"?>
<?xml-stylesheet href="factorial.xsl" type="text/xsl" ?>
<n>
  20
</n>

Файл XSLT, factorial.xsl :

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"                     
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:msxsl="urn:schemas-microsoft-com:xslt" >
  <xsl:output method="text"/>
  <!-- 0! = 1 -->
  <xsl:template match="text()[. = 0]">
    1
  </xsl:template>
  <!-- n! = (n-1)! * n-->
  <xsl:template match="text()[. > 0]">
    <xsl:variable name="x">
      <xsl:apply-templates select="msxsl:node-set( . - 1 )/text()"/>
    </xsl:variable>
    <xsl:value-of select="$x * ."/>
  </xsl:template>
  <!-- Calculate n! -->
  <xsl:template match="/n">
    <xsl:apply-templates select="text()"/>
  </xsl:template>
</xsl:stylesheet>

Сохраните оба файла в одном каталоге и откройте factorial.xml в IE.

Python: функциональный, ОДН-вкладыш

factorial = lambda n: reduce(lambda x,y: x*y, range(1, n+1), 1)

NOTE:

• Он поддерживает большие целые числа. Пример:

print factorial(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915\
608941463976156518286253697920827223758251185210916864000000000000000000000000

• Он не работает для n < 0 .