Eu amo sardinhas, não consigo obter o suficiente delas, e meu computador, o Omnilang 5000, que é independente da linguagem.

Para dar ao meu computador a alegria de experimentar sardinha, decidi alimentá-lo com vários programas que são capazes de exibir na tela latas de sardinha em várias orientações e mostrar até dez sardinhas.

Neste desafio, você será responsável por criar os programas com base nesses parâmetros:

A entrada

Um número (entre 0 e 10) e uma letra de um dos seguintes "LR" (representando esquerda ou direita, respectivamente) Por exemplo: 3Lou 5R; depende de você como isso é inserido no programa.

Saída

Uma lata aberta de sardinha com as sardinhas voltadas para a direção indicada, com a chave (representada pelo %caractere " ") e a tampa descascada (lata enrolada no final representada pelo @caractere " ") localizada no topo da lata.

• Todas as sardinhas devem estar voltadas para a direção indicada pela entrada.
• Todas as sardinhas terão corpos com cinco caracteres entre a guelra (" )" ou " (") e a cauda " ><"
• A chave e o rolo da tampa descascada sempre estarão voltados para a direção oposta às sardinhas.
• A lata deve ter uma aparência 3D, como mostrado abaixo nos exemplos.
• A altura mínima da lata é de 3 sardinhas de altura. Portanto, se um número for menor que 3, uma lata de 3 sardinhas de altura deve ser mostrada, com o número de sardinhas inserido. Caso contrário, o estanho deve ser o número de sardinhas alto indicado na entrada. Portanto, insira 0Rou 0Lmostre uma lata de sardinha vazia.
• Qualquer outra entrada que não possa ser validada não mostrará nada.

Por exemplo, para " 3L"

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

Para " 7R"

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

Para " 2L"

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

Para " 0R"

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

" 0L"

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

Entrada inválida não retornará nada ...

• Isso é código de golfe, então o menor número de caracteres vencerá esse desafio.
• Sem brechas, como de costume.

> <> , 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<

Experimente online ou assista no playground de peixes ! Lê o "L" ou "R" do STDIN e assume que o número de sardinhas já está na pilha (precisa de um -vsinalizador para +3 bytes).

Porque é claro que eu tive que escrever isso em> <>.

Emojicode , 456 448 bytes

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

Toma 2 argumentos: o primeiro é linhas, o segundo é a direção (0 ou 1).

Experimente online!

Versão não legível "legível" e versão de pseudocódigo:

🐋 🚂 🍇
  🐖 🐟  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+"''"])

Experimente online!

A entrada consiste em uma tupla de comprimento 2. O primeiro elemento indica o número de sardinhas. O segundo elemento indica a direção; 0para a esquerda, 1para a direita.

-84 bytes usando magia lambda, graças a notjagan e officialaimm

Pesca , 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]

Recebe entrada stdinno formato:

5
R

A pesca não está disponível no Try It Online , mas há um intérprete no Ruby na página de esolangs vinculada.

Este é o primeiro programa que eu criei no Fishing - na verdade, é o primeiro programa que eu criei em qualquer linguagem 2D - então provavelmente pode ser muito mais curto. Dicas de golfe são bem-vindas (embora eu não ficasse surpreso se ninguém desse alguma, considerando que nem eu sei o que diabos acabei de escrever).

Aqui está um GIF do caminho que o programa leva para entrada 1R(desculpe pela baixa qualidade):

(Isso foi criado usando um intérprete que eu criei; não existem programas publicamente disponíveis que "visualizem" o Fishing, tanto quanto eu sei)

Carvão , 49 bytes

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

Experimente online! Link é a versão detalhada do código. O primeiro argumento é o número de sardinhas, o segundo é a direção (0 = esquerda, 1 = direita).

SOGL V0.12 , 51 48 bytes

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

Experimente aqui!
Espera que a entrada seja a 1ª sendo a contagem e a 2ª - esquerda ou direita representada por 1 ou 0.

Explicação:

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

A função assume um valor numérico para n e uma sequência para a direção.

Esta é a primeira vez que publico, então admito que não tenho certeza de como contar bytes de código.

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

Uso:

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

-11 bytes economizados graças ao usuário ThePirateBay -4 bytes graças a 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]

Experimente online!

Entrada é uma vírgula separados tuple dos números deste formato: 2, 1. O primeiro número é a quantidade de peixes e o segundo é 0 para a esquerda e 1 para a direita.

Isso começou como uma tentativa de superar a outra resposta (eu pensei que podia), mas é péssimo. : P Se alguém puder fazer cara de pau e ajudar e jogar golfe (eu culpo as 12 horas agora), ficaria feliz.

C # (.NET Core), 289 bytes

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

Experimente online!

Pega um número inteiro e um caractere (L, R) como parâmetros e gera a string resultante.

Ugh. Teve que lidar com algumas constantes irritantes de string, infelizmente você não pode simplesmente fazer string * lengthem C #. E o método com new string(char, length)não teria valido o custo de bytes.

O algoritmo funciona da seguinte maneira:

1. No início, determinamos se as sardinhas estão voltadas para a direita ou para a esquerda, pois, em seguida, formataremos nossas seqüências de acordo. Criamos uma string para o topo, com alguns operadores condicionais para alternar entre as perspectivas L e R.
2. Em seguida, criamos um loop que é executado 3 vezes no mínimo e os tempos de entrada esquerdos no máximo. Dessa forma, podemos criar espaços vazios se tivermos menos de 3 sardinhas em nossa caixa.
3. Dentro desse loop formata-se uma string, dependendo da perspectiva e também, se h > icolocarmos uma sardinha dentro dela. Se i >= hhouver um espaço vazio onde normalmente seria uma sardinha.
4. No final, criamos a parte inferior da caixa, novamente formatada de acordo com a perspectiva.

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),"'==========''"

Experimente online!

JavaScript (ES6), 283 273 269 251 bytes

Guardado 10 bytes graças a @WallyWest

4 bytes salvos removendo parênteses extras

Guardado 18 bytes graças a @ThePirateBay

Sofre da falta de reversão de cadeia na biblioteca padrão. Define uma função que recebe entradas npara o número de peixes e dpara a direção. Lança se dnão for "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([`'`,_(`=`),`''`]))

Experimente online