Zrób kolczaste pudełko

31

Biorąc pod uwagę dwie dodatnie liczby całkowite, W i H, generuje pole ASCII-art, którego ramka składa się z ukośników ( /i \) z W „pikami” na górnej i dolnej krawędzi oraz H „pikami” na lewej i prawej krawędzi. Wnętrze skrzynki jest wypełnione spacjami.

„Kolec” to po prostu dwa ukośniki łączące się w kształt strzałki:

/\    \/

/      \
\      /

Więc wynik W = 4, H = 3byłby

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

ponieważ na górze znajdują się 4 kolce skierowane w górę, 4 na dole skierowane w dół, 3 po lewej skierowane w lewo i 3 po prawej skierowane w prawo.

Oto kilka innych par wejścia / wyjścia:

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

Żadne wiersze na wyjściu nie powinny mieć spacji wiodących ani końcowych. Opcjonalnie może istnieć jedna nowa linia.

Najkrótszy kod w bajtach wygrywa.

code-golf  string  ascii-art  integer 
— Hobby Calvina
źródło
Czy ktoś, kto wykonuje skrypty javascript, może utworzyć w tym celu fragment kodu?
— FantaC

Odpowiedzi:

15

Węgiel , 9 bajtów

ＢײＮײＮ/\

Wypróbuj online!

Wyjaśnienie

Ｂ           Box
  ײＮ       Next input as number * 2
      ײＮ   Next input as number * 2
          /\ With border "/\"
— Tylko ASCII
źródło
3
Oczywiście węgiel drzewny ma wbudowany „draw box”
— benzen
1
@benzene To było trochę szczęśliwe, że ostatnio dodał możliwość narysowania dowolnego ciągu wokół pudełka, ale nawet wcześniej były odpowiedzi, takie jak codegolf.stackexchange.com/a/120065
— Neil
1
@Neil ostatnio czekać? Kiedy? (Czy znam węgiel gorszy, dziękuję? Haha)
— tylko ASCII
@ Tylko ASCII My bad! Byłem zdezorientowany z powodu zmiany, która spowodowała cofnięcie pozycjonowania kursora. (Zmiana, która wprowadziła dowolny ciąg graniczny, to około 904 b0, co było prawie rok temu.)
— Neil
@ Benzen Bez wbudowanego pola, nadal ma tylko 13 bajtów: Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(pobiera dane wejściowe w wysokości, kolejności szerokości).
— Neil
11

MATL , 18 bajtów

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

Wypróbuj w MATL Online!

Wyjaśnienie

Rozważmy wejść W = 4, H = 3. Kod buduje wektory wierszowe [1 2 3 4 5 6 7 8](zakres od 1do 2*W) i [1 2 3 4 5 6](zakres od 1do 2*H). Przeniesienie tego drugiego i dodanie do tego pierwszego z transmisją daje macierz

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

Modułowe indeksowanie w łańcuchu \/daje pożądany wynik w ramce macierzy:

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

Aby usunąć wartości bez obramowania, ustawiamy je na 0(interpretowane jako char jest wyświetlane jako spacja):

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

Skomentowany kod:

'\/'    % 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
źródło
7

Haskell , 90 88 87 82 bajtów

1 6 bajtów zapisanych dzięki Lynn

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

Wypróbuj online!

Nadal czuję się naprawdę długo, zobaczę, co mogę zrobić.

— Kreator pszenicy
źródło
Zdefiniowanie a#b=[a..b]i zastąpienie wszystkich wystąpień pozwala zaoszczędzić jeden bajt:a#b=[a..b];x!y|i<-2#x>>" "=(1#x>>"/\\"):(2#y>>['\\':i++"/",'/':i++"\\"])++[1#x>>"\\/"]
— Lynn,
Och, a#b=[1..a]>>b;x!y|i<-(x-1)#" "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]właściwie oszczędza 6 ~
— Lynn,
@Lynn Thanks! Ostatnio naprawdę łapiesz mój luz.
— Wheat Wizard
@ Lynn Mam go do pracy, ale kosztem innego bajtu.
— Wheat Wizard
5

05AB1E , 14 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Tworzy to tylko lewy górny róg, szerokość x znaków i wysokość y znaków. Następnie odzwierciedla to w obu osiach:

x=3, y=2

/\/|
\  |
---+
— kalsowerus
źródło
4

JavaScript (ES6), 84 bajtów

Pobiera dane wejściowe w składni curry (w)(h).

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

Próbny

Pokaż fragment kodu

— Arnauld
źródło
3

Swift 3 , 166 bajtów

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

Pełny zestaw testów.

Niestety wersja zamknięcia jest nieco dłuższa (175 bajtów):

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

Zestaw testowy z wersją zamknięcia.

— Pan Xcoder
źródło
3

Retina , 77 73 bajtów

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

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

Wypróbuj online! Link zawiera przypadki testowe. Pobiera dane wejściowe w formacie <height> <width>. Wyjaśnienie:

\d+
$*

Konwertuj wejścia na unary.

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

Pomnóż dane wejściowe, ale dodaj nowy wiersz, aby wynik był prostokątem.

1
/\

Stwórz kolczasty top.

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

Duplikuj każdy kolczasty rząd, ale z przesunięciem kolców w drugim rzędzie.

¶$

Usuń końcowe znaki nowej linii.

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

Usuń wnętrze pudełka. (Uwaga spacja w ostatnim wierszu.)

— Neil
źródło
3

Excel, 95 bajtów

=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)
— Wernisch
źródło
3

APL (Dyalog) , 41 39 bajtów

Monity o listę [H,W]

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

Wypróbuj online!

⎕-1 monit o wprowadzenie (mnemonic: stylizowana konsola) i odjęcie 1

2× pomnóż przez dwa

''⍴⍨ użyj tego, aby przekształcić pusty ciąg (pola ze spacjami)

⊢ wydajność, która (służy do jej oddzielenia 4)

{… }⍣4 Zastosuj następującą funkcję cztery razy:

 ≢⍵ Tally (długość) argumentu

 '/\'⍴⍨ cyklicznie r eshape "/\"tej długości

 ⍵, dołącz to po prawej stronie argumentu

 ⌽⍉ transpozycja i odbicie lustrzane (tj. obrót o 90 °)

¯1⌽1 cyklicznie obracaj pierwszy rząd o jeden krok w prawo

⊢ wydajność, która (służy do jej oddzielenia 1)

'\'@2@1 wprowadzić odwrotny ukośnik na 2 nd pozycji 1 st głównego elementu.

— Adám
źródło
3

C (gcc) ,170 166 158 155 108 105

-3 bajty dzięki 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);}

Wypróbuj online!

Myślę, że można to pograć w golfa przy mniej prostym podejściu. Zobaczę, co da się zrobić, kiedy znajdę czas.

Ok nie mogę znaleźć innego sposobu na zmniejszenie liczby bajtów dla tego kodu.

Objaśnienie: prosta podwójna pętla drukująca pole char po char.

Podczas drukowania ramki: jeśli współrzędne xiy są parzyste lub nieparzyste, wyświetla a /, w przeciwnym razie a\ wyświetla się a

Jeśli nie jest obramowaniem, zamiast niego wyświetlany jest znak spacji

— szkocki
źródło
1
Możesz ogolić kolejne 3 bajty, przenosząc puts("")pierwszy do pętli for w ten sposóbx,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 Thanks!
— scottinet,
3

/// , 172 117 bajtów

Ponieważ dane wyjściowe składają się z ///s i whitespaces, należy przesyłać dane w tych 2 językach.

Umieść dane wejściowe za kodem W,Hjako liczbę jednoznaczną (unary dla /// jest dozwolone , dzięki Challenger5 dla sugestii) (użyj *do przedstawienia cyfry, oddziel od ,).

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

Wypróbuj online! (z wejściem W=4, H=3)

— użytkownik202729
źródło
Możesz pominąć parsowanie, wprowadzając dane w Unary .
— Esolanging Fruit,
Powinienem też wspomnieć, że jest to bardzo imponujące! Dobra robota!
— Esolanging Fruit,
2

Python 3 , 87 82 bajtów

Edycja: Zapisano 5 bajtów dzięki @officialaimm , @ Mr.Xcoder i @tsh

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

Wypróbuj online!

— Halvard Hummel
źródło
— officialaimm
Jeśli chcesz zachować to w Pythonie 3, *(b-1)możesz być *~-bna -2 bajty.
— Mr. Xcoder,
2
@officialaimm Dlaczego " "*2*~-a? Właśnie "__"*~-a.
— tsh
@tsh Tak, masz rację ... Haha nie zdawała sobie z tego sprawy ...
— officialaimm
@officialaimm zachowa go w Pythonie 3, jednak zaoszczędził trochę bajtów ze względu na ciebie, Mr.Xcodera i tsh
— Halvard Hummel
2

J, 48 bajtów

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

bez golfa

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

wyjaśnienie

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

Wypróbuj online!

— Jonasz
źródło
1
33 bajty ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:. Amend jest tutaj świetny.
— mile
ooooch, bardzo fajna poprawa
— Jonah
1
30 bajtów '/\ '{~2(<,~<<0 _1)}2|+/&i.&+:z pewną refaktoryzacją
— mile
2

Java 8, 141 bajtów

Curled lambda od szerokości do wysokości do wyjścia.

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

Wypróbuj online (nie,return t+i+o; nie było zamierzone)

Niegolfowana lambda

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

To rozwiązanie jest nietypowo wybredne pod względem wielkości wejściowej, ponieważ a charsłuży do zliczania do szerokości wejściowej. Na szczęście algorytm jest na tyle zły, że przy tych rozmiarach ukończenie programu prawdopodobnie już stanowi problem. Zdecydowałem się użyć charindeksu pętli, aby móc go później użyć jako taniego aliasu '\n'.

— Jakob
źródło
2

SOGL V0.12 , 22 21 13 bajtów

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

Wypróbuj tutaj! (oczekuje obu danych wejściowych na stosie, więc ..(i" ponieważ ciąg nie został jawnie uruchomiony) - weź dwa razy dane wejściowe, aby ułatwić obsługę)

Wyjaśnienie:

/\”            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
źródło
>: D nie bije tutaj Węgla
— tylko ASCII
@ Tylko ASCII, ponieważ węgiel drzewny ma do tego wbudowane: p (a SOGL naprawdę stworzył dla skomplikowanych i długich wyzwań)
— dzaima
1

Mathematica, 87 bajtów

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

Wypróbuj w Mathics (z jakiegoś powodu drukuje dodatkowe spacje na początku większości linii) lub w piaskownicy Wolfram ! Pobiera na wejściu dwie liczby całkowite.

To dość naiwne rozwiązanie, ale wszystkie sprytne rzeczy, których próbowałem, miały więcej bajtów. Coś, co prawie działa

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

z wyjątkiem tego, że nie powiedzie się, jeśli jeden z wymiarów ma wartość 1 (wejście to lista zawierająca wymiary).

— Nie drzewo
źródło
1

J , 39 bajtów

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

Wypróbuj online!

Przyjmuje dwa argumenty, jak heightw przypadku LHS i widthRHS.

— mile
źródło
Dobra robota, jak zwykle. Ciekawe podejście.
— Jonasz
@Jonah Nie, twój pomysł jest znacznie lepszy przy użyciu poprawki. W połączeniu z połową mojej ...
— mile,
1

VBA (Excel), 161 bajtów

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
źródło
Grał w golfa (139 bajtów):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
Anonimowa wersja funkcji bezpośredniego okna powyżej (113 bajtów):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 bajtów 152 bajty

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

Wypróbuj online!

Dzięki BLT za golenie 8 bajtów.

— znak
źródło
Czy korzystasz kiedykolwiek z tej sfunkcji?
— BLT
Funkcja s jest tym, co nazywasz, aby zrobić kolczaste pudełko
— Mark
1
Rozumiem. Możesz usunąć do 152 bajtów, jeśli usuniesz spację i s=bit. Funkcje anonimowe są dozwolone.
— BLT
Dobrze wiedzieć, że funkcje anonowe są dozwolone
— Mark
0

dc , 123 bajty

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

Jest daleki od najkrótszego, ale jeśli weźmie się dwie ostatnie linie i obróci je pi/2radianami zgodnie z ruchem wskazówek zegara do pozycji „pionowej”, to wygląda to jak słup totemu .

Pobiera dane wejściowe jako dwie liczby całkowite oddzielone spacjami.

Wypróbuj online!

— R. Kap
źródło
1
Obecnie najdłuższa odpowiedź tutaj. Myślałem, że to jest praca Javy ...
— R. Kap.
Nie martw się, teraz jest rozwiązanie Java i jest ono dłuższe.
— Jakob
0

Mathematica, 116 bajtów

(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&
— J42161217
źródło
Rotate[w,Pi]jest równoznaczne z w~Rotate~Pi, jak to o["/\\",#]do"/\\"~o~#
— Jonathan Frech
Znam notację infix i zawsze używam jej, gdy naprawdę potrzebuję 1 bajta. W tym przypadku po prostu
— puszczam
2
Nie wątpiłem w twoją znajomość notacji infiksowej; Chciałem tylko zmniejszyć liczbę bajtów. Wiesz, w duchu golfa i tym podobnych.
— Jonathan Frech,
0

C # (.NET Core) , 188 bajtów

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

Liczba bajtów obejmuje również:

using System.Linq;

Wypróbuj online!

Zacząłem wyjaśniać polecenie po poleceniu, ale przestało to mieć sens w połowie ... Podstawową zasadą jest zrobienie pełnego kolczastego pudełka, a następnie wydrążenie środka. Użyłem Linq ze względu na użycie Linq, prawdopodobnie może być krótszy przy użyciu standardowych iteracji.

Oto wyjaśnienie idące na środek (najpierw wewnętrzna komenda):
Najpierw utwórz wiersze dla pełnego pola i połącz w pojedynczy ciąg

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

Następnie weź każdy znak z rzędu, a jeśli nie jest to obrys ramki, zastąp spacją, połącz je z powrotem w jeden ciąg dla każdego rzędu

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

Na koniec pobierz każdy wiersz i połącz je razem z nowymi wierszami (obejmuje również generowanie kolekcji dla wierszy)

string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));
— Grzegorz Puławski
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.