Morgen, am 23. November, ist Thanksgiving in den Vereinigten Staaten. Zur Vorbereitung müssen Sie einige ASCII-Puten kochen. Da Sie jedoch zu spät in der Planung sind, benötigen Sie ein Programm (oder eine Funktion), um zu ermitteln, wie viele Vögel Sie vorbereiten müssen.

      .---.   _
    .'     './ )
   /   _   _/ /\
 =(_____) (__/_/==
===================

Die Puten, die Sie gefunden haben, sind eher klein, also haben Sie die folgenden Verhältnisse herausgefunden - eine Pute füttert:

• vier Leute, die nur weißes Fleisch mögen und drei Leute, die nur dunkles Fleisch mögen
• oder sieben Leute, die sich nicht darum kümmern
• oder eine Kombination davon.

Das heißt, es gibt insgesamt 4 Portionen weißes Fleisch und 3 Portionen dunkles Fleisch in einem bestimmten Truthahn. Außerdem können Sie einen Teil der Pute nicht kaufen und kochen.

Zum Beispiel werden für 3 Personen, die nur weißes Fleisch mögen, 6 Personen, die nur dunkles Fleisch mögen, und 3 Personen, die sich nicht darum kümmern, zwei Puten benötigt. Das ergibt 8 Portionen Weiß und 6 Portionen Dunkel, was ausreicht, um alle zufriedenzustellen und etwas übriggebliebenes weißes Fleisch zu haben:

      .---.   _         .---.   _
    .'     './ )      .'     './ )
   /   _   _/ /\     /   _   _/ /\
 =(_____) (__/_/== =(_____) (__/_/==
=====================================

Für 20 Personen, die sich nicht darum kümmern, brauchen Sie drei Puten und haben entweder ein wenig weiße oder dunkle Reste:

      .---.   _         .---.   _         .---.   _
    .'     './ )      .'     './ )      .'     './ )
   /   _   _/ /\     /   _   _/ /\     /   _   _/ /\
 =(_____) (__/_/== =(_____) (__/_/== =(_____) (__/_/==
=======================================================

Und so weiter.

Regeln

• Die drei Eingänge können in beliebiger Reihenfolge und in einem beliebigen Format eingegeben werden . Bitte geben Sie in Ihrer Antwort an, wie die Eingabe erfolgt.
• Es werden niemals mehr als 25 Puten benötigt (also maximal 175 Personen zu füttern).
• Führende / nachfolgende Zeilenumbrüche oder andere Leerzeichen sind optional, sofern die Zeichen richtig ausgerichtet sind.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Die Ausgabe kann an die Konsole erfolgen, als Liste von Zeichenfolgen zurückgegeben werden, als einzelne Zeichenfolge zurückgegeben werden usw.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Befunge-93, 231 224 Bytes

p&:10p3+4/:&:20p2+3/\-:v
v<0-1:+*`0:-\/7+++&g02<0
>"   _   .---.      "vg`
>"  ) /.'     '.    "v0*
>"  \/ /_   _   /   "v1+
>"==/_/__( )_____(= "v6:
v^0-1 _$"v"000g1+:>v v^<
:#,_$:^1,+55:p+1p00< >>>
_$$99+*"=":>,#:\:#->#1_@

Probieren Sie es online!

Die drei Werte werden von stdin in der Reihenfolge gelesen: weißes Fleisch, dunkles Fleisch, egal.

APL (Dyalog) , 120 118 104 Bytes

Dank @ Adám wurden 14 Bytes gespeichert

{,/(⌈⌈/4 3 7÷⍨⍵,⍺++/⍵)/⊂'='⍪⍨' .-_''/)\=('[4 19⍴10 10⊤¯35+⎕UCS'###(##-:77-&(#F*####+,&0N&&)#,N0Z&d++#']}

Probieren Sie es online!

Das wählerische Weiß und Dunkel sind rechts, das nicht wählerische links.

Schade, dass der Großteil der Byteanzahl von der aktuellen Zeichenfolge übernommen wird.

Wie?

⍵,⍺++/⍵ - Erzeugt eine Reihe von Weiß-, Dunkel- und Gesamtsummen sowie Non-Pickys

4 3 7÷⍨ - Teilen Sie durch, wie viele von ihnen ihre Wünsche von einem Huhn erhalten

⌈/ - nehmen Sie die höchste Schätzung der drei - wenn wir also eine extrem hohe Anzahl dunkler Fleischsucher haben, werden sie nicht beiseite gelassen

⌈ - Höchstgrenze, falls nur ein halbes Huhn nachgefragt wird

Dann erstellen wir einen String, umschließen ihn mit ⊂, wiederholen die eclosed-Matrix mit den berechneten Hühnern /und verketten schließlich alle Hühner mit ,/.

Python 2 , 142 Bytes

lambda w,d,n:[min(e)+-min(-w/3,-d/4,-(w+d+n)/7)*e.center(18)for e in"  .---.   _"," .'     './ )","/   _   _/ /\\","=(_____) (__/_/==","="*18]

Probieren Sie es online!

-16 Bytes dank Lynn
-4 Bytes dank Mr. Xcoder

und zurück zu einem Lambda xD

SOGL V0.12 , 65 Bytes

N∫4*κ:F3*.-:h+.-¹χ∆>?F"Ωeχ&i[A⁄╔■§‼╗╝│¼ο≠≈⁹,Ρ⁴žγūž℮3zl3βΜ%G‘'³n*←

Probieren Sie es hier aus!

Reihenfolge der Eingänge ist white, darkund dann either.

Python 2 , 197 189 174 Bytes

danke an Erik den Outgolfer für -12 Bytes
danke an Jonathan Frech für -1 Bytes

a,b,c=input()
for i in range(5):print'='[i<4:]+(' '+"   =   (  /_ . _ ' _.  _- __-  )-   .  ( '__ ./_ / /_ /_ )\\/   =   ="[i::4],'='*18)[i>3]*max((6+c+a+b)/7,a+3>>2,(b+2)/3)

Probieren Sie es online!

Kohle , 76 Bytes

”{‴∨➙×95;{；Ｃ.ÞgＦ⁷Ｊ*←λ|⁸ＫＫ][§Ｘ⎚¦»Ｚ◧↘gⅉ✳⟧F⎇≧h”×=¹⁹ＮθＮηＦ⊖⌈⌈⟦∕θ³∕η⁴∕⁺⁺θηＮ⁷⟧Ｃ¹⁸¦⁰

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

”{‴∨➙×95;{；Ｃ.ÞgＦ⁷Ｊ*←λ|⁸ＫＫ][§Ｘ⎚¦»Ｚ◧↘gⅉ✳⟧F⎇≧h”

Drucken Sie einen mit 1 Leerzeichen eingerückten Truthahn.

×=¹⁹

Drucken Sie die Tabelle.

ＮθＮη

Geben Sie die Anzahl der dunklen und weißen Fleischesser ein.

Ｆ⊖⌈⌈⟦∕θ³∕η⁴∕⁺⁺θηＮ⁷⟧

Wiederholen Sie eine unter der Obergrenze des Maximums von a) einem Drittel der Anzahl dunkler Fleischesser b) einem Viertel der Anzahl weißer Fleischesser c) einem Siebtel der Anzahl der Gäste.

Ｃ¹⁸¦⁰

Machen Sie eine Kopie des Truthahns.

Excel VBA, _{222 219 211} 198 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich [A1:C1]in der Reihenfolge von weißem Fleisch, dunklem Fleisch und in dieser Reihenfolge gleichgültig nimmt und in den Bereich ausgibt [D1].

[D1]=[Int(Max((A1+3)/4,(B1+2)/5,Sum(1:1,6)/7))]:For Each s In Split("      .---.   _   1    .'     './ )  1   /   _   _/ /\  1 =(_____) (__/_/==1",1):[E1]=s:?[Rept(E1,D1)]:Next:?[Rept("=",18*D1+1)]

Zunächst findet die Lösung die richtige Anzahl von Truthähnen und wiederholt dann das Truthahnmuster so oft wie möglich. Im Idealfall wird dies dann direkt auf das VBE-Direktfenster ausgegeben, wie die folgende Funktion zeigt

[D1]=[Int(Max((A1+3)/4,(B1+2)/5,Sum(1:1,6)/7))]:For Each s In Split("      .---.   _   1    .'     './ )  1   /   _   _/ /\  1 =(_____) (__/_/==1",1):[E1]=s:?[Rept(E1,D1)]:Next:?[Rept("=",18*D1+1)]

Diese Version liefert anfangs die richtige Antwort, wird jedoch vom Compiler sofort automatisch formatiert, ebenso _wie das Zeilenfortsetzungszeichen, und wird daher so verschoben, dass nur ein ( Leer- ) Zeichen nach links verschoben wird, wodurch das Muster gebrochen wird.

Beispiel unten zur Verdeutlichung

[A1:C1]=Array(0,0,20):[D1].Clear
[D1]=[Int(Max((A1+3)/4,(B1+2)/5,Sum(1:1,6)/7))]:For Each s In Split("      .---.   _   1    .'     './ )  1   /   _   _/ /\  1 =(_____) (__/_/==1",1):[E1]=s:?[Rept(E1,D1)]:Next:?[Rept("=",18*D1+1)]

'' Note that the `_` to the right has moved     V
      .---.   _         .---.   _         .---. _
    .'     './ )      .'     './ )      .'     './ )  
   /   _   _/ /\     /   _   _/ /\     /   _   _/ /\  
 =(_____) (__/_/== =(_____) (__/_/== =(_____) (__/_/==
=======================================================

Um dies zu korrigieren, wird das letzte Leerzeichen ( , char 32) vor dem _in Zeile 1 der Ausgabe durch ein nicht unterbrechendes Leerzeichen (  , char 160, Alt + 255) ersetzt.

      .---.   _         .---.   _         .---.   _   
    .'     './ )      .'     './ )      .'     './ )  
   /   _   _/ /\     /   _   _/ /\     /   _   _/ /\  
 =(_____) (__/_/== =(_____) (__/_/== =(_____) (__/_/==
=======================================================

-3 Bytes für die Verwendung einer getrennten 1Split-Anweisung

-8 Bytes für das Verschieben =in den Split und das Hinzufügen von Strings über die Verkettung

-13 Byte für die Verwendung eines nicht unterbrechenden Speicherplatzes, um die automatische Formatierung der Ausgabe zu verhindern

Kotlin , 207 198 Bytes

Dank an Taylor Scott für -7 Bytes

{a,b,c->val n=maxOf((a+3)/4,(b+2)/3,(6+c+a+b)/7);arrayOf("      .---.   _   ","    .'     './ )  ","   /   _   _/ /\\  "," =(_____) (__/_/==").map{println(it.repeat(n))};println("=".repeat(n*18+1))}

Dies funktioniert unter TIO noch nicht, da Kotlin 1.1 erforderlich ist

Probieren Sie es online!

JavaScript (ES6), 180 179 Byte

Gibt ein Array von Strings aus.

(a,b,c)=>[...`      .---.   _   
    .'     './ )  
   /   _   _/ /\\  
 =(_____) (__/_/==`.split`
`.map(l=>l.repeat(n=Math.max((6+c+a+b)/7,a+3>>4,(b+2)/3)|0)),'='.repeat(18*n+1)]

f=

(a,b,c)=>[...`      .---.   _   
    .'     './ )  
   /   _   _/ /\\  
  =(_____) (__/_/==`.split`
`.map(l=>l.repeat(n=Math.max((6+c+a+b)/7,a+3>>4,(b+2)/3)|0)),'='.repeat(18*n+1)]

console.log(f(3, 2, 3))
console.log(f(0, 0, 20))

JavaScript (ES6), 182 181 Bytes

Gibt eine einzelne Zeichenfolge aus.

(a,b,c)=>`      .---.   _   
    .'     './ )  
   /   _   _/ /\\  
 =(_____) (__/_/==
${'='.repeat(18)}`.split`
`.map(l=>l.repeat(Math.max((6+c+a+b)/7,a+3>>4,(b+2)/3))).join`
`+'='

f=

(a,b,c)=>`      .---.   _   
    .'     './ )  
   /   _   _/ /\\  
 =(_____) (__/_/==
${'='.repeat(18)}`.split`
`.map(l=>l.repeat(Math.max((6+c+a+b)/7,a+3>>4,(b+2)/3))).join`
`+'='

console.log(f(3, 2, 3))
console.log(f(0, 0, 20))

-1 Byte (Arnauld): a+3>>4statt(a+3)/4)