Crea una scatola appuntita

31

Dati due numeri interi positivi, W e H, emettono una casella di arte ASCII il cui bordo è costituito da barre ( /e \) con W "punte" sui bordi superiore e inferiore e H "punte" sui bordi sinistro e destro. L'interno della scatola è pieno di spazi.

Uno "spike" è semplicemente due barre che si uniscono per formare una forma di freccia:

/\    \/

/      \
\      /

Quindi l'output per W = 4, H = 3sarebbe

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

in quanto vi sono 4 punte nella parte superiore rivolta verso l'alto, 4 nella parte inferiore rivolta verso il basso, 3 a sinistra che punta a sinistra e 3 a destra che punta a destra.

Ecco alcune altre coppie input / output:

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

Nessuna linea nell'output dovrebbe avere spazi iniziali o finali. Opzionalmente potrebbe esserci una nuova riga finale.

Vince il codice più breve in byte.

code-golf  string  ascii-art  integer 
— Hobby di Calvin
fonte
Qualcuno che javascript può creare uno snippet di stack per questo?
— FantaC,

Risposte:

15

Carbone , 9 byte

ＢײＮײＮ/\

Provalo online!

Spiegazione

Ｂ           Box
  ײＮ       Next input as number * 2
      ײＮ   Next input as number * 2
          /\ With border "/\"
— ASCII-only
fonte
3
Naturalmente Charcoal ha un built-in per 'draw box'
— benzene
1
@benzene È stato un po 'fortunato che di recente abbia aggiunto la possibilità di disegnare una stringa arbitraria attorno alla scatola, ma anche prima di allora c'erano risposte come codegolf.stackexchange.com/a/120065
— Neil
1
@Neil aspetta di recente? Quando? (Conosco meno bene il carbone, grazie? Haha)
— ASCII il
@ ASCII-only My bad! Mi sono confuso a causa del cambiamento che ha regredito il posizionamento del cursore. (La modifica che ha introdotto la stringa di confine arbitraria è stata ca904b0 che era quasi un anno fa.)
— Neil
@benzene Senza il box incorporato sono ancora solo 13 byte: Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(accetta input in altezza, ordine di larghezza).
— Neil,
11

MATL , 18 byte

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

Provalo su MATL Online!

Spiegazione

Considerate ingressi W = 4, H = 3. Il codice crea i vettori di riga [1 2 3 4 5 6 7 8](intervallo da 1a 2*W) e [1 2 3 4 5 6](intervallo da 1a 2*H). Trasporre il secondo e aggiungerlo al primo con la trasmissione dà 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'indicizzazione modulare nella stringa \/produce il risultato desiderato nel bordo matrice:

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

Per rimuovere i valori non di frontiera, li impostiamo su 0(quando interpretato come carattere viene visualizzato come spazio):

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

Codice commentato:

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

Haskell , 90 88 87 82 byte

1 6 byte salvati grazie a Lynn

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

Provalo online!

Mi sento ancora molto a lungo, vedrò cosa posso fare.

— Mago del grano
fonte
La definizione a#b=[a..b]e la sostituzione di tutte le occorrenze consente di risparmiare un byte:a#b=[a..b];x!y|i<-2#x>>" "=(1#x>>"/\\"):(2#y>>['\\':i++"/",'/':i++"\\"])++[1#x>>"\\/"]
— Lynn
Oh, in a#b=[1..a]>>b;x!y|i<-(x-1)#" "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]realtà salva 6 ~
— Lynn il
@Lynn Grazie! Ultimamente mi stai prendendo in giro.
— Mago del grano
@Lynn L'ho fatto funzionare ma a costo di un altro byte.
— Wheat Wizard
5

05AB1E , 14 byte

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

Provalo online!

Spiegazione

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

Questo crea solo l'angolo in alto a sinistra, x caratteri larghi e y caratteri alti. Quindi rispecchia questo su entrambi gli assi:

x=3, y=2

/\/|
\  |
---+
— kalsowerus
fonte
4

JavaScript (ES6), 84 byte

Accetta input nella sintassi del curry (w)(h).

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

dimostrazione

Mostra snippet di codice

— Arnauld
fonte
3

Swift 3 , 166 byte

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 di test completa.

La versione di chiusura è un po 'più lunga, purtroppo (175 byte):

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 di test con la versione di chiusura.

— Mr. Xcoder
fonte
3

Retina , 77 73 byte

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

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

Provalo online! Il link include casi di test. Accetta input nel formato <height> <width>. Spiegazione:

\d+
$*

Converti gli input in unario.

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

Moltiplica gli input, ma aggiungi una nuova riga in modo che il risultato sia un rettangolo.

1
/\

Crea la cima appuntita.

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

Duplica ogni riga appuntita, ma con l'offset delle punte sulla seconda riga.

¶$

Elimina le nuove righe finali.

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

Elimina l'interno della scatola. (Nota lo spazio sull'ultima riga.)

— Neil
fonte
3

Excel, 95 byte

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

APL (Dyalog) , 41 39 byte

Richiede un elenco di [H,W]

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

Provalo online!

⎕-1 richiesta di input (mnemonico: console stilizzata) e sottrazione 1

2× moltiplicare per due

''⍴⍨ usalo per rimodellare una stringa vuota (pad con spazi)

⊢ cedere che (serve a separarlo da 4)

{... }⍣4 applica la seguente funzione quattro volte:

 ≢⍵ calcolare (lunghezza di) l'argomento

 '/\'⍴⍨ ciclicamente r eshape "/\"a quella lunghezza

 ⍵, aggiungilo al lato destro dell'argomento

 ⌽⍉ trasporre e specchiare (ovvero ruotare di 90 °)

¯1⌽1 ciclicamente ruotare il 1 ° passaggio di una riga verso destra

⊢ cedere che (serve a separarlo da 1)

'\'@2@1 mettere un backslash alla 2 ° posizione del 1 ° voce importante.

— Adamo
fonte
3

C (gcc) ,170 166 158 155 108 105

-3 byte grazie a 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);}

Provalo online!

Penso che questo possa essere ulteriormente approfondito con un approccio meno semplice, vedrò cosa posso fare quando trovo il tempo.

Ok, non riesco a trovare nessun altro modo per ridurre il numero di byte per quel codice.

Spiegazione: un semplice doppio giro che stampa il carattere della scatola per carattere.

Quando si stampa un bordo: se entrambe le coordinate xey sono pari o dispari, viene visualizzato a /, altrimenti \viene visualizzato a

Se non un bordo, viene invece visualizzato un carattere spazio

— scottinet
fonte
1
Puoi radere altri 3 byte spostando puts("")il primo nel ciclo in questo modox,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 Grazie!
— scottinet,
3

/// , 172 117 byte

Quindi, perché l'uscita è costituita da ///s e whitespaces, ci dovrebbe essere lavori in quei 2 lingue.

Inserisci l'input dopo il codice W,Hcome numero unario (è consentito unario per /// , grazie a Challenger5 per il suggerimento) (usa *per rappresentare il ,formato , separato con ).

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

Provalo online! (con input W=4, H=3)

— user202729
fonte
È possibile saltare l'analisi analizzando input in Unary .
— Esolanging Fruit,
Inoltre, dovrei menzionare che questo è davvero impressionante! Buon lavoro!
— Esolanging Fruit,
2

Python 3 , 87 82 byte

Modifica: 5 byte salvati grazie a @officialaimm , @ Mr.Xcoder e @tsh

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

Provalo online!

— Halvard Hummel
fonte
— officialaimm,
Se vuoi mantenerlo in Python 3, *(b-1)può essere *~-b, per -2 byte.
— Mr. Xcoder,
2
@officialaimm Why " "*2*~-a? Basta "__"*~-a.
— TSH
@tsh Sì, hai ragione ... Haha non si è reso conto che ...
— officialaimm il
@officialaimm lo manterrà Python 3, tuttavia ha salvato alcuni byte grazie a te, Mr.Xcoder e tsh
— Halvard Hummel,
2

J, 48 byte

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

ungolfed

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

spiegazione

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

Provalo online!

— Giona
fonte
1
33 byte ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:. Amend è fantastico qui.
— miglia
ooooh, miglioramento molto bello
— Giona
1
30 byte '/\ '{~2(<,~<<0 _1)}2|+/&i.&+:con alcuni refactoring
— miglia
2

Java 8, 141 byte

Una lambda al curry dalla larghezza all'altezza all'uscita.

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

Provalo online (no, return t+i+o;non era intenzionale)

Lambda ungolfed

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

Questa soluzione è atipicamente esigente per le dimensioni dell'input poiché charviene utilizzata per contare fino all'input della larghezza. Fortunatamente, l'algoritmo è abbastanza grave che a tali dimensioni il completamento del programma è probabilmente già un problema. Ho scelto di utilizzare charper l'indice del ciclo in modo da poterlo riutilizzare in seguito come alias economico per '\n'.

— Jakob
fonte
2

SOGL V0.12 , 22 21 13 byte

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

Provalo qui! (si aspetta entrambi gli input in pila così ..(e" poiché una stringa non è stata avviata in modo esplicito) - prendere il numero input due volte viene aggiunto per facilità d'uso)

Spiegazione:

/\”            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
fonte
>: D non batte il carbone qui
— solo ASCII il
@ ASCII-only perché il carbone ha un built-in per questo: p (e SOGLs fatti davvero per sfide complesse e lunghe comunque)
— dzaima
1

Mathematica, 87 byte

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

Provalo in Matematica (stampa spazi extra all'inizio della maggior parte delle linee per qualche motivo) o nella sandbox Wolfram ! Accetta due numeri interi come input.

È una soluzione abbastanza ingenua, ma tutte le cose intelligenti che ho provato avevano più byte. Qualcosa che quasi funziona è

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

eccetto che fallisce se una delle dimensioni è 1 (l'input è un elenco contenente le dimensioni).

— Non un albero
fonte
1

J , 39 byte

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

Provalo online!

Prende due argomenti come heightsu LHS e widthsu RHS.

— miglia
fonte
Bel lavoro, come al solito. Approccio interessante anche.
— Giona,
@Jonah No, la tua idea è molto meglio usando un emendamento. Se combinato con la metà della mia ...
— miglia
1

VBA (Excel), 161 byte

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
fonte
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
Versione anonima della funzione finestra immediata di cui sopra (113 byte):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 byte 152 byte

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

Provalo online!

Grazie BLT per la rasatura di 8 byte.

— marchio
fonte
Usi mai la sfunzione?
— BLT,
La funzione s è ciò che chiami per creare la spikey box
— Mark
1
Fatto. È possibile arrivare a 152 byte se si rimuovono spazi bianchi e s=bit. Sono ammesse funzioni anonime.
— BLT,
Buono a sapersi che sono consentite funzioni anonime
— Marco
0

dc , 123 byte

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

È tutt'altro che il più corto, ma, se si prendono le ultime due linee e le ruotano in pi/2senso orario in posizione "verticale", sembra un totem .

Accetta l'input come due numeri interi separati da spazio.

Provalo online!

— R. Kap
fonte
1
Attualmente la risposta più lunga qui. Pensavo fosse il lavoro di Java ...
— R. Kap
Non preoccuparti, ora c'è una soluzione Java ed è più lunga.
— Jakob,
0

Mathematica, 116 byte

(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&
— J42161217
fonte
Rotate[w,Pi]è equivalente a w~Rotate~Pi, come è o["/\\",#]a"/\\"~o~#
— Jonathan Frech
Conosco la notazione infix e la uso sempre quando ho davvero bisogno di 1 byte. In questo caso la lascio andare ... ;-)
— J42161217
2
Non avevo dubbi sulla tua conoscenza della notazione infix; Volevo solo ridurre il numero di byte. Sai, nello spirito del golf e simili.
— Jonathan Frech,
0

V , 18 byte

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

La risposta non richiederebbe le sole colonne del carattere llse <M-h>ollowlasciate da sole :(

Provalo online!

— nmjcman101
fonte
0

C # (.NET Core) , 188 byte

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

Il conteggio dei byte include anche:

using System.Linq;

Provalo online!

Ho iniziato a dare spiegazioni comando per comando, ma ha smesso di avere senso a metà strada. L'essenza di base è quella di creare una scatola piena appuntita, quindi svuotare il centro. Ho usato Linq per usare Linq, probabilmente può essere più breve usando solo iterazioni standard.

Ecco la spiegazione che va al centro (il comando più interno per primo): per
prima cosa, crea le righe per l'intero riquadro e concatena in una singola stringa

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

Quindi prendi ogni carattere in una riga e, se non è il contorno del riquadro, sostituiscilo con lo spazio, concatenali in una stringa per ogni riga

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

Infine, ottieni ogni riga e concatenale insieme alle nuove righe (include anche la generazione di una raccolta per le righe)

string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));
— Grzegorz Puławski
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.