Dans la prison maintenant

18

Défi

Étant donné un entier n(où 4<=n<=10**6) comme entrée, créez une "porte de prison" ASCII art * mesurant des n-1caractères larges et des ncaractères hauts, en utilisant les symboles de l'exemple ci-dessous.

Exemple

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

Les caractères utilisés sont les suivants:

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

Règles

  • Vous pouvez recevoir des informations par tout moyen raisonnable et pratique tant que cela est autorisé par les règles d'E / S standard .
  • Pour les besoins de ce défi, dans les langues où les symboles utilisés pour construire la "porte" sont des caractères multi-octets, ils peuvent être comptés dans votre score comme un seul octet chacun.
  • Tous les autres caractères (mono ou multi-octets) doivent être comptés comme normaux.
  • La sortie ne peut contenir aucun espace de fin, mais une nouvelle ligne de fin est autorisée si cela est absolument nécessaire.
  • C'est le code-golf, donc le nombre d'octets le plus bas gagne.

Cas de test

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

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

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

* Oui, je suis conscient que plus il grossit, moins il ressemble à une porte de prison! :RÉ

code-golf  ascii-art 
— Hirsute
source
4
Cela aurait été bien si vous pouviez entrer les dimensions x et y
— Beta Decay
15
Il était dans le bac à sable plus que suffisamment longtemps pour que vous le suggériez.
— Shaggy
Mon programme peut-il contenir ╬même un creux qui ╬n'est pas dans sa page de codes? Sinon, est-il "'Z“ζautorisé en tant que coût d'un octet (ou 2)? (pousser 9580, convertir en unicode)?
— dzaima
@dzaima Aux fins de ce défi, dans les langues où les symboles utilisés pour la "porte" prennent plusieurs octets, ils peuvent être comptés dans votre score comme un seul octet chacun.
— Okx
@Okx `╬` - qui ne peut pas être prédéfini dans aucun octet, "'Z“ζégal à un octet serait comme en javascript "╬"coûte 1 octet
— dzaima

Réponses:

9

Java 8, 156 151 148 148 118 octets

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 octets en créant un port de réponse @raznagul C # (.NET Core) , après avoir joué au golf 5 octets.

Essayez-le en ligne.

Ancienne réponse de 148 octets:

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 octets grâce à @raznagul .

Explication:

Essayez-le ici.

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
source
Pouvez-vous enregistrer des octets avec des codes d'échappement / char au lieu de les coder en dur?
— TheLethalCoder
@TheLethalCoder Peut-être, mais puisque l'état de la règle de défi nous pouvons compter les symboles comme 1 octet chacun, il est probablement plus court comme celui-ci (d'où le compte de 156 octets au lieu du 176 réel). Mais n'hésitez pas à essayer certaines choses pour le raccourcir avec les char-codes.
— Kevin Cruijssen
Ah, j'ai raté cette partie des règles.
— TheLethalCoder
2
+1 pour l' -->opérateur va à ( ).
— raznagul
1
Si vous utilisez i-->3, i-->2et j-->3´ you can save 5 bytes by removing the n- = 3` et n+1.
— raznagul
7

Charbon de bois , 34-5 = 29 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. La réduction de 5 octets concerne les caractères de dessin de boîte.

ReflectOverlapOverlap(0)devrait être équivalent à ReflectMirror()mais à la place, Charcoal fait juste un à la ReflectTransform()place, sinon cette solution fonctionnerait également pour n=3. Voici une solution de contournement qui montre ce qui se passerait n=3pour 38 - 5 = 33 octets:

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

Mieux encore, si cela ReflectOverlapOverlap(0)fonctionne, mais je n'ai pas pris la peine de le supporter n=3, je pourrais le faire pour 31 - 4 = 27 octets:

Ａ⁻Ｎ³γＵＢ╬↓×╠γ╚×╩γ‖ＢＯγ‖ＢＯ↑⁻γ¹
— Neil
source
1
Hmm, ne connaissait Charcoal reflète également des miroirs / ╠à ╣et tels. " Le compteur d'octets de Charcoal ne fonctionne pas pour une raison quelconque. " Peut-être que le compteur d'octets de Charcoal ne fonctionne pas parce que ces caractères ne font pas partie de sa page de code? Vous pouvez les compter comme 1 octet chacun selon les règles du défi, donc c'est en effet 27.
— Kevin Cruijssen
@KevinCruijssen Cela dépend de l'opérateur que vous utilisez. (Je dois revenir en arrière et revérifier à chaque fois; il y en a un certain nombre et cela devient déroutant ...)
— Neil
@Neil Oups, c'est un bug, corrigera dès que possible. Merci de l'avoir trouvé!
— ASCII uniquement
@Neil Aussi pour une raison quelconque, il est cassé lorsque n = 4
— ASCII uniquement
1
— ASCII uniquement
6

Haskell, 75 octets

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

Essayez-le en ligne!

La fonction wprend un entier iet une liste où aest le premier, ble deuxième élément et cle reste de la liste et crée une nouvelle liste a, suivie de i-3copies de b, suivie de c. Appliquer d' wabord sur chaque élément de la liste ["╔╦╗\n","╠╬╣\n","╚╩╝"], puis à nouveau (avec iaugmenté de 1) sur la liste résultante. Concaténer en une seule liste.

— nimi
source
Qu'est-ce que l'opérateur <$? Est-ce juste >> avec les arguments retournés?
— Aneesh Durg
@AneeshDurg: <$est originaire de Data.Functoret a été intégré Prelude. C'est presque la même chose que >>. a <$ bremplace chaque élément de bwith a, alors qu'il b >> as'attend aà être une liste et concatène la longueur des bcopies dea . [1,2] >> "aa"-> "aaaa", "aa" <$ [1,2]-> ["aa","aa"]. Remarque: 'x' <$ [1,2]est égal à [1,2] >> "x".
— nimi
5

Vim, 29 octets

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

Puisqu'il y a des caractères de contrôle, voici un vidage 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

Essayez-le en ligne! (L'interpréteur V semble avoir des problèmes avec les caractères exotiques, de sorte que le lien utilise des caractères plus banals.)

Explication

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
— Jordan
source
Pour confirmer: est-ce seulement l'interprète TIO qui s'étouffe avec les symboles?
— Shaggy
@Shaggy Ouais, il lance une erreur Python sur Latin-1, pas une erreur Vim. (J'ai utilisé la page V juste parce que TIO n'a pas de page Vim simple, et je pense que V utilise le latin-1.) Vim sur ma machine n'a aucun problème avec les caractères.
— Jordan
5

GNU sed, 74 + 1 = 75 octets

+1 octet pour le -rdrapeau. Prend la saisie comme un nombre unaire.

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

Essayez-le en ligne!

Explication

C'est assez simple. Supposons que l'entrée soit 6 (unaire 111111). La première ligne laisse tomber quatre 1s et transforme l'entrée restante en ceci:

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

La troisième ligne, en boucle, remplace chaque 1 par le caractère qui la précède. Cela crée nos colonnes:

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

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

...

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

Notez que cela a également dupliqué le ;caractère. Enfin, la cinquième ligne, en boucle, remplace chaque ;caractère par une copie de la ligne qui suit:

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

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

╔╦╦╦╗
╠╬╬╬╣
╠╬╬╬╣
╠╬╬╬╣
╠╬╬╬╣
╚╩╩╩╝
— Jordan
source
4

Gelée , 33 octets

... est-ce 33? - il en coûte 5 pour convertir des littéraux de chaîne d'un octet (index de page de code) en caractères Unicode.

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

Un programme complet imprimant le résultat.

Essayez-le en ligne!

Comment?

_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
source
@Shaggy - J'utilise 9 octets pour représenter les caractères à l'intérieur des littéraux de chaîne - ce sont des index de page de code. Les 5 octets avant le Yà la fin, +⁽"7Ọajoute 9556 à ceux-ci, puis convertit en caractères. Sont-ils (les 5) gratuits? J'ai l'impression que ce serait la même chose que si je pouvais utiliser directement les caractères Unicode. (Je pourrais également utiliser des caractères réels plutôt que des index de page de code et utiliser un mappage pour plus d'octets).
— Jonathan Allan
Nan. Après discussion, il a été conclu que seul le caractère lui-même peut toujours être compté comme 1, pas toute autre représentation.
— Erik the Outgolfer
3

Python 3 , 75 octets

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

Essayez-le en ligne!

— Leaky Nun
source
Vous pouvez le n-3n=int(input())-3;print("╔"+"╦"*n+"╗\n"+("╠"+"╬"*n+"╣\n")*(n+1)+"╚"+"╩"*n+"╝")
— jouer
Est également n+1équivalent à -~n.
— Leaky Nun
3

Dyalog APL, 71 octets

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

Essayez-le en ligne!

— Uriel
source
Vous pouvez certainement jouer au golf. Par exemple, vous pouvez toujours remplacer (some expr)f Ypar Y f⍨ some expr.
— Adám
@ Adám je sais, c'est en cours, je ne suis pas sur ordinateur actuellement
— Uriel
3

Japt , 60 52 49 48 36 octets

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

Essayez-le en ligne!

Une autre version (47 octets + -R drapeau)

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

A besoin de -R drapeau (ajouté au champ de saisie).Essayez-le en ligne!

Comment ça marche?

Parce que je supposais à l'origine que les «caractères de porte» coûtaient plus d'un octet, je me suis dit que je pouvais économiser quelques octets en les codant. Ensuite, j'ai soustrait 9500 des codes de caractères, ce qui m'a laissé les caractères 8J; DPG >MA, qui ne coûtaient qu'un octet chacun. Ensuite, je pourrais simplement ajouter 9500 à chaque code de caractère, et tout irait bien.

 "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.
— Luc
source
Oh, ouais, tu as raison.
— Luke
— Shaggy
2

Swift, 161 octets

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

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

Vous pouvez essayer cette réponse ici

— Caleb Kleveter
source
2

QBIC , 78 octets

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

Heureusement, tous les symboles utilisés dans out cell door se trouvent sur la page de code QBasic.

Explication

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

Exemple de sortie

Command line: 7

╔╦╦╦╦╗
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╠╬╬╬╬╣
╚╩╩╩╩╝
— steenbergh
source
1
+1 pour l'utilisation d'une langue qui les contient en fait comme un octet dans sa page de codes par défaut.
— Joshua
Pouvez-vous ajouter un TIO (ou équivalent)?
— Shaggy
— steenbergh
1
Oh oui! Je m'en souviendrai finalement, je le promets! : D
— Shaggy
@Shaggy bien, ne t'habitue pas trop à l'idée. Je viens de trouver une version Emscripten fonctionnelle de Dosbox exécutant QBasic. J'essaierai d'orienter cela vers le QBIC dans le mois à venir, donc un env Web pourrait arriver ...
— steenbergh
2

PHP , 131 octets, 113 caractères

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

Essayez-le en ligne!

PHP , 133 octets, 115 caractères

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

Essayez-le en ligne!

— Jörg Hülsermann
source
2

JavaScript (ES6), 86 octets

C'est beaucoup plus long que l'autre réponse JS , mais je voulais l'essayer avec une autre méthode.

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)

Comment?

Nous attribuons un poids à chaque bord de la grille: 1 pour la droite, 2 pour la gauche, 3 pour le bas et 6 pour le haut. La somme des poids donne l'indice du caractère à utiliser.

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

Démo

Afficher l'extrait de code

— Arnauld
source
2

JavaScript (ES6), 80 74 octets

n=>`╔${"╦"[a="repeat"](n-=3)}╗${`
╠${"╬"[a](n)}╣`[a](n+1)}
╚${"╩"[a](n)}╝`
— Luc
source
Vous pouvez compter les symboles comme un octet chacun, ce qui fait 80 octets. Et vous devriez être en mesure de mieux utiliser les littéraux de modèle pour économiser quelques octets;)
— Shaggy
Vous ne pouvez compter les symboles comme un octet que si vous pouvez trouver une implémentation ES6 qui acceptera nativement l'entrée CP437.
— user5090812
@ user5090812, c'est une allocation spécifique à ce défi.
— Shaggy
@ user5090812 Inutile de trouver cette implémentation, car les règles de défi indiquent " Aux fins de ce défi, dans les langues où les symboles utilisés pour la" porte "prennent plusieurs octets, ils peuvent être comptés dans votre score comme un seul octet chacun. "Donc, cela a un nombre d'octets de 80 octets au lieu de 98 (si j'ai compté correctement).
— Kevin Cruijssen
Eh bien, c'est une mauvaise règle. Il supprime toute incitation à rechercher une meilleure façon de stocker les personnages.
— Luke
2

Rubis, 54 52 octets

-2 octets grâce à ymbirtt.

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

Essayez-le en ligne!

Non golfé

C'est super ennuyeux:

->n{
   ?╔ + ?╦ * (n-=3) + "╗\n" + 
  (?╠ + ?╬ * n      + "╣\n") * -~n + 
   ?╚ + ?╩ * n      + ?╝
}
— Jordan
source
Vous pouvez raccourcir (n+1)un peu en écrivant -~n- la priorité des opérateurs vous permettra également de sauvegarder les crochets.
— ymbirtt
2

Java 8, 102 + 101 octets

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

Voici un autre répéteur de chaîne de la même longueur:

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

Essayez-le en ligne!

— Roberto Graham
source
Pas mal, vous pouvez rendre votre approche encore plus faible que ma réponse. Tout d'abord, vous pouvez le réduire à 78 + 72 octets (150 au total) en utilisant une méthode Java 7 au lieu de BiFunction: n->{n-=3;return"╔"+r("╦",n)+"╗\n"+r("╠"+r("╬",n)+"╣\n",-~n)+"╚"+r("╩",n)+"╝";}et String r(String c,int n){return c.valueOf(new char[n]).replace("\0",c);} essayez-le en ligne. Et la deuxième méthode peut également être modifiée en String r(String c,int n){String r=c;for(;n-->1;r+=c);return r;}(63 octets), elle devient donc 141 octets au total
— Kevin Cruijssen
Correction, vous pouvez même le réduire à 130 octets : n->"╔"+r("╦",n-=3)+"╗\n"+r("╠"+r("╬",n)+"╣\n",-~n)+"╚"+r("╩",n)+"╝"et l' String r(String c,int n){String r=c;for(;n-->1;r+=c);return r;} essayer en ligne.
— Kevin Cruijssen
2

C # (.NET Core) , Score 123 (141 octets) Score 118 (136 octets)

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

Essayez-le en ligne!

-5 octets grâce à @KevinCruijssen

Explication:

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
source
1
Belle réponse, +1 de ma part. Je sais que cela fait un moment, mais vous pouvez jouer au golf 5 octets de plus en changeant b+="╣\n";c+="╝";for(;n-->2;)a+=b;return a+c;};pour for(b+="╣\n";n-->2;)a+=b;return a+c+"╝";} Essayer en ligne.
— Kevin Cruijssen
@KevinCruijssen: Merci.
— raznagul
2

Stax , 23 octets

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

Exécuter et déboguer

Voici la version non golfée. De manière amusante, il est en fait plus petit pour stax de ne pas utiliser les caractères littéraux, car les inclure comme littéraux empêcherait le remplissage de la source.

"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

Exécutez celui-ci

— récursif
source
1

Mathematica, 106 octets

(T[a_,b_,c_]:=a<>Table[b,#-3]<>c;w=Column;w[{T["╔","╦","╗"],w@Table[T["╠","╬","╣"],#-2],T["╚","╩","╝"]}])&
— J42161217
source
Pourriez-vous ajouter un TIO (ou équivalent)?
— Shaggy
1
goto sandbox.open.wolframcloud.com/app/objects collez le code (ctrl + v), ajoutez [8] à la fin et appuyez sur Maj + Entrée
— J42161217
Il semble y avoir un saut de ligne supplémentaire entre chaque ligne, aurais-je raison de dire que c'est un problème avec le rendu de la sortie, plutôt qu'avec la sortie elle-même?
— Shaggy
@Shaggy wolfram cloud affiche tous les personnages d'une manière amusante et déformée, ce n'est donc pas la meilleure façon de présenter de telles tâches.il n'y a pas de lignes supplémentaires et tout semble correct sur mathématique. copiez et collez votre cas de test pour vérifier. Je l'ai fait et ils ont l'air identiques
— J42161217
1

oK, 38 caractères

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

Essayez-le en ligne.

k ne semble pas vouloir bien gérer unicode, j'ai donc opté pour oK.

— zgrep
source
1

Lot, 126 octets

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

Fonctionne en CP437 ou CP850. Cela ressemble à ces pages de codes:

@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
source
1

Rétine , 56 50 octets

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

Essayez-le en ligne! Fonctionne en construisant un carré de ╬s puis en fixant les bords (en particulier trois colonnes sont supprimées lorsque les côtés sont ajoutés).

— Neil
source
1

PowerShell , 67 octets

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

Prend l'entrée $args[0], soustrait 3, enregistre cela dans $x, utilise cela dans la construction du haut de la porte pour sortir le nombre approprié de sections centrales. Ensuite, nous sortons les lignes du milieu, dont nous avons $x+1de. Enfin, la rangée du bas est similaire à la rangée du haut. Tous ceux-ci sont laissés sur le pipeline, et l'impliciteWrite-Output insère une nouvelle ligne entre les éléments gratuitement.

Essayez-le en ligne!

— AdmBorkBork
source
1

Perl 5 , 61

60 caractères de code (90 y compris les caractères de porte multi-octets) + 1 pour -p

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

Essayez-le en ligne!

— Xcali
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.