Adoro le sardine, non ne ho mai abbastanza, così come il mio computer, l'Omnilang 5000, che è agnostico in termini di linguaggio.

Per dare al mio computer la gioia di provare le sardine, ho deciso di dargli da mangiare un numero di programmi in grado di visualizzare sullo schermo scatole di sardine in vari orientamenti e mostrare fino a dieci sardine.

In questa sfida, sarai responsabile della creazione dei programmi basati su questi parametri:

L'input

Un numero (compreso tra 0 e 10) e una lettera di una delle seguenti "LR" (che rappresentano rispettivamente Sinistra o Destra) Ad esempio: 3Loppure 5R; come questo viene inserito nel programma dipende da te.

Produzione

Una scatola aperta di sardine con le sardine rivolte nella direzione indicata, con la chiave (rappresentata dal %carattere " ") e il coperchio pelato (latta arrotolata all'estremità rappresentata dal @carattere " ") situato nella parte superiore della scatola.

• Tutte le sarde devono essere rivolte nella direzione indicata dall'input.
• Tutte le sardine avranno corpi lunghi cinque caratteri tra la branchia (" )" o " (") e la coda " ><"
• La chiave e il rotolo del coperchio pelato saranno sempre rivolti nella direzione opposta alle sarde.
• Lo stagno deve avere un aspetto tridimensionale come mostrato di seguito negli esempi.
• L'altezza minima della latta è di 3 sardine in altezza. Quindi, se un numero è inferiore a 3, deve essere mostrata una scatola di 3 sardine in altezza, con il numero immesso di sardine al suo interno. Altrimenti, lo stagno deve essere il numero di sardine alto indicato nell'input. Quindi l'ingresso di 0Ro 0Lmostrerà una scatola di sardine vuota.
• Qualsiasi altro input che non può essere convalidato non mostrerà nulla.

Ad esempio, per " 3L"

 __________
(__________@%
|<*)_____><||
|<*)_____><||
|<*)_____><||
'==========''

Per " 7R"

   __________
 %@__________)
 ||><_____(*>|
 ||><_____(*>|
 ||><_____(*>|
 ||><_____(*>|
 ||><_____(*>|
 ||><_____(*>|
 ||><_____(*>|
 ''=========='  

Per " 2L"

 __________
(__________@%
|<*)_____><||
|<*)_____><||
|          ||
'==========''

Per " 0R"

   __________
 %@__________)
 ||          |
 ||          |
 ||          |
 ''=========='

" 0L"

 __________
(__________@%
|          ||
|          ||
|          ||
'==========''

Un input non valido non restituirà nulla ...

• Questo è il golf del codice, quindi il minor numero di personaggi vincerà questa sfida.
• Nessuna scappatoia come al solito.

> <> , 250 235 + 3 = 238 byte

</~?{"  __________"a:="L"i&
o/?=1l
:/}rv?{~$?{"()__________@%":
l< o/?=1
:&oa/&~$?(3$@0-3:
/!?:</"||><_____(*>|"av?@:$-1
 /=?/v"|<*)_____><||"a/
 \2lo/
\~&
\>:?!\1+$::{a"|"{?:"          ||"{?~
<\?=2 lo
"'":~/~?{"''==========":?{
;!?lo<

Provalo online o guardalo nel parco giochi per pesci ! Legge la "L" o la "R" da STDIN e presuppone che il numero di sardine sia già nello stack (è necessario un -vflag per +3 byte).

Perché ovviamente ho dovuto scrivere questo in> <>.

Emojicode , 456 448 byte

🐋🚂🍇🐖🐟d🚂🍇🍦a😛0d🍊a🍇😀🔤 __________❌n(__________@%🔤🍉🍓🍇😀🔤  __________❌n%@__________)🔤🍉🔂i⏩0🐕🍇🍊a🍇😀🔤|<*)_____><||🔤🍉🍓🍇😀🔤||><_____(*>|🔤🍉🍉🍊▶️4🐕🍇🔂i⏩0➖3🐕🍇🍊a🍇😀🔤|          ||🔤🍉🍓🍇😀🔤||          |🔤🍉🍉🍉🍊a🍇😀🔤'==========''🔤🍉🍓🍇😀🔤''=========='🔤🍉🍉🍉

Accetta 2 argomenti: il primo è la riga, il secondo è la direzione (0 o 1).

Provalo online!

Versione non leggibile "leggibile" e versione pseudocodice:

🐋 🚂 🍇
  🐖 🐟  d 🚂  🍇
    🍦 a  😛 0 d

    🍊 a 🍇
      😀 🔤 __________❌n(__________@%🔤
    🍉
    🍓 🍇
      😀 🔤  __________❌n%@__________)🔤
    🍉

    🔂 i ⏩ 0 🐕 🍇
      🍊 a 🍇
        😀 🔤|<*)_____><||🔤
      🍉
      🍓 🍇
        😀 🔤||><_____(*>|🔤
      🍉
    🍉

    🍊 ▶️ 4 🐕 🍇
      🔂 i ⏩ 0  ➖ 3 🐕  🍇
        🍊 a 🍇
          😀 🔤|          ||🔤
        🍉
        🍓 🍇
          😀 🔤||          |🔤
        🍉
      🍉
    🍉

    🍊 a 🍇
      😀 🔤'==========''🔤
    🍉
    🍓 🍇
      😀 🔤''=========='🔤
    🍉
  🍉
🍉

👵
extendclass int { // this makes the first argument be an int without declaring it
  func 🐟(int d) {
    const a = 0 == d // a bool

    if a {
      print " __________\n(__________@%"
    }
    else {
      print "  __________\n%@__________)"
    }

    for i in range(1, arg) {
      if a {
        print "|<*)_____><||"
      }
      else {
        print "||><_____(*>|"
      }
    }

    if 4 > arg {
      for i in range(0, arg - 3) {
        if a {
          print "|          ||"
        }
        else {
          print "||          |"
        {
      }
    }

    if a {
      print "'==========''"
    }
    else {
      print "''=========='"
    {
  }
}
👵

Python 2 , 155 byte

lambda x,y,t='_'*10:'\n'.join(x[::1-2*y]for x in[' %s  '%t,'()'[y]+t+'@%']+['|'+('<>**)(%s><<>'%t)[y::2]+'||']*x+['|'+' '*10+'||']*(3-x)+["'"+'='*10+"''"])

Provalo online!

L'input consiste in una tupla di lunghezza 2. Il primo elemento indica il numero di sardine. Il secondo elemento indica la direzione; 0per sinistra, 1per destra.

-84 byte usando la magia lambda grazie a notjagan e officialaimm

Pesca , 1311 byte

v+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC?CCCDCC[CCCCCCCCCCCCCCCCCCCCC?CCCCCCCCCCCCCCCCCCCC[CCC[CCCCC?CCCC?DDDDD[CCCCCCCCCCCCCCCCCCC?CCCCCCCCCCCCCCCCC[?CCCCCCCCCCCCCCCC_
  `3`n{n{In{I{`L`{`  __________ `}}!{{rD}}D{{NE`%@__________)`}}!{{E`(__________@%`}}D{{NDE}}}}={d}}!  d  D{{{{{`><_____(*>`}}!{{E`<*)_____><`}}D!{{{E`|`P}PE`||`ND
                                   [DDDDDD|                     [DDDDDDDDDDDDDDDDDDDD|   D     [C?CDDDDDDDDCCCCCCCCCCCCCCCCCCC[DDDDDDDDDDDDDDDDD|[CCCCCCCCCCCCCCCC_
                                                                                         D      }=d [^+Cv-|{{{{{`          `}}                    {{{E`||`P}PE`|`ND
                                                                                         D       [CCCCCCCCCCCCCCCCCCC?DDDDDDDDD+CCCC                              D
                                                                                         D        E`''=========='`{{{= }}}r{{{ [CCCC                              D
                                                                                         D                           [^CCCCCCCv|}}}N                              D
                                                                                         |DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD]

Prende input dal stdinmodulo:

5
R

Fishing non è su Try It Online , ma c'è un interprete per esso in Ruby nella pagina degli esolang collegati.

Questo è il primo programma che ho realizzato in Fishing - in effetti, è il primo programma che ho realizzato in qualsiasi linguaggio 2D - quindi probabilmente può essere molto più breve. I consigli sul golf sono i benvenuti (anche se non sarei sorpreso se nessuno ne avesse dato uno, considerando che anche io non so cosa diavolo ho appena scritto).

Ecco una GIF del percorso seguito dal programma per l'input 1R(scusate per la bassa qualità):

(Questo è stato creato usando un interprete che ho creato; non ci sono programmi disponibili al pubblico che "visualizzano" la pesca, per quanto ne so)

Carbone , 49 byte

Ａ⌈⟦Ｉθ³⟧ζＢχ²_←↓(↓ζ'×=χ''↖Ｐ↑ζ←↑ζ@%ＦＮ“#∨‹ＶＢ“«ji”ＦＮ‖Ｔ

Provalo online! Il collegamento è alla versione dettagliata del codice. Il primo argomento è il numero di sardine, il secondo è la direzione (0 = sinistra, 1 = destra).

SOGL V0.12 , 51 48 byte

!gX⁴‘gj⁰%!⁵‘b⌡"κN╥█*≤⌡║)‘3b-"÷AZ⁴‘∙_"Χccσ«‘⁰e?±↔

Provalo qui!
Si aspetta che l'ingresso come primo sia il conteggio e il secondo - sinistra o destra rappresentati da 1 o 0.

Spiegazione:

..‘..‘                          push 2 compressed strings - the 1st two lines of the box - "  __________ " and "%@__________)"
      b⌡                        input times do
        "..‘                      push a line with a sardine - "||><_____(*>|"
            3b-                 push 3-input
               "..‘∙            get an array of that many "||          |"
                    _           put all the arrays contents on the stack
                     "..‘       push "''=========='" - the last line
                         ⁰      wrap all of that in an array
                          e?    if the 2nd input [is not 0]
                            ±↔    reverse the array horizontally

R, 334 byte 311 byte

s=function(n,d){
a="__________"
b="'=========='"
if(d == "L"){cat(paste(c(" ",a,"\n(",a,"@%\n",rep("|<*)_____><||\n",n),rep("|          ||\n",max(c(3-n,0))),b,"'\n"),collapse=""))} else {cat(paste(c("  ",a,"\n%@",a,")\n",rep("||><_____(*>|\n",n),rep("||          |\n",max(c(3-n,0))),"'",b,"\n"),collapse=""))}}

La funzione accetta un valore numerico per n e una stringa per la direzione.

Questa è la mia prima pubblicazione, quindi ammetto che non sono sicuro di come contare i byte di codice.

C ++, 307 296 292 byte

#include<string>
auto z(int n,char c){std::string r=c-82?" __________\n(__________@%\n":"  __________\n%@__________)\n";int l=0;for(;l<n;++l)r+=c-82?"|<*)_____><||\n":"||><_____(*>|\n";for(;l<3;++l)r+=c-82?"|          ||\n":"||          |\n";r+=c-82?"'==========''":"''=========='";return r;}

Utilizzo:

z(<number of sardines>,<'L' or 'R'>);

-11 byte salvati grazie all'utente ThePirateBay -4 byte grazie a Zacharý

Python 2 , 287 byte

n,d=input()
t,a,b,c,e,k=' __________   ','(__________@% ','|<*)_____><|| ','|          || ',"'=========='' ",'\n'
print[t+k+a+k+k.join([b]*n)+k+k.join([c]*(3-n))+k*(n<3)+e,t[::-1]+k+a[::-1].replace(*'()')+k+k.join([b[::-1].replace(*')(')]*n)+k+k.join([c[::-1]]*(3-n))+k*(n<3)+e[::-1]][d]

Provalo online!

Input è un separati da virgola coppia di numeri di questo formato: 2, 1. Il primo numero è la quantità di pesce e il secondo è 0 per sinistra e 1 per destra.

Questo è iniziato come un tentativo di superare l'altro campo (pensavo di poterlo fare), ma fa schifo. : P Se qualcuno riesce a capirlo e aiutarlo a giocare a golf (la colpa è che sono le 12 in questo momento), sarei felice.

C # (.NET Core), 289 byte

(h,d)=>{var l=d=='L';string r=(l?" ":"  ")+"__________\n"+(l?"(":"%@")+"__________"+(l?"@%":")")+"\n";for(int i=0;i<(h>3?h:3);i++){r+=(l?"|":"||")+(i<h?(d=='L'?"<*)_____><":(d=='R'?"><_____(*>":"")):"          ")+(l?"||":"|")+'\n';}var b=(l?"'":"''")+"=========="+(l?"''":"'");return r+b;}

Provalo online!

Prende un numero intero e un carattere (L, R) come parametri e genera la stringa risultante.

Ugh. Dovevo affrontare alcune fastidiose costanti di stringa, purtroppo non puoi semplicemente farlo string * lengthin C #. E il metodo con new string(char, length)non avrebbe valso il costo in byte.

L'algoritmo funziona come segue:

1. All'inizio determiniamo se le sardine sono rivolte a destra oa sinistra, poiché formatteremo quindi le nostre stringhe di conseguenza. Creiamo una stringa per la parte superiore, con alcuni operatori condizionali per alternare tra la prospettiva L e R.
2. Quindi creiamo un loop che viene eseguito 3 volte al minimo e il tempo di input sinistro al massimo. In questo modo possiamo creare spazi vuoti se abbiamo meno di 3 sardine nella nostra scatola.
3. All'interno di questo loop formattiamo una stringa, a seconda della prospettiva e anche, se h > i, inseriamo una sardina al suo interno. Se i >= h, ci sarà uno spazio vuoto in cui sarebbe normalmente una sardina.
4. Alla fine creiamo il fondo della scatola, di nuovo formattato secondo la prospettiva.

Perl 5 , 167 + 1 (-n) = 168 byte

($n,$d)=/(\d+)([LR])/ or die;say('R'eq$d?(reverse$_)=~y/()></)(<>/r:$_)for" __________  ","(__________@%",("|<*)_____><||")x$n,("|          ||")x(3-$n),"'==========''"

Provalo online!

JavaScript (ES6), 283 273 269 251 byte

Salvato 10 byte grazie a @WallyWest

Salvato 4 byte rimuovendo le parentesi extra

Risparmiato 18 byte grazie a @ThePirateBay

Soffre della mancanza di inversione di stringa nella libreria standard. Definisce una funzione che accetta input nper numero di pesci e dper direzione. Genera se dnon è "L" o "R".

(n,d,_=c=>c.repeat(10),x=_(`_`),z=a=>a.reverse``.join``)=>
([p,q,g,r,s]=d>`L`?d>`R`?[]:[`)`,`(`,`>`,z,y=>z(y.split``)]:
[`(`,`)`,`<`,a=>a.join``,y=>y],` ${x}
`+r([p,x,s(`@%`)])+`
`+(r([`|`,g,`*`,q,`_____`,`><`,`||`])+`
`).repeat(n)+r([`'`,_(`=`),`''`]))

Provalo online