In The Jailhouse Now

18

Sfida

Dato un numero intero n(dove 4<=n<=10**6) come input crea un'arte ASCII "porta della prigione" * che misura n-1caratteri larghi e ncaratteri alti, usando i simboli dell'esempio seguente.

Esempio

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

I caratteri utilizzati sono i seguenti:

┌───────────────┬─────────┬───────┐
│ 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  │
└───────────────┴─────────┴───────┘

Regole

  • È possibile accettare input con qualsiasi mezzo ragionevole e conveniente purché consentito dalle regole I / O standard .
  • Ai fini di questa sfida, nelle lingue in cui i simboli utilizzati per costruire la "porta" sono caratteri multibyte, possono essere conteggiati nel punteggio come un singolo byte ciascuno.
  • Tutti gli altri caratteri (a byte singolo o multiplo) devono essere conteggiati normalmente.
  • L'output non può contenere spazi finali ma è consentita una nuova riga finale se assolutamente necessario.
  • Questo è code-golf, quindi vince il conteggio di byte più basso.

Casi test

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

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

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

* Sì, sono consapevole che più diventa grande e meno sembra una porta della prigione! : D

code-golf  ascii-art 
— ispido
fonte
4
Ciò sarebbe positivo se si potessero inserire entrambe le dimensioni xey
— Decadimento beta il
15
È stato nella Sandbox più che lungo abbastanza da permetterti di suggerirlo.
— Shaggy,
Il mio programma può contenere ╬anche che trogolo ╬non è nella sua tabella codici? In caso contrario, è "'Z“ζconsentito il costo di un byte (o 2)? (premi 9580, converti in Unicode)?
— dzaima,
@dzaima Ai fini di questa sfida, nelle lingue in cui i simboli utilizzati per la "porta" occupano più byte, possono essere conteggiati nel punteggio come un singolo byte ciascuno.
— Okx,
@Okx `╬` - non rappresentabile in nessuna quantità di byte, "'Z“ζuguagliare un byte sarebbe come in javascript che "╬"costa 1 byte
— dzaima,

Risposte:

9

Java 8, 156 151 148 118 byte

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 byte creando una porta di risposta @raznagul C # (.NET Core) , dopo aver golfato 5 byte.

Provalo online.

Vecchia risposta da 148 byte:

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 byte grazie a @raznagul .

Spiegazione:

Provalo qui.

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
— Kevin Cruijssen
fonte
È possibile salvare byte con codici escape / char anziché codificarli?
— TheLethalCoder
@TheLethalCoder Forse, ma poiché lo stato della regola di sfida è possibile contare i simboli come 1 byte ciascuno, è probabilmente più breve come questo (quindi il conteggio di 156 byte anziché i 176 effettivi). Ma sentiti libero di provare alcune cose per renderlo più breve con i codici char.
— Kevin Cruijssen,
Ah, mi mancava quella parte delle regole.
— TheLethalCoder
2
+1 per l' -->operatore va a ( ).
— raznagul,
1
Se usi i-->3, i-->2e j-->3´ you can save 5 bytes by removing the n- = 3` e n+1.
— raznagul,
7

Carbone , 34-5 = 29 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. La riduzione di 5 byte è per i caratteri del disegno a riquadro.

ReflectOverlapOverlap(0)dovrebbe essere equivalente a ReflectMirror()ma invece Charcoal fa solo un ReflectTransform()invece, altrimenti questa soluzione funzionerebbe anche per n=3. Ecco una soluzione alternativa che mostra cosa succederebbe n=3per 38-5 = 33 byte:

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

Meglio ancora, se ha ReflectOverlapOverlap(0)funzionato, ma non mi sono preoccupato di supportare n=3, quindi potrei farlo per 31 - 4 = 27 byte:

Ａ⁻Ｎ³γＵＢ╬↓×╠γ╚×╩γ‖ＢＯγ‖ＢＯ↑⁻γ¹
— Neil
fonte
1
Hmm, non sapeva Carbone riflette anche / specchi ╠per ╣e tali. " Il contatore di byte di Charcoal non funziona per qualche motivo. " Forse il contatore di byte di Charcoal non funziona perché quei caratteri non fanno parte della sua tabella codici? Puoi contarli come 1 byte ciascuno secondo le regole della sfida, quindi questo è davvero 27.
— Kevin Cruijssen,
@KevinCruijssen Dipende dall'operatore che usi. (Devo tornare indietro e ricontrollare ogni volta; ce ne sono alcuni e diventa confuso ...)
— Neil
@Neil Oops, questo è un bug, risolverà al più presto. Grazie per averlo trovato!
— ASCII il
@Neil Anche per qualche motivo è rotto quando n = 4
— ASCII-only il
1
— ASCII il
6

Haskell, 75 byte

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

Provalo online!

La funzione waccetta un numero intero ie un elenco in cui si atrova il primo, bil secondo elemento e cil resto dell'elenco e crea un nuovo elenco a, seguito da i-3copie di b, seguito da c. Applicare wprima su ogni elemento dell'elenco ["╔╦╗\n","╠╬╣\n","╚╩╝"]e poi di nuovo (con un iaumento di 1) nell'elenco risultante. Concatenare in un unico elenco.

— Nome del modello
fonte
Cos'è l'operatore <$? È solo >> con gli argomenti invertiti?
— Aneesh Durg,
@AneeshDurg: <$è originario di Data.Functored è stato inserito Prelude. È quasi lo stesso di >>. a <$ bsostituisce ogni elemento in bcon a, mentre si b >> aaspetta ache sia un elenco e concatena la lunghezza delle bcopie di a. [1,2] >> "aa"-> "aaaa", "aa" <$ [1,2]-> ["aa","aa"]. Nota: 'x' <$ [1,2]uguale a [1,2] >> "x".
— nimi,
5

Vim, 29 byte

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

Dato che ci sono personaggi di controllo, ecco un dump 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

Provalo online! (L'interprete V sembra avere problemi con personaggi esotici, quindi quel link ne usa di più banali.)

Spiegazione

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
— Giordania
fonte
Per confermare: è solo l'interprete TIO che sta soffocando sui simboli?
— Shaggy,
@Shaggy Sì, genera un errore Python su Latin-1, non un errore Vim. (Ho usato la pagina V solo perché TIO non ha una pagina Vim semplice e penso che V usi Latin-1.) Vim sulla mia macchina non ha alcun problema con i personaggi.
— Giordania,
5

GNU sed, 74 + 1 = 75 byte

+1 byte per -rflag. Accetta input come numero unario.

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

Provalo online!

Spiegazione

Questo è abbastanza semplice Supponiamo che l'ingresso sia 6 (unario 111111). La prima riga rilascia quattro 1s e trasforma l'input rimanente in questo:

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

La terza riga, in un ciclo, sostituisce ciascuna 1con il carattere che la precede. Questo crea le nostre colonne:

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

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

...

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

Si noti che questo ha anche duplicato il ;personaggio. Infine, la quinta riga, in un ciclo, sostituisce ogni ;carattere con una copia della riga che segue:

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

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

╔╦╦╦╗
╠╬╬╬╣
╠╬╬╬╣
╠╬╬╬╣
╠╬╬╬╣
╚╩╩╩╝
— Giordania
fonte
4

Gelatina , 33 byte

... sono 33? - costa 5 per convertire da letterali di una stringa di byte (indici di tabella codici) ai caratteri Unicode.

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

Un programma completo che stampa il risultato.

Provalo online!

Come?

_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
— Jonathan Allan
fonte
@Shaggy - Sto usando 9 byte per rappresentare i caratteri all'interno dei valori letterali delle stringhe - questi sono indici della tabella codici. I 5 byte prima del Yalla fine +⁽"7Ọ, aggiungono 9556 a questi e poi li lanciano ai personaggi. Sono (i 5) gratuiti? Sento che sarebbe lo stesso che se potessi usare direttamente i caratteri Unicode. (Potrei anche usare caratteri reali piuttosto che indici di code page e usare una mappatura per più byte).
— Jonathan Allan,
No. Dopo la discussione, si è concluso che solo il carattere stesso può sempre essere considerato come 1, non qualsiasi altra rappresentazione.
— Erik the Outgolfer,
3

Dyalog APL, 71 byte

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

Provalo online!

— Uriel
fonte
Puoi sicuramente giocare a golf. Ad esempio, puoi sempre sostituire (some expr)f Ycon Y f⍨ some expr.
— Adám,
@Adám Lo so, è in corso, non sono attualmente al computer
— Uriel
3

Japt , 60 52 49 48 36 byte

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

Provalo online!

Un'altra versione (47 byte + -Rflag)

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

Ha bisogno del -Rflag (aggiunto al campo di input). Provalo online!

Come funziona?

Dato che inizialmente pensavo che i "personaggi delle porte" costassero più di un byte, ho pensato di poter salvare parecchi byte codificandoli. Quindi, ho sottratto 9500 dai codici dei caratteri, il che mi ha lasciato con i caratteri 8J; DPG >MA, che costavano solo un byte ciascuno. Quindi, potrei semplicemente aggiungere 9500 a ciascun codice carattere e tutto andrebbe bene.

 "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.
— Luca
fonte
Oh sì, hai ragione.
— Luke
— Shaggy,
2

Rapido, 161 byte

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

Un-giocato a golf:

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

Puoi provare questa risposta qui

— Caleb Kleveter
fonte
2

QBIC , 78 byte

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

Fortunatamente, tutti i simboli utilizzati nella porta della cella sono sulla tabella codici QBasic.

Spiegazione

            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+@╝`

Uscita campione

Command line: 7

╔╦╦╦╦╗
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╚╩╩╩╩╝
— steenbergh
fonte
1
+1 per l'utilizzo di una lingua che li ha effettivamente come caratteri a un byte nella sua tabella codici predefinita.
— Giosuè,
Puoi aggiungere un TIO (o equivalente)?
— Shaggy,
— steenbergh
1
O si! Ricorderò che alla fine, te lo prometto! : D
— Shaggy,
@Shaggy bene, non abituarti troppo all'idea. Ho appena trovato una build Emscripten funzionante di Dosbox con QBasic. Proverò a orientarlo verso QBIC nel prossimo mese, quindi un ambiente web potrebbe ancora arrivare ...
— steenbergh,
2

PHP , 131 byte, 113 caratteri

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

Provalo online!

PHP , 133 byte, 115 caratteri

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

Provalo online!

— Jörg Hülsermann
fonte
2

JavaScript (ES6), 86 byte

Questo è significativamente più lungo dell'altra risposta JS , ma volevo provarlo con un metodo 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)

Come?

Assegniamo un peso a ciascun bordo della griglia: 1 per destra, 2 per sinistra, 3 per fondo e 6 per alto. La somma dei pesi fornisce l'indice del personaggio da usare.

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

dimostrazione

Mostra snippet di codice

— Arnauld
fonte
2

JavaScript (ES6), 80 74 byte

n=>`╔${"╦"[a="repeat"](n-=3)}╗${`
╠${"╬"[a](n)}╣`[a](n+1)}
╚${"╩"[a](n)}╝`
— Luca
fonte
Puoi contare i simboli come un byte ciascuno, rendendolo 80 byte. E dovresti essere in grado di fare un uso migliore dei letterali dei template per risparmiare qualche byte;)
— Shaggy,
Puoi contare i simboli come un byte solo se riesci a trovare un'implementazione ES6 che prenderà l'input CP437 in modo nativo.
— user5090812
@ user5090812, è un'indennità specifica per questa sfida.
— Shaggy,
@ user5090812 Non è necessario trovare tale implementazione, poiché le regole della sfida indicano " Ai fini di questa sfida, nelle lingue in cui i simboli utilizzati per la" porta "occupano più byte, possono essere conteggiati nel punteggio come un singolo byte ciascuno. "Quindi questo ha un conteggio dei byte di 80 byte anziché 98 (se ho contato correttamente).
— Kevin Cruijssen,
Bene, questa è una brutta regola. Rimuove tutto l'incentivo a cercare un modo migliore per conservare i personaggi.
— Luca,
2

Rubino, 54 52 byte

-2 byte grazie a ymbirtt.

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

Provalo online!

Ungolfed

Questo è super noioso:

->n{
   ?╔ + ?╦ * (n-=3) + "╗\n" + 
  (?╠ + ?╬ * n      + "╣\n") * -~n + 
   ?╚ + ?╩ * n      + ?╝
}
— Giordania
fonte
Puoi accorciare (n+1)un po 'scrivendo -~n: la precedenza dell'operatore ti salverà anche le parentesi.
— ymbirtt,
2

Java 8, 102 + 101 byte

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)+"╝";}

Questo è un altro ripetitore di stringhe della stessa lunghezza:

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

Provalo online!

— Roberto Graham
fonte
Non male, puoi rendere il tuo approccio ancora più basso della mia risposta. Prima di tutto puoi abbassarlo a 78 + 72 byte (150 in totale) usando un metodo Java 7 invece di BiFunction: n->{n-=3;return"╔"+r("╦",n)+"╗\n"+r("╠"+r("╬",n)+"╣\n",-~n)+"╚"+r("╩",n)+"╝";}e String r(String c,int n){return c.valueOf(new char[n]).replace("\0",c);} provalo online. E il secondo metodo può anche essere cambiato in String r(String c,int n){String r=c;for(;n-->1;r+=c);return r;}(63 byte), quindi diventa 141 byte in totale
— Kevin Cruijssen
Correzione, puoi persino abbassarlo a 130 byte : n->"╔"+r("╦",n-=3)+"╗\n"+r("╠"+r("╬",n)+"╣\n",-~n)+"╚"+r("╩",n)+"╝"e String r(String c,int n){String r=c;for(;n-->1;r+=c);return r;} provalo online.
— Kevin Cruijssen,
2

C # (.NET Core) , Punteggio 123 (141 byte) Punteggio 118 (136 byte)

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+"╝";}

Provalo online!

-5 byte grazie a @KevinCruijssen

Spiegazione:

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.
}
— raznagul
fonte
1
Bella risposta, +1 da parte mia. So che è passato un po 'di tempo, ma puoi giocare a golf 5 byte in più cambiando b+="╣\n";c+="╝";for(;n-->2;)a+=b;return a+c;};in for(b+="╣\n";n-->2;)a+=b;return a+c+"╝";} Provalo online.
— Kevin Cruijssen,
@KevinCruijssen: grazie.
— raznagul,
2

Stax , 23 byte

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

Esegui ed esegui il debug

Ecco la versione non golfata. In modo divertente, in realtà è più piccolo per la stax non usare i caratteri letterali perché includerli come letterali impedirebbe l'imballaggio della 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

Esegui questo

— ricorsivo
fonte
1

Mathematica, 106 byte

(T[a_,b_,c_]:=a<>Table[b,#-3]<>c;w=Column;w[{T["╔","╦","╗"],w@Table[T["╠","╬","╣"],#-2],T["╚","╩","╝"]}])&
— J42161217
fonte
Potresti aggiungere un TIO (o equivalente)?
— Shaggy,
1
Goto sandbox.open.wolframcloud.com/app/objects incollare il codice (Ctrl + V), aggiungere [8] alla fine e premere SHIFT + ENTER
— J42161217
Sembra che ci sia un'interruzione di riga in più tra ogni riga, avrei ragione nel dire che è un problema con il rendering dell'outpu, piuttosto che l'output stesso?
— Shaggy,
@Shaggy wolfram cloud mostra tutti i personaggi in modo divertente e distorto, quindi non è il modo migliore per presentare tali compiti. Non ci sono righe extra e tutto sembra a posto in matematica. copia e incolla il test case per verificarlo. L'ho fatto e sembrano identici
— J42161217
1

OK, 38 caratteri

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

Provalo online.

k non sembra voler gestire bene l'unicode, quindi sono andato con oK.

— zgrep
fonte
1

Lotto, 126 byte

@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:Î=Ê%¼

Funziona con CP437 o CP850. Sembra così in quelle pagine di codice:

@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:╬=╩%╝
— Neil
fonte
1

Retina , 56 50 byte

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

Provalo online! Funziona costruendo un quadrato di and e quindi fissando i bordi (in particolare tre colonne vengono eliminate quando vengono aggiunti i lati).

— Neil
fonte
1

PowerShell , 67 byte

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

Prende input $args[0], sottrae 3, lo salva in$x , lo utilizza nella costruzione della parte superiore della porta per produrre il numero appropriato di sezioni centrali. Quindi stiamo emettendo le file centrali, di cui abbiamo $x+1. Infine, la riga inferiore è simile alla riga superiore. Tutti questi vengono lasciati sulla pipeline e l'implicito Write-Outputinserisce una nuova riga tra gli elementi gratuitamente.

Provalo online!

— AdmBorkBork
fonte
1

Perl 5 , 61

60 caratteri di codice (90 inclusi i caratteri multibyte della porta) + 1 per -p

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

Provalo online!

— Xcali
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.