Introducción:

Cuando pensamos en Ladybugs, generalmente pensamos en un insecto rojo o naranja oscuro con manchas negras. Aunque esto no es necesariamente cierto, ya que también hay mariquitas negras con manchas rojas / anaranjadas , o mariquitas sin manchas , principalmente nos imaginamos mariquitas algo así como esta mariquita asiática:

Otra cosa a tener en cuenta es que las manchas en las mariquitas son casi siempre simétricas. Y ahí es donde entra este desafío.

Reto:

Dado un entero n( >= 0), genera la siguiente mariquita ASCII-art una o varias veces, con puntos simétricos divididos equitativamente entre los dos lados, así como las dos o más mariquitas.

Aquí está el diseño predeterminado de la mariquita:

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

Si n=0, sacamos la mariquita arriba como está

Cuando nes mayor que cero, rellenamos los espacios del error ASCII-art con minúsculas o, o reemplazamos el |del centro con una mayúscula O. El objetivo es realizar ncambios en la (s) mariquita (s) 'vacía', sin dejar de producir una salida simétrica (por mariquita) y generar la menor cantidad posible de mariquitas.

Las salidas válidas para n=1son:

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

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

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

Pero esto sería inválido:

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

Las salidas válidas para n=2son:

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

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

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

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

etc. There are a lot of possible outputs.

Lo primero nque ya no es posible caber en una sola mariquita es n=24. En ese caso, tendrá que dividirlo de la manera más uniforme posible en dos mariquitas (puede elegir si se mostrarán una al lado de la otra, o una debajo de la otra, con un espacio opcional o una nueva línea entre ellas). Por ejemplo:

    _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/
  ''-!-''    ''-!-''

O:

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

Reglas de desafío:

• nestará en el rango de 0-1000.
• Puede elegir enviar a STDOUT, regresar como String o 2D-char array / list, etc. Su llamada.
• No se permiten líneas nuevas o espacios en blanco innecesarios. Se permiten espacios en blanco al final y una nueva línea al final.
• Como se mencionó anteriormente, cuando son necesarias dos o más mariquitas, puede elegir si las enviará una al lado de la otra o una debajo de la otra (o una combinación de ambas ...)
• Cuando se imprimen dos o más mariquitas una al lado de la otra, se permite un solo espacio opcional en el medio. Cuando dos o más mariquitas se imprimen entre sí, se permite una nueva línea opcional en el medio.
• Puede elegir el diseño de las mariquitas en cualquier paso durante la secuencia, siempre que sean simétricas e iguales a la entrada n.
• Dado que el objetivo es tener ncambios Y la menor cantidad de mariquitas posible, comenzará a usar más de una mariquita cuando esté arriba n=23. El diseño de estas mariquitas no necesariamente tiene que ser el mismo. De hecho, esto ni siquiera es posible para algunas entradas, como n=25o n=50para nombrar dos.
• Además, a veces no es posible dividir equitativamente los puntos entre dos o más mariquitas. En ese caso, tendrá que dividirlos de la manera más uniforme posible, con una diferencia de 1 como máximo entre ellos.

Entonces n=50, teniendo en cuenta las dos últimas reglas, esta sería una salida posible válida (donde el primer error tiene 16 puntos y los otros dos tienen 17):

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

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Carbón , 84 81 bytes

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

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

Ｎθ

Ingrese el número total de puntos.

≔⌈∕∨θ¹¦²³η

Calcule la cantidad de mariquitas necesarias.

Ｆη«

Pase sobre cada mariquita.

≔⁺÷θη‹ι﹪θηζ

Calcule el número de puntos para poner en esta mariquita.

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

Imprime la cabeza y el ala derecha de la mariquita.

↑⎇›ζ²¹OO²

Si hay más de 21 puntos, imprima dos puntos, de lo contrario imprima el reverso.

§|Oζ

Si el número de puntos es impar, imprima otro punto; de lo contrario, imprima el resto del reverso.

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

Divida el número de puntos por dos, y distribúyalos entre tres filas de 3, 4 y 3 puntos.

↙»

Ir al inicio de la próxima mariquita.

‖Ｂ←

Refleja el lienzo a la izquierda, manteniendo la espalda.

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

Pruébalo en línea!

• Guardado 9 bytes gracias a Kevin Cruijssen
• Guardado 18 bytes gracias al Sr. Xcoder
• Guardado 2 bytes gracias a Jonathan Frech

JavaScript (ES6), 183 186 bytes

Utiliza la misma fórmula que la respuesta de TFeld para dividir las manchas entre las mariquitas.

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)

Manifestación

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

Pruébalo en línea!

Explicación

El arte ASCII para la mariquita está codificado en una sola cadena Befunge, compensada por 15, para permitir que los primeros 15 caracteres imprimibles se reserven para fines especiales. Los primeros dos de estos caracteres especiales representan la nueva línea y el |carácter, que de lo contrario no serían imprimibles. El tercero no se usa, porque es un ", que no se puede usar en una cadena. Los dos siguientes representan los puntos grandes en el centro. Y los diez restantes son para las manchas en las alas.

Estos caracteres especiales se traducen a su forma final a través de una tabla de búsqueda, que se escribe sobre la primera parte de la primera línea.

Para que sea más fácil de explicar, este es el código con las diversas partes componentes resaltadas:

Comenzamos inicializando la nueva línea y el |carácter en la tabla de búsqueda, ya que estos son constantes.
A continuación, leemos la cantidad de puntos de stdin y calculamos la cantidad de mariquitas requeridas.
Entonces podemos comenzar el bucle externo para el conjunto de errores, calculando el número de puntos para que se represente la próxima mariquita.
Para cada mariquita, calculamos si es necesario mostrar el punto central grande (si spots%2 == 1), y escribimos el valor apropiado en la tabla de búsqueda.
Del mismo modo, calculamos si es necesario mostrar el otro par de puntos grandes (si spots/2 > 10), actualizando nuevamente la tabla de búsqueda. También calculamos los puntos restantes requeridos en cada ala.
La parte final de la inicialización de la tabla de búsqueda es un ciclo que calcula cuáles de los pequeños puntos deben mostrarse. Esencialmente, el algoritmo es: si (spotnum*spotcount+4)%10 > ((spotnum+1)*spotcount+4)%10, entonces el punto debe mostrarse.
A continuación, empujamos la representación de cadena codificada de la mariquita en la pila. Esto es esencialmente una simple cadena, pero se volvió un poco enrevesado cuando traté de meterlo en los huecos del código para que la fuente formara un rectángulo.
En este punto, estamos listos para comenzar el ciclo de salida, procesando los caracteres uno por uno, convirtiendo los casos especiales (puntos, saltos de línea, etc.) a través de la tabla de búsqueda previamente construida.
Finalmente, verificamos si hemos mostrado todas las mariquitas requeridas, de lo contrario, continuamos hasta el inicio del bucle externo.

Rubí , 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}

Pruébalo en línea!

• Guardado 10 bytes gracias a Jordan