Introduzione:

Quando pensiamo alle coccinelle, di solito pensiamo a un insetto rosso o arancione scuro con macchie nere. Anche se questo non è necessariamente vero, dal momento che ci sono anche neri con coccinelle rosse / arancioni o coccinelle senza macchie , principalmente immaginiamo coccinelle qualcosa come questa coccinella asiatica:

Un'altra cosa da notare è che le macchie sulle coccinelle sono quasi sempre simmetriche. Ed è qui che arriva questa sfida.

Sfida:

Dato un numero intero n( >= 0), emette una o più volte la seguente coccinella di arte ASCII, con punti simmetrici divisi uniformemente tra i due lati, così come le due o più coccinelle.

Ecco il layout predefinito della coccinella:

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

Se n=0, abbiamo emesso la coccinella sopra com'è.

Quando nè maggiore di zero, riempiamo gli spazi del bug di arte ASCII con una lettera minuscola oo sostituiamo |il centro con una maiuscola O. L'obiettivo è faren modifiche alle coccinelle 'vuote', pur producendo un risultato simmetrico (per coccinella) e producendo il minor numero possibile di coccinelle.

Quindi gli output validi per n=1sono:

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

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

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

Ma questo non sarebbe valido:

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

Le uscite valide per n=2sono:

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

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

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

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

etc. There are a lot of possible outputs.

Il primo nche non è più possibile inserire in una singola coccinella è n=24. Nel qual caso dovrai dividerlo il più uniformemente possibile in due coccinelle (puoi scegliere se riprodurle una accanto all'altra o una sotto l'altra - opzionalmente con uno spazio o una nuova riga tra di loro). Per esempio:

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

Regole della sfida:

• n sarà nella gamma di 0-1000 .
• È possibile scegliere di eseguire l'output su STDOUT, tornare come stringa o array / elenco di caratteri 2D, ecc. La chiamata.
• Non sono consentite nuove righe o spazi bianchi non necessari. Sono consentiti spazi vuoti finali e una sola nuova riga finale.
• Come accennato in precedenza, quando sono necessarie due o più coccinelle, è possibile scegliere se riprodurle una accanto all'altra o una sotto l'altra (o una combinazione di entrambe ..)
• Quando due o più coccinelle sono stampate una accanto all'altra, è consentito un solo spazio opzionale in mezzo. Quando due o più coccinelle sono stampate l'una sull'altra, è consentita una singola nuova riga opzionale in mezzo.
• Puoi scegliere il layout delle coccinelle in qualsiasi momento della sequenza, purché simmetriche e uguali all'input n.
• Poiché l'obiettivo è quello di avere ncambiamenti E il minor numero possibile di coccinelle, inizierai a utilizzare più di una coccinella quando sopra n=23. Il layout di queste coccinelle non deve necessariamente essere lo stesso. In realtà, questo non è nemmeno possibile per alcuni input, come n=25on=50 per nominarne due.
• Inoltre, a volte non è possibile dividere uniformemente i punti tra due o più coccinelle. In tal caso dovrai dividerli il più uniformemente possibile, con al massimo una differenza di 1 tra di loro.

Quindi n=50, tenendo a mente le ultime due regole, questo sarebbe un output possibile valido (dove il primo bug ha 16 punti e gli altri due ne hanno 17):

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

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Carbone , 84 81 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Inserisci il numero totale di punti.

≔⌈∕∨θ¹¦²³η

Calcola il numero di coccinelle necessarie.

Ｆη«

Passa sopra ogni coccinella.

≔⁺÷θη‹ι﹪θηζ

Calcola il numero di punti da mettere su questa coccinella.

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

Stampa la testa e l'ala destra della coccinella.

↑⎇›ζ²¹OO²

Se sono presenti più di 21 punti, stampare due punti, altrimenti stampare il retro.

§|Oζ

Se il numero di punti è dispari, stampare un altro punto, altrimenti stampare il resto della parte posteriore.

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

Dividi il numero di punti per due e distribuiscili su tre file di 3, 4 e 3 punti.

↙»

Passa all'inizio della prossima coccinella.

‖Ｂ←

Rifletti la tela a sinistra, mantenendo la schiena.

Pitone 2 , 252 249 238 212 211 213 209 byte

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

Provalo online!

• Salvataggio di 9 byte grazie a Kevin Cruijssen
• Risparmiato 18 byte grazie a Mr. Xcoder
• Salvato 2 byte grazie a Jonathan Frech

JavaScript (ES6), 183 186 byte

Utilizza la stessa formula della risposta di TFeld per dividere i punti tra le coccinelle.

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)

dimostrazione

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 byte

#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

Provalo online!

Spiegazione

L'arte ASCII per la coccinella è codificata in una singola stringa di Befunge, sfalsata di 15, per consentire ai primi 15 caratteri stampabili di essere riservati per scopi speciali. I primi due di questi caratteri speciali rappresentano la nuova riga e il |personaggio, che altrimenti non sarebbero stampabili. Il terzo non viene utilizzato, perché è a ", che non può essere utilizzato in una stringa. I prossimi due rappresentano i grandi punti al centro. E i restanti dieci sono per i punti sulle ali.

Questi caratteri speciali sono tradotti nella loro forma finale tramite una tabella di ricerca, che è scritta sulla prima parte della prima riga.

Per semplificare la spiegazione, questo è il codice con le varie parti componenti evidenziate:

Iniziamo inizializzando la nuova riga e il |carattere nella tabella di ricerca, poiché questi sono costanti.
Quindi leggiamo il numero di punti da stdin e calcoliamo il numero di coccinelle richieste.
Possiamo quindi avviare il ciclo esterno per l'insieme di bug, calcolando il numero di punti per il rendering della coccinella successiva.
Per ogni coccinella, calcoliamo se deve essere mostrato (se spots%2 == 1) il punto centrale grande e scriviamo il valore appropriato nella tabella di ricerca.
Allo stesso modo, calcoliamo se è necessario mostrare (se spots/2 > 10) l'altra coppia di punti grandi , aggiornando nuovamente la tabella di ricerca. Calcoliamo anche i punti rimanenti richiesti su ogni ala.
La parte finale dell'inizializzazione della tabella di ricerca è un ciclo che calcola quale dei piccoli punti deve essere visualizzato. In sostanza l'algoritmo è: if (spotnum*spotcount+4)%10 > ((spotnum+1)*spotcount+4)%10, quindi lo spot deve essere visualizzato.
Quindi spingiamo la rappresentazione di stringa codificata della coccinella sullo stack. Questa è essenzialmente solo una semplice stringa, ma è diventata un po 'contorta mentre cercavo di comprimerla negli spazi del codice in modo che l'origine formasse un rettangolo.
A questo punto, siamo pronti per iniziare il ciclo di output, elaborando i caratteri uno per uno, convertendo i casi speciali (punti, interruzioni di riga, ecc.) Tramite la tabella di ricerca precedentemente costruita.
Infine controlliamo se abbiamo visualizzato tutte le coccinelle richieste, altrimenti torniamo all'inizio del ciclo esterno.

Rubino , 203 193 190 byte

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}

Provalo online!

• Risparmiato 10 byte grazie alla Giordania