Wollten Sie schon immer den Compiler fragen "Warum?" Die meisten von uns waren frustriert, als der Code nicht so funktionierte, wie er sollte. Mathworks hat daher eine nette kleine Funktion implementiert why, die die Frage beantwortet. Um einige Beispiele aus MATLAB zu nennen:

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.

Ihre Aufgabe ist es, die whyFunktion in Ihrer Sprache zu implementieren . Die Funktion sollte mit und ohne Eingabeargument funktionieren (alternativ kann auch input 0oder verwendet werden -1). Die Funktion muss benannt werden why(oder why(n)wenn Sie in STDIN schreiben, wird die entsprechende Zeichenfolge gedruckt).

Wenn kein Argument angegeben wird oder das Argument null oder negativ ist, sollte die Ausgabezeichenfolge eine zufällige, gültige Phrase sein. So soll es eine Funktion sein why, why(), why(0)oder why(-1)dass die Rendite eines zufälliger Satz.

Wenn ein Eingabeargument nangegeben wird (Funktionsargument, nicht STDIN), sollte die Ausgabe die n-te Zeichenfolge sein (unten definiert). Soll also why(1)immer das gleiche Ergebnis ausgeben (drucken / anzeigen).

Die Sätze setzen sich wie folgt zusammen (Typ 1, Typ 2 und Spezial). Alle Sätze enden mit !.

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

Die Liste der Personen:

Stewie
Peter
Homer
The programmer
The system manager
You

Die Liste der Endungen:

suggested it
insisted on it
did it

Die Liste der Verben ist:

To fool
To satisfy
To please

Die Liste der Adjektive:

the smart
the bald
the tall
the rich
the stupid

Die Liste der Sonderfälle:

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

Die Art, eine Nummer auszuwählen, ist:

Art der Sätze:

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

Namen: Der n-te Name wird mit dem Modul (%) definiert.

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!

Endungen: Die n-te Endung wird ebenfalls mit dem Modul definiert. Angenommen, die Endungen (1, 2 und 3) sind wie folgt aufgeführt (1 2 2 3). Verwenden Sie, da die Zahlen immer ungerade sind((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

Adjektive: Das n-te Adjektiv wird über den Modul definiert. Da die Zahlen immer gerade sind, verwenden Sie:(n % 10)/2

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

Verben: Das n-te Verb wird ebenfalls mit dem Modul definiert. Angenommen, die Verben (1, 2 und 3) sind wie (1 2 2 3)folgt aufgeführt: Verwenden Sie, da die Zahlen für Verben immer gerade sind(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

Nun sollte der Weg zum Erstellen eines Zufalls ziemlich einfach sein. Wählen Sie einfach einen Zufallsgenerator aus n.

Einige Beispiele:

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!

Es gelten die Standard-Code-Golfregeln. Ein Gewinner wird eine Woche nach dem Tag ausgewählt, an dem die Herausforderung veröffentlicht wurde.

JavaScript (ES6) 345

Ich bin mir nicht sicher über die Zahlen, aber hier ist mein Versuch.

Testen Sie das folgende Snippet in einem EcmaScript-kompatiblen Browser.

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

Für dieses Projekt muss AssemblyName auf why gesetzt sein, wodurch eine ausführbare Datei mit dem richtigen Namen erstellt wird.

Völlig Golf gespielt:

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

Einrückung und neue Zeilen für Klarheit:

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

Beispiel Ein- / Ausgabe:

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

Powershell 437 461 453 Bytes

Bearbeiten: Verpasste die duplizierten Verben

Aufteilung zwischen dem Korpus und den Berechnungen für die Byteanzahl

• 267 Bytes = Pre-codierten Text ( mit Ausnahme von to, the, itund !da sie feste Plätze haben).
• 186 Bytes = Berechnung

Setzt das Standardargument auf 0, wenn nichts angegeben ist. Wenn argument gleich ist <1, wird eine Zufallszahl <99 fn:1abgerufen und erneut ausgeführt. Technisch -50funktioniert dies auch, da es sich um einen zufälligen Fall handelt.

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

Erläuterung:

# 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 Wurde ausgewählt, um ein Byte zu speichern. Wenn es mehr als 99 mögliche Sätze oben gibt (nicht berechnet), erhöhen Sie sich auf 999 bzw. 9999 (+1/2 Byte).

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

Wenn keine Eingabe erfolgt, wird eine Zufallszahl in 0..839 generiert.

Verwendung:

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

Durch die von links nach rechts verlaufende Bewertungsstrategie von MUMPS werden hier einige Bytes in Klammern gespart.

Randnotiz: Sehen Sie die Saiten, die aussehen "foo^bar^baz^qux"? Dies sind sogenannte "begrenzte Zeichenfolgen" und die Standardmethode zum Speichern von Listen, die innerhalb der maximalen Zeichenfolgengrößenbeschränkung liegen, da MUMPS tatsächlich keine Listen / Arrays (oder sogar keine Datenstrukturen außer Bäumen) hat. Für Listen, die zu groß sind, um in eine einzelne Zeichenfolge zu passen, verwenden wir stattdessen Bäume der Tiefe 1 und setzen die Werte auf die Blätter des Baums. Spaß!

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

Größte ‚Abfall‘ ist wahrscheinlich die format, %s... Abschnitte. Wenn Variablen ohne die Angabe in die Zeichenfolgen eingefügt werden könnten, würden 10 Byte %sund weitere 12 Byte eingespartformat

Ruby 396 378 372 Bytes

Ich bin sicher, dass dies nicht bis zum Äußersten golfen wird.

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

Bearbeiten: Ich habe gerade festgestellt, dass ich die Rangfolge der Operatoren nicht kenne. Naja..

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

Ich habe CJam noch nie benutzt, daher nehme ich alle Tipps an. Ich bin mir sicher, dass es viele Tricks gibt, die ich nicht kenne!

(Ich konnte nicht herausfinden, wie ich diese Funktion als "warum" bezeichnen soll - es scheint, dass es in CJam keine Funktionen gibt - ich bin mir also nicht sicher, ob eine CJam-Antwort in Ordnung ist oder nicht ...)

Lua 5.3.0, 452 460 446 Bytes

Dies ist mein erster Versuch, einen Code Golf zu spielen. Bitte korrigieren Sie mich, wenn ich etwas falsch gemacht habe!

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

Ich lerne noch, also sei bitte sanft! :)

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

Funktioniert mit oder ohne int als Befehlszeilenargument.

Ich habe versucht, die Code-Korrektheit so weit wie möglich zu betonen, wie beim Erzeugen von Zufallszahlen von -sys.maxint - 1bissys.maxint und im richtigen Fall Sätze anzeigte.

Der Code basiert sehr stark auf if-Anweisungen, von denen ich sicher bin, dass sie durch etwas effizienteres ersetzt werden könnten.

Feedback ist sehr willkommen!

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