Você já quis perguntar ao compilador "Por quê?" Muitos de nós ficamos frustrados quando o código não está funcionando como deveria. Portanto, o Mathworks implementou uma pequena função agradável why, que responde à pergunta. Para dar alguns exemplos do 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.

Sua tarefa é implementar a whyfunção no seu idioma. A função deve funcionar com e sem um argumento de entrada (use alternativamente input 0ou -1). A função deve ser nomeada why(ou, escrever why(n)STDIN deve resultar na impressão da string apropriada).

Se nenhum argumento for fornecido, ou o argumento for zero ou negativo, a sequência de saída deve ser uma frase válida e aleatória. Então, deve haver uma função why, why(), why(0)ou why(-1)que os retornos uma frase aleatória.

Se nfor fornecido um argumento de entrada (argumento de função, não STDIN), a saída deve ser a n-ésima sequência (definida abaixo). Portanto, why(1)sempre deve imprimir (imprimir / exibir) o mesmo resultado.

As frases são construídas da seguinte forma (Tipo 1, Tipo 2 e Especial). Todas as frases terminam com !.

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

A lista de pessoas:

Stewie
Peter
Homer
The programmer
The system manager
You

A lista de finais:

suggested it
insisted on it
did it

A lista de verbos é:

To fool
To satisfy
To please

A lista de adjetivos:

the smart
the bald
the tall
the rich
the stupid

A lista de casos especiais:

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

A maneira de selecionar uma numerada é:

Tipo de frases:

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

Nomes: o enésimo nome é definido usando o 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!

Finais: O enésimo final também é definido usando o módulo. Suponha que os finais (1, 2 e 3) estejam listados como (1 2 2 3). Como os números são sempre ímpares, 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: O enésimo adjetivo é definido usando o módulo. Como os números são sempre pares, use:(n % 10)/2

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

Verbos: O enésimo verbo também é definido usando o módulo. Suponha que os verbos (1, 2 e 3) estejam listados como (1 2 2 3)Como os números são sempre pares para 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

Agora, a maneira de criar uma aleatória deve ser bastante simples, basta selecionar uma aleatória n.

Alguns exemplos:

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!

Aplicam-se as regras de código padrão Um vencedor será selecionado uma semana a partir do dia em que o desafio foi lançado.

JavaScript (ES6) 345

Não tenho certeza sobre os números, mas aqui está a minha tentativa.

Teste a execução do snippet abaixo em um navegador compatível com 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

Esse projeto precisa ter o AssemblyName definido como o motivo que produzirá um executável com o nome correto.

Totalmente jogado:

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

Recuo e novas linhas para maior clareza:

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

Exemplo de entrada / saída:

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

Powershell 437 461 453 Bytes

Edit: Perdeu os verbos duplicados

Divisão entre o corpus e os cálculos para contagem de bytes

• 267 Bytes = texto pré-codificado (excluindo to, the, ite !lugares desde que tenham fixos).
• 186 bytes = cálculo

Define o argumento padrão como 0 se não for especificado. Se argumento for <1, ele obtém um número aleatório <99 fn:1e é executado novamente . Tecnicamente, isso significa que -50também funcionará, sendo tratado como um caso aleatório.

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!"}}}

Explicação:

# 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 Escolhido para salvar um byte. Se houver mais de 99 frases possíveis acima (não calculou), aumente para 999 ou 9999, conforme aplicável (+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)_"!"

Quando nenhuma entrada é fornecida, um número aleatório em 0..839 é gerado.

Uso:

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

A estratégia de avaliação da esquerda para a direita do MUMPS economiza alguns bytes entre parênteses aqui.

Nota lateral: vê aquelas cordas que se parecem "foo^bar^baz^qux"? Essas são as chamadas "cadeias delimitadas" e são a maneira padrão de armazenar listas que se encaixam dentro do limite máximo de tamanho de cadeia, pois o MUMPS não possui realmente listas / matrizes (ou, de fato, nenhuma estrutura de dados além das árvores). Para listas muito grandes para caberem em uma única sequência, usamos árvores de profundidade 1 e colocamos os valores nas folhas da árvore. Diversão!

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

Maior 'resíduos' é provavelmente a format, %s... seções. Se variáveis ​​pudessem ser incorporadas nas strings sem a especificação, economizariam 10 bytes %se outros 12 emformat

Ruby 396 378 372 bytes

Tenho certeza de que isso não é praticado ao 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!'}

Edit: Acabei de perceber que não conheço precedência do operador. Ah bem..

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!"]\(=}?

Permalink

Não usei o CJam antes, então vou dar algumas dicas. Tenho certeza de que há muitos truques que não conheço!

(Eu não conseguia descobrir como nomear isso como uma função chamada "por quê" - parece que as funções não existem no CJam - por isso não tenho certeza se uma resposta do CJam está correta ou não ...)

Lua 5.3.0, 452 460 446 bytes

Esta é a minha primeira tentativa de um código de golfe, por favor, corrija-me se eu fiz algo errado!

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

Ungolfed:

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

Eu ainda estou aprendendo, então por favor seja 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 com ou sem um int como argumento de linha de comando.

Tentei enfatizar a correção do código o máximo possível, como na geração de números aleatórios de -sys.maxint - 1parasys.maxint e exibindo frases no caso direita.

O código se baseia muito em declarações if que, com certeza, poderiam ser substituídas por algo mais eficiente em termos de local.

O feedback é muito bem-vindo!

Ungolfed (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()