Tarea

Cree un programa que calcule el factorial de un número sin utilizar funciones factoriales integradas. ¿Fácil? El problema es que debe escribir todo su programa (incluida la prueba) en forma de haiku .

Puedes usar tantos haikus como necesites, pero cuando se pronuncian, deben seguir el formato de sílaba 5-7-5.

Puntuación

Este es un concurso de popularidad , por lo que debes obtener la mayor cantidad de votos para ganar. Su programa debe constar de al menos un haiku completo, y todos los haikus deben estar completos.

Al leer el código, la primera línea de cada haiku tendrá 5 sílabas, la segunda tendrá 7 y la tercera tendrá 5.

Charla

(evaluar en un espacio de trabajo; abre un cuadro de diálogo, solicita un número e imprime el resultado en 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".

Traté de traer algo de reflexión ("en este poema") y kigo también. Además, se incluyen algunos elementos de rima de estilo occidental (por favor-> estos, tiempo-> rima); sin embargo, al no ser hablante nativo de japonés ni de inglés, perdona los detalles estilísticos ;-)

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

Tiempo de educación de Haskell:

• La range xfunción crea una lista de enteros desde 1 hasta el valor de x.
• La fact xfunción multiplica todos los valores de la lista range xpara calcular el resultado.
• La primera línea dice que la factfunción toma un número entero y devuelve un número entero.

Java - 2 haikus

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

Incluso cuando la pregunta no es el golf de código , a menudo me encuentro jugando la respuesta. En este caso, jugué al golf el número de haikus.

Lo pronuncio así:

estática protegida
int factorial int n
si n es cero

retorno n más uno
factorial de retorno n
menos uno veces n

Programa de prueba:

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

Tenga en cuenta que este programa comienza a generar 0s rápidamente; eso es resultado del desbordamiento. Puede obtener fácilmente números correctos más grandes cambiando cada uno inta long.

Las pronunciaciones estándar para System.out.printlny public static void main(String[] args)se reflejan en el programa.

APL

factorial←{×/⍳⍵}

Factorial es:
el producto de productos naturales
hasta 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 de prueba (imaginado):

A pesar de su longitud, este programa solo toma un solo entero como entrada y proporciona un solo entero como salida. Entonces:

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

("Seis, siete y veinte. / Siete, cinco mil cuarenta. / Cero, uno. Uno, uno.")

Pitón 2, 4 Haikus

Un programa completo de Python 2 haifac.py. Correr comopython 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))

Pronunciación:

ejecutar este
operador de importación de programa completo como
sistema de importación op

proporcione una arg
n igual a sys arg v 1
defina hai fac n

si n menos de 1
devuélveme 1 a la vez
, haz otra cosa

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

GolfScript, 2 Haikus

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

Lea como haiku, enumerando cada pulsación de tecla:

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

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

Con caso de prueba (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

Leer como 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

Adelante

: 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 es la función y mi intento de kigo : el pez globo es una referencia invernal. Tengo la intención ?dode ser kireji , el punto de inflexión, antes del bucle contado.

PHP, 4 haikus

¡Haikus todo en 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)

Espacio en blanco

Esto hace uso de uno de los más famoso haiku s, y mucho se ha escrito sobre él.

No tengo idea de por qué nadie ha hecho esto antes, ¡ ni siquiera requiere esfuerzo!

Antes que nada, antes de leer el poema, quiero que te recuestes, te relajes y disfrutes de la tranquilidad creada por el gran vacío que rodea el poema. Destaca el estanque, rodeado de un vasto paisaje.

古 池 や    
蛙 飛 び こ む               
水 の 音             

código fuente en filebin

En caso de que no hable japonés, esto se pronuncia de la siguiente manera:

fu ru i ke ya

ka wa zu a bi ko mu

mi zu no o a

Naturalmente, se cuenta por morae. El kireji es や ( ya ) , el kigo (referencia estacional) es 蛙 ( kawazu , rana, -> primavera) .

Usando el intérprete de Linux de la página oficial, puede usarlo así:

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

Los pendientes pueden leer la última línea como "f de 1 es 1", pero no pude resistir el saludo a Basho.

Pruebas:

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

Volviendo:

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

Bonus de distinción lingüística Haiku (inspirado en @cormullion)

Rewrite any term
High-level functions abound —
Mathematica

Lote

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

pronunciación ; ignora las expresiones matemáticas y estos símbolos @ / % ^ , ( ):

establecer en 1 y
para L a en 2 1 1
establecer un ata

Nota; esto calcula el factorial, no lo genera, la variable tcontiene el factorial.

El siguiente código / Haiku se puede agregar al mismo archivo por lotes para generar el factorial (los |'s se pronuncian como tubería):

@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

deje que el hecho de n sea
de uno a n, aplique
Seq dot fold star one

nuevoLISP

Los paréntesis no se pronuncian:

(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

El código Lisp consiste en

numerosos paréntesis

y algunas funciones

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

Mezcle esto en un archivo llamado f.pl

Y la salida:

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

Que se lee como:

perl fpl three
perl fpl uno menos uno
perl fpl diez

LiveScript

Este es medieval:

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

Impresiones 3628800, que es 10!. Es una pequeña rotonda: la función storydevuelve una función ones-misery, que siempre devuelve la respuesta. Es más artístico de esa manera.

¡Sin comentarios de relleno ni cadenas innecesarias!

Historia de depuración de bonificación:

Me eché a reír
cuando me informaron que un error era
" deathes undefined"

Haskell

¡Este será un haiku que rima !

hecho 0 = 1 - hecho cero es uno
hecho ton = ton * (hecho aturdido) - hecho ton es ton veces hecho hecho aturdimiento
        donde aturdir = pred ton - donde aturdir es pred ton

¡Sí!

Nota: Pred significa el número anterior. También en haskell, puede tener múltiples definiciones de una función, y se usa la primera que tiene sentido.

Ruby - Un Haiku

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

Lea (ignorando la puntuación, pero incluyendo un emoticón) como este:

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

leído como:

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

Perl

Sé que está en contra de las reglas usar funciones listas para usar, pero esto es lo que obtengo.

Imagine que su tarea es instruir a un roedor de gran tamaño:

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

Solo puedo adivinar qué significa la última palabra y cómo se pronuncia, pero te aseguro que es una sílaba. Aparentemente, él no entiende lo que quieres de él, por lo que debes elaborar (suavizando los estándares de calidad a medida que pierdes la paciencia):

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

aún en vano. Luego tienes que explicarlo en inglés simple:

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

Lo que sucedió después no lo sé, pero el código es válido:

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

y

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

y

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

Pitón

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

La forma en que lo leo:

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

Pronunciación:

la libra incluye el
punto h estándar de E / S la libra incluye
el punto h lib estándar

int main int arg c
coma char star star arg v
abrir paréntesis comentario

calcular iterativamente factorial aquí
largo int n es igual

coma cero i
es igual a coma cero r
es igual a un comentario

el producto comienza en un
punto y coma si arg c
es mayor que uno

abra la llave n es
str-to-l de arg v sub
una coma NULL coma diez

punto y coma si
n menos que cero comienza
printf arg must

ser mayor o
igual a cero barra invertida
n punto y coma

salir negativo
un punto y coma final de la llave de la
llave de la esquina i es igual

n punto
y coma mientras abro la llave r
es igual a r veces i

punto y coma
decremento punto y coma
cierre corsé comentario imprimir

el resultado printf
porcentaje d factorial
es igual a porcentaje d

whack n coma n
coma punto y coma
comentario hecho fin llave

C # - 3 haikus

Eliminé el C # habitual usando, el espacio de nombres y el desorden de definición de clase, que sería un cuarto 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 leí como

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

tenga en cuenta que el módulo ... donde se agrega automáticamente a cualquier código de Haskell sin él en la compilación, por lo que no escribirlo es prácticamente una trampa.

JAVA:

En respuesta a la pregunta y al Dwaiku (Double-Haiku o como quieras llamarlo) publicado por Quincunx en Java, aquí está el Haiku correcto:

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

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

No soy un hablante nativo. Entonces, usé un diccionario para contar las sílabas. Con suerte, es lo suficientemente bueno. Cualquier comentario es bienvenido :)

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

¿Se nos permite usar relleno?

Python 2 haikus:

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

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

Befunge-93

Tres haikus:

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

La última línea es ciertamente un poco engañosa.

Pruebe aquí: http://www.bedroomlan.org/tools/befunge-93-playground