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
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
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
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é
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
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
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
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
source
3

Excel, 95 octets

=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)
— Wernisch
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
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
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
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
source
— 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
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
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
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
source
1

J , 39 octets

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

Essayez-le en ligne!

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

— milles
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
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
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
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
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

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