Demain, le 23 novembre, c'est le jour de Thanksgiving aux États-Unis. Pour vous préparer, vous devez préparer des dindes ASCII. Cependant, comme vous êtes en retard dans la planification, vous avez besoin d'un programme (ou d'une fonction) pour vous aider avec combien d'oiseaux vous devez préparer.

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

Les dindes que vous avez trouvées sont plutôt petites, vous avez donc compris les ratios suivants - une dinde se nourrira:

• quatre personnes qui aiment seulement la viande blanche et trois personnes qui aiment seulement la viande brune
• ou sept personnes qui ne se soucient pas de toute façon
• ou une combinaison de ceux-ci.

Cela signifie qu'il y a un total de 4 portions de viande blanche et 3 portions de viande brune dans une dinde donnée. De plus, vous ne pouvez pas acheter et cuire une dinde partielle.

Par exemple, pour 3 personnes qui n'aiment que la viande blanche, 6 personnes qui n'aiment que la viande brune et 3 personnes qui s'en moquent, vous aurez besoin de deux dindes. Cela donne 8 portions de blanc et 6 portions de noir, ce qui est suffisant pour satisfaire tout le monde et avoir des restes de viande blanche:

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

Pour 20 personnes qui s'en moquent, vous aurez besoin de trois dindes et il vous restera un peu de blanc ou de noir:

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

Etc.

Règles

• Les trois entrées peuvent être dans l'ordre de votre choix et dans n'importe quel format pratique . Veuillez indiquer dans votre réponse comment la saisie est effectuée.
• Il n'y aura jamais besoin de plus de 25 dindes (donc un maximum de 175 personnes à nourrir).
• Les sauts de ligne de début / fin ou d'autres espaces sont facultatifs, à condition que les caractères s'alignent correctement.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• La sortie peut être vers la console, renvoyée sous forme de liste de chaînes, retournée sous forme de chaîne unique, etc.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Befunge-93, 231224 octets

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_@

Essayez-le en ligne!

Les trois valeurs sont lues à partir de stdin dans l'ordre: viande blanche, viande noire, peu importe.

APL (Dyalog) , 120 118 104 octets

14 octets économisés grâce à @ Adám

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

Essayez-le en ligne!

Le blanc et le noir difficiles sont à droite, le non difficile à gauche.

Dommage que la plupart du nombre d'octets soit pris par la chaîne actuellement.

Comment?

⍵,⍺++/⍵ - crée un tableau de whity, darky et la somme de tous, plus non pickys

4 3 7÷⍨ - divisez par combien d'entre eux obtiennent leurs souhaits d'un poulet

⌈/ - prenez l'estimation la plus élevée des trois - donc si nous avons une quantité extrêmement élevée de demandeurs de viande brune, ils ne seront pas laissés de côté

⌈ - plafond, dans le cas où seul un demi-poulet est demandé

Ensuite, nous créons une chaîne, ⊂l'enfermons avec , puis répétons la matrice fermée les temps de poulets calculés avec /, et enfin concaténons tous les poulets avec ,/.

Python 2 , 142 octets

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

Essayez-le en ligne!

-16 octets grâce à Lynn
-4 octets grâce à M. Xcoder

et retour à un lambda xD

SOGL V0.12 , 65 octets

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

Essayez-le ici!

Ordre des entrées est white, darket puis either.

Python 2 , 197 189 174 174 octets

merci à Erik l'Outgolfer pour -12 octets
merci à Jonathan Frech pour -1 octet

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)

Essayez-le en ligne!

Fusain , 76 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Imprimez une dinde en retrait d'un espace.

×=¹⁹

Imprimez le tableau.

ＮθＮη

Entrez le nombre de mangeurs de viande foncés et blancs.

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

Répétez un de moins que le plafond du maximum de a) un tiers du nombre de mangeurs de viande brune b) un quart du nombre de mangeurs de viande blanche c) un septième du nombre de convives.

Ｃ¹⁸¦⁰

Faites une copie de la dinde.

Excel VBA, _{222 219 211} 198 octets

Fonction de fenêtre immédiate VBE anonyme qui prend l'entrée de la plage [A1:C1]avec l'ordre de la viande blanche, la viande brune et indifférente dans cet ordre et sort vers la plage [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)]

Initialement, la solution trouve le nombre correct de dindes, puis elle répète le modèle de dinde autant de fois. Idéalement, cela serait ensuite directement sorti sur la fenêtre immédiate du VBE comme indiqué par la fonction ci-dessous

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

Cette version produit initialement la réponse correcte, cependant, elle est immédiatement mise en forme automatiquement par le compilateur, tout comme _le caractère de continuation de ligne, et est donc déplacée pour n'avoir qu'un seul caractère (espace) à sa gauche, cassant le motif.

Exemple illustré ci-dessous pour plus de clarté

[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
      .---.   _         .---.   _         .---. _
    .'     './ )      .'     './ )      .'     './ )  
   /   _   _/ /\     /   _   _/ /\     /   _   _/ /\  
 =(_____) (__/_/== =(_____) (__/_/== =(_____) (__/_/==
=======================================================

Pour corriger cela, le dernier caractère d'espace ( , caractère 32) avant celui _en ligne de la sortie est remplacé par un espace insécable (  , caractère 160, Alt + 255)

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

-3 octets pour l'utilisation d'une 1instruction de division délimitée

-8 octets pour utiliser le déplacement =dans le fractionnement et l'utilisation de l'ajout de chaînes sur la concaténation

-13 octets pour l'utilisation d'un espace insécable pour empêcher la mise en forme automatique de la sortie

Kotlin , 207 198 octets

merci à Taylor Scott pour -7 octets

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

Cela ne fonctionne pas encore sur TIO , car il nécessite Kotlin 1.1

Essayez-le en ligne!

JavaScript (ES6), 180 179 octets

Génère un tableau de chaînes.

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

Génère une seule chaîne.

(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 octet (Arnauld): a+3>>4au lieu de(a+3)/4)