Ich liebe Sardinen, ich kann nicht genug davon bekommen, und mein Computer, der Omnilang 5000, ist sprachunabhängig.

Um meinem Computer die Freude am Erleben von Sardinen zu geben, habe ich beschlossen, ihm eine Reihe von Programmen zu geben, die in der Lage sind, Sardinen in verschiedenen Ausrichtungen auf dem Bildschirm anzuzeigen und bis zu zehn Sardinen anzuzeigen.

In dieser Herausforderung sind Sie dafür verantwortlich, die Programme basierend auf den folgenden Parametern zu erstellen:

Die Eingabe

Eine Zahl (zwischen 0 und 10) und ein Buchstabe von einem der folgenden "LR" (für Links oder Rechts) Zum Beispiel: 3Loder 5R; Wie dies in das Programm eingegeben wird, liegt bei Ihnen.

Ausgabe

Eine offene Dose Sardinen mit den Sardinen in die angegebene Richtung, wobei sich der Schlüssel (dargestellt durch das %Zeichen " ") und der abgezogene Deckel (aufgerollte Dose am Ende, dargestellt durch das @Zeichen " ") oben auf der Dose befinden.

• Alle Sardinen müssen in die vom Eingang angegebene Richtung zeigen.
• Alle Sardinen haben Körper mit einer Länge von fünf Zeichen zwischen der Kieme (entweder " )" oder " (") und dem Schwanz " ><".
• Der Schlüssel und die abgezogene Deckelrolle zeigen immer in die entgegengesetzte Richtung zu den Sardinen.
• Die Dose muss dreidimensional aussehen, wie in den Beispielen unten gezeigt.
• Die Mindesthöhe der Dose beträgt 3 Sardinen. Wenn eine Zahl kleiner als 3 ist, muss eine Dose mit 3 Sardinen mit der eingegebenen Anzahl von Sardinen angezeigt werden. Andernfalls muss die Dose die Anzahl der Sardinen haben, die in der Eingabe angegeben ist. Die Eingabe von 0Roder 0Lzeigt also eine leere Sardinenform.
• Alle anderen Eingaben, die nicht validiert werden können, zeigen nichts an.

Zum Beispiel für " 3L"

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

Für " 7R"

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

Für " 2L"

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

Für " 0R"

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

" 0L"

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

Ungültige Eingaben geben nichts zurück ...

• Dies ist Codegolf, daher gewinnt die kleinste Anzahl von Charakteren diese Herausforderung.
• Keine Schlupflöcher wie gewohnt.

> <> , 250 235 + 3 = 238 Bytes

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

Probieren Sie es online aus oder schauen Sie es sich auf dem Fischspielplatz an ! Liest das "L" oder "R" von STDIN und nimmt an, dass sich die Anzahl der Sardinen bereits auf dem Stapel befindet (benötigt ein -vFlag für +3 Bytes).

Weil ich das natürlich in> <> schreiben musste.

Emojicode , 456 448 Bytes

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

Nimmt 2 Argumente auf: das erste sind Linien, das zweite ist die Richtung (0 oder 1).

Probieren Sie es online!

"Lesbare" Ungolf-Version und Pseudocode-Version:

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

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

Probieren Sie es online!

Die Eingabe besteht aus einem Tupel der Länge 2. Das erste Element gibt die Anzahl der Sardinen an. Das zweite Element gibt die Richtung an; 0für links, 1für rechts.

-84 Bytes mit Lambda-Magie dank Notjagan und Officialaimm

Angeln , 1311 Bytes

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]

Übernimmt Eingaben aus stdindem Formular:

5
R

Fischen ist nicht in Try It Online , aber es gibt einen Dolmetscher für Ruby auf der verknüpften Esolangs-Seite.

Dies ist das erste Programm, das ich in Fishing erstellt habe - in der Tat ist es das erste Programm, das ich in einer 2D-Sprache erstellt habe - daher kann es wahrscheinlich viel kürzer sein. Golftipps sind willkommen (obwohl ich mich nicht wundern würde, wenn niemand welche gäbe, wenn man bedenkt, dass selbst ich nicht weiß, was zum Teufel ich gerade geschrieben habe).

Hier ist ein GIF des Pfades, den das Programm für die Eingabe verwendet 1R(Entschuldigung für die schlechte Qualität):

(Dies wurde mit einem von mir erstellten Interpreter erstellt. Soweit ich weiß, gibt es keine öffentlich verfügbaren Programme, die das Angeln "visualisieren".)

Kohle , 49 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Das erste Argument ist die Anzahl der Sardinen, das zweite die Richtung (0 = links, 1 = rechts).

SOGL V0.12 , 51 48 Bytes

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

Probieren Sie es hier aus!
Erwartet, dass die Eingabe als erste die Zählung und die zweite - links oder rechts durch 1 oder 0 dargestellt - ist.

Erläuterung:

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

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

Die Funktion verwendet einen numerischen Wert für n und eine Zeichenfolge für die Richtung.

Dies ist meine erste Veröffentlichung, daher gebe ich zu, dass ich nicht sicher bin, wie ich die Bytes des Codes zählen soll.

C ++, 307 296 292 Bytes

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

Verwendung :

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

-11 Bytes dank Benutzer ThePirateBay gespeichert -4 Bytes dank Zacharý

Python 2 , 287 Bytes

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]

Probieren Sie es online!

Die Eingabe ist ein durch Kommas getrenntes Tupel von Zahlen dieses Formats: 2, 1 . Die erste Zahl gibt die Menge der Fische an und die zweite ist 0 für links und 1 für rechts.

Dies begann als Versuch, die andere Antwort zu übertreiben (ich dachte, ich könnte es), aber es ist scheiße. : P Wenn irgendjemand Kopf und Schwanz davon machen und beim Golfen helfen kann (ich beschuldige es, dass es gerade 12 Uhr ist), wäre ich froh.

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

Probieren Sie es online!

Nimmt eine Ganzzahl und ein Zeichen (L, R) als Parameter und gibt den resultierenden String aus.

Pfui. Musste mich mit einigen nervigen String-Konstanten auseinandersetzen, leider kann man das nicht einfach string * lengthin C # machen. Und die Methode mit new string(char, length)wäre die Bytekosten nicht wert gewesen.

Der Algorithmus funktioniert wie folgt:

1. Zu Beginn bestimmen wir, ob die Sardinen nach rechts oder links zeigen, da wir dann unsere Zeichenfolgen entsprechend formatieren. Wir erstellen eine Zeichenfolge für den Anfang mit einigen bedingten Operatoren, um zwischen der L- und der R-Perspektive zu wechseln.
2. Dann erstellen wir eine Schleife, die mindestens dreimal und höchstens die linken Eingabezeiten ausgeführt werden. Auf diese Weise können wir leere Räume schaffen, wenn wir weniger als 3 Sardinen in unserer Box haben.
3. Innerhalb dieser Schleife formatieren wir je nach Perspektive eine Zeichenkette und h > ilegen eine Sardine hinein. Wenn ja i >= h, wird es einen leeren Raum geben, in dem sich normalerweise eine Sardine befinden würde.
4. Am Ende erstellen wir den unteren Rand der Box, wieder entsprechend der Perspektive formatiert.

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

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

Probieren Sie es online!

JavaScript (ES6), 283 273 269 251 Byte

Dank @WallyWest 10 Bytes gespart

4 Bytes gespart, indem zusätzliche Parens entfernt wurden

18 Bytes dank @ThePirateBay gespart

Leidet unter dem Mangel an String-Umkehrung in der Standardbibliothek. Definiert eine Funktion, die Eingaben nfür die Anzahl der Fische und dfür die Richtung übernimmt . Wirft, wenn dnicht "L" oder "R" ist.

(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([`'`,_(`=`),`''`]))

Probieren Sie es online aus