Faça uma caixa espetada

31

Dados dois inteiros positivos, W e H, produzem uma caixa de arte ASCII cuja borda é feita de barras ( /e \) com W "espigões" nas bordas superior e inferior e H "espigões" nas bordas esquerda e direita. O interior da caixa está cheio de espaços.

Um "pico" é simplesmente duas barras que se juntam para formar uma seta:

/\    \/

/      \
\      /

Portanto, a saída para W = 4, H = 3seria

/\/\/\/\
\      /
/      \
\      /
/      \
\/\/\/\/

pois há 4 pontas na parte superior apontando para cima, 4 na parte inferior apontando para baixo, 3 à esquerda apontando para a esquerda e 3 à direita apontando para a direita.

Aqui estão alguns outros pares de entrada / saída:

W H
[spiky slash box]

1 1
/\
\/

1 2
/\
\/
/\
\/

2 1
/\/\
\/\/

2 2
/\/\
\  /
/  \
\/\/

1 3
/\
\/
/\
\/
/\
\/

3 1
/\/\/\
\/\/\/

2 3
/\/\
\  /
/  \
\  /
/  \
\/\/

3 2
/\/\/\
\    /
/    \
\/\/\/

10 1
/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\/\/\/\/\/\/

10 2
/\/\/\/\/\/\/\/\/\/\
\                  /
/                  \
\/\/\/\/\/\/\/\/\/\/

4 5
/\/\/\/\
\      /
/      \
\      /
/      \
\      /
/      \
\      /
/      \
\/\/\/\/

Nenhuma linha na saída deve ter espaços à esquerda ou à direita. Opcionalmente, pode haver uma nova linha à direita.

O código mais curto em bytes vence.

code-golf  string  ascii-art  integer 
— Passatempos de Calvin
fonte
Alguém que javascripts pode fazer um snippet de pilha para isso?
— FantaC

Respostas:

15

Carvão , 9 bytes

ＢײＮײＮ/\

Experimente online!

Explicação

Ｂ           Box
  ײＮ       Next input as number * 2
      ײＮ   Next input as number * 2
          /\ With border "/\"
— Somente ASCII
fonte
3
Claro carvão tem um built-in para 'caixa de desenhar'
— benzeno
1
@benzene Foi um pouco sorte que ele recentemente adicionou a capacidade de desenhar uma cadeia arbitrária ao redor da caixa, mas mesmo antes disso houve respostas como codegolf.stackexchange.com/a/120065
— Neil
1
@ Neil espera recentemente? Quando? (Eu sei carvão menos bem obrigado fazer Haha?)
— ASCII-only
@ Somente ASCII Meu mal! Fiquei confuso por causa da mudança que regrediu o posicionamento do cursor. (A mudança que introduziu a seqüência de fronteira arbitrária foi ca904b0 que foi há quase um ano.)
— Neil
@ benzene Sem a caixa embutida, ainda são apenas 13 bytes: Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(recebe entrada em altura, ordem de largura).
— 1111 Neil
11

MATL , 18 bytes

'\/',iE:]!+)O6Lt&(

Experimente no MATL Online!

Explicação

Considere entradas W = 4, H = 3. O código cria os vetores de linha [1 2 3 4 5 6 7 8](intervalo de 1até 2*W) e [1 2 3 4 5 6](intervalo de 1até 2*H). Transpor o último e adicionar ao primeiro com transmissão fornece a matriz

2  3  4  5  6  7  8  9
3  4  5  6  7  8  9 10
4  5  6  7  8  9 10 11
5  6  7  8  9 10 11 12
6  7  8  9 10 11 12 13
7  8  9 10 11 12 13 14

A indexação modular na string \/produz o resultado desejado na borda da matriz:

/\/\/\/\
\/\/\/\/
/\/\/\/\
\/\/\/\/
/\/\/\/\
\/\/\/\/

Para remover os valores que não são de borda, os definimos como 0(quando interpretados como char, eles são exibidos como espaço):

/\/\/\/\
\      /
/      \
\      /
/      \
\/\/\/\/

Código comentado:

'\/'    % Push this string. Will be indexed into
,       % Do twice
  i     %   Input a number
  E     %   Multiply by 2
  :     %   Range 
]       % End
!       % Transpose
+       % Add
)       % Index
O       % Push 0
6L      % Push [2 -1+1j]. As an index, this means 2:end
t       % Duplicate
&(      % Write 0 into the center rectangle. Implicit display
— Luis Mendo
fonte
7

Haskell , 90 88 87 82 bytes

1 6 bytes economizados graças ao Lynn

a#b=[1..a]>>b
x!y|i<-(x-1)#"  "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]

Experimente online!

Ainda parece muito longo, vou ver o que posso fazer.

— Assistente de Trigo
fonte
Definir a#b=[a..b]e substituir todas as ocorrências economiza um byte:a#b=[a..b];x!y|i<-2#x>>" "=(1#x>>"/\\"):(2#y>>['\\':i++"/",'/':i++"\\"])++[1#x>>"\\/"]
— Lynn
Oh, a#b=[1..a]>>b;x!y|i<-(x-1)#" "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]realmente salva 6 ~
— Lynn
@Lynn Thanks! Você realmente está pegando minha folga ultimamente.
— Wheat Wizard
@ Lynn eu consegui fazê-lo funcionar, mas ao custo de outro byte.
— Wheat Wizard
5

05AB1E , 14 bytes

„/\|∍`S¦`).B∞∊

Experimente online!

Explicação

„/\|∍`S¦`).B∞∊   Arguments: x, y
„/\              Push the string "/\"
   |             Push inputs as array: [x,y]
    ∍            Push the string extended/shortened to those lengths
     `           Flatten
      S          Push seperate chars of second string
       ¦`        Remove first char and flatten again
         )       Wrap stack to an array
          .B     Squarify
            ∞∊   Mirror on both axes

Isso cria apenas o canto superior esquerdo, x caracteres de largura e y caracteres de altura. Em seguida, espelha isso nos dois eixos:

x=3, y=2

/\/|
\  |
---+
— kalsowerus
fonte
4

JavaScript (ES6), 84 bytes

Recebe entrada na sintaxe de currying (w)(h).

w=>h=>'/\\'[R='repeat'](w)+`
${`\\${p='  '[R](w-1)}/
/${p}\\
`[R](h-1)}`+'\\/'[R](w)

Demo

Mostrar snippet de código

— Arnauld
fonte
3

Swift 3 , 166 bytes

func f(a:Int,b:Int){let k=String.init(repeating:count:),n="\n";var r="\\"+k("  ",a-1)+"/";print(k("/\\",a)+n+k(r+n+String(r.characters.reversed())+n,b-1)+k("\\/",a))}

Conjunto de teste completo.

Infelizmente, a versão de fechamento é um pouco mais longa (175 bytes):

var g:(Int,Int)->String={let k=String.init(repeating:count:),n="\n";var r="\\"+k("  ",$0-1)+"/";return k("/\\",$0)+n+k(r+n+String(r.characters.reversed())+n,$1-1)+k("\\/",$0)}

Conjunto de testes com a versão de fechamento.

— Mr. Xcoder
fonte
3

Retina , 77 73 bytes

\d+
$*
 1+|1(?=1* (1+))
$1¶
1
/\
.((..)*.)
/$1¶$1/
¶$

(?<=¶.+).(?=.+¶)

Experimente online! O link inclui casos de teste. Recebe entrada no formato <height> <width>. Explicação:

\d+
$*

Converta as entradas para unárias.

 1+|1(?=1* (1+))
$1¶

Multiplique as entradas, mas adicione uma nova linha para que o resultado seja um retângulo.

1
/\

Crie o topo pontudo.

.((..)*.)
/$1¶$1/

Duplique cada linha pontiaguda, mas com os pontos deslocados na segunda linha.

¶$

Exclua as novas linhas à direita.

(?<=¶.+).(?=.+¶)

Exclua o interior da caixa. (Anote o espaço na última linha.)

— Neil
fonte
3

Excel, 95 bytes

=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)
— Wernisch
fonte
3

APL (Dyalog) , 41 39 bytes

Solicita uma lista de [H,W]

'\'@2@1⊢¯1⌽@1{⌽⍉⍵,'/\'⍴⍨≢⍵}⍣4⊢''⍴⍨2×⎕-1

Experimente online!

⎕-1 solicitar entrada (mnemônico: console estilizado) e subtrair 1

2× multiplicar por dois

''⍴⍨ use isso para remodelar uma string vazia (almofadas com espaços)

⊢ rendimento que (serve para separá-lo 4)

{… }⍣4 Aplique a seguinte função quatro vezes:

 ≢⍵ registro (comprimento) do argumento

 '/\'⍴⍨ ciclicamente r eshape "/\"para que o comprimento

 ⍵, acrescente isso ao lado direito do argumento

 ⌽⍉ transpor e espelhar (ou seja, virar 90 °)

¯1⌽1 ciclicamente girar a 1 r um passo linha à direita

⊢ rendimento que (serve para separá-lo 1)

'\'@2@1 colocar uma barra invertida no 2º posição do 1º item principal.

— Adão
fonte
3

C (gcc) ,170 166 158 155 108 105

-3 bytes graças a cleblanc

x,y;f(w,h){for(y=h*=2;y--;puts(""))for(x=w*2;x--;)putchar(!x|x==w*2-1|!y|y==h-1?x&y&1|~x&~y&1?47:92:32);}

Experimente online!

Eu acho que isso pode ser mais aprofundado com uma abordagem menos direta. Verei o que posso fazer quando encontrar o tempo.

Ok, não consigo encontrar outra maneira de reduzir o número de bytes para esse código.

Explicação: um loop duplo simples imprimindo o caractere de caixa por caractere.

Ao imprimir uma borda: se as coordenadas x e y forem pares ou ímpares, ele exibirá a /, caso contrário, a\ será exibido

Se não for uma borda, um caractere de espaço será exibido.

— escoteiro
fonte
1
Você pode raspar mais 3 bytes movendo o puts("")para o primeiro loop for assimx,y;f(w,h){for(y=h*=2;y--;puts(""))for(x=w*2;x--;)putchar(!x|x==w*2-1|!y|y==h-1?x&y&1|~x&~y&1?47:92:32);}
— cleblanc
@cleblanc Obrigado!
— Scottinet 11/08/19
3

/// , 172 117 bytes

Portanto, como a saída consiste em ///s e whitespaces, deve haver envios nesses 2 idiomas.

Coloque a entrada após o código W,Hcomo número unário (é permitido unário para /// , graças ao Challenger5 pela sugestão) (use *para representar o dígito, separe com ,) o formato.

/W/VV//V/\\\///`/\\\\\\\\\\\\\V/,/W>+  V`/`\>+W  !V!``WV>+WV-  V`\
`\W+  V`/
`/W-!V`\
W``\\V`\V>!//!*/+%-%!//*/  //%/

Experimente online! (com entrada W=4, H=3)

— user202729
fonte
Você pode pular a análise inserindo Unary .
— Esolanging Fruit
Além disso, devo mencionar que isso é muito impressionante! Bom trabalho!
— Esolanging Fruit
2

Python 3 , 87 82 bytes

Edit: salvou 5 bytes graças a @officialaimm , @ Mr.Xcoder e @tsh

def f(a,b,n="\n"):r="\\"+"  "*~-a+"/";print("/\\"*a+n+(r+n+r[::-1]+n)*~-b+"\\/"*a)

Experimente online!

— Halvard Hummel
fonte
— officialaimm
Se você deseja mantê-lo em Python 3, *(b-1)pode ser *~-b, por -2 bytes.
— Sr. Xcoder
2
@officialaimm Por quê " "*2*~-a? Apenas "__"*~-a.
— TSH
@tsh Sim, você está certo ... Haha não sabia que ...
— officialaimm
@officialaimm irá mantê-lo Python 3, fez no entanto salvar alguns bytes devido a você, Mr.Xcoder e TSH
— Halvard Hummel
2

J, 48 bytes

' '&((<,~<<0 _1)})@(+:@[$(1&|.,:])@('\/'$~+:)@])

destroçado

' '&((< ,~ <<0 _1)}) @ (+:@[ $ (1&|. ,: ])@('\/' $~ +:)@])

explicação

                       (+:@[ $ (1&|. ,: ])@('\/' $~ +:)@])    creates box, but interior filled with slashes
                                           ('\/' $~ +:)@]       take right arg, W, doubles it, then fills that
                                          @                       many characters with '\/' repeating
                               (1&|. ,: ])                      stacks (,:) the above on top of itself rotated 
                                                                  by one char, producing top and bottom spikes
                              $                                 reshape to..
                       (+:@[                                    double the length of the left arg, height
                                                                  this creates the sides, as well as a filled interior
                     @                                    
' '&((< ,~ <<0 _1)})                                          removes slashes from interior by using the complement               
                                                                form of amend }.  ie, replace everything but the first
                                                                and last row and first and last col with a space

Experimente online!

— Jonah
fonte
1
33 bytes ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:. Alterar é ótimo aqui.
— miles
ooooh, melhoria muito agradável
— Jonah
1
30 bytes '/\ '{~2(<,~<<0 _1)}2|+/&i.&+:com alguma refatoração
— milhas
2

Java 8, 141 bytes

A curried lambda from width to height to output.

w->h->{String f="/",b="\\",t=f,o=b,p="";char i=1;for(;i++<w;t+=b+f,o+=f+b)p+="  ";t+=b;o+=f;for(i=10;--h>0;)t+=i+b+p+f+i+f+p+b;return t+i+o;}

Try It Online (no, return t+i+o; was not intentional)

Ungolfed lambda

w ->
    h -> {
        String
            f = "/",
            b = "\\",
            t = f,
            o = b,
            p = ""
        ;
        char i = 1;
        for (; i++ < w; t += b + f, o += f + b)
            p += "  ";
        t += b;
        o += f;
        for (i = 10; --h > 0; )
            t += i + b + p + f + i + f + p + b;
        return t + i + o;
    }

This solution is atypically picky about input size since a char is used to count up to the width input. Fortunately, the algorithm is bad enough that at those sizes program completion is probably already an issue. I chose to use char for the loop index so I could reuse it later as a cheap alias for '\n'.

— Jakob
fonte
2

SOGL V0.12, 22 21 13 bytes

/\”m;HΙ»mč+╬¡

Try it Here! (expects both inputs on stack so .. (and " because a string hasn't been explicitly started) - take number input twice is added for ease-of-use)

Explanation:

/\”            push "/\"
   m           mold to the 1st inputs length
    ;          get the other input ontop of stack
     H         decrease it
      Ι        push the last string - "/\"
       »       rotate it right - convert to "\/"
        m      mold "\/" to the length of 2nd input - 1
         č     chop into characters
          +    prepend the 1st molded string to the character array of the 2nd
           έ  quad-palindromize
— dzaima
fonte
>:D it isn't beating Charcoal here
— ASCII-only
@ASCII-only because charcoal has a built-in for this :p (and SOGLs really made for complicated & long challenges anyway)
— dzaima
1

Mathematica, 87 bytes

Table[Which[1<i<2#2&&1<j<2#," ",OddQ[i+j],"\\",1>0,"/"],{i,2#2},{j,2#}]~Riffle~"
"<>""&

Try it in Mathics (it prints extra spaces at the start of most lines for some reason), or at the Wolfram sandbox! Takes two integers as input.

It's a fairly naïve solution, but all of the clever things I tried had more bytes. Something that nearly works is

ArrayPad[Array[" "&,2#-2],1,{{"/",s="\\"},{s,"/"}}]~Riffle~"\n"<>""&

except it fails if either dimension is 1 (input is a list containing the dimensions).

— Not a tree
fonte
1

J, 39 bytes

(' \/'{~=/&(2&|)(*>:)~0=*/&(*|.))&i.&+:

Try it online!

Takes two arguments as height on the LHS and width on the RHS.

— miles
fonte
Nice work, as usual. Interesting approach, too.
— Jonah
@Jonah No, your idea is much better using amend. If combined with half of mine...
— miles
1

VBA (Excel) , 161 Bytes

Sub a()
c=[A2]*2
r=[B2]*2
For i=1To r
For j=1To c
b=IIf(i=1 Or j=1 Or i=r Or j=c,IIf((i+j) Mod 2,"\","/")," ")
d=d & b
Next
d=d & vbCr
Next
Debug.Print d
End Sub
— remoel
fonte
Golfed Sub (139 Bytes): Sub b c=[2*A1] r=[2*B1] For i=1To r For j=1To c Debug.?IIf(i=1Or j=1Or i=r Or j=c,IIf((i + j)Mod 2,"\","/")," "); Next Debug.? Next End Sub
— Taylor Scott
Anonymous immediate window function version of above (113 Bytes): c=[2*A1]:r=[2*B1]:For i=1To r:For j=1To c:?IIf(i=1Or j=1Or i=r Or j=c,IIf((i + j)Mod 2,"\","/")," ");:Next:?:Next
— Taylor Scott
1

R, 160 bytes 152 bytes

p=function(x,n){paste(rep(x,n),collapse='')}
function(w,h){f=p(' ',w*2-2)
cat(paste0(p('/\\',w),'\n',p(paste0('\\',f,'/\n/',f,'\\\n'),h-1),p('\\/',w)))}

Try it online!

Thanks BLT for shaving off 8 bytes.

— Mark
fonte
Do you ever use the s function?
— BLT
The s function is what you call to make the spikey box
— Mark
1
Got it. You can get down to 152 bytes if you remove whitespace and the s= bit. Anonymous functions are allowed.
— BLT
Good to know anon functions are allowed
— Mark
0

dc, 123 bytes

?1-sesf[/\]su[lfsh[lunlh1-dsh0<q]dsqx]dsrx[[
\]P[lf2*2-st[32Plt1-dst0<z]dszx]dsmx[/
/]Plmx92Ple1-dse0<l]slle0<l10P[\/]sulrx

It's far from the shortest, but, if one takes the last two lines and rotates them pi/2 radians clockwise to an "upright" position, it kind of looks like a totem pole.

Takes input as two space-separated integers.

Try it online!

— R. Kap
fonte
1
Currently the longest answer here. I thought that was Java's job...
— R. Kap
Don't worry, there's now a Java solution, and it's longer.
— Jakob
0

Mathematica, 116 bytes

(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&
— J42161217
fonte
Rotate[w,Pi] is equivalent to w~Rotate~Pi, as is o["/\\",#] to "/\\"~o~#
— Jonathan Frech
I know infix notation and I always use it when I really need 1 byte.In this case I just let it go... ;-)
— J42161217
2
I did not doubt your knowledge of infix notation; I just wanted to reduce the byte count. You know, in the spirit of golfing and such.
— Jonathan Frech
0

C# (.NET Core), 188 bytes

a=>b=>string.Join("\n",new int[2*b].Select((x,i)=>string.Concat(string.Concat(new int[a].Select(y=>i%2==0?"/\\":"\\/")).Select((y,j)=>i>0&i<2*b-1&j>0&j<2*a-1?" ":""+y))))

Byte count also includes:

using System.Linq;

Try it online!

I started making explanation command-by-command but it stopped making sense midway... Basic gist is to make full spiky box, and then hollow out the middle. I used Linq for the sake of using Linq, probably can be shorter using just standard iterations.

Here's explanation going middle-out (the inner-most command first):
First, create rows for the full box, and concatenate to a single string

string.Concat(new int[a].Select(y => i % 2 == 0 ? "/\\" : "\\/"))

Then get each character in a row, and if it isn't the outline of the box, replace with space, concatenate them back into one string for each row

string.Concat(PREVIOUS_STEP.Select((y, j) => i > 0 & i < 2 * b - 1 & j > 0 & j < 2 * a - 1 ? " " : "" + y))

Finally, get each row and concatenate them together with newlines (also includes generating of a collection for rows)

string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));
— Grzegorz Puławski
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.