Czy kiedykolwiek chciałeś zapytać kompilatora „Dlaczego?” Większość z nas była sfrustrowana, gdy kod nie działa tak, jak powinien. Mathworks wdrożył więc ładną małą funkcję why, która odpowiada na pytanie. Aby podać kilka przykładów z 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.

Twoim zadaniem jest wdrożenie whyfunkcji w Twoim języku. Funkcja powinna działać z argumentem wejściowym i bez niego (alternatywnie użyj danych wejściowych 0lub -1). Funkcja musi zostać nazwana why(lub napisanie why(n)w STDIN powinno spowodować wydrukowanie odpowiedniego łańcucha).

Jeśli nie podano żadnego argumentu lub argument jest zerowy lub ujemny, ciąg wyjściowy powinien być losową, prawidłową frazą. Więc nie powinno być funkcją why, why(), why(0)lub why(-1)że zwraca losowego zdania.

Jeśli podano argument wejściowy n(argument funkcyjny, a nie STDIN), wynik powinien być n-tym ciągiem (zdefiniowanym poniżej). Dlatego why(1)zawsze powinien wypisywać (drukować / wyświetlać) ten sam wynik.

Zdania są budowane w następujący sposób (Typ 1, Typ 2 i Specjalne). Wszystkie zdania kończą się na !.

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

Lista osób:

Stewie
Peter
Homer
The programmer
The system manager
You

Lista zakończeń:

suggested it
insisted on it
did it

Lista czasowników to:

To fool
To satisfy
To please

Lista przymiotników:

the smart
the bald
the tall
the rich
the stupid

Lista przypadków specjalnych:

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

Sposób na wybranie numeru jest:

Rodzaj zdań:

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

Nazwy: n-ta nazwa jest definiowana za pomocą modułu (%).

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!

Zakończenia: n-te zakończenie jest również definiowane za pomocą modułu. Załóżmy, że zakończenia (1, 2 i 3) są wymienione podobnie (1 2 2 3). Ponieważ liczby są zawsze nieparzyste, użyj((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

Przymiotniki: n-ty przymiotnik definiuje się za pomocą modułu. Ponieważ liczby są zawsze parzyste, użyj:(n % 10)/2

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

Czasowniki: n-ty czasownik jest również definiowany za pomocą modułu. Załóżmy, że czasowniki (1, 2 i 3) są wymienione tak, (1 2 2 3)jak w przypadku czasowników, więc zawsze używaj liczb(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

Teraz sposób utworzenia losowego powinien być dość prosty, wystarczy wybrać losowy n.

Kilka przykładów:

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!

Obowiązują standardowe zasady gry w golfa. Zwycięzca zostanie wybrany tydzień po opublikowaniu wyzwania.

JavaScript (ES6) 345

Nie jestem pewien co do liczb, ale oto moja próba.

Przetestuj poniższy fragment kodu w przeglądarce zgodnej z 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 bajtów

Ten projekt musi mieć AssemblyName zestaw do dlaczego która będzie produkować wykonywalny z poprawną nazwą.

W pełni golfa:

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

Wcięcia i nowe linie dla przejrzystości:

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

Przykładowe wejście / wyjście:

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

PowerShell 437 461 453 bajtów

Edycja: pominięto zduplikowane czasowniki

Podział między ciałem a obliczeniami dla liczby bajtów

• 267 bajtów = Pre-kodowane tekst (z wyjątkiem to, the, iti !ponieważ mają stałe miejsca).
• 186 bajtów = obliczenie

Ustawia domyślny argument na 0, jeśli nie został określony. Jeśli argument jest <1taki, otrzymuje losową liczbę <99 fn:1i uruchamia się ponownie. Technicznie oznacza -50to również, że będzie działać jako przypadek.

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

Wyjaśnienie:

# 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 Wybrano, aby zapisać bajt. Jeśli jest więcej niż 99 możliwych zdań powyżej (nie obliczono), zwiększ odpowiednio do 999 lub 9999 (+1/2 bajtów)

MUMPS, 379 bajtów

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

Gdy nie podano danych wejściowych, generowana jest liczba losowa w 0..839.

Stosowanie:

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

Strategia oceny od lewej do prawej MUMPS pozwala zaoszczędzić kilka dobrych bajtów w nawiasach.

Uwaga dodatkowa: widzisz te ciągi, które wyglądają "foo^bar^baz^qux"? Są to tak zwane „łańcuchy rozdzielane” i są standardowym sposobem przechowywania list, które mieszczą się w limicie maksymalnego rozmiaru łańcucha, ponieważ MUMPS tak naprawdę nie ma list / tablic (a nawet żadnych struktur danych oprócz drzew). W przypadku list zbyt dużych, aby zmieściły się w jednym ciągu, zamiast tego używamy drzew o głębokości 1 i umieszczamy wartości na liściach drzewa. Zabawa!

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

Największy „odpady” to prawdopodobnie format, %s... sekcje. Jeśli zmienne mogłyby zostać wstawione do ciągów bez specyfikacji, zapisałoby to 10 bajtów %si kolejne 12format

Rubinowy 396 378 372 bajtów

Jestem pewien, że nie gra w golfa na maksa.

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

Edycja: Właśnie zdałem sobie sprawę, że nie znam pierwszeństwa operatora. No cóż..

CJam, 281 bajtów

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

Nie korzystałem wcześniej z CJam, więc wezmę jakieś wskazówki. Jestem pewien, że jest wiele sztuczek, których nie znam!

(Nie mogłem wymyślić, jak nazwać to jako funkcję o nazwie „dlaczego” - wygląda na to, że funkcje nie istnieją w CJam - więc nie jestem pewien, czy odpowiedź CJam jest dobra, czy nie ...)

Lua 5.3.0, 452 460 446 bajtów

To moja pierwsza próba gry w golfa kodowego, więc popraw mnie, jeśli zrobiłem coś złego!

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

Nie golfowany:

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 bajty

Wciąż się uczę, więc proszę, bądź delikatny! :)

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

Działa z lub bez int jako argument wiersza poleceń.

Starałem się podkreślać poprawność kodu tak bardzo, jak to możliwe, jak przy generowaniu liczb losowych od -sys.maxint - 1do sys.maxinti wyświetlaniu zdań w odpowiednim przypadku.

Kod w dużej mierze opiera się na instrukcjach if, które z pewnością mogłyby zostać zastąpione przez coś bardziej wydajnego pod względem miejsca.

Informacje zwrotne są bardzo mile widziane!

Niegolfowany (1341 bajtów)

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