Desafio

Dado um número inteiro n(onde 4<=n<=10**6) como entrada, crie uma "porta da prisão" de arte ASCII *, medindo n-1caracteres largos e naltos, usando os símbolos do exemplo abaixo.

Exemplo

╔╦╗
╠╬╣
╠╬╣
╚╩╝

Os caracteres usados ​​são os seguintes:

┌───────────────┬─────────┬───────┐
│ Position      │ Symbol  │ Char  │
├───────────────┼─────────┼───────┤
│ Top Left      │    ╔    │ 9556  │
├───────────────┼─────────┼───────┤
│ Top           │    ╦    │ 9574  │
├───────────────┼─────────┼───────┤
│ Top Right     │    ╗    │ 9559  │
├───────────────┼─────────┼───────┤
│ Right         │    ╣    │ 9571  │
├───────────────┼─────────┼───────┤
│ Bottom Right  │    ╝    │ 9565  │
├───────────────┼─────────┼───────┤
│ Bottom        │    ╩    │ 9577  │
├───────────────┼─────────┼───────┤
│ Bottom Left   │    ╚    │ 9562  │
├───────────────┼─────────┼───────┤
│ Left          │    ╠    │ 9568  │
├───────────────┼─────────┼───────┤
│ Inner         │    ╬    │ 9580  │
└───────────────┴─────────┴───────┘

Regras

• Você pode receber informações por qualquer meio razoável e conveniente, desde que permitido pelas regras de E / S padrão .
• Para os propósitos deste desafio, nos idiomas em que os símbolos usados ​​para criar a "porta" são caracteres de vários bytes, eles podem ser contados na sua pontuação como um único byte cada.
• Todos os outros caracteres (um ou vários bytes) devem ser contados normalmente.
• A saída pode não conter espaços à direita, mas uma nova linha à direita é permitida se for absolutamente necessário.
• Isso é código-golfe, e a menor contagem de bytes ganha.

Casos de teste

Input: 4
Output:
╔╦╗
╠╬╣
╠╬╣
╚╩╝

Input: 8
Output:
╔╦╦╦╦╦╗
╠╬╬╬╬╬╣
╠╬╬╬╬╬╣
╠╬╬╬╬╬╣
╠╬╬╬╬╬╣
╠╬╬╬╬╬╣
╠╬╬╬╬╬╣
╚╩╩╩╩╩╝

Input: 20
Output:
╔╦╦╦╦╦╦╦╦╦╦╦╦╦╦╦╦╦╗
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╠╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╣
╚╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╝

_{* Sim, eu sei que quanto maior fica, menos parece uma porta de prisão! : D}

Java 8, 156 151 148 118 bytes

n->{String a="╔",b="╠",c="╚";for(int i=n;i-->3;a+="╦",b+="╬")c+="╩";a+="╗\n";for(b+="╣\n";n-->2;)a+=b;return a+c+"╝";}

-30 bytes, criando uma porta de resposta @raznagul C # (.NET Core) , depois que eu jogava 5 bytes.

Experimente online.

Resposta antiga de 148 bytes:

n->{String r="╔";int i=n,j;for(;i-->3;r+="╦");r+="╗\n╠";for(i=n;i-->2;r+="╣\n"+(i>2?"╠":"╚"))for(j=n;j-->3;r+="╬");for(;n-->3;r+="╩");return r+"╝";}

-5 bytes graças a @raznagul .

Explicação:

Experimente aqui.

n->{                   // Method with integer parameter and String return-type
  String r="╔";        //  Result String (starting with the top-left corner)
  int i=n,j;           //  Indexes `i` and `j`
  for(;i-->3;          //  Loop (1) `n`-3 times:
      r+="╦"           //   Append result with top edges
  );                   //  End of loop (1)
  r+="╗\n╠";           //  Append result with the top-right corner, new-line and left edge
  for(i=n;i-->2        //  Loop (2) `n`-2 times
      ;                //     After every iteration:
      r+="╣\n"         //   Append result with right edge and new-line
      +(i>2?"╠":"╚"))  //    + either the left edge or bottom-left corner
    for(j=n;j-->3;     //   Inner loop (3) `n`-3 times:
        r+="╬"         //    Append result with middle section
    );                 //   End of inner loop (3)
                       //  End of loop (2) (implicit / single-line body)
  for(;n-->3;          //  Loop (4) `n`-3 times:
    r+="╩"             //   Append result with bottom edges
  );                   //  End of loop (4)
  return r+"╝";        //  Return result with its bottom-right corner
}                      // End of method

Carvão , 34 - 5 = 29 bytes

Ａ⁻Ｎ³γＵＢ╬↓×╠γ╠¶╚×╩γ‖ＢＯγ‖ＢＯ↑⁺γ

Experimente online! Link é a versão detalhada do código. A redução de 5 bytes é para caracteres de desenho de caixa.

ReflectOverlapOverlap(0)deve ser equivalente a, ReflectMirror()mas, em vez disso, o carvão vegetal faz apenas uma ReflectTransform()substituição; caso contrário, essa solução também funcionaria n=3. Aqui está uma solução alternativa que mostra o que aconteceria comn=3 para 38 - 5 = 33 bytes:

Ａ⁻Ｎ³γＵＢ╬↓×╠γ╠¶╚×╩γ¿γ‖ＢＯγ‖Ｍ‖ＢＯ↑⁺γ¹

Melhor ainda, se ReflectOverlapOverlap(0)funcionou, mas eu não me incomodei em dar suporte n=3, então eu poderia fazer isso por 31 - 4 = 27 bytes:

Ａ⁻Ｎ³γＵＢ╬↓×╠γ╚×╩γ‖ＢＯγ‖ＢＯ↑⁻γ¹

Carvão , 44 42 bytes

^{Riscado 44 ainda é regular 44}

Ａ⁺±³ＮαＡ⁺¹αω╔×α╦¦╗Ｊ⁰¦¹×ω╠
¦╚×α╩¦╝Ｍ↖↑×ω╣Ｍ↙¤╬

Experimente online!

Haskell, 75 bytes

w i(a:b:c)=a:(b<$[4..i])++c
f n=concat$w(n+1)$w n<$>["╔╦╗\n","╠╬╣\n","╚╩╝"]  

Experimente online!

A função wpega um número inteiro ie uma lista onde aestá o primeiro, bo segundo elemento e co restante da lista e faz uma nova lista a, seguida por i-3cópias de b, seguidas por c. Aplique wprimeiro em cada elemento da lista ["╔╦╗\n","╠╬╣\n","╚╩╝"]e depois novamente (com iaumento de 1) na lista resultante. Concatene em uma única lista.

Vim, 29 bytes

3<C-x>C╔╦╗
╠╬╣
╚╩╝<Esc>h<C-v>kkx@-Pjyy@-p

Como existem caracteres de controle, aqui está um despejo do xxd:

00000000: 3318 43e2 9594 e295 a6e2 9597 0de2 95a0  3.C.............
00000010: e295 ace2 95a3 0de2 959a e295 a9e2 959d  ................
00000020: 1b68 166b 6b78 402d 506a 7979 402d 70    .h.kkx@-Pjyy@-p

Experimente online! (O intérprete V parece ter problemas com caracteres exóticos, de modo que o link usa caracteres mais mundanos.)

Explicação

3<C-x>     " Decrement the number by 3
C╔╦╗
╠╬╣
╚╩╝<Esc>   " Cut the number (goes in @- register) and enter the "template"
h<C-v>kkx  " Move to the middle column, highlight and cut it
@-P        " Paste @- copies of the cut column
jyy        " Move to the middle line and copy it
@-p        " Paste @- copies of the copied line

GNU sed, 74 + 1 = 75 bytes

+1 byte para -rsinalizador. Recebe a entrada como um número unário.

s/1111(1*)/╔╦\1╗\n;\1╠╬\1╣\n╚╩\1╝/
:
s/(.)1/\1\1/
t
s/;([^;\n]+)/\1\n\1/
t

Experimente online!

Explicação

Isso é bem simples. Suponha que a entrada seja 6 (111111 unário). A primeira linha descarta quatro se 1transforma a entrada restante nela:

╔╦11╗
;11╠╬11╣
╚╩11╝

A terceira linha, em um loop, substitui todos 1pelos caracteres que a precedem. Isso cria nossas colunas:

╔╦╦1╗
;11╠╬11╣
╚╩11╝

╔╦╦╦╗
;11╠╬11╣
╚╩11╝

...

╔╦╦╦╗
;;;╠╬╬╬╣
╚╩╩╩╝

Observe que isso também duplicou o ;caractere. Finalmente, a quinta linha, em um loop, substitui cada ;caractere por uma cópia da linha a seguir:

╔╦╦╦╗
;;╠╬╬╬╣
╠╬╬╬╣
╚╩╩╩╝

╔╦╦╦╗
;╠╬╬╬╣
╠╬╬╬╣
╠╬╬╬╣
╚╩╩╩╝

╔╦╦╦╗
╠╬╬╬╣
╠╬╬╬╣
╠╬╬╬╣
╠╬╬╬╣
╚╩╩╩╝

Gelatina , 33 bytes

_{... é 33? - custa 5 para converter de literais de string de um byte (índices da página de códigos) em caracteres Unicode.}

_2µ“€ðБẋ“¡Ø¤“©ßµ‘js3x€2¦€’+⁽"7ỌY

Um programa completo imprimindo o resultado.

Experimente online!

Quão?

_2µ“€ðБẋ“¡Ø¤“©ßµ‘js3x€2¦€’+⁽"7ỌY - Main link: n
_2                                - subtract 2
  µ                               - start a new monadic chain with n-2 on the left
   “€ðБ                          - code page indexes [12, 24, 15] (middle row characters)
        ẋ                         - repeat n-2 times (make unexpanded middle rows)
         “¡Ø¤“©ßµ‘                - code page indexes [[0,18,3],[6,21,9]] (top & bottom)
                  j               - join (one list: top + middles + bottom)
                   s3             - split into threes (separate into the unexpanded rows)
                          ’       - decrement n-2 = n-3
                        ¦€        - sparsely apply to €ach:
                       2          -   at index 2
                     x€           -   repeat €ach (expand centre of every row to n-3 chars)
                            ⁽"7   - literal 9556
                           +      - addition (0->9556; 12->9568; etc...)
                               Ọ  - cast to characters (╠; ╔; etc...)
                                Y - join with newlines
                                  - implicit print

Python 3 , 75 bytes

n=int(input())-3
print("╔"+"╦"*n+"╗\n"+("╠"+"╬"*n+"╣\n")*-~n+"╚"+"╩"*n+"╝")

Experimente online!

Dyalog APL, 71 bytes

{('╔',('╠'⍴⍨⍵-2),'╚'),((⍵-3)\⍪('╦',('╬'⍴⍨⍵-2),'╩')),'╗',('╣'⍴⍨⍵-2),'╝'}

Experimente online!

Japt , 60 52 49 48 36 bytes

"╔{Uµ3 ç'╦}╗{UÄ ç"
╠{ç'╬}╣"}
╚{ç'╩}╝

Experimente online!

Outra versão (47 bytes + -Rsinalizador)

"8{Uµ3 ç'J};{UÄ ç"D{ç'P}G"}>{ç'M}A"c_+9500ÃòU+2

Precisa do -Rsinalizador (adicionado ao campo de entrada). Experimente online!

Como funciona?

Como originalmente assumi que os 'caracteres da porta' custam mais de um byte, achei que poderia economizar alguns bytes codificando-os. Subtraí 9500 dos códigos de caracteres, o que me deixou com os caracteres8J; DPG >MA , que custam apenas um byte cada. Então, eu poderia adicionar 9500 a cada código de caractere e tudo ficaria bem.

 "8{   Uµ 3 ç'J}  ;{   UÄ  ç"D{   ç'P}  G"}  >{   ç'M}  A"c_+9500Ã òU+2
 "8"+((U-=3 ç'J)+";"+((U+1 ç"D"+(Uç'P)+"G")+">"+(Uç'M)+"A"c_+9500} òU+2
 "8"+           +";"+                      +">"+      +"A"              # Take this string of characters
     ((U-=3 ç'J)                                                        # Repeat "J" input - 3 times
                     ((    ç              )                             # Repeat the string
                            "D"+(Uç'P)+"G"                              # "D" + input-3 times "P" + "G"
                       U+1                                              # Input - 2 times
                                                (Uç'M)                  # Repeat "M" input - 3 times
                                                          c_     }      # Take the character code of every character
                                                            +9500       # Add 9500 to it
                                                          c_     }      # And convert it back to a character
                                                                   òU+2 # Split this string on every (input)th character
                                                                        # Print the resulting array, joined with newlines.

05AB1E , 29 bytes

3-…╩╬╦S×`…╔ÿ╗Š…╠ÿ╣IÍ×s…╚ÿ╝Jä»

Experimente online!

Rápido, 161 bytes

let f:(String,Int)->String={String(repeating:$0,count:$1)};var p={i in print("╔\(f("╦",i-3))╗\n\(f("╠\(f("╬",i-3))╣\n",i-2))╚\(f("╩",i-3))╝")}

Sem golfe:

let f:(String,Int)->String = {
    String(repeating:$0,count:$1)
}
var p={ i in
    print("╔\(f("╦",i-3))╗\n\(f("╠\(f("╬",i-3))╣\n",i-2))╚\(f("╩",i-3))╝")
}

Você pode tentar esta resposta aqui

QBIC , 78 bytes

[:-3|X=X+@╦`]?@╔`+X+@╗`[b-2|Y=Z[b-3|Y=Y+@╬`]?@╠`+Y+@╣`}[b-3|W=W+@╩`]?@╚`+W+@╝`

Felizmente, todos os símbolos usados ​​na porta da célula estão na página de códigos QBasic.

Explicação

            The TOP
[:-3|       FOR a = 1 to n-3 (-1 for the width, -2 for beginning and end)
X=X+@╦`]    Build out X$ with the parts of the middle-top
?@╔`+X+@╗`  Then print that preceded and followed by the corners
┘           Syntactic linebreak

            The MIDDLE
[b-2|       FOR c = 1 to n-2 (all the middle rows)
Y=Z         Reset Y$ to ""
            Build up the middle rows in the same way as the top,
            just with different symbols and once for each middle row
[b-3|Y=Y+@╬`]?@╠`+Y+@╣`
}           Close the FOR loop
            The BOTTOM
            The same as the top, just with different symbols
[b-3|W=W+@╩`]?@╚`+W+@╝`

Saída de amostra

Command line: 7

╔╦╦╦╦╗
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╚╩╩╩╩╝

PHP , 131 bytes, 113 caracteres

for($z=str_split("╔╠╚╦╬╩╗╣╝",3);$i<$a=$argn;)echo str_pad($z[$b=$i++?$i<$a?1:2:0],3*$a-3,$z[$b+3]),$z[$b+6],"\n";

Experimente online!

PHP , 133 bytes, 115 caracteres

for(;$i<$a=$argn;)echo str_pad(["╔","╠","╚"][$b=$i++?$i<$a?1:2:0],3*$a-3,["╦","╬","╩"][$b]),["╗","╣","╝"][$b],"\n";

Experimente online!

JavaScript (ES6), 86 bytes

Isso é significativamente mais longo que a outra resposta JS , mas eu queria tentar com um método alternativo.

n=>(g=i=>--i?`╬╣╠╩╝╚╦╗╔
`[(j=i%n)?!--j+2*!(n-j-2)+3*(i<n)+6*(i>n*n-n):9]+g(i):'')(n*n)

Quão?

Atribuímos um peso a cada extremidade da grade: 1 para a direita, 2 para a esquerda, 3 para a parte inferior e 6 para a parte superior. A soma dos pesos fornece o índice do caractere a ser usado.

8666667    0 1 2 3 4 5 6 7 8
2000001    ╬ ╣ ╠ ╩ ╝ ╚ ╦ ╗ ╔
2000001
2000001
2000001
2000001
2000001
5333334

Demo

let f =

n=>(g=i=>--i?`╬╣╠╩╝╚╦╗╔
`[(j=i%n)?!--j+2*!(n-j-2)+3*(i<n)+6*(i>n*n-n):9]+g(i):'')(n*n)

console.log(f(8))

JavaScript (ES6), 80 74 bytes

n=>`╔${"╦"[a="repeat"](n-=3)}╗${`
╠${"╬"[a](n)}╣`[a](n+1)}
╚${"╩"[a](n)}╝`

Ruby, 54 52 bytes

-2 bytes graças a ymbirtt.

->n{?╔+?╦*(n-=3)+"╗
"+(?╠+?╬*n+"╣
")*-~n+?╚+?╩*n+?╝}

Experimente online!

Ungolfed

Isso é super chato:

->n{
   ?╔ + ?╦ * (n-=3) + "╗\n" + 
  (?╠ + ?╬ * n      + "╣\n") * -~n + 
   ?╚ + ?╩ * n      + ?╝
}

Java 8, 102 + 101 bytes

java.util.function.BiFunction<String,Integer,String>r=(c,n)->"".valueOf(new char[n]).replace("\0",c);

n->{n-=3;return "╔"+r.apply("╦",n)+"╗\n"+r.apply('╠'+r.apply("╬",n)+"╣\n",-~n)+"╚"+r.apply("╩",n)+"╝";}

Este é outro repetidor de cadeia do mesmo comprimento:

java.util.function.BiFunction<String,Integer,String>r=(c,n)->{String p=c;for(;--n>0;p+=c);return p;}

Experimente online!

C # (.NET Core) , Pontuação 123 (141 bytes) Pontuação 118 (136 bytes)

n=>{string a="╔",b="╠",c="╚";for(int i=3;i++<n;a+="╦",b+="╬")c+="╩";a+="╗\n";for(b+="╣\n";n-->2;)a+=b;return a+c+"╝";}

Experimente online!

-5 bytes graças a @KevinCruijssen

Explicação:

n => 
{
    string a = "╔", b = "╠", c = "╚"; //Initialize the first, last and the middle lines with the starting character.
    for (int i = 3; i++ < n;          //Loop n-3 times
        a += "╦", b += "╬")           //Add the middle character to the first and middle line.
        c += "╩";                     //Add the middle character to the last line.
    a += "╗\n";                       //Add the end character to the first line.
    for (b += "╣\n";                  //Add the end character to the first line.
        n-- > 2;)                     //Loop n-2 times.
        a += b;                       //Add the middle line to the first line.
    return a + c + "╝";               //Add the last line and the final character and return.
}

Stax , 23 bytes

÷ÅoB↔╒╢Fm|╦a⌐á5µ┐»♫÷d╕Ñ

Execute e depure

Aqui está a versão não destruída. Divertidamente, é realmente menor para stax não usar os caracteres literais porque incluí-los como literal impediria o empacotamento da fonte.

"2Pfj_EQGG]T"!  packed representation of the 9 characters
3/              split into groups of 3
GG              call into trailing program twice
m               print each row
}               trailing program begins here
1|xv\           [1, --x - 1]; x starts as original input
:B              repeat each element corresponding number of times
                effectively, this repeats the internal row of the matrix
M               transpose door; this way it expands the two dimensions

Execute este

Mathematica, 106 bytes

(T[a_,b_,c_]:=a<>Table[b,#-3]<>c;w=Column;w[{T["╔","╦","╗"],w@Table[T["╠","╬","╣"],#-2],T["╚","╩","╝"]}])&

OK, 38 caracteres

`0:"╔╠╚╦╬╩╗╣╝"{+x+/:3*0,2_x}@&1,|1,-2+

Experimente online.

^{O k parece não querer lidar bem com o unicode, então fui com o ok.}

Lote, 126 bytes

@set s=
@for /l %%i in (4,1,%1)do @call set s=%%s%%Î
@echo É%s:Î=Ë%»
@for /l %%i in (3,1,%1)do @echo Ì%s%¹
@echo È%s:Î=Ê%¼

Funciona no CP437 ou CP850. É assim nas páginas de código:

@set s=
@for /l %%i in (4,1,%1)do @call set s=%%s%%╬
@echo ╔%s:╬=╦%╗
@for /l %%i in (3,1,%1)do @echo ╠%s%╣
@echo ╚%s:╬=╩%╝

Retina , 56 50 bytes

.+
$*╬╣
^╬╬╬
╠
.?
$_¶
T`╠╬╣`╔╦╗`^.*
T`╠╬╣`╚╩╝`.*¶$

Experimente online! Funciona construindo um quadrado de ╬s e depois fixando as bordas (em particular, três colunas são excluídas quando os lados são adicionados).

PowerShell , 67 bytes

'╔'+'╦'*($x=$args[0]-3)+'╗';,('╠'+'╬'*$x+'╣')*($x+1);'╚'+'╩'*$x+'╝'

Pega entrada $args[0], subtrai 3, salva isso em $x, usa isso na construção da parte superior da porta para gerar o número apropriado de seções do meio. Então estamos produzindo as linhas do meio, das quais temos $x+1. Finalmente, a linha inferior é semelhante à linha superior. Tudo isso é deixado no pipeline e o implícitoWrite-Output insere uma nova linha entre os elementos gratuitamente.

Experimente online!

Perl 5 , 61

60 caracteres de código (90 incluindo os caracteres de porta multibyte) + 1 para -p

$_='╔'.'╦'x($n=$_-3)."╗\n";$_.=y/╔╦╗/╠╬╣/r x++$n.y/╔╦╗/╚╩╝/r

Experimente online!

C # (.NET Core), 130 bytes

n=>"╔"+R("╦",n-=3)+"╗\n"+R("╠"+R("╬",n)+"╣\n",-~n)+"╚"+R("╩",n)+"╝";string R(string c,int n){string r=c;for(;n-->1;r+=c);return r;}

Porta da resposta Java 8 de @RobertoGraham , depois de jogar cerca de 70 bytes.

Experimente online.

J , 41 37 bytes

ucp@'╬╠╣╦╔╗╩╚╝'{~1 1|.{.&6 3+/<:{.2,*

Experimente online!

O desenho padrão da caixa ocupa 13 bytes , infelizmente a melhor maneira de substituir os caracteres que eu pude encontrar custa 28.