задача

Создайте программу, которая вычисляет факториал числа, не используя встроенные функции факториала. Легко? Уловка в том, что вы должны написать всю свою программу (включая ее тестирование) в форме хайку .

Вы можете использовать столько хайкусов, сколько вам нужно, но когда они произносятся, они должны соответствовать формату слогов 5-7-5.

счет

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

При чтении кода первая строка каждого хайку будет иметь 5 слогов, вторая - 7, а третья - 5.

Болтовня

(оценивать в рабочей области; открывает диалоговое окно, запрашивает номер и выводит результат на стандартный вывод):

"in" "this" 'poem,' "you" "must"
"pronounce" "characters" "like" "these:"
"return(^)," "and" "times(*);" "please".

"but" 'never' "in" "here"
"tell" "anyone" "about" "those"
"few" "parentheses".

"otherwise" "these" "words" 
"are" "stupid" "and" "this" "coded" 
"rhyme" "is" "wasted" Time.

"let" "us" "now" "begin" 
"by" "defining," "in" Object
"and" compile: "the" "rhyme:"

'fac: "with" arg"ument"
"to" "compare" arg <"against" 2 ">"
"and" ifTrue: [ ^"return"

"["1] "or" ifFalse: "then"
["return"^ arg *"times" "the" "result"
"of" ("my"self ")getting"

"the" fac:"torial"
"of" "the" "number" arg "minus"-
1 "[(yes," "its" "easy")]'.

("Let" "me" "my"self "ask"
"for" "a" "number," "to" "compute"
"the" fac:"torial"

("by" "opening" "a" 
"nice" Dialog "which" "sends" "a"
request: "asking" "for"

'the Number to use' 
"(which" "is" "(" "treated" ) asNumber)
"then" print "the" "result".

Я попытался внести некоторые отражения («в этом стихотворении») и киго. Кроме того, некоторые элементы рифмы в западном стиле включены (пожалуйста-> они, время-> рифма); однако, не будучи ни носителем ни японского, ни английского, простите любые стилистические детали ;-)

Haskell

fact :: Int -> Int          -- fact is Int to Int
fact x = product (range x)  -- fact x is product range x
range x = [1..x]            -- range x is 1 [pause] x

Время обучения на Хаскеле:

• range xФункция создает список целых чисел от 1 до величины x.
• В fact xфункции умножает все значения в списке range xвместе , чтобы вычислить результат.
• Первая строка говорит, что factфункция принимает целое число и возвращает целое число.

Ява - 2 хайкуса

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

Даже когда вопрос не в код-гольфе , я часто ловлю себя на том, что играю в гольф. В этом случае я поиграл в число хайкусов.

Я произношу это так:

защищенное статическое
int факториальное int n,
если n равно нулю

возврат n плюс один
возврат факториал n
минус один раз n

Тестовая программа:

class Factorial {                                    // class Factorial
    public static void main(String[]                 // public static void main string
            command_line_run_args) {                 // command line run args

        int i = 0;                                   // int i is zero
        while (7 != 0)                               // while seven is not zero
            System.out.                              // System dot out dot

                    println(i + "!"                  // print line i plus not
                            + " = " + factorial(     // plus is plus factorial
                            i += 1));}               // i plus equals 1

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

Обратите внимание, что эта программа начинает 0быстро выводить s; это результат переполнения. Вы можете легко получить правильные цифры большего размера, изменив каждый intна long.

Стандартные произношения для System.out.printlnи public static void main(String[] args)отражены в программе.

APL

factorial←{×/⍳⍵}

Факториал -
продукт натуральных продуктов
до омеги

Шекспир

The Products of Love:
A haiku tragedy with
mathy undertones.

Romeo, a man.
Juliet, a maiden fair.
Friar John, a monk.

Act I: A Cycle.
Scene I: Pertinent Values.
[Enter Romeo]

[Enter Friar John]
Romeo: Listen to thy
heart. Thou art thyself.

Friar John: Thou art
as forthright as a songbird.
[Exit Friar John]

[Enter Juliet]
Romeo: Thou art as fair
as a violet.

Scene II: Questioning
Themselves. [Exit Juliet]
[Enter Friar John]

Friar John: Art thou
as just as the sum of me
and a nobleman?

Romeo: If so,
let us proceed to scene III.
[Exit Friar John]

[Enter Juliet]
Romeo: Thou art as good
as the product of

thyself and myself.
Juliet: Thou art as fierce
as the sum of an

eagle and thyself.
We must return to scene II.
Scene III: A Lengthy

Title for a Brief
Dénouement; Or, The Last Word.
[Exit Friar John]

[Enter Juliet]
Romeo: Open your heart.
[Exit Romeo]

(Воображаемый) контрольный пример:

Несмотря на свою длину, эта программа просто принимает одно целое число в качестве входных данных и предоставляет одно целое число в качестве выходных данных. Так:

6 ↵ 720
7 ↵ 5040
0 ↵ 1    1 ↵ 1

(«Шесть, семь двадцать. / Семь, пять тысяч сорок. / Ноль, один. Один, один.»)

Python 2, 4 Haikus

Полная программа Python 2 haifac.py. Беги какpython haifac.py <n>

#run this full program
import operator as\
op; import sys#tem

#please provide an arg
n = sys.argv[1]
def haifac (n):

    if n < 1:
        return 1#to me at once
    else:#do something else

        return op.mul(
            n, haifac(n - 1))
print haifac(int(n))

Произношение:

запустить этот
оператор импорта полной программы как
операционную систему импорта

пожалуйста, укажите аргумент,
равный sys arg v 1,
определите hai fac n

если n меньше 1,
верните мне 1 сразу,
сделайте что-нибудь еще

возврат опт мул
н фэй фин минус 1
печать

GolfScript, 2 Haikus

),{0>},{,,*}*

Читайте как хайку, перечисляя каждое нажатие клавиши:

#close parenthesis
#comma open-brace zero
#greater-than close-brace

#comma open-brace
#comma comma asterisk
#close-brace asterisk

С тестовым набором (5 гайкусов):

[1 2 3]4+          #generate the array [1 2 3 4]
{                  #start creating block
),{0>},{,,*}*      #actual factorial code
}%                 #close block and map across array (so that we should have [1! 2! 3! 4!])
[1 2 6]2.3**12++=  #generate the array [1 2 6 24] and check for equality

Читайте как хайку:

#open-bracket one
#space two space three close-bracket
#four plus open-brace

#close parenthesis
#comma open-brace zero
#greater-than close-brace

#comma open-brace
#comma comma asterisk
#close-brace asterisk

#close-brace percent-sign
#open-bracket one space two
#space six close-bracket

#two period three
#asterisk asterisk one
#two plus plus equals

вперед

: fugu 1              \ colon fugu one                = 5
swap 1 + 1 ?do        \ swap one plus one question do = 7
i * loop ;            \ eye star loop semi            = 5

Fugu - это функция, и моя попытка kigo : blowfish - это зимняя ссылка. Я намерен ?doбыть kireji , поворотный момент, перед отсчитанным циклом.

PHP, 4 хайкуса

Все в рифму хайкус!

function haiku($can) { // function haiku can (5)
    if ($can == 1) // if can is equal to one (7)
        return ++$stun; // return increase stun (5)

    if ($can == 0) { // if can equals ou (5)
        echo "It is one, you know! "; //echo "It is one, you know! " (7)
        return 1+$blow; } //return one plus blow (5)

    if ($can > $fun) { //if can exceeds fun (5)
        return haiku($can-1) //return haiku can less one (7)
            *$can; }} //multiplied by can (5)

if (null == $knee) { // if null equals knee (5)
    $free=0+3; // free equals zero plus three (7)
    echo haiku($free); } // echo haiku free (5)

Пробелы

Это делает использование одной из наиболее известного хайку s, и много было написано о нем.

Понятия не имею, почему никто не делал этого раньше, это даже не требует никаких усилий!

Прежде всего, прежде чем читать стихотворение, я хочу, чтобы вы откинулись назад, расслабились и наслаждались спокойствием, созданным великой пустотой, окружающей стихотворение. Он подчеркивает пруд, окруженный обширным ландшафтом.

古 池 や    
蛙 飛 び こ む               
水 の 音             

исходный код в filebin

Если вы не говорите по-японски, это произносится следующим образом:

фу ру я ке я

Ка Ва Цзу Би Би Му

ми цу нет о к

Естественно, это считается по морали. Kireji являетсяや( я ) , то Кое (сезонным рекомендуемым)蛙( Kawazu , лягушка, -> весны) .

Используя интерпретатор Linux с официальной страницы, вы можете использовать его следующим образом:

$ echo 5 | ./wspace .ws

Mathematica

f[x_]:=     (* f of x defined *)
 x f[x-1]   (* x times f of x less 1 *)
f[1]=1      (* Mogami River *) 

Педанты могут читать последнюю строку как «f of 1 is 1», но я не мог удержаться от крика Башо.

Тестирование:

Table[f[n],     (* Table f of n *)
 {n, 1, 10, 1}] (* n from 1 to 10 by 1 *)
ListLogPlot[%]  (* ListLogPlot output *)

Возвращение:

(1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800)

Бонус лингвистической отличительности Haiku (вдохновленный @cormullion)

Rewrite any term
High-level functions abound —
Mathematica

партия

@set /a t=1 &^
for /L %%a in (2, 1, %1) ^
do @set /a t*=%%a

Произношение ; игнорирует математические выражения, а также эти символы @ / % ^ , ( ):

установите в 1 и
для L a в 2 1 1
установите ata

Запись; это вычисляет факториал, но не выводит его - переменная tсодержит факториал.

Следующий Haiku / код может быть добавлен к тому же пакетному файлу для вывода факториала ( |они произносится как труба):

@echo %t% ||^
When will you learn, unclemeat ^
Why must you use Batch?

Clojure

(->> *command-line-args*                ; thrush com-mand line args
  seq last read-string range (map inc)  ; seq last read string range map inc
  (reduce *) println)                   ; re-duce times print-lin

F #

let fact n =
    [1..n] |>
    Seq.fold (*) 1

пусть факт n будет
от одного до n, примените
Seq dot fold star one

newLISP

Скобки не произносится:

(define (fac n (so))            ; define fac n so 
(if (= n 0) 1                   ; if equals n zero 1
(* n (fac (dec n)))))           ; times n fac dec n

(for (n 0 10)                   ; for n zero ten
; let's test from zero to ten
(println (fac n thus)))         ; printline fac n thus

Лисп-код состоит из

многочисленные скобки

и несколько функций

Perl

$r = 1; for(1           # r gets one for one
.. pop @ARGV) { $r *=   # to pop arg v r splat gets
$_; } print $r;         # the default print r

Бросьте это в файл с именем f.pl

И вывод:

$ perl f.pl 3
6 $ perl f.pl 1-1
1 $ perl f.pl 10
3628800 $ 

Который читается как:

Perl Fpl три
perl fpl один меньше одного
Perl FPL десять

LiveScript

Это средневековое

prelude = ^^ do                       # prelude is clone do
  require \prelude-ls                 # require prelude dash ls
{ product } = prelude                 # product is prelude

story = (ah) ->                       # story is ah such:
  ones-misery = (one) ->              # one's misery is one such
    let death = product               # let death be product

      fight = [1 to one]              # fight is one to one
      why = (one) -> death <| fight   # why is one such death take fight
  ones-misery ah                      # one's misery ah

room = console.log                    # room is console log
room <| (story 10)!                   # room take story three bang
[null of { use : this }]              # no of use is this

Принты 3628800, которые есть 10!. Это немного обходно: функция storyвозвращает функцию ones-misery, которая всегда возвращает ответ. Так художественнее.

Нет комментариев наполнителя или лишних строк!

Бонусная история отладки:

Я расхохотался,
когда узнал, что ошибка была
" deathесть undefined"

Haskell

Этот будет рифмованным хайку!

факт 0 = 1 - фактический ноль равен единице
фактическая тонна = тонна * (факт оглушения) - фактическая тонна раз факт оглушения
        где оглушение = пред тонна - где оглушение пред тонна

Да уж!

Примечание: Pred означает предыдущий номер. Также в haskell вы можете иметь несколько определений функции, и используется первое, которое имеет смысл.

Руби - Один Хайку

ARGV.first.to_i.
 tap do |please| puts 1.upto(
 please ).inject( :*) end

Прочитайте (игнорируя пунктуацию, но включив один смайлик) примерно так:

 arg vee first to i
   tap do please puts one up to
 please inject smile end

В SML:

fun fact 0 = 1
  | fact n = n*fact(n-1)
  ;

читать как:

"fun fact 0 is one,
bar that, fact n is n times
fact of n less one"

Perl

Я знаю, что использование готовых функций противоречит правилам, но вот что я получаю.

Представьте, что ваша задача - научить грызуна негабаритного размера:

use Math::BigRat; use
feature 'say'; use warnings; say
new Math::BigRat($_)->bfac

Я могу только догадываться, что означает последнее слово и как оно произносится, но уверяю вас, это один слог. Видимо, он не понимает, что вы хотите от него, поэтому вы должны уточнить (ослабление стандартов качества по мере того, как вы теряете терпение):

use Math::BaseConvert
':all'; no strict subs; no warnings;
reset and say fact($_)

до сих пор безрезультатно. Тогда вы должны объяснить это простым английским языком:

no strict; no warnings;
use Math::Combinatorics;
say factorial($_)

Что произошло дальше, я не знаю, но код действителен:

perl -nE 'use Math::BigRat; use feature "say"; use warnings; say new Math::BigRat($_)->bfac'
42
1405006117752879898543142606244511569936384000000000

а также

perl -nE 'use Math::BaseConvert ":all"; no strict subs; no warnings; reset and say fact($_)'
33
8683317618811886495518194401280000000

а также

perl -nE 'no strict; no warnings; use Math::Combinatorics; say factorial($_)'
16
20922789888000

питон

lambda n: reduce(
    lambda a, b: a * b,
    range(1, n), n)

То, как я это читаю:

lambda n: reduce
lambda a b: a times b
range 1 to n, n

`

С

#include <std\
io.h> 
#include \
<stdlib.h>

int main(int argc
 , char** argv)
{   // iteratively
    // compute factorial here
long int n = \
0, i \
= 0, r = \
1 /*
product starts at one*/;

if (argc 
> 1) { n = 
strtol(argv[\
1], NULL, 10)
; if (n 
< 0) {
       printf("Arg must\
       be >= 0\n");
       exit(-
    1);}
} i = 
n;
while (i) { r 
= r * i;
    i
--;
} /* print
the result*/ printf(
"%d factorial\
equals %d\
\n", n
, r);
/*done*/}

Произношение:

фунт включает стандартную
точку ввода / вывода h фунт включает
стандартную точку lib h

int main int arg c
запятая char звезда звезда arg v
открытая скобка комментарий

итеративно
вычислять факториал здесь
long int n равен

ноль запятая я
равен ноль запятая г
равен один комментарий

произведение начинается с одной
точки с запятой, если arg c
больше единицы

открывающая скобка n - это
строковый аргумент arg v sub
одна запятая NULL запятая десять

точка с запятой, если
n меньше нуля, начать
printf аргумент должен

быть больше или
равно нулю обратная косая черта
n точка с запятой

выход отрицательный
один конец точку с запятой скобка
закрывающая фигурные скобки я равен

n точка с запятой, в
то время как я открываю скобку г
равен г раз я

точка с запятой и
декремент точка с запятой
закрыть скобку комментарий печать

результат printf
процент d факториал
равен проценту d

удар запятая
запятая
комментарий запятой завершено скобка

C # - 3 хайкуса

Я удалил обычный C #, используя пространство имен и беспорядок определения классов, что будет четвертым хайку.

public static void
Main(){int num = Convert.
ToInt32

(Console.ReadLine());
 Console.WriteLine(num ==
 0 ? 1 :

Enumerable.
Range(1, num).Aggregate
((i, j) => i * j));}

который я читаю как

public static void 
Main int num equals Convert
To int thirty-two

Console dot Read line
Console Write line num equals
zero? then one, else

Enumerable
Range 1 to num aggregate
i j i times j

Haskell

module Haiku where          -- read literally.
fac x = let in do           -- = is read as 'equals'
product [1..x]              -- product one to x

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

ЯВА:

В ответ на вопрос и на Dwaiku (Double-Haiku или как вы хотите это называть), опубликованный Quincunx на Java, вот правильное Haiku:

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

Javascript - Два Хайкуса

function factor (a) {          // function factor a
  if(!a){ return 1 ||          // if not a return 1 or
    a & 17}                    // a and seventeen

  else if (a + 1){             // else if a plus one 
    return a * factor          // return a into factor
    (a + ( - 1) )  }}          // a plus minus one 

Я не носитель языка. Итак, я использовал словарь для подсчета слогов. Надеюсь, это достаточно хорошо. Любые отзывы приветствуются :)

Powershell, 2 Haikus

function facto ($num){    # function facto num
$i = 1; 1..$num|          # i equals one; i to num
foreach { $i =            # for each i equals

$i * $_}; write $i}       # i times this write i
$answer = facto $args[    # answer equals facto args
0]; write $answer         # zero write answer

Разрешено ли использовать наполнитель?

Python 2 haikus:

number = num + 1
a = 13 + 4
b = 14

nuum = len([1])
for i in range(1, number):
    nuum *= i

Befunge-93

Три хайкуса:

0&>:v
-:|:>1>
v#>$\
>:>>v
>$.@v<<
^#v*_
#>>>v
<<:\<>^
<#<#<

Последняя строка по общему признанию обманчива.

Попробуйте здесь: http://www.bedroomlan.org/tools/befunge-93-playground