Introdução:

Quando pensamos em joaninhas, geralmente pensamos em um bug vermelho ou laranja escuro com manchas pretas. Embora isso não seja necessário, como também existem pretos com joaninhas manchadas de vermelho / laranja ou joaninhas sem manchas , imaginamos principalmente joaninhas algo como esta joaninha asiática:

Outra coisa a notar é que as manchas nas joaninhas são quase sempre simétricas. E é aí que entra esse desafio.

Desafio:

Dado um número inteiro n( >= 0), produza a joaninha ASCII a seguir uma ou várias vezes, com pontos simétricos divididos igualmente entre os dois lados, bem como as duas ou mais joaninhas.

Aqui está o layout padrão da joaninha:

    _V_ 
  /(@I@)\
 /   |   \
|    |    |
 \   |   /
  ''-!-''

Se n=0, produzimos a joaninha acima como está.

Quando né maior que zero, preenchemos os espaços do bug da arte ASCII com uma minúscula oou substituímos o |no centro por uma capital O. O objetivo é fazer nalterações nas joaninhas 'vazias', enquanto ainda produz uma saída simétrica (por joaninha) e produzir o mínimo possível de joaninhas.

As saídas tão válidas para n=1são:

    _V_ 
  /(@I@)\
 /   O   \
|    |    |
 \   |   /
  ''-!-''

    _V_ 
  /(@I@)\
 /   |   \
|    O    |
 \   |   /
  ''-!-''

    _V_ 
  /(@I@)\
 /   |   \
|    |    |
 \   O   /
  ''-!-''

Mas isso seria inválido:

    _V_ 
  /(@I@)\
 /   |   \
| o  |    |
 \   |   /
  ''-!-''

As saídas válidas para n=2são:

    _V_ 
  /(@I@)\
 /   O   \
|    O    |
 \   |   /
  ''-!-''

    _V_ 
  /(@I@)\
 /   O   \
|    |    |
 \   O   /
  ''-!-''

    _V_ 
  /(@I@)\
 /  o|o  \
|    |    |
 \   |   /
  ''-!-''

    _V_ 
  /(@I@)\
 /   |   \
| o  |  o |
 \   |   /
  ''-!-''

etc. There are a lot of possible outputs.

O primeiro nque não é mais possível encaixar em uma única joaninha é n=24. Nesse caso, você terá que dividi-lo o mais uniformemente possível em duas joaninhas (você pode optar por produzi-las uma perto da outra ou uma debaixo da outra - com opcionalmente um espaço ou uma nova linha entre elas). Por exemplo:

    _V_        _V_ 
  /(@I@)\    /(@I@)\
 /o o|o o\  /o o|o o\
|o o | o o||o o | o o|
 \o o|o o/  \o o|o o/
  ''-!-''    ''-!-''

OU:

    _V_ 
  /(@I@)\
 /ooo|ooo\
|    |    |
 \ooo|ooo/
  ''-!-''
    _V_ 
  /(@I@)\
 /ooo|ooo\
|    |    |
 \ooo|ooo/
  ''-!-''

Regras do desafio:

• nestará na faixa de 0-1000.
• Você pode optar por enviar para STDOUT, retornar como String ou matriz / lista de caracteres 2D, etc. Sua chamada.
• Não são permitidas novas linhas de frente ou espaços em branco desnecessários. Espaços em branco à direita e uma única linha nova à direita são permitidos.
• Como mencionado acima, quando duas ou mais joaninhas são necessárias, você pode optar por produzi-las uma perto da outra ou uma abaixo da outra (ou uma mistura de ambas ..)
• Quando duas ou mais joaninhas são impressas uma ao lado da outra, é permitido um único espaço opcional no meio. Quando duas ou mais joaninhas são impressas uma na outra, é permitida uma única nova linha opcional intermediária.
• Você pode escolher o layout das joaninhas em qualquer etapa da sequência, desde que simétricas e iguais à entrada n.
• Como o objetivo é ter nalterações E o menor número possível de joaninhas, você começará a usar mais de uma joaninha quando estiver acima n=23. O layout dessas joaninhas não precisa ser o mesmo. De fato, isso nem é possível para algumas entradas, como n=25ou n=50para citar duas.
• Além disso, às vezes não é possível dividir os pontos uniformemente entre duas ou mais joaninhas. Nesse caso, você terá que dividi-los o mais uniformemente possível, com no máximo uma diferença de 1 entre eles.

Portanto n=50, mantendo as duas últimas regras em mente, essa seria uma saída possível válida (onde o primeiro bug tem 16 pontos e os outros dois têm 17):

    _V_        _V_        _V_ 
  /(@I@)\    /(@I@)\    /(@I@)\
 /oooOooo\  /   O   \  /o oOo o\
|ooooOoooo||ooooOoooo||o ooOoo o|
 \   |   /  \oooOooo/  \o oOo o/
  ''-!-''    ''-!-''    ''-!-''

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Carvão , 84 81 bytes

Ｎθ≔⌈∕∨θ¹¦²³ηＦη«≔⁺÷θη‹ι﹪θηζV_¶I@)↘²↙|/←''-↑!↑⎇›ζ²¹OO²§|OζＥ037×o⌊⟦⁻÷ζ²Ｉκ⁺³⁼κ3⟧↙»‖Ｂ←

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

Ｎθ

Insira o número total de pontos.

≔⌈∕∨θ¹¦²³η

Calcule o número de joaninhas necessárias.

Ｆη«

Laço sobre cada joaninha.

≔⁺÷θη‹ι﹪θηζ

Calcule o número de pontos para colocar nesta joaninha.

V_¶I@)↘²↙|/←''-↑!

Imprima a cabeça e a asa direita da joaninha.

↑⎇›ζ²¹OO²

Se houver mais de 21 pontos, imprima dois pontos, caso contrário, imprima o verso.

§|Oζ

Se o número de pontos for ímpar, imprima outro ponto, caso contrário, imprima o restante das costas.

Ｅ037×o⌊⟦⁻÷ζ²Ｉκ⁺³⁼κ3⟧

Divida o número de pontos por dois e distribua-os entre três linhas de 3, 4 e 3 pontos.

↙»

Vá para o início da próxima joaninha.

‖Ｂ←

Reflita a tela para a esquerda, mantendo as costas.

Python 2 , 252 249 238 212 211 213 209 bytes

n=input()
x=(n+22)/23or 1
for i in range(x):b=n/x+(n%x>i);c=r"""    _V_
  /(@I@)\
 /361%s163\
|408717804|
 \5201025/
  ''-!-''"""%'|O'[b%2];i=0;exec"c=c.replace(`i%9`,' |oO'[i>9::2][i<b/2],2);i+=1;"*11;print c

Experimente online!

• Guardado 9 bytes graças a Kevin Cruijssen
• Economizou 18 bytes graças ao Sr. Xcoder
• Economizou 2 bytes graças a Jonathan Frech

JavaScript (ES6), 183 186 bytes

Usa a mesma fórmula da resposta de TFeld para dividir os pontos entre as joaninhas.

n=>(g=k=>k--?`    _V_
  /(@I@)\\
 /3\\
|4|
 \\3/
  ''-!-''
`.replace(/\d/g,i=>(h=s=>i--?h((p=N?(N-=2,'o'):' ')+s+p):s)('|O'[N>2*i|N&1&&+!!N--]),N=(n%j>k)+n/j|0)+g(k):'')(j=n/23+.99|0||1)

Demo

let f =

n=>(g=k=>k--?`    _V_
  /(@I@)\\
 /3\\
|4|
 \\3/
  ''-!-''
`.replace(/\d/g,i=>(h=s=>i--?h((p=N?(N-=2,'o'):' ')+s+p):s)('|O'[N>2*i|N&1&&+!!N--]),N=(n%j>k)+n/j|0)+g(k):'')(j=n/23+.99|0||1)

console.log(f(0))
console.log(f(1))
console.log(f(9))
console.log(f(25))

Befunge, 292 279 bytes

#j07-00p&>::1-27*9+/\!!*:1+06pv-1_@#:<<g61$<<:
v"h"**95%2:+`g61%g60\/g60::p61<>-0g*+35*-,:!|
>\-30p2/:55+`:59**"g"\-40p-26pv^*84\!`"."::<<9
v\%+55+g62:%+55+4*g62:::-1<+55<>:"/n"$#->#<^#<
>`26g!+"O"*"Y"\-\-\5+0p:>#^_" 66<0<66// >,-"v
"n //>7OXO8k />'&%$%&'k !(*+)#)+*(! /k,-.$."<v

Experimente online!

Explicação

A arte ASCII da joaninha é codificada em uma única string Befunge, deslocada em 15, para permitir que os 15 primeiros caracteres imprimíveis sejam reservados para fins especiais. Os dois primeiros desses caracteres especiais representam a nova linha e o |caractere, que de outra forma não seriam imprimíveis. O terceiro não é usado, porque é um ", que não pode ser usado em uma string. Os próximos dois representam os grandes pontos no centro. E os dez restantes são para os pontos nas asas.

Esses caracteres especiais são traduzidos para sua forma final por meio de uma tabela de pesquisa, escrita sobre a primeira parte da primeira linha.

Para facilitar a explicação, este é o código com as várias partes componentes destacadas:

Começamos inicializando a nova linha e o |caractere na tabela de pesquisa, pois eles são constantes.
Em seguida, lemos o número de pontos do stdin e calculamos o número de joaninhas necessárias.
Podemos então iniciar o loop externo para o conjunto de bugs, calculando o número de pontos para a próxima joaninha a ser renderizada.
Para cada joaninha, calculamos se o ponto central grande precisa ser mostrado (se spots%2 == 1) e gravamos o valor apropriado na tabela de pesquisa.
Da mesma forma, calculamos se o outro par de pontos grandes precisa ser mostrado (se spots/2 > 10), atualizando novamente a tabela de pesquisa. Também calculamos os pontos restantes necessários em cada asa.
A parte final da inicialização da tabela de pesquisa é um loop que calcula quais dos pequenos pontos precisam ser exibidos. Essencialmente, o algoritmo é: se (spotnum*spotcount+4)%10 > ((spotnum+1)*spotcount+4)%10, então o local precisa ser exibido.
Em seguida, colocamos a representação em cadeia codificada da joaninha na pilha. Essa é essencialmente uma string simples, mas ficou um pouco complicada quando tentei comprimir as lacunas do código para que a fonte formasse um retângulo.
Neste ponto, estamos prontos para iniciar o loop de saída, processando os caracteres um por um, convertendo os casos especiais (os pontos, quebras de linha etc.) por meio da tabela de pesquisa construída anteriormente.
Finalmente, verificamos se exibimos todas as joaninhas necessárias, caso contrário, continuamos de volta ao início do loop externo.

Rubi , 203 193 190 bytes

f=->n{s=%q{    _V_ 
  /(@I@)\
 /137x731\
|0596x6950|
 \248x842/
  ''-!-''
}
n-=d=n>0?n/(1+~-n/23):0
s.gsub!(/\d/){$&.to_i<d/2??o:' '}
x=[d%2,d<=>21]*2
s.gsub!(?x){"|O|"[x.pop]}
n>0?s+f[n]:s}

Experimente online!

• Economizou 10 bytes graças a Jordan