Compito

Creare un programma che calcola il fattoriale di un numero senza utilizzare alcuna funzione fattoriale incorporata. Facile? Il trucco è che devi scrivere l'intero programma (incluso testarlo) in forma haiku .

Puoi usare tutti gli haikus di cui hai bisogno, ma quando pronunciati devono seguire il formato 5-7-5 sillabe.

punteggio

Questo è un concorso di popolarità , quindi devi ottenere il maggior numero di voti per vincere. Il tuo programma deve consistere in almeno un haiku completo e tutti gli haikus devono essere completi.

Durante la lettura del codice, la prima riga di ogni haiku avrà 5 sillabe, la seconda avrà 7 e la terza avrà 5.

Smalltalk

(valuta in un'area di lavoro; apre una finestra di dialogo, chiede un numero e stampa il risultato su 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".

Ho provato a portare qualche riflessione ("in questa poesia") e anche Kigo. Inoltre, sono inclusi alcuni elementi di rima in stile occidentale (per favore-> questi, tempo-> rima); tuttavia, non essendo né madrelingua giapponese né inglese, perdona qualsiasi dettaglio stilistico ;-)

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

Tempo di istruzione Haskell:

• La range xfunzione crea un elenco di numeri interi da 1 fino al valore di x.
• La fact xfunzione moltiplica tutti i valori dell'elenco range xper calcolare il risultato.
• La prima riga dice che la factfunzione accetta un numero intero e restituisce un numero intero.

Java - 2 haikus

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

Anche quando la domanda non è il golf di codice , spesso mi sorprendo a giocare a golf la risposta. In questo caso, ho giocato a golf il numero di haikus.

Lo pronuncio così:

protetto statico
int fattoriale int n
se n è zero

ritorno n più uno
ritorno fattoriale n
meno uno volte n

Programma di test:

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

Si noti che questo programma inizia a produrre 0velocemente; questo è il risultato di un overflow. È possibile ottenere facilmente numeri corretti più grandi cambiando ciascuno intin long.

Le pronunce standard per System.out.printlne public static void main(String[] args)si riflettono nel programma.

APL

factorial←{×/⍳⍵}

Il fattoriale è
il prodotto dei naturali
fino all'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]

Un caso di prova (immaginato):

Nonostante la sua lunghezza, questo programma accetta solo un intero come input e fornisce un intero come output. Così:

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

("Sei, sette-venti. / Sette, cinquemila quaranta. / Zero, uno. Uno, uno.")

Python 2, 4 Haikus

Un programma Python 2 completo haifac.py. Correre comepython 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))

pronounciation:

eseguire questo
operatore di importazione programma completo come
sistema di importazione op

si prega di fornire un arg
n uguale a sys arg v 1
definire hai fac n

se n meno di 1
restituisci 1 a me in
un'altra volta , fai qualcos'altro

ritorno op punto mul
n hai fac n meno 1
stampa hai fac int n

GolfScript, 2 Haikus

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

Leggi come haiku, enumerando ogni sequenza di tasti:

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

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

Con test case (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

Leggi come 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

Via

: 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 è la funzione e il mio tentativo di kigo : il pesce palla è un riferimento invernale. Intendo ?doessere il kireji , il punto di svolta, prima del ciclo contato.

PHP, 4 haikus

Hikus tutto in rima !

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)

Lo spazio bianco

Questo fa uso di uno dei più famosi haiku s, e molto è stato scritto su di esso.

Non ho idea del perché nessuno l'abbia mai fatto prima, non ci vuole nemmeno nessuno sforzo!

Prima di tutto, prima di leggere la poesia, voglio che ti inclini all'indietro, ti rilassi e goda della tranquillità creata dal grande vuoto che circonda la poesia. Sottolinea lo stagno, circondato da un vasto paesaggio.

古 池 や    
蛙 飛 び こ む               
水 の 音             

codice sorgente su filebin

Nel caso in cui non parli giapponese, questo è pronunciato come segue:

fu ru i ke ya

Ka Wa Zu a Bi Ko Mu

mi zu no o to

Naturalmente, è contato dalle morene. Il kireji è や ( ya ) , il kigo (riferimento stagionale) è 蛙 ( kawazu , rana, -> primavera) .

Usando l'interprete linux dalla pagina ufficiale, puoi usarlo in questo modo:

$ echo 5 | ./wspace .ws

matematica

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

I pedanti possono leggere l'ultima riga come "f di 1 è 1", ma non ho potuto resistere al grido di Basho.

test:

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

tornando:

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

Bonus di carattere distintivo linguistico Haiku (ispirato a @cormullion)

Rewrite any term
High-level functions abound —
Mathematica

Lotto

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

Pronuncia ; ignora le espressioni matematiche e questi simboli @ / % ^ , ( ):

impostato su 1 e
per L a in 2 1 1
impostare ata

Nota; questo calcola il fattoriale, non lo genera: la variabile tcontiene il fattoriale.

Il seguente Haiku / codice può essere aggiunto allo stesso file batch per generare il fattoriale ( |i caratteri sono pronunciati come pipe):

@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

lasciare che n sia
da uno a n, applicare
Seq dot fold star one

newLISP

Le parentesi non sono pronunciate:

(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

Il codice Lisp è composto da

numerose parentesi

e alcune funzioni

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

Inseriscilo in un file chiamato f.pl

E l'output:

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

Che si legge come:

perl fpl tre
perl fpl uno in meno uno
perl fpl ten

LiveScript

Questo è medievale:

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

Stampe 3628800, che è 10!. È una piccola rotonda: la funzione storyrestituisce una funzione ones-misery, che restituisce sempre la risposta. È più artistico in questo modo.

Nessun commento di riempimento o stringhe non necessarie!

Storia di debug bonus:

Sono scoppiato a ridere
quando informato che un bug era
" deathè undefined"

Haskell

Questo sarà un haiku in rima !

fatto 0 = 1 - il fatto zero è uno
fact ton = ton * (fact stun) - la fact fact è tonnellate volte la fact stun
        dove stun = pred ton - dove stun è pred ton

Si!

Nota: Pred indica il numero precedente. Anche in haskell, puoi avere più definizioni di una funzione e viene usata la prima che ha senso.

Ruby - Un Haiku

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

Leggi (ignorando la punteggiatura, ma includendo una emoticon) in questo modo:

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

leggi come:

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

Perl

So che è contro le regole usare funzioni già pronte, ma ecco cosa ottengo.

Immagina che il tuo compito sia quello di istruire un roditore di grandi dimensioni:

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

Posso solo immaginare cosa significhi l'ultima parola e come sia pronunciata, ma ti assicuro che è una sillaba. Apparentemente non capisce cosa vuoi da lui, quindi devi elaborare (allentando gli standard di qualità mentre perdi la pazienza):

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

ancora inutilmente. Quindi devi spiegarlo in un inglese semplice:

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

Cosa è successo dopo non lo so, ma il codice è valido:

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

e

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

e

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

Pitone

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

Il modo in cui l'ho letto:

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

pronounciation:

la libbra include il punto
I / O
standard h la libbra include il punto lib standard h

int main int arg c
virgola char star star arg v
commento parentesi graffa aperta

calcola iterativamente fattoriale qui
long int n uguale

zero virgola i
equivale a zero virgola r
equivale a un commento

il prodotto inizia con un
punto e virgola se arg c
è maggiore di uno

parentesi aperta n è
str-to-l di arg v sotto
una virgola NULL virgola dieci

punto e virgola se
n meno di zero inizia
printf arg deve

essere maggiore o
uguale a zero barra rovesciata al
punto e virgola

uscita negativa
un punto e virgola fine parentesi
graffa uguale a

n punto
e virgola mentre apro la parentesi graffa r
equivale a r volte i

punto e virgola
decremento punto e virgola
chiusura parentesi graffa commento stampa

il risultato printf
percento d fattoriale
equivale a percento d

whack n virgola n
virgola r punto e virgola
commento fatto parentesi graffa

C # - 3 haikus

Ho rimosso il solito uso di C #, spazio dei nomi e disordine di definizione della classe, che sarebbe un quarto haiku.

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

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

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

che ho letto come

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

si noti che il modulo .. dove viene aggiunto automaticamente a qualsiasi codice Haskell senza di esso durante la compilazione, quindi non scriverlo è praticamente un imbroglio.

GIAVA:

In risposta alla domanda e al Dwaiku (Double-Haiku o come vuoi chiamarlo) pubblicato da Quincunx in Java, ecco l'Haiku corretto:

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

Javascript - Due 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 

Non sono un madrelingua. Quindi, ho usato un dizionario per contare le sillabe. Spero sia abbastanza buono. Qualsiasi feedback è il benvenuto :)

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

Ci è permesso usare il filler?

Python 2 haikus:

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

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

Befunge-93

Tre haikus:

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

L'ultima riga è certamente un po 'economica.

Prova qui: http://www.bedroomlan.org/tools/befunge-93-playground