Tâche

Créez un programme qui calcule la factorielle d'un nombre sans utiliser de fonctions factorielles intégrées. Facile? Le problème, c'est que vous devez écrire tout votre programme (y compris le tester) sous forme de haiku .

Vous pouvez utiliser autant de haïkus que nécessaire, mais une fois prononcés, ils doivent suivre le format de syllabes 5-7-5.

Notation

Il s’agit d’un concours de popularité , vous devez donc remporter le plus de votes positifs. Votre programme doit comporter au moins un haïku complet et tous les haïkus doivent être complets.

Lors de la lecture du code, la première ligne de chaque haïku aura 5 syllabes, la seconde 7 et la troisième 5.

Petite conversation

(évalue dans un espace de travail; ouvre une boîte de dialogue, demande un numéro et imprime le résultat sur 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".

J'ai essayé d'introduire de la réflexion ("dans ce poème") et du kigo également. En outre, certains éléments de rimes de style occidental sont inclus (veuillez-> ceux-ci, temps-> rimes); cependant, n'étant ni le japonais, ni l'anglais, ne pardonnez aucun détail stylistique ;-)

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

Temps d'éducation Haskell:

• La range xfonction crée une liste d'entiers allant de 1 à la valeur de x.
• La fact xfonction multiplie toutes les valeurs de la liste range xpour calculer le résultat.
• La première ligne indique que la factfonction prend un entier et retourne un entier.

Java - 2 haïkus

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

Même lorsque la question n'est pas du code-golf , je me surprends souvent à jouer au golf. Dans ce cas, j'ai golfé le nombre de haïkus.

Je le prononce ainsi:

int statique protégée factorielle int n
si n est zéro

retour n plus un
retour factoriel n
moins un fois n

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

Notez que ce programme commence à sortir 0rapidement; c'est le résultat d'un débordement. Vous pouvez facilement obtenir des nombres corrects plus grands en changeant chacun inten long.

Les prononciations standard pour System.out.printlnet public static void main(String[] args)sont reflétées dans le programme.

APL

factorial←{×/⍳⍵}

Factorial is—
le produit de produits naturels
jusqu'à oméga

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 cas de test (imaginé):

Malgré sa longueur, ce programme ne prend qu'un seul entier en entrée et fournit un seul entier en sortie. Alors:

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

("Six, sept à vingt. / Sept, cinq mille quarante. / Zéro, un. Un, un.")

Python 2, 4 Haikus

Un programme complet de Python 2 haifac.py. Courir commepython 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:

exécuter cet
opérateur d'importation de programme complet en tant que
système d'importation op

s'il vous plaît fournir un arg
n égal à sys arg v 1
définir hai fac n

si n moins de 1,
revenez 1 à la fois
, faites autre chose

retour op dot mul
n hai fac n moins 1
impression hai fac int n

GolfScript, 2 Haikus

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

Lire comme haiku, énumérant chaque frappe:

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

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

Avec cas de test (5 haïkus):

[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

Lire comme 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

4ème

: 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 est la fonction et ma tentative de kigo : blowfish est une référence en hiver. J'ai l'intention ?dod'être kireji , le tournant, avant la boucle comptée.

PHP, 4 haïkus

Haïkus tout-en-rime !

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)

Espace blanc

Cela fait l’un des plus célèbres haïku et beaucoup a été écrit à ce sujet.

Aucune idée pourquoi personne n'a déjà fait cela auparavant, cela ne prend même pas d'effort!

Tout d’abord, avant de lire le poème, je veux que vous vous allongez, vous détendiez et profitiez de la tranquillité créée par le grand vide qui entoure le poème. Il met en valeur l'étang, entouré d'un vaste paysage.

池 や    
飛 び こ む               
の 音             

code source sur filebin

Si vous ne parlez pas japonais, cela se prononce comme suit:

fu ru i ke ya

ka wa zu à bi ko mu

mi zu no o to

Naturellement, il est compté par les morae. Le kireji est ya ( ya ) , le kigo (référence saisonnière) est ( kawazu , grenouille, -> printemps) .

En utilisant l'interpréteur Linux de la page officielle, vous pouvez l'utiliser comme ceci:

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

Les pédants peuvent lire la dernière ligne comme suit: "f of 1 is 1", mais je n'ai pas pu résister à l'appel lancé à Basho.

Essai:

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

Retour:

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

Bonus de distinction linguistique haïku (inspiré de @cormullion)

Rewrite any term
High-level functions abound —
Mathematica

Lot

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

La prononciation ; ignore les expressions mathématiques ainsi que ces symboles @ / % ^ , ( ):

réglé sur 1 et
pour L a dans 2 1 1
définissez ata

Remarque; cela calcule la factorielle, il ne la sort pas - la variable tcontient la factorielle.

Le code / haiku suivant peut être ajouté au même fichier batch pour générer la factorielle (les |sont prononcés sous forme de tube):

@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

laisser n fait
de 1 à n, appliquer
Seq dot fold star one

nouveauLISP

Les parenthèses ne sont pas prononcées:

(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

Le code Lisp consiste en

nombreuses parenthèses

et quelques fonctions

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

Ajoutez ceci dans un fichier nommé f.pl

Et la sortie:

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

Qui se lit comme:

perl fpl trois
perl fpl un moins un
perl fpl dix

LiveScript

Celui-ci est médiéval:

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

Les impressions 3628800, ce qui est 10!. C'est un petit rond point: la fonction storyretourne une fonction ones-misery, qui retourne toujours la réponse. C'est plus artistique comme ça.

Pas de commentaires de remplissage ou de chaînes inutiles!

Bonus histoire de débogage:

J'éclate de rire
quand on me dit qu'un bug est
" deathest undefined"

Haskell

Celui-ci sera un haïku qui rime !

fait 0 = 1 - le zéro est un
fact ton = ton * (fait étourdi) --fact ton est fois fois stupéfait
        où étourdissement = pred ton - où étourdissement est pred ton

Ouais!

Remarque: Pred signifie le numéro précédent. Également dans haskell, vous pouvez avoir plusieurs définitions d'une fonction, et la première qui a du sens est utilisée.

Ruby - Un haïku

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

Lire (en ignorant la ponctuation, mais en incluant un émoticône) comme ceci:

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

En SML:

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

lire comme:

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

Perl

Je sais que l'utilisation de fonctions toutes faites est contraire aux règles, mais voici ce que je comprends.

Imaginez que votre tâche consiste à instruire un rongeur surdimensionné:

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

Je ne peux que deviner ce que le dernier mot signifie et comment il est prononcé, mais je vous assure que c'est une syllabe. Apparemment, il ne comprend pas ce que vous attendez de lui. Vous devez donc élaborer (assouplir les normes de qualité en perdant patience):

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

toujours en vain. Ensuite, vous devez l'expliquer simplement en anglais:

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

Qu'est-ce qui s'est passé ensuite, je ne le sais pas, mais le code est valide:

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

et

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

et

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)

La façon dont je l'ai lu:

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:

livre inclure standard
I / O dot h livre inclure
standard lib dot h

int principal int arg c
virgule étoile étoiles arg v
accolade commentaire

calculer de manière itérative factorielle ici
long int n égal

zéro virgule i
est égal à zéro virgule r
est égal à un commentaire

le produit commence à un
point-virgule si arg c
est supérieur à un

accolade ouverte n est
str-to-l de arg v sous
une virgule NULL virgule dix

point-virgule si
n inférieur à zéro commence
printf arg doit

être supérieur ou
égal à zéro barre oblique inverse
n point-virgule

sortie négative
un point virgule fin accolade
accolade i est égal à

n point-virgule
pendant que j'ouvre l'accolade r
est égal à r fois i

point-virgule i
décrémenter point-virgule
accolade commentaire imprimer

le résultat printf
% d factoriel
est égal à% d

whack n virgule
virgule virgule
commentaire terminé

C # - 3 haïkus

J'ai enlevé le fouillis habituel de définitions de classe utilisant un espace de noms et le C #, ce qui serait un 4ème 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));}

que je lis comme

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

notez que le module .. où est ajouté automatiquement à tout code Haskell sans celui-ci lors de la compilation, il est donc pratiquement impossible de l'écrire.

JAVA:

En réponse à la question et au message publié par Quincunx dans Java, voici le haïku correct:

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

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

Je ne suis pas un locuteur natif. J'ai donc utilisé un dictionnaire pour compter les syllabes. J'espère que c'est assez bon. Tout commentaire est le bienvenu :)

Powershell, 2 haïkus

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

Sommes-nous autorisés à utiliser du mastic?

Python 2 haïkus:

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

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

Befunge-93

Trois haïkus:

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

La dernière ligne est certes un peu trompeuse.

Essayez ici: http://www.bedroomlan.org/tools/befunge-93-playground