Avez-vous déjà voulu demander au compilateur "Pourquoi?" La plupart d'entre nous ont été frustrés lorsque le code ne fonctionne pas comme il se doit. Mathworks a donc implémenté une jolie petite fonction why, qui répond à la question. Pour donner quelques exemples 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.

Votre tâche consiste à implémenter la whyfonction dans votre langue. La fonction doit fonctionner avec et sans argument d'entrée (utilisez alternativement input 0ou -1). La fonction doit être nommée why(ou, l'écriture why(n)en STDIN devrait entraîner l'impression de la chaîne appropriée).

Si aucun argument n'est donné ou si l'argument est nul ou négatif, la chaîne de sortie doit être une phrase valide et aléatoire. Donc, il devrait y avoir une fonction why, why(), why(0)ou why(-1)qui retourne une phrase au hasard.

Si un argument d'entrée nest donné (argument de fonction, pas STDIN), la sortie doit être la nième chaîne (définie ci-dessous). Donc, why(1)devrait toujours produire (imprimer / afficher) le même résultat.

Les phrases sont construites comme suit (Type 1, Type 2 et Spécial). Toutes les phrases se terminent par !.

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

La liste des personnes:

Stewie
Peter
Homer
The programmer
The system manager
You

La liste des terminaisons:

suggested it
insisted on it
did it

La liste des verbes est:

To fool
To satisfy
To please

La liste des adjectifs:

the smart
the bald
the tall
the rich
the stupid

La liste des cas particuliers:

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

La façon de sélectionner un numéro est:

Type de phrases:

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

Noms: Le nième nom est défini en utilisant le module (%).

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!

Terminaisons: La nième terminaison est également définie à l'aide du module. Supposons que les terminaisons (1, 2 et 3) sont répertoriées comme (1 2 2 3). Comme les nombres sont toujours impairs, utilisez((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

Adjectifs: Le nième adjectif est défini à l'aide du module. Comme les nombres sont toujours pairs, utilisez:(n % 10)/2

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

Verbes: Le nième verbe est également défini à l'aide du module. Supposons que les verbes (1, 2 et 3) sont répertoriés comme (1 2 2 3)Comme les nombres sont toujours identiques pour les verbes, utilisez(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

Maintenant, la façon d'en créer un au hasard devrait être assez simple, il suffit de sélectionner un au hasard n.

Quelques exemples:

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!

Les règles de golf du code standard s'appliquent. Un gagnant sera sélectionné une semaine après le jour où le défi a été publié.

JavaScript (ES6) 345

Je ne suis pas sûr des chiffres, mais voici ma tentative.

Testez l'exécution de l'extrait ci-dessous dans un navigateur compatible 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 octets

Ce projet doit avoir le AssemblyName défini sur pourquoi ce qui produira un exécutable avec le nom correct.

Entièrement golfé:

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

Indentation et nouvelles lignes pour plus de clarté:

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

Exemple d'entrée / sortie:

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

Powershell 437 461 453 octets

Edit: manqué les verbes en double

Division entre le corpus et les calculs pour le comptage d'octets

• 267 Octets = texte pré-codé (sauf to, the, itet !étant donné qu'ils ont fixé des lieux).
• 186 octets = calcul

Définit l'argument par défaut à 0 s'il n'est pas spécifié. Si l'argument est <1alors il obtient un nombre aléatoire <99 fn:1et se réexécute. Techniquement, cela signifie -50qu'il fonctionnera également, étant traité comme un cas aléatoire.

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

Explication:

# 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 Choisi pour enregistrer un octet. S'il y a plus de 99 phrases possibles ci-dessus (n'a pas été calculé), passez à 999 ou 9999 selon le cas (+1/2 octets)

MUMPS, 379 octets

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)_"!"

Lorsqu'aucune entrée n'est donnée, un nombre aléatoire dans 0..839 est généré.

Usage:

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

La stratégie d'évaluation de gauche à droite de MUMPS permet d'économiser quelques bons octets entre parenthèses ici.

Note: voyez ces cordes qui ressemblent "foo^bar^baz^qux"? Ce sont ce que l'on appelle des "chaînes délimitées" et constituent le moyen standard de stocker des listes qui correspondent à la limite de taille de chaîne maximale, car MUMPS n'a pas réellement de listes / tableaux (ou, en fait, aucune structure de données en dehors des arbres). Pour les listes trop grandes pour tenir dans une seule chaîne, nous utilisons à la place des arbres de profondeur 1 et mettons les valeurs sur les feuilles de l'arbre. Amusement!

Emacs Lisp 473 octets

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

Le plus grand « déchets » est probablement format, %s... sections. Si des variables pouvaient être insérées dans les chaînes sans la spécification, cela économiserait 10 octets %set 12 autresformat

Ruby 396 378 372 octets

Je suis sûr que ce n'est pas joué au maximum.

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: Je viens de réaliser que je ne connais pas la priorité des opérateurs. Tant pis..

CJam, 281 octets

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

Lien permanent

Je n'ai jamais utilisé CJam auparavant, je vais donc suivre tous les conseils. Je suis sûr qu'il y a beaucoup de trucs que je ne connais pas!

(Je ne savais pas comment nommer cela en tant que fonction appelée "pourquoi" - il semble que les fonctions n'existent pas dans CJam - donc je ne sais pas si une réponse CJam est correcte ou non ...)

Lua 5.3.0, 452 460 446 octets

C'est ma première tentative de golf à code, alors corrigez-moi si j'ai fait quelque chose de 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

Non 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 octets

J'apprends encore, alors s'il vous plaît soyez doux! :)

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

Fonctionne avec ou sans int comme argument de ligne de commande.

J'ai essayé de mettre l'accent sur l'exactitude du code autant que possible, comme pour générer des nombres aléatoires à partir -sys.maxint - 1de sys.maxintet afficher des phrases dans le bon cas.

Le code repose très fortement sur les instructions if qui, j'en suis sûr, pourraient être remplacées par quelque chose de plus efficace.

Les commentaires sont les bienvenus!

Non golfé (1341 octets)

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