J'adore les sardines, je n'en ai jamais assez, tout comme mon ordinateur, l'Omnilang 5000, qui n'a pas de langage.

Pour donner à mon ordinateur le plaisir de goûter aux sardines, j'ai décidé de lui alimenter un certain nombre de programmes capables d'afficher sur l'écran des boîtes de sardines dans diverses orientations et de montrer jusqu'à dix sardines.

Dans ce défi, vous serez responsable de la création des programmes en fonction de ces paramètres:

L'entrée

Un nombre (compris entre 0 et 10) et une lettre de l'un des "LR" suivants (représentant respectivement la gauche ou la droite) Par exemple: 3Lou 5R; comment cela est entré dans le programme est à vous.

Sortie

Une boîte ouverte de sardines avec les sardines faisant face à la direction indiquée, avec la clé (représentée par le caractère " %") et le couvercle pelé (boîte métallique enroulée à la fin représentée par le caractère " @") situé au sommet de la boîte.

• Toutes les sardines doivent faire face à la direction indiquée par l'entrée.
• Toutes les sardines auront un corps long de cinq caractères entre le branchie (" )" ou " (") et la queue " ><"
• La clé et le rouleau de couvercle pelé seront toujours dans le sens opposé à celui des sardines.
• La boîte doit avoir une apparence 3D, comme indiqué ci-dessous dans les exemples.
• La hauteur minimale de la boîte est de 3 sardines en hauteur. Donc, si un nombre est inférieur à 3, une boîte de 3 sardines de hauteur doit être indiquée, avec le nombre entré de sardines. Sinon, la boîte doit correspondre au nombre de sardines indiqué dans l’entrée. Donc, l'entrée de 0Rou 0Lmontrera une boîte de sardine vide.
• Toute autre entrée qui ne peut pas être validée ne montrera rien.

Par exemple, pour " 3L"

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

Pour " 7R"

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

Pour " 2L"

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

Pour " 0R"

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

" 0L"

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

Une entrée invalide ne retournera rien ...

• C'est du code golf, donc le plus petit nombre de personnages gagnera ce défi.
• Aucune échappatoire comme d'habitude.

> <> , 250 235 + 3 = 238 octets

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

Essayez-le en ligne ou regardez-le au terrain de jeu du poisson ! Lit le "L" ou le "R" dans STDIN et suppose que le nombre de sardines est déjà sur la pile (nécessite un -vindicateur pour +3 octets).

Bien sûr, je devais écrire ceci dans> <>.

Emojicode , 456 448 octets

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

Prend 2 arguments: le premier est les lignes, le second est la direction (0 ou 1).

Essayez-le en ligne!

Version "non lisible" et version pseudocode "lisible":

🐋 🚂 🍇
  🐖 🐟  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 octets

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+"''"])

Essayez-le en ligne!

L'entrée consiste en une longueur de 2 tuple. Le premier élément indique le nombre de sardines. Le deuxième élément indique la direction; 0pour gauche, 1pour droite.

-84 octets utilisant la magie lambda grâce à notjagan et officialaimm

Pêche , 1311 octets

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]

Prend les entrées stdinsous la forme:

5
R

La pêche n’est pas sur Try It Online , mais il existe un interprète pour cela en Ruby sur la page des esolangs liée.

C'est le premier programme que j'ai créé dans Pêche - en fait, c'est le premier programme que j'ai créé dans un langage 2D -, donc il peut probablement être beaucoup plus court. Les astuces de golf sont les bienvenues (même si je ne serais pas surpris si personne n'en donnait, vu que je ne sais même pas ce que je viens d'écrire).

Voici un GIF du chemin que le programme prend pour l'entrée 1R (désolé pour la qualité médiocre):

(Ceci a été créé à l'aide d'un interprète que j'ai créé; il n'y a pas de programme disponible au public qui "visualise" la pêche, à ma connaissance)

Charbon de bois , 49 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Le premier argument est le nombre de sardines, le second est la direction (0 = gauche, 1 = droite).

SOGL V0.12 , 51 48 octets

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

Essayez-le ici!
La première entrée est le décompte et la deuxième, à gauche ou à droite, représentée par 1 ou 0.

Explication:

..‘..‘                          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 octets 311 octets

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=""))}}

Function prend une valeur numérique pour n et une chaîne pour la direction.

C’est ma première publication, je vais donc admettre que je ne suis pas sûr de savoir comment compter les octets de code.

C ++, 307 296 292 octets

#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;}

Utilisation:

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

-11 octets enregistrés grâce à l'utilisateur ThePirateBay -4 octets grâce à Zacharý

Python 2 , 287 octets

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]

Essayez-le en ligne!

L' entrée est séparées par une virgule tuple de numéros de ce format: 2, 1. Le premier nombre est la quantité de poisson et le second est 0 pour gauche et 1 pour droite.

Cela a commencé comme une tentative de sur-jouer l’autre réponse (je pensais pouvoir le faire), mais ça craint. : P Si quelqu'un peut faire la queue et la queue et aider à jouer au golf (je le blâme sur le fait qu'il soit midi maintenant), je serais heureux.

C # (.NET Core), 289 octets

(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;}

Essayez-le en ligne!

Prend un entier et un caractère (L, R) en tant que paramètres et génère la chaîne résultante.

Pouah. A dû faire face à des constantes de chaînes ennuyeuses, malheureusement, vous ne pouvez pas le faire string * lengthen C #. Et la méthode avec new string(char, length)n'aurait pas valu le coût en octets.

L'algorithme fonctionne comme suit:

1. Au début, nous déterminons si les sardines sont tournées vers la droite ou vers la gauche, car nous allons ensuite formater nos chaînes en conséquence. Nous créons une chaîne pour le sommet, avec certains opérateurs conditionnels pour basculer entre les perspectives L et R.
2. Ensuite, nous créons une boucle qui s'exécute 3 fois au minimum et les temps d'entrée de gauche au maximum. De cette façon, nous pouvons créer des espaces vides si nous avons moins de 3 sardines dans notre boîte.
3. À l'intérieur de cette boucle, nous formaterons une chaîne en fonction de la perspective et, si h > inous y mettons une sardine. Si i >= h, il y aura un espace vide où une sardine serait normalement.
4. À la fin, nous créons le bas de la boîte, à nouveau formatée selon la perspective.

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

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

Essayez-le en ligne!

JavaScript (ES6), 283 273 269 251 octets

Sauvegardé 10 octets grâce à @WallyWest

4 octets enregistrés en supprimant les parents supplémentaires

Enregistrement de 18 octets grâce à @ThePirateBay

Souffre de l'absence d'inversion de chaîne dans la bibliothèque standard. Définit une fonction qui prend des entrées npour le nombre de poissons et dpour la direction. Lance si dn'est pas "L" ou "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([`'`,_(`=`),`''`]))

Essayez-le en ligne