Amanhã, 23 de novembro, é o dia de ação de graças nos Estados Unidos. Para preparar, você precisa preparar alguns perus ASCII. No entanto, como você está atrasado no planejamento, precisa de um programa (ou função) para ajudá-lo com quantos pássaros você precisa preparar.

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

Os perus que você encontrou são bastante pequenos, então você descobriu as seguintes proporções - um peru será alimentado:

• quatro pessoas que só gostam de carne branca e três pessoas que só gostam de carne escura
• ou sete pessoas que não se importam
• ou uma combinação dos mesmos.

Ou seja, há um total de 4 porções de carne branca e 3 porções de carne escura em qualquer peru. Além disso, você não pode comprar e cozinhar um peru parcial.

Por exemplo, para 3 pessoas que gostam apenas de carne branca, 6 pessoas que gostam apenas de carne escura e 3 pessoas que não se importam, você precisará de dois perus. Isso dá 8 porções de branco e 6 porções de escuro, o que é suficiente para satisfazer a todos e ter um pouco de carne branca restante:

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

Para 20 pessoas que não se importam, você precisará de três perus e restará um pouco de branco ou escuro:

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

E assim por diante.

Regras

• As três entradas podem estar na ordem que você escolher e em qualquer formato conveniente . Indique na sua resposta como a entrada é recebida.
• Nunca haverá a exigência de mais de 25 perus (portanto, um máximo de 175 pessoas para alimentar).
• Novas linhas à esquerda / à direita ou outro espaço em branco são opcionais, desde que os caracteres sejam alinhados adequadamente.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• A saída pode ser no console, retornada como uma lista de cadeias, retornada como uma única cadeia, etc.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

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

Experimente online!

Os três valores são lidos a partir de stdin na ordem: carne branca, carne escura, não importa.

APL (Dyalog) , 120 118 104 bytes

14 bytes salvos graças a @ Adám

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

Experimente online!

O branco e o escuro exigentes estão à direita e os não exigentes à esquerda.

Pena que a maior parte da contagem de bytes é obtida pela string atualmente.

Quão?

⍵,⍺++/⍵ - cria uma variedade de whity, dark e soma de todos eles, mais não pickys

4 3 7÷⍨ - divida por quantos deles recebe seus desejos de uma galinha

⌈/ - faça a estimativa mais alta dos três - por isso, se tivermos uma quantidade extremamente alta de caçadores de carne escura, eles não serão deixados de lado

⌈ - teto, caso exista apenas meia galinha

Em seguida, criamos uma string, anexamos-a e ⊂, em seguida, repetimos a matriz eclosed com a qual as galinhas calculadas criam /e finalmente concatenamos todas as galinhas ,/.

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]

Experimente online!

-16 bytes graças ao Lynn
-4 bytes graças ao Sr. Xcoder

e de volta a um lambda xD

SOGL V0.12 , 65 bytes

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

Experimente aqui!

Ordem de entradas é white, darke então either.

Python 2 , 197 189 174 bytes

graças a Erik the Outgolfer por -12 bytes
graças 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)

Experimente online!

Carvão , 76 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Imprima um peru recuado com 1 espaço.

×=¹⁹

Imprima a tabela.

ＮθＮη

Digite o número de comedores de carne branca e escura.

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

Repita um a menos do que o limite máximo de: a) um terço do número de comedores de carne escura; b) um quarto do número de comedores de carne branca; c) um sétimo do número de clientes.

Ｃ¹⁸¦⁰

Faça uma cópia da Turquia.

Excel VBA, _{222 219 211} 198 bytes

Função de janela imediata VBE anônima que recebe entradas do intervalo [A1:C1]com a ordem de carne branca, carne escura e indiferente nessa ordem e sai para o intervalo [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, a solução encontra o número correto de perus e depois repete o padrão de peru muitas vezes. Idealmente, isso seria enviado diretamente para a janela imediata do VBE, como mostra a função abaixo

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

Essa versão produz inicialmente a resposta correta, no entanto, é imediatamente formatada automaticamente pelo compilador, como _é o caractere de continuação de linha e, portanto, é movida para ter apenas um caractere (espaço) à esquerda, quebrando o padrão.

Exemplo mostrado abaixo para maior clareza

[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 corrigir isso, o último caractere de espaço ( , caractere 32) antes da _linha um da saída ser substituído por um espaço sem quebra (  , caractere 160, Alt + 255)

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

-3 bytes para uso da 1instrução de divisão delimitada

-8 bytes para usar movendo =para a divisão e usando adição de cadeia por concatenação

-13 bytes para uso de um espaço sem quebra para impedir a autoformatação da saída

Kotlin , 207 198 bytes

graças 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))}

Isso ainda não funciona no TIO , pois requer o Kotlin 1.1

Experimente online!

JavaScript (ES6), 180 179 bytes

Produz uma matriz de seqüências de caracteres.

(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

Produz uma única sequência.

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