Mañana, 23 de noviembre, es el Día de Acción de Gracias en los Estados Unidos. Para prepararse, debe cocinar algunos pavos ASCII. Sin embargo, dado que está retrasado en la planificación, necesita un programa (o función) que lo ayude con la cantidad de aves que necesita preparar.

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

Los pavos que encontraste son más bien pequeños, por lo que has descubierto las siguientes proporciones: un pavo se alimentará:

• cuatro personas a las que solo les gusta la carne blanca y tres personas a las que solo les gusta la carne oscura
• o siete personas a las que no les importa de ninguna manera
• o una combinación de los mismos.

Es decir, hay un total de 4 porciones de carne blanca y 3 porciones de carne oscura en cualquier pavo. Además, no puede comprar y cocinar un pavo parcial.

Por ejemplo, para 3 personas a las que solo les gusta la carne blanca, 6 personas a las que solo les gusta la carne oscura y 3 personas a las que no les importa, necesitará dos pavos. Eso da 8 porciones de blanco y 6 porciones de oscuro, que es suficiente para satisfacer a todos y tener algo de carne blanca sobrante:

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

Para 20 personas a las que no les importa, necesitará tres pavos y tendrá un poco de sobras blancas u oscuras:

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

Y así.

Reglas

• Las tres entradas pueden estar en el orden que elija y en cualquier formato conveniente . Indique en su respuesta cómo se toma la entrada.
• Nunca habrá un requisito para más de 25 pavos (por lo tanto, un máximo de 175 personas para alimentar).
• Las nuevas líneas iniciales / finales u otros espacios en blanco son opcionales, siempre que los caracteres se alineen adecuadamente.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• La salida puede ser a la consola, devuelta como una lista de cadenas, devuelta como una sola cadena, etc.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

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

Pruébalo en línea!

Los tres valores se leen de stdin en el orden: carne blanca, carne oscura, no me importa.

APL (Dyalog) , 120 118 104 bytes

14 bytes guardados gracias a @ Adám

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

Pruébalo en línea!

El blanco y oscuro exigentes están a la derecha, los no exigentes a la izquierda.

Lástima que la mayor parte del recuento de bytes sea tomada por la cadena actualmente.

¿Cómo?

⍵,⍺++/⍵ - crea una variedad de whity, dark y sum of all all plus non pickys

4 3 7÷⍨ - dividir entre cuántos de ellos obtienen sus deseos de un pollo

⌈/ - tome la estimación más alta de las tres - así que si tenemos una cantidad extremadamente alta de buscadores de carne oscura, no se dejarán de lado

⌈ - techo, en caso de que solo se demande medio pollo

Luego creamos una cadena, ⊂la encerramos, luego repetimos la matriz cerrada con la que los pollos calculados multiplican /y finalmente concatenamos todos los pollos ,/.

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]

Pruébalo en línea!

-16 bytes gracias a Lynn
-4 bytes gracias al Sr. Xcoder

y de vuelta a un lambda xD

SOGL V0.12 , 65 bytes

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

Pruébalo aquí!

Orden de las entradas es white, darky luego either.

Python 2 , 197 189 174 bytes

gracias a Erik the Outgolfer por -12 bytes
gracias a Jonathan Frech por -1 byte

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)

Pruébalo en línea!

Carbón , 76 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Imprima un pavo con sangría de 1 espacio.

×=¹⁹

Imprime la tabla.

ＮθＮη

Ingrese el número de comedores de carne oscura y blanca.

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

Repita uno menos del límite máximo de a) un tercio del número de comedores de carne oscura b) un cuarto del número de comedores de carne blanca c) un séptimo del número de comensales.

Ｃ¹⁸¦⁰

Haz una copia del pavo.

Excel VBA, _{222 219 211} 198 Bytes

Función de ventana inmediata anónima VBE que toma la entrada del rango [A1:C1]con el orden de carne blanca, carne oscura e indiferente en ese orden y las salidas al rango [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)]

Inicialmente, la solución encuentra el número correcto de pavos y luego repite el patrón del pavo tantas veces. Idealmente, esto se generaría directamente en la ventana inmediata de VBE como se muestra en la siguiente función

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

Inicialmente, esta versión produce la respuesta correcta, sin embargo, el compilador lo autoformata inmediatamente, al igual _que el carácter de continuación de línea, y por lo tanto se mueve para tener solo un carácter (espacio) a su izquierda, rompiendo el patrón.

Ejemplo que se muestra a continuación para mayor claridad.

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

Para corregir esto, el último carácter de espacio ( , char 32) antes de la _línea uno de la salida se reemplaza con un espacio sin interrupción (  , char 160, Alt + 255)

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

-3 bytes para el uso de la 1declaración dividida delimitada

-8 bytes para usar moviéndose =en la división y usando la suma de cadenas sobre la concatenación

-13 bytes para el uso de un espacio sin interrupciones para evitar el autoformato de la salida

Kotlin , 207 198 bytes

gracias a Taylor Scott por -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))}

Esto aún no funciona en TIO , ya que requiere Kotlin 1.1

Pruébalo en línea!

JavaScript (ES6), 180 179 bytes

Emite una matriz de cadenas.

(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

Emite una sola cadena.

(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): en a+3>>4lugar de(a+3)/4)