태스크

내장 요인 함수를 사용하지 않고 숫자의 계승을 계산하는 프로그램을 작성하십시오. 쉬운? 문제는 전체 프로그램 (테스트 포함)을 하이쿠 형식으로 작성 해야한다는 것 입니다.

필요한만큼의 haikus를 사용할 수 있지만 발음 할 때는 5-7-5 음절 형식을 따라야합니다.

채점

이것은 인기있는 경연 대회 이므로 가장 많은 찬사를 얻으십시오. 프로그램은 최소 하나의 하이쿠 크로 구성되어야하며 모든 하이 쿠스는 완전해야합니다.

코드를 읽을 때 각 하이쿠의 첫 번째 줄에는 5 음절이 있고 두 번째 줄에는 7 절이 있고 세 번째 줄에는 5 절이 있습니다.

잡담

(작업 공간에서 평가; 대화 상자를 열고 숫자를 요청한 후 stdout에 결과를 인쇄합니다) :

"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".

나는 약간의 성찰 ( "이시")과 키고를 가져 오려고했다. 또한 일부 서양식 운율 요소가 포함됩니다 (제발-> 이들, 시간-> 동요). 그러나 일본어 나 영어를 모국어로 사용하는 사람은 아니고 어떤 문체도 용서할 수 있습니다 ;-)

하스켈

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 haikus

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

질문이 code-golf 가 아닌 경우에도 나는 종종 대답을 골라냅니다. 이 경우, 나는 haikus의 수를 골랐다.

나는 그렇게 발음했다.

n이 0 인 경우 보호 된 정적
int factorial int n

리턴 n + 1
리턴 계승 n
-1 회 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빠른 출력을 시작합니다 . 그것은 오버플로의 결과입니다. 당신은 쉽게 각을 변경하여 더 정확한 수치를 얻을 수 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

( "6, 칠십. / 일곱, 오천 사십. / 제로, 하나. 하나, 하나.")

파이썬 2, 4 하이 쿠스

완전한 파이썬 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))

발음 :

이 전체 프로그램
가져 오기 연산자를
op 가져 오기 시스템으로 실행

arg
n은 sys arg v 1과 동일
합니다. hai fac n을 정의하십시오.

n이 1보다 작 으면
한 번에 1을 반환
하고 다른 것을 수행하십시오.

반환 op 도트 mul
n hai fac n 빼기 1
print hai fac int n

GolfScript, 2 하이 쿠스

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

haiku로 읽고 각 키 입력을 열거하십시오.

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

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

테스트 케이스 (5 haikus) :

[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

복어 는 기능이고 kigo 에서의 나의 시도 : 복어는 겨울 참조입니다. 나는 의도 ?do로 kireji 카운트 루프 전에, 전환점.

PHP, 4 헤이 커스

모든 운율 haikus!

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)

공백

이 중 하나의 용도 만드는 가장 유명한 하이쿠 들 및 큰 거래는 그것에 대해 작성되었습니다.

왜 아무도 이것을 전에 한 적이 없는지 전혀 모릅니다. 아무 노력도하지 않습니다!

우선,시를 읽기 전에,시를 둘러싼 큰 공허로 인해 생기는 평온함을 편안하게 즐기고 쉬기를 바랍니다. 광대 한 풍경으로 둘러싸인 연못을 강조합니다.

古 池 や    
蛙 飛 び こ む               
水 の 音             

filebin의 소스 코드

일본어를 할 줄 모르는 경우 다음과 같이 발음 됩니다.

푸루 나 케 나중에

카와 즈에서 비코 뮤까지

미즈노 오

당연히, 그것은 morae에 의해 계산됩니다. kireji은 (や이다 나중에 ) 상기 kigo ((계절 참조)蛙이다 카와 -> 스프링 개구리) .

공식 페이지에서 Linux 인터프리터를 사용하면 다음과 같이 사용할 수 있습니다.

에코 5 | ./wspace .ws

매스 매 티카

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

Pedants는 마지막 줄을 "f of 1 is 1"로 읽을 수 있지만 Basho에 대한 외침에 저항 할 수는 없었습니다.

테스트 :

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)

언어 특유의 보너스 하이쿠 (@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에서 설정하고
2 1 1에서 L a
설정

노트; 이것은 계승을 계산하고 출력하지 않습니다-변수 t는 계승을 포함합니다.

다음 Haiku / 코드를 동일한 배치 파일에 추가하여 계승을 출력 할 수 있습니다 (는 |파이프로 발음 됨).

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

클로저

(->> *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

에프#

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

n의 사실을
1에서 n까지로하고,
점을 접어 스타 1을 적용하십시오.

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

리스프 코드는

수많은 괄호

그리고 몇 가지 기능

펄

$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

그리고 출력 :

$ 펄 f.pl 3
6 $ perl f.pl 1-1
1 달러 perl f.pl 10
3628800 $ 

다음과 같이 읽습니다.

펄 fpl 세
펄 fpl 하나 적은 하나
펄 fpl 10

라이브 스크립트

이것은 중세입니다.

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 항상 를 반환합니다. 그런 식으로 더 예술적입니다.

필러 주석이나 불필요한 문자열이 없습니다!

보너스 디버깅 스토리 :

버그가
" deathis undefined" 라는 알림을 받았을 때 웃으며 터졌습니다.

하스켈

이것은 운이 좋은 하이쿠 가 될 것입니다 !

사실 0 = 1-사실 0은 1
팩트 톤 = 톤 * (팩트 톤)-팩트 톤은 톤 수 팩트 톤
        여기서 stun = pred ton-스턴은 pred ton입니다

네!

참고 : 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"

펄

기성품 기능을 사용하는 것은 규칙에 위배된다는 것을 알고 있지만 여기에 내가 얻는 것이 있습니다.

너의 임무가 너무 큰 설치류를 지시하는 것이라고 상상해보십시오.

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*/}

발음 :

파운드 표준
I / O 도트 h 포함 파운드
표준 lib 도트 h 포함 파운드

int main int arg c
쉼표 char 스타 star arg v
열린 괄호 주석

반복적으로
여기 계승 계산
long int와 n 개의 등호를

제로 쉼표 i는
제로 쉼표 r과
하나의 주석과 같습니다.

arg c
가 1보다 큰 경우 곱은 하나의 세미콜론 에서 시작합니다.

열린 괄호 n은
인수 v 하위
1 쉼표 NULL 쉼표 10의 str-to-l입니다.

n이 0보다 작은 경우 세미콜론
printf arg는

백 슬래시
n 세미콜론 이 0 보다 크거나 같아야합니다.

종료 음의
세미콜론 끝 버팀대
끝 버팀대 i

괄호를 여는 동안 n 세미콜론 r
은 r 곱하기 i

세미콜론 I
세미콜론
닫기 중괄호 주석 인쇄 감소

결과 printf
퍼센트 d 계승
은 퍼센트 d와 같습니다.

엉망 n 쉼표 n
쉼표 r 세미콜론
주석 끝 괄호

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

하스켈

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

모듈 .. where는 컴파일 할 때 Haskell 코드에 자동으로 추가되므로 작성하지 않으면 실제로 속임수입니다.

자바:

Quincunx가 Java로 게시 한 질문과 Dwaiku (Double-Haiku 또는 전화하고 싶은 것)에 대한 답변으로 올바른 Haiku가 있습니다.

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

자바 스크립트-두 개의 하이 쿠스

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 

나는 원어민이 아닙니다. 그래서 나는 음절을 세기 위해 사전을 사용했습니다. 잘하면 충분합니다. 모든 의견을 환영합니다 :)

파워 쉘, 2 하이 쿠스

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

필러를 사용할 수 있습니까?

파이썬 2 헤이 커스 :

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

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

베 펀지 -93

세 개의 haikus :

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

마지막 줄은 틀림없이 일종의 부정한 일입니다.

여기를보십시오 : http://www.bedroomlan.org/tools/befunge-93-playground