Faire une boîte épineuse

31

Étant donné deux entiers positifs, W et H, affichez une boîte de type ASCII dont la bordure est faite de barres obliques ( /et \) avec W "pointes" sur les bords supérieur et inférieur, et H "pointes" sur les bords gauche et droit. L'intérieur de la boîte est rempli d'espaces.

Un "pic" est simplement deux barres obliques qui se rejoignent pour former une forme de flèche:

/\    \/

/      \
\      /

Ainsi, la sortie pour W = 4, H = 3serait

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

car il y a 4 pointes en haut pointant vers le haut, 4 en bas pointant vers le bas, 3 à gauche pointant vers la gauche et 3 à droite pointant vers la droite.

Voici quelques autres paires d'entrée / sortie:

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
/\/\/\/\
\      /
/      \
\      /
/      \
\      /
/      \
\      /
/      \
\/\/\/\/

Aucune ligne dans la sortie ne doit avoir d'espaces de début ou de fin. Il peut éventuellement y avoir une nouvelle ligne de fin.

Le code le plus court en octets gagne.

code-golf string ascii-art integer Les passe-temps de Calvin
la source
Est-ce que quelqu'un qui javascripts peut créer un extrait de pile pour cela?
FantaC

Réponses:

15

Fusain , 9 octets

ＢײＮײＮ/\

Essayez-le en ligne!

Explication

Ｂ           Box
  ײＮ       Next input as number * 2
      ײＮ   Next input as number * 2
          /\ With border "/\"
ASCII seulement
la source
3
Bien sûr, le charbon de bois a une boîte de tirage intégrée
benzène
1
@benzene Il a été assez heureux qu'il ait récemment ajouté la possibilité de dessiner une chaîne arbitraire autour de la boîte, mais même avant cela, il y avait des réponses telles que codegolf.stackexchange.com/a/120065
Neil
1
@Neil a attendu récemment? Quand? (Est-ce que je connais moins bien le charbon de bois, merci? Haha)
ASCII uniquement
@ ASCII uniquement Mon mauvais! Je suis devenu confus à cause du changement qui a régressé le positionnement du curseur. (Le changement qui a introduit la chaîne de bordure arbitraire était ca904b0 il y a presque un an.)
Neil
@benzene Sans la boîte intégrée, il ne reste que 13 octets: Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(prend l'entrée en hauteur, ordre de largeur).
Neil
11

MATL , 18 octets

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

Essayez-le sur MATL Online!

Explication

Tenez compte des entrées W = 4, H = 3. Le code construit les vecteurs de ligne [1 2 3 4 5 6 7 8](plage de 1à 2*W) et [1 2 3 4 5 6](plage de 1à 2*H). Transposer ce dernier et l'ajouter au premier avec diffusion donne la matrice

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

L'indexation modulaire dans la chaîne \/produit le résultat souhaité dans la bordure de la matrice:

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

Pour supprimer les valeurs non frontières, nous les définissons sur 0(lorsqu'il est interprété comme char, il est affiché comme un espace):

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

Code commenté:

'\/'    % 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
la source
7

Haskell , 90 88 87 82 octets

1 6 octets enregistrés grâce à Lynn

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

Essayez-le en ligne!

Ça me semble encore très long, je vais voir ce que je peux faire.

Assistant de blé
la source
La définition a#b=[a..b]et le remplacement de toutes les occurrences permettent d'économiser un octet: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#"\\/"]sauve en fait 6 ~
Lynn
@Lynn Merci! Vous m'avez vraiment rattrapé récemment.
Wheat Wizard
@Lynn Je l'ai fait fonctionner mais au prix d'un autre octet.
Wheat Wizard
5

05AB1E , 14 octets

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

Essayez-le en ligne!

Explication

„/\|∍`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

Cela ne crée que le coin supérieur gauche, x caractères de large et y caractères de haut. Il reflète ensuite cela sur les deux axes:

x=3, y=2

/\/|
\  |
---+
kalsowerus
la source
4

JavaScript (ES6), 84 octets

Prend des entrées dans la syntaxe de currying (w)(h).

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

Démo

Afficher l'extrait de code

Arnauld
la source
3

Swift 3 , 166 octets

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

Suite de tests complète.

La version de fermeture est un peu plus longue, malheureusement (175 octets):

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

Suite de tests avec la version de fermeture.

M. Xcoder
la source
3

Rétine , 77 73 octets

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

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

Essayez-le en ligne! Le lien inclut des cas de test. Prend l'entrée au format <height> <width>. Explication:

\d+
$*

Convertissez les entrées en unaire.

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

Multipliez les entrées, mais ajoutez une nouvelle ligne pour que le résultat soit un rectangle.

1
/\

Créez le haut hérissé.

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

Dupliquez chaque ligne épineuse, mais avec les pointes décalées sur la deuxième ligne.

¶$

Supprimez les sauts de ligne de fin.

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

Supprimez l'intérieur de la boîte. (Notez l'espace sur la dernière ligne.)

Neil
la source
3

Excel, 95 octets

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

APL (Dyalog) , 41 39 octets

Demande une liste de [H,W]

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

Essayez-le en ligne!

⎕-1 invite pour la saisie (mnémonique: console stylisée) et soustraire 1

2× multiplier par deux

''⍴⍨ utiliser cela pour remodeler une chaîne vide (tampons avec des espaces)

⊢ rendement qui (sert à le séparer de 4)

{… }⍣4 Appliquez la fonction suivante quatre fois:

 ≢⍵ tally (longueur de) l'argument

 '/\'⍴⍨ cyclique r Eshape "/\"à cette longueur

 ⍵, ajouter cela à droite de l'argument

 ⌽⍉ transposer et miroir (c'est-à-dire tourner à 90 °)

¯1⌽1 faire pivoter cycliquement la 1 ère rangée d'un pas vers la droite

⊢ rendement qui (sert à le séparer de 1)

'\'@2@1 mettre une barre oblique inverse à la 2 e position du 1 er élément majeur.

Adam
la source
3

C (gcc) ,170 166 158 155 108 105

-3 octets grâce à 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);}

Essayez-le en ligne!

Je pense que cela peut être joué plus loin avec une approche moins simple, je verrai ce que je peux faire quand je trouverai le temps.

Ok, je ne trouve pas d'autre moyen de réduire le nombre d'octets pour ce code.

Explication: une simple boucle double imprimant la boîte char par char.

Lors de l'impression d'une bordure: si les coordonnées x et y sont paires ou impaires, elles affichent a /, sinon, a \s'affiche

S'il ne s'agit pas d'une bordure, un caractère espace s'affiche à la place

scottinet
la source
1
Vous pouvez raser 3 autres octets en déplaçant le puts("")dans la première boucle for comme cecix,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 Merci!
scottinet
3

/// , 172 117 octets

Donc, comme la sortie se compose de ///s et whitespaces, il devrait y avoir des soumissions dans ces 2 langues.

Mettez l'entrée après le code sous la W,Hforme d'un nombre unaire (unaire pour /// est autorisé , merci à Challenger5 pour la suggestion) (utilisez *pour représenter le chiffre, séparé avec ,) le format.

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

Essayez-le en ligne! (avec entrée W=4, H=3)

utilisateur202729
la source
Vous pouvez ignorer l'analyse en prenant des entrées dans Unary .
Esolanging Fruit
Je dois également mentionner que c'est très impressionnant! Bon travail!
Esolanging Fruit
2

Python 3 , 87 82 octets

Edit: 5 octets enregistrés grâce à @officialaimm , @ Mr.Xcoder et @tsh

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

Essayez-le en ligne!

Halvard Hummel
la source
81 octets en python 2 après quelques améliorations
officialaimm
Si vous voulez le garder en Python 3, cela *(b-1)peut être *~-b, pour -2 octets.
M. Xcoder
2
@officialaimm Pourquoi " "*2*~-a? Justement "__"*~-a.
tsh
@tsh Oui, vous avez raison ... Haha ne s'en rend pas compte ...
officialaimm
@officialaimm le gardera Python 3, mais a cependant économisé quelques octets grâce à vous, Mr.Xcoder et tsh
Halvard Hummel
2

J, 48 octets

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

non golfé

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

explication

                       (+:@[ $ (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

Essayez-le en ligne!

Jonas
la source
1
33 octets ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:. Modifier est super ici.
miles
ooooh, très belle amélioration
Jonah
1
30 octets '/\ '{~2(<,~<<0 _1)}2|+/&i.&+:avec quelques refactoring
miles
2

Java 8, 141 octets

Un lambda au curry de largeur en hauteur jusqu'à la sortie.

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

Essayez-le en ligne (non, ce return t+i+o;n'était pas intentionnel)

Lambda non golfé

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

Cette solution est atypiquement pointilleuse quant à la taille d'entrée car a charest utilisé pour compter jusqu'à la largeur entrée. Heureusement, l'algorithme est suffisamment mauvais pour qu'à ces tailles l'achèvement du programme soit probablement déjà un problème. J'ai choisi d'utiliser charl'index de boucle afin de pouvoir le réutiliser plus tard comme alias bon marché pour '\n'.

Jakob
la source
2

SOGL V0.12 , 22 21 13 octets

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

Essayez-le ici! (attend les deux entrées sur la pile donc ..(et "parce qu'une chaîne n'a pas été explicitement démarrée) - prendre le numéro d'entrée deux fois est ajouté pour faciliter l'utilisation)

Explication:

/\”            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
la source
>: D il ne bat pas Charcoal ici
ASCII uniquement
@ ASCII uniquement parce que le charbon de bois a une fonction intégrée pour cela: p (et les SOGL sont vraiment conçus pour des défis compliqués et longs de toute façon)
dzaima
1

Mathematica, 87 octets

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

Essayez-le en mathématiques (il imprime des espaces supplémentaires au début de la plupart des lignes pour une raison quelconque), ou au bac à sable Wolfram ! Prend deux entiers en entrée.

C'est une solution assez naïve, mais toutes les choses intelligentes que j'ai essayées avaient plus d'octets. Quelque chose qui fonctionne presque est

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

sauf qu'il échoue si l'une des dimensions est 1 (l'entrée est une liste contenant les dimensions).

Pas un arbre
la source
1

Pyth , 40 39 38 octets

+++*Q"/\\"b*tE+++K++\\*d*2tQ\/b_Kb*"\/

Cela prend les deux entiers séparés par une nouvelle ligne.

Suite de tests complète.

M. Xcoder
la source
1

J , 39 octets

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

Essayez-le en ligne!

Prend deux arguments comme heightsur le LHS et widthsur le RHS.

milles
la source
Beau travail, comme d'habitude. Approche intéressante aussi.
Jonah
@Jonah Non, votre idée est bien meilleure en utilisant amend. Si combiné avec la moitié du mien ...
miles
1

VBA (Excel), 161 octets

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
la source
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
Version anonyme de la fonction de fenêtre immédiate ci-dessus (113 octets):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 octets 152 octets

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

Essayez-le en ligne!

Merci BLT d'avoir rasé 8 octets.

marque
la source
Avez-vous déjà utilisé la sfonction?
BLT
La fonction s est ce que vous appelez pour créer la boîte à pointes
Mark
1
Je l'ai. Vous pouvez descendre à 152 octets si vous supprimez les espaces et le s=bit. Les fonctions anonymes sont autorisées.
BLT
Bon à savoir que les fonctions anon sont autorisées
Mark
0

dc , 123 octets

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

C'est loin d'être le plus court, mais, si l'on prend les deux dernières lignes et les fait tourner de pi/2radians dans le sens des aiguilles d'une montre jusqu'à une position "verticale", cela ressemble à un totem .

Prend l'entrée comme deux entiers séparés par des espaces.

Essayez-le en ligne!

R. Kap
la source
1
Actuellement, la réponse la plus longue ici. Je pensais que c'était le travail de Java ...
R. Kap
Ne vous inquiétez pas, il existe maintenant une solution Java et c'est plus long.
Jakob
0

Mathematica, 116 octets

(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&
J42161217
la source
Rotate[w,Pi]est équivalent à w~Rotate~Pi, comme o["/\\",#]à"/\\"~o~#
Jonathan Frech
Je connais la notation infixe et je l'utilise toujours quand j'ai vraiment besoin d'un octet.Dans ce cas, je la laisse aller ... ;-)
J42161217
2
Je ne doutais pas de votre connaissance de la notation infixe; Je voulais juste réduire le nombre d'octets. Vous savez, dans l'esprit du golf et autres.
Jonathan Frech
0

V , 18 octets

Ài/\Ùæ$Àäkllòjjkè

Réponse ne nécessiterait pas le llcas <M-h>ollowlaissé seul 2 colonnes char :(

Essayez-le en ligne!

nmjcman101
la source
0

C # (.NET Core) , 188 octets

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

Le nombre d'octets comprend également:

using System.Linq;

Essayez-le en ligne!

J'ai commencé à faire des explications commande par commande mais cela n'a plus de sens à mi-chemin ... L'essentiel est de faire une boîte pleine de pointes, puis de creuser le milieu. J'ai utilisé Linq dans le but d'utiliser Linq, peut probablement être plus court en utilisant seulement des itérations standard.

Voici une explication allant au milieu (la commande la plus interne en premier):
Tout d'abord, créez des lignes pour la boîte complète et concaténez en une seule chaîne

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

Ensuite, obtenez chaque caractère dans une ligne, et si ce n'est pas le contour de la boîte, remplacez-le par un espace, concaténez-les à nouveau dans une chaîne pour chaque ligne

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

Enfin, récupérez chaque ligne et concaténez-les avec des retours à la ligne (comprend également la génération d'une collection pour les lignes)

string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));
Grzegorz Puławski
la source