¿Alguna vez has querido preguntarle al compilador "¿Por qué?" La mayoría de nosotros nos hemos sentido frustrados cuando el código no funciona como debería. Mathworks por lo tanto ha implementado una pequeña y agradable función whyque responde a la pregunta. Para dar algunos ejemplos de MATLAB:

why
The programmer suggested it.

why
To fool the tall good and smart system manager.    

why(2)
You insisted on it.

why(46)
Bill insisted on it.

Su tarea es implementar la whyfunción en su idioma. La función debería funcionar con y sin un argumento de entrada (alternativamente, use input 0o -1). La función debe ser nombrada why(o, escribir why(n)en STDIN debería dar como resultado que se imprima la cadena apropiada).

Si no se proporciona ningún argumento, o el argumento es cero o negativo, la cadena de salida debe ser una frase aleatoria y válida. Por lo tanto, no debería ser una función why, why(), why(0)o why(-1)que devuelve una frase al azar.

Si se proporciona un argumento de entrada n(argumento de función, no STDIN), la salida debería ser la enésima cadena (definida a continuación). Por lo tanto, why(1)siempre debe generar (imprimir / mostrar) el mismo resultado.

Las oraciones se construyen de la siguiente manera (Tipo 1, Tipo 2 y Especial). Todas las oraciones terminan con! .

"Person" "ending" !
"Verb" "adjective" "Person" !
A list of special cases

La lista de personas:

Stewie
Peter
Homer
The programmer
The system manager
You

La lista de finales:

suggested it
insisted on it
did it

La lista de verbos son:

To fool
To satisfy
To please

La lista de adjetivos:

the smart
the bald
the tall
the rich
the stupid

La lista de casos especiales:

How should I know?
Stop asking!
Don't ask!

La forma de seleccionar una numerada es:

Tipo de oraciones:

Odd number => Type 1
Even number => Type 2
n % 7 = 0 => Type 3 (% is the modulus operator)

Nombres: el enésimo nombre se define mediante el módulo (%).

n = 1:   1 % 7  => Stewie
n = 2:   2 % 7  => Peter
...
n = 6:   6 % 7  => You
n = 7:   7 % 7  => How should I know?
n = 11:  11 % 7 => The programmer
n = 14:  14 % 7 => Stop asking!
n = 21:  21 % 7 => Don't ask!

Terminaciones: la enésima terminación también se define utilizando el módulo. Suponga que las terminaciones (1, 2 y 3) se enumeran como (1 2 2 3). Como los números siempre son impares, use((n+1)/2 % 4)

n = 1:    ((1+1)/2 % 4)  => suggested it
n = 3:    ((3+1)/2 % 4)  => insisted on it
n = 13:   ((13+1)/2 % 4) => did it

Adjetivos: el enésimo adjetivo se define utilizando el módulo. Como los números son siempre pares, use:(n % 10)/2

n = 2:   (2 % 10)/2 => Smart
n = 6:   (6 % 10)/2 => The tall
...

Verbos: el enésimo verbo también se define utilizando el módulo. Suponga que los verbos (1, 2 y 3) se enumeran como (1 2 2 3)Como los números son siempre pares para los verbos, use(n % 8) / 2

n = 2:   (2 % 8)/2 => To fool
n = 4:   (4 % 8)/2 => To satisfy
n = 6:   (6 % 8)/2 => To satisfy
n = 8:   (8 % 8)/2 => To please

Ahora, la forma de crear una aleatoria debería ser bastante simple, simplemente seleccione una aleatoria n.

Algunos ejemplos:

why
You suggested it!

why
To fool the tall Homer!

why
Don't ask!

why(1)
Stewie suggested it!

why(14)
Stop asking!

why(8)
To please the rich Stewie!

Se aplican reglas estándar de golf de código. Se seleccionará un ganador una semana a partir del día en que se publicó el desafío.

JavaScript (ES6) 345

No estoy seguro acerca de los números, pero aquí está mi intento.

Pruebe a ejecutar el fragmento a continuación en un navegador compatible con EcmaScript.

why=n=>(n<1?n=Math.random()*840|0:0,s="suggested,insisted on,did,fool,satisfy,please,stupid,smart,bald,tall,rich,Don't ask!,How should I know?,Stop asking!,Stewie,Peter,Homer,programmer,system manager,You".split`,`,n%7?(p=s[n%7+13],n&1?(p>'a'?'The ':'')+p+` ${s['2011'[-~n/2%4]]} it!`:`To ${s['5344'[n%8/2]]} the ${s[n/2%5+6]} ${p}!`):s[11+n%3])  

for(o='',i=0;++i<1e3;)o+=i+':'+why(i)+'\n';O.innerHTML=o

function test() { R.innerHTML=why(+I.value) }

// Less golfed

WHY=n=>(
  n=n<1?Math.random()*999|0:n,
  s=["suggested", "insisted on", "did", "fool", "satisfy", "please",
     "stupid", "smart", "bald", "tall", "rich",
     "Don't ask!", "How should I know?", "Stop asking!",
     "Stewie", "Peter", "Homer", "programmer", "system manager", "You"],
  n%7
    ? ( p=s[n%7+13],
        n&1
        ? (p>'a'?'The ':'')+p+` ${s['2011'[-~n/2%4]]} it!`
        : `To ${s['5344'[n%8/2]]} the ${s[n/2%5+6]} ${p}!`)
    : s[11+n%3]
)  

#O { height:300px; width:50%; overflow:auto }
#I { width:2em }

Why(<input id=I>)<button onclick=test()>-></button><span id=R></span>
<pre id=O>

C #, 502 bytes

Este proyecto debe tener el nombre de ensamblado establecido en por qué, lo que producirá un ejecutable con el nombre correcto.

Completamente golfizado:

using System;class W{static void Main(string[]i)int n=i.Length>0?int.Parse(i[0]):new Random().Next();string[]s={"Don't ask!","How should I know?","Stop asking!"},v={"To please ","To fool ","To satisfy ",null},a={"the stupid","the smart","the bald","the tall","the rich"},p={"","Stewie","Peter","Homer","The programmer","The system manager","You"},e={"suggested it!","insisted on it!",null,"did it!"};Console.Write(n%7<1?s[n%3]:n%2<1?(v[n%8/2]??v[2])+a[n%10/2]+" {0}!":"{0} "+(e[n/2%4]??e[1]),p[n%7]);}}

Sangría y nuevas líneas para mayor claridad:

using System;
class W{
    static void Main(string[]i)
        int n=i.Length>0
            ?int.Parse(i[0])
            :new Random().Next();
        string[]
            s={"Don't ask!","How should I know?","Stop asking!"},
            v={"To please ","To fool ","To satisfy ",null},
            a={"the stupid","the smart","the bald","the tall","the rich"},
            p={"","Stewie","Peter","Homer","The programmer","The system manager","You"},
            e={"suggested it!","insisted on it!",null,"did it!"};
        Console.Write(
            n%7<1
                ?s[n%3]
                :n%2<1
                    ?(v[n%8/2]??v[2])+a[n%10/2]+" {0}!"
                    :"{0} "+(e[n/2%4]??e[1]),
            p[n%7]
        );
    }
}

Ejemplo de entrada / salida:

>Why
To fool the bald Homer!
>Why 1
Stewie suggested it!

Powershell 437 461 453 Bytes

Editar: se perdieron los verbos duplicados

División entre el corpus y los cálculos para el conteo de bytes

• 267 Bytes = texto pre-codificado (excluyendo to, the, ity !lugares, ya que han fijas).
• 186 Bytes = cálculo

Establece el argumento predeterminado en 0 si no se especifica. Si el argumento es, <1entonces obtiene un número aleatorio <99 fn:1y vuelve a ejecutar. Técnicamente, esto significa -50que funcionará también, siendo tratado como un caso aleatorio.

function why{param($b=0)$p=@('Stewie','Peter','Homer','The programmer','The system manager','You');$e=@('did','suggested','insisted on','insisted on');$v=@('please','fool','satisfy','satisfy');$a=@('stupid','smart','bald','tall','rich');$s=@("Don't ask!",'How should I know?','Stop asking!');if($b-le0){why(Get-Random 99)}elseif(!($b%7)){$s[$b/7%3]}else{$n=$p[$b%7-1];if($b%2){"$n $($e[($b+1)/2%4]) it!"}else{"To $($v[$b%8/2]) the $($a[$b%10/2]) $n!"}}}

Explicación:

# Any -1 in calculations is to account for arrays starting at index 0
# Final key placed in position 0 for indexing (4%4 = 0)
# Powershell 1 = True, 0 = False
if($b-le0){why(Get-Random 99)}          # If not positive, choose random number
elseif(!($b%7))                         # $b%7 means special so use that
  {$s[$b/7%3]}                          # Divide by 7 and find modulo, use that phrase.
else{$n=$p[$b%7-1]                      # Get the correct person (Used in both types). 6 max
if($b%2){"$n $($e[($b+1)/2%4]) it!"}    # Create type 1 sentence
else{"To $($v[$b%8/2]) the $($a[$b%10/2]) $n!"} # Type 2

fn:199 Elegido para guardar un byte. Si hay más de 99 posibles oraciones anteriores (no se calcularon) aumente a 999 o 9999 según corresponda (+1/2 bytes)

MUMPS, 379 bytes

f(s,i) s:'i i=$L(s,"^") q $P(s,"^",i)
why(n) s:'n n=$R(840) s p="Stewie^Peter^Homer^The programmer^The system manager^You",e="suggested^insisted on^did",v="fool^satisfy^please",a="smart^bald^tall^rich^stupid",s="How should I know?^Stop asking!^Don't ask!" q:n#7=0 $$f(s,n#3) q:n#2 $$f(p,n#7)_" "_$$f(e,n+1/2#4)_" it!" q "To "_$$f(v,n#8/2)_" the "_$$f(a,n#10/2)_" "_$$f(p,n#7)_"!"

Cuando no se proporciona ninguna entrada, se genera un número aleatorio en 0..839.

Uso:

>w $$why(15)
Stewie did it!
>w $$why()
Don't ask!

La estrategia de evaluación de izquierda a derecha de MUMPS ahorra unos pocos bytes entre paréntesis aquí.

Nota al margen: ¿ves esas cadenas que se parecen "foo^bar^baz^qux"? Esas son las llamadas "cadenas delimitadas", y son la forma estándar de almacenar listas que se ajustan dentro del límite máximo de tamaño de cadena, ya que MUMPS en realidad no tiene listas / matrices (o, de hecho, ninguna estructura de datos además de árboles). Para listas demasiado grandes para caber en una sola cadena, en su lugar utilizamos árboles de profundidad 1 y colocamos los valores en las hojas del árbol. ¡Divertido!

Emacs Lisp 473 Bytes

(defun why(n)(if(and n(> n 0))(let*((p'(t"Stewie""Peter""Homer""The programmer""The system manager""You"))(e'("did""suggested""insisted on""insisted on"))(v'("please""fool""satisfy""satisfy"))(a'("stupid""smart""bald""tall""rich"))(s'("Don't ask!""How should I know?""Stop asking!"))(q(nth(% n 7)p)))(cond((=(% n 7)0)(nth(%(/ n 7)3)s))((=(% n 2)1)(format"%s %s it!"q(nth(%(/(1+ n)2)4)e)))(t(format"To %s the %s %s!"(nth(/(% n 8)2)v)(nth(/(% n 10)2)a)q))))(why(random 99))))

Más grande 'de desecho' es probablemente el format, %s... secciones. Si las variables pudieran integrarse en las cadenas sin la especificación, ahorraría 10 bytes %sy otros 12 enformat

Ruby 396 378 372 bytes

Estoy seguro de que esto no se juega al máximo.

p=%w[a Stewie Peter Homer The\ programmer The\ system\ manager You]
why=->n{n<1 ? why[rand(99)+1]:n%7<1 ? $><<%w[a How\ should\ I\ know? Stop\ asking! Don't\ ask!][n/7]:n%2<1 ? $><<'To '+%w[fool satisfy satisfy please][n%8/2-1]+' the '+%w[smart bald tall rich stupid][n%10/2-1]+' '+p[n%7]+?!:$><<p[n%7]+' '+%w[a suggested insisted\ on insisted\ on did][(n+1)/2%4]+' it!'}

Editar: Me acabo de dar cuenta de que no sé la precedencia del operador. Oh bien..

CJam, 281 bytes

99mrqi_])0>=i:A7md{;A2%{S["suggested""insisted on""did"]A2/=+" it"+}{"To "["fool""satisfy"_"please"]A(2/:B=" the "["smart""bald""tall""rich""stupid"]B=SM}?[M"Stewie""Peter""Homer""The programmer""The system manager""You"]A=\'!}{["How should I know?""Stop asking!""Don't ask!"]\(=}?

Enlace permanente

No he usado CJam antes, así que tomaré algunos consejos. ¡Estoy seguro de que hay muchos trucos que no sé!

(No pude entender cómo nombrar esto como una función llamada "por qué", parece que las funciones no existen en CJam, así que no estoy seguro de si una respuesta de CJam está bien o no ...)

Lua 5.3.0, 452 460 446 bytes

Este es mi primer intento en un código de golf, ¡así que corríjame si hice algo mal!

a={"Stewie","Peter","Homer","The Programmer","The system manager","You"}b={"fool ","satisfy ",n,"please "}b[3]=b[2]why=function(n)pcall(math.randomseed,n and n>0 and n)n=math.random(1e9)q=n>>4r=n>>8return 1>n&7 and({"How should I Know?","Stop asking!","Don't ask!"})[q%3+1]or 0<n%2 and a[q%6+1]..({" suggested"," insisted on"," did"})[r%3+1].." it"or"To "..b[q%4+1].."the "..({"smart ","bald ","tall ","rich ","stupid "})[r%5+1]..a[(r>>4)%6+1]end

Sin golf:

a={
    "Stewie",
    "Peter",
    "Homer",
    "The Programmer",
    "The system manager",
    "You"
}
b={
    "fool ",
    "satisfy ",
    n,
    "please "
}
b[3]=b[2]
why=function(n)
    pcall(math.randomseed,n and n>0 and n)
    n=math.random(1e9)
    q=n>>4
    r=n>>8
    return
            1>n&7 and
                ({"How should I Know?","Stop asking!","Don't ask!"})[q%3+1]
            or 0<n%2 and
                a[q%6+1]..({" suggested"," insisted on"," did"})[r%3+1].." it"
            or
                "To "..b[q%4+1].."the "..({"smart ","bald ","tall ","rich ","stupid "})[r%5+1]..a[(r>>4)%6+1]
end

Python (2), 692 bytes

Todavía estoy aprendiendo, ¡así que por favor sé gentil! :)

from sys import argv,maxint
import random
def why(*O):
 P=["You","Stewie","Peter","Homer","programmer","system manager"];E=["did","suggested","insisted on","insisted on"];I=["please","fool","satisfy","satisfy"];Q=["stupid","smart","bald","tall","rich"];S=["Don't ask!","How should I know?","Stop asking!"]
 if len(argv)>1:A=O[0]
 else:A=random.randint(-maxint-1,maxint)
 if A%7==0:print S[A%3]
 else:
  M=P[A%6]
  if A%11==0:
   M=P[4]
  if A%2==0:
   if M==P[0]:M="you"
   U=I[(A%8)/2];Z=Q[(A%10)/2];print"To %s the %s %s!"%(U,Z,M)
  if A%2==1:
   if M==P[4]:M="The %s"%P[4]
   if M==P[5]:M="The %s"%P[5]
   C=E[((A+1)/2)%4];print"%s %s it!"%(M,C)
if len(argv)>1:why(int(argv[1]))
else:why()

Funciona con o sin un int como argumento de línea de comando.

Traté de enfatizar código de corrección tanto como sea posible, al igual que con la generación de números aleatorios a partir -sys.maxint - 1de sys.maxinty visualización de frases en el caso correcto.

El código se basa en gran medida en sentencias if que estoy seguro de que podrían reemplazarse con algo más eficiente.

¡La retroalimentación es muy bienvenida!

Sin golf (1341 bytes)

from sys import argv, maxint
import random

def Why(*Optional):
    Persons = ["You", "Stewie", "Peter", "Homer", "programmer", "system manager"]
    Endings = ["did it", "suggested it", "insisted on it", "insisted on it"]
    Verbs = ["please", "fool", "satisfy", "satisfy"]
    Adjectives = ["stupid", "smart", "bald", "tall", "rich"]
    SpecialCases = ["Don't ask!", "How should I know?", "Stop asking!"]

    if len(argv) > 1:
        Argument = Optional[0]
    else:
        Argument = random.randint(-maxint - 1, maxint)

    if Argument % 7 is 0:
        print SpecialCases[Argument % 3]
    else:
        Person = Persons[(Argument) % 6]
        if Argument % 11 is 0:
            Person = "programmer"
        if Argument % 2 is 0:
            if Person is "You":
                Person = "you"
            Verb = Verbs[(Argument % 8) / 2]
            Adjective = Adjectives[(Argument % 10) / 2]
            print "To %s the %s %s!" % (Verb, Adjective, Person)
        if Argument % 2 is 1:
            if Person is "programmer":
                Person = "The programmer"
            if Person is "system manager":
                Person = "The system manager"
            Ending = Endings[((Argument + 1) / 2) % 4]
            print "%s %s!" % (Person, Ending)

if len(argv) > 1:
    Why(int(argv[1]))
else:
    Why()