Aufgabe

Erstellen Sie ein Programm, das die Fakultät einer Zahl ohne eingebaute Fakultätsfunktionen berechnet. Einfach? Der Haken ist, dass Sie Ihr gesamtes Programm (einschließlich des Testens) in Haiku- Form schreiben müssen .

Sie können so viele Haikus verwenden, wie Sie benötigen, aber wenn sie ausgesprochen werden, müssen sie dem 5-7-5-Silbenformat folgen.

Wertung

Dies ist ein Beliebtheitswettbewerb , also musst du die meisten Upvotes bekommen, um zu gewinnen. Ihr Programm muss aus mindestens einem vollständigen Haiku bestehen und alle Haikus müssen vollständig sein.

Beim Lesen von Code hat die erste Zeile jedes Haikus 5 Silben, die zweite 7 und die dritte 5.

Smalltalk

(In einem Arbeitsbereich auswerten; öffnet einen Dialog, fragt nach einer Zahl und druckt das Ergebnis auf 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".

Ich habe versucht, eine Reflexion ("in diesem Gedicht") und auch Kigo einzubringen. Auch einige westliche Reimelemente sind enthalten (bitte-> diese, Zeit-> Reim); da ich jedoch weder Japanisch noch Englisch als Muttersprache habe, vergebe ich keine stilistischen Details ;-)

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

Haskell Ausbildungszeit:

• Die range xFunktion erstellt eine Liste von ganzen Zahlen von 1 bis zum Wert vonx .
• Die fact xFunktion multipliziert alle Werte der Listerange x , um das Ergebnis zu berechnen.
• In der ersten Zeile steht, dass die factFunktion eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt.

Java - 2 Haikus

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

Auch wenn die Frage nicht Code-Golf ist , ertappe ich mich oft beim Golfspielen als Antwort. In diesem Fall habe ich die Anzahl der Haikus golfen.

Ich spreche es so aus:

protected static
int factorial int n
wenn n Null ist

return n plus eins
return factorial n
minus eins mal n

Testprogramm:

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;}}

Beachten Sie, dass dieses Programm 0s schnell ausgibt . das ist eine Folge von Überlauf. Sie könnten leicht größere korrekte Zahlen erhalten, indem Sie jede intin ändernlong .

Standardaussprachen für System.out.printlnund public static void main(String[] args)spiegeln sich im Programm wider.

APL

factorial←{×/⍳⍵}

Factorial ist -
das Produkt von Naturprodukten
bis hin zu Omega

Shakespeare

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]

Ein (imaginärer) Testfall:

Trotz seiner Länge nimmt dieses Programm nur eine einzelne Ganzzahl als Eingabe und stellt eine einzelne Ganzzahl als Ausgabe bereit. Damit:

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

("Sechs, siebenundzwanzig. / Sieben, fünftausendvierzig. / Null, eins. Eins, eins.")

Python 2, 4 Haikus

Ein vollständiges Python 2-Programm haifac.py. Rennen wiepython 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))

Aussprache:

Führen Sie diesen vollständigen Programmimport-
Operator als
op-Import-System aus

Bitte geben Sie ein Argument an, das
gleich ist sys arg v 1
define hai fac n

Wenn n kleiner als 1 ist, gebe
1 sofort an mich zurück,
sonst mache ich etwas anderes

return op dot mul
n hai fac n minus 1
print hai fac int n

GolfScript, 2 Haikus

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

Als Haiku lesen und jeden Tastendruck aufzählen:

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

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

Mit Testfall (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

Gelesen als Haiku:

#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

Forth

: 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 ist die Funktion und mein Versuch bei Kigo : Blowfish ist eine Winterreferenz. Ich beabsichtige ?do, Kireji zu sein , der Wendepunkt vor der gezählten Schleife.

PHP, 4 Haikus

All-in-Rhyme- 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)

Leerzeichen

Dies macht Gebrauch von einem der berühmtesten Haikus , und es wurde viel darüber geschrieben.

Keine Ahnung, warum das noch niemand gemacht hat, es ist nicht mal anstrengend!

Vor dem Lesen des Gedichts möchte ich, dass Sie sich zurücklehnen, entspannen und die Ruhe genießen, die durch die große Leere entsteht, die das Gedicht umgibt. Es betont den Teich, umgeben von einer weiten Landschaft.

古 古 池    
蛙 蛙 び こ こ               
水 水 の             

Quellcode auf Filebin

Falls Sie kein Japanisch sprechen, wird dies wie folgt ausgesprochen :

fu ru i ke ya

ka wa zu bi ko mu

mi zu no o to

Natürlich wird es von Mora gezählt. Der Kireji ist や ( ya ) , der Kigo (saisonale Referenz) ist 蛙 ( Kawazu , Frosch, -> Frühling) .

Mit dem Linux-Interpreter von der offiziellen Seite können Sie es wie folgt verwenden:

$ 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 *) 

Pedanten lesen die letzte Zeile vielleicht als "f von 1 ist 1", aber ich konnte dem Ruf nach Basho nicht widerstehen.

Testen:

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

Rückgabe:

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

Bonus für sprachliche Unterscheidbarkeit Haiku (inspiriert von @cormullion)

Rewrite any term
High-level functions abound —
Mathematica

Stapel

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

Aussprache ; ignoriert mathematische Ausdrücke sowie diese Symbole@ / % ^ , ( ) :

setze auf 1 und
für L a in 2 1 1
setze ata

Hinweis; dies berechnet die Fakultät, gibt sie nicht aus - die Variablet enthält die Fakultät.

Der folgende Haiku / Code kann an dieselbe Batchdatei angehängt werden, um die Fakultät auszugeben (die |werden als Pipe ausgesprochen):

@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

lass die Tatsache von n
von eins bis n sein, wende
Seq dot fold star one an

newLISP

Die Klammern sind nicht ausgesprochen:

(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

Lisp-Code besteht aus

zahlreiche Klammern

und ein paar funktionen

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

Wirf dies in eine Datei mit dem Namen f.pl

Und die Ausgabe:

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

Welches heißt:

Perl fpl drei
Perl fpl eins weniger eins
Perl fpl zehn

LiveScript

Dieser ist mittelalterlich:

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

Druckt 3628800, was ist 10!. Es ist ein kleiner Kreisverkehr: Die Funktion storygibt eine Funktion zurück ones-misery, die immer die Antwort liefert. So ist es künstlerischer.

Keine Füllerkommentare oder unnötige Zeichenketten!

Bonus-Debugging-Geschichte:

Ich brach in Lachen aus,
als ich informiert wurde, dass ein Fehler
" deathist undefined"

Haskell

Dieser wird ein reimendes Haiku sein!

Fakt 0 = 1 - Fakt Null ist Eins
Fakt Tonne = Tonne * (Fakt Stun) - Fakt Tonne ist Tonne mal Fakt Stun
        where stun = pred ton - wo stun pred ton ist

Ja!

Hinweis: Pred bedeutet die vorherige Nummer. In haskell können Sie auch mehrere Definitionen einer Funktion haben, und die erste, die Sinn macht, wird verwendet.

Rubin - Ein Haiku

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

Lesen Sie (ohne Zeichensetzung, aber mit einem Emoticon) wie folgt:

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

In SML:

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

gelesen als:

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

Perl

Ich weiß, dass es gegen die Regeln verstößt, fertige Funktionen zu verwenden, aber hier ist, was ich bekomme.

Stellen Sie sich vor, Sie müssen ein übergroßes Nagetier anweisen:

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

Ich kann nur raten, was das letzte Wort bedeutet und wie es ausgesprochen wird, aber ich versichere Ihnen, dass es eine Silbe ist. Anscheinend versteht er nicht, was Sie von ihm wollen, daher müssen Sie Folgendes ausarbeiten (Qualitätsverbesserung, wenn Sie die Geduld verlieren):

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

noch vergebens Dann muss man es im Klartext erklären:

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

Was als nächstes passierte, weiß ich nicht, aber der Code ist gültig:

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

und

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

und

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

Python

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

So habe ich es gelesen:

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

`

C

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

Aussprache:

Pfund enthalten Standard-
I / O-Punkt h Pfund enthalten
Standard-Lib-Punkt h

int main int arg c
Komma Stern Stern arg v
Klammer Kommentar

Berechnen Sie hier iterativ Fakultät
lang int n gleich

null Komma i
entspricht null Komma r
entspricht einem Kommentar

Produkt beginnt mit einem
Semikolon, wenn arg c
größer als eins ist

offene geschweifte Klammer n ist
str-to-l von arg v sub
one comma NULL comma ten

Semikolon, wenn
n kleiner als Null ist,
muss printf arg beginnen

größer oder
gleich Null Backslash
n Semikolon sein

Ende negativ ein Semikolon Klammer
Ende Klammer i gleich

n Semikolon,
während ich Klammer r öffne,
entspricht r mal i

Semikolon Ich
dekrementiere Semikolon
Schließen Klammer Kommentar drucken

Das Ergebnis printf
Prozent d Fakultät
entspricht Prozent d

whack n comma n
comma r Semikolon
Kommentar fertig Ende Klammer

C # - 3 Haikus

Ich entfernte das übliche C # mit, Namespace und Klassendefinitionsunordnung, die ein 4. Haiku sein würde.

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

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

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

was ich als

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

Beachten Sie, dass das Modul bei der Kompilierung automatisch zu jedem Haskell-Code hinzugefügt wird, ohne dass es kompiliert wird.

JAVA:

Als Antwort auf die Frage und auf das Dwaiku (Double-Haiku oder wie auch immer Sie es nennen möchten), das von Quincunx in Java gepostet wurde, hier das richtige Haiku:

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

Javascript - Zwei Haikus

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 

Ich bin kein Muttersprachler. Also habe ich ein Wörterbuch benutzt, um die Silben zu zählen. Hoffentlich ist es gut genug. Jedes Feedback ist willkommen :)

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

Dürfen wir Füller verwenden?

Python 2 Haikus:

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

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

Befunge-93

Drei Haikus:

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

Die letzte Zeile ist zugegebenermaßen irgendwie betrogen.

Versuchen Sie es hier: http://www.bedroomlan.org/tools/befunge-93-playground