뾰족한 상자 만들기

31

두 개의 양의 정수 W와 H가 주어지면 상단 및 하단 가장자리에 W "스파이크"가 있고 왼쪽 및 오른쪽 가장자리에 H "스파이크" 가있는 테두리가 슬래시 ( /및 \)로 구성된 ASCII 아트 상자를 출력 하십시오. 상자의 내부는 공백으로 채워져 있습니다.

"스파이크 (spike)"는 단순히 화살표 모양을 형성하기 위해 두 개의 슬래시로 구성됩니다.

/\    \/

/      \
\      /

그래서에 대한 출력 W = 4, H = 3될 것이다

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

위쪽이 위쪽을 가리키고 아래쪽이 아래쪽을 가리키고 4가 왼쪽을 가리키고 3이 오른쪽을 가리키면 3 개의 스파이크가 있습니다.

다른 입력 / 출력 쌍은 다음과 같습니다.

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

출력의 행에는 선행 또는 후행 공백이 없어야합니다. 선택적으로 하나의 후행 줄 바꿈이있을 수 있습니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

code-golf  string  ascii-art  integer 
— 캘빈의 취미
소스
자바 스크립트를 사용하는 사람 이 스택 스 니펫을 만들 수 있습니까 ?
— FantaC

답변:

15

숯 , 9 바이트

ＢײＮײＮ/\

온라인으로 사용해보십시오!

설명

Ｂ           Box
  ײＮ       Next input as number * 2
      ײＮ   Next input as number * 2
          /\ With border "/\"
— ASCII 전용
소스
3
물론 숯에는 '드로잉 박스'가 내장되어 있습니다
— 벤젠
1
@ 벤젠 최근에 상자 주위에 임의의 문자열을 그리는 기능을 추가 한 것은 다소 운이 좋았지 만 그 전에도 codegolf.stackexchange.com/a/120065
— Neil
1
@Neil 최근에 기다 립니까? 언제? (차콜이 덜 감사하다는 것을 아십니까? 하하)
— ASCII 전용
@ ASCII- 전용 My bad! 커서 위치를 되 돌린 변경으로 인해 혼란스러워했습니다. (임의의 테두리 문자열을 도입 한 변경 사항은 거의 1 년 전인 ca904b0입니다.)
— Neil
@ 벤젠 상자가 없으면 여전히 13 바이트입니다 Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(높이, 너비 순서로 입력).
— Neil
11

MATL , 18 바이트

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

MATL Online 에서 사용해보십시오 !

설명

입력을 고려 W = 4, H = 3. 이 코드는 행 벡터 [1 2 3 4 5 6 7 8](범위에서 1~ 2*W) 및 [1 2 3 4 5 6](범위에서 1~ 2*H)를 빌드합니다 . 후자를 변환하고 브로드 캐스트로 전자에 추가하면 행렬이 제공됩니다.

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

문자열에 대한 모듈 식 인덱싱 \/은 매트릭스 경계에서 원하는 결과를 생성합니다.

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

경계가 아닌 값을 제거하려면 값을 설정합니다 0(char로 해석 될 때 공백으로 표시됨).

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

주석이 달린 코드 :

'\/'    % 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
— 루이스 멘도
소스
7

하스켈 , 90 88 87 82 바이트

Lynn 덕분에 1 6 바이트 절약

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

온라인으로 사용해보십시오!

아직도 정말 길게 느낀다. 내가 할 수있는 것을 볼 것이다.

— 밀 마법사
소스
a#b=[a..b]모든 발생을 정의 하고 교체하면 1 바이트가 절약됩니다.a#b=[a..b];x!y|i<-2#x>>" "=(1#x>>"/\\"):(2#y>>['\\':i++"/",'/':i++"\\"])++[1#x>>"\\/"]
— Lynn
오, a#b=[1..a]>>b;x!y|i<-(x-1)#" "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]실제로 6을 저장합니다
— Lynn
@Linnn 감사합니다! 당신은 정말 최근에 내 슬랙을 잡고있다.
— 밀 마법사
@ Liny는 작동하지만 다른 바이트를 희생했습니다.
— 밀 마법사
5

05AB1E , 14 바이트

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

온라인으로 사용해보십시오!

설명

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

이것은 왼쪽 상단 모서리, x 문자 너비 및 y 문자 높이 만 만듭니다. 그런 다음 두 축에서이를 미러링합니다.

x=3, y=2

/\/|
\  |
---+
— 칼 소웨 루스
소스
4

자바 스크립트 (ES6), 84 바이트

카레 구문으로 입력을 (w)(h)받습니다.

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

데모

코드 스 니펫 표시

— 아르나 울드
소스
3

스위프트 3 , 166 바이트

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

전체 테스트 스위트.

클로저 버전은 불행히도 조금 더 길다 (175 바이트).

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

클로저 버전의 테스트 스위트.

— 미스터 Xcoder
소스
3

망막 , 77 73 바이트

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

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 형식으로 입력을 <height> <width>받습니다. 설명:

\d+
$*

입력을 단항으로 변환하십시오.

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

입력 값을 곱하지만 결과가 사각형이되도록 개행을 추가하십시오.

1
/\

뾰족한 상단을 만듭니다.

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

각 뾰족한 행을 복제하지만 두 번째 행의 스파이크 오프셋을 사용합니다.

¶$

후행 줄 바꿈을 삭제하십시오.

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

상자 내부를 삭제하십시오. (마지막 줄에 공백이 있습니다.)

— 닐
소스
3

엑셀, 95 바이트

=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)
— 베르니 쉬
소스
3

APL (Dyalog) , 41 39 바이트

목록을 요구하는 프롬프트 [H,W]

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

온라인으로 사용해보십시오!

⎕-1 입력 프롬프트 (니모닉 : 양식화 된 콘솔) 및 빼기 1

2× 2를 곱하다

''⍴⍨ 그것을 사용하여 빈 문자열 (공백이있는 패드)을 재구성하십시오.

⊢ 수확량 (과 분리하여 제공 4)

{… }⍣4 다음 기능을 네 번 적용하십시오.

 ≢⍵ 인수의 길이 (길이)

 '/\'⍴⍨ 주기적 r에 eshape을 "/\"그 길이

 ⍵, 인수의 오른쪽에 추가

 ⌽⍉ 조옮김 및 대칭 (예 : 90 ° 회전)

¯1⌽1 주기적으로 첫 번째 행을 한 단계 오른쪽 으로 회전

⊢ 수확량 (과 분리하여 제공 1)

'\'@2@1첫 번째 주요 항목  의 두 번째 위치에 백 슬래시를 넣습니다 .

— 아담
소스
3

C (gcc) ,170 166 158 155 108 105

cleblanc 덕분에 -3 바이트

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

온라인으로 사용해보십시오!

나는 이것이 덜 간단한 접근법으로 더 골프화 될 수 있다고 생각합니다. 시간을 찾으면 어떻게 할 수 있는지 볼 것입니다.

Ok 그 코드의 바이트 수를 줄이는 다른 방법을 찾을 수 없습니다.

설명 : char로 상자 char을 인쇄하는 간단한 이중 루프.

테두리를 인쇄 할 때 : x와 y 좌표가 모두 짝수이거나 홀수이면 a를 표시하고 /그렇지 않으면 a \를 표시합니다

테두리가 아닌 경우 공백 문자가 대신 표시됩니다

— 스코티 넷
소스
1
다음 puts("")과 같이 첫 번째 for 루프로 이동하여 3 바이트를 더 줄일 수 있습니다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);}
— cleblanc
@cleblanc 감사합니다!
— scottinet
3

/// , 172117 바이트

따라서 출력은 ///s와 whitespaces 로 구성 되므로이 두 언어로 제출해야합니다.

코드 뒤에 입력 W,H을 단항 번호로 입력하십시오 ( 제안을 위해 Challenger5 덕분 에 /// 단항은 허용됩니다 ) ( *숫자로 표시하고으로 구분 ,) 형식으로 입력하십시오.

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

온라인으로 사용해보십시오! (입력 W=4, H=3)

— 사용자
소스
Unary에서 입력 을 받아 구문 분석을 건너 뛸 수 있습니다 .
— Esolanging 과일
또한 이것은 매우 인상적입니다. 잘 했어!
— Esolanging 과일
2

파이썬 3 , 87 82 바이트

편집 : @officialaimm , @ Mr.Xcoder 및 @tsh 덕분에 5 바이트가 절약 되었습니다.

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

온라인으로 사용해보십시오!

— 할 바드 험멜
소스
— officialaimm
파이썬 3에서 유지하려면 -2 바이트 *(b-1)가 될 수 있습니다 *~-b.
— Mr. Xcoder
2
@officialaimm 왜 " "*2*~-a? 그냥 "__"*~-a.
— tsh
@tsh 예, 당신 말이 맞아 ... Haha는 그것을 몰랐다 ...
— officialaimm
@officialaimm은 파이썬 3을 유지하지만, Mr.Xcoder와 tsh로 인해 바이트를 절약했습니다.
— Halvard Hummel
2

J, 48 바이트

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

언 골프

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

설명

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

온라인으로 사용해보십시오!

— 요나
소스
1
33 바이트 ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:. 여기에 Amend이 훌륭합니다.
— 마일
ooooh, 아주 좋은 개선
— Jonah
1
30 바이트 '/\ '{~2(<,~<<0 _1)}2|+/&i.&+:리팩토링과
— 마일
2

자바 8, 141 바이트

너비에서 높이까지의 카레 람다.

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

온라인으로 사용해보십시오 ( return t+i+o;의도하지 않았습니다)

언 골프 람다

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

이 솔루션은 a char를 사용하여 너비 입력을 계산하기 때문에 입력 크기에 대해 비정형 적으로 까다 롭습니다 . 다행스럽게도 알고리즘은 그 크기에서 프로그램 완료가 이미 문제가 될 정도로 충분히 나쁩니다. char루프 인덱스 에 사용하기로 결정하여 나중에이를 저렴한 별칭으로 재사용 할 수 있습니다 '\n'.

— 야콥
소스
2

SOGL V0.12 , 22 21 13 바이트

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

여기 사용해보십시오! (스택에서 두 입력을 모두 예상하므로 ..( "문자열이 명시 적으로 시작되지 않았으므로)-사용하기 쉽도록 숫자 입력을 두 번 추가하십시오)

설명:

/\”            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
— 자 지마
소스
> : D 숯을 치고 있지 않습니다
— ASCII 전용
@ ASCII 전용 때문에 숯 A 본에 내장있다 : P (그리고 SOGLs 정말 어쨌든 복잡 및 긴 도전을 위해 만든)
— dzaima
1

수학, 87 바이트

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

그것을 시도 Mathics (그것은 어떤 이유로 대부분의 라인의 시작 부분에 여분의 공백을 출력), 또는에서 볼프람 샌드 박스 ! 두 개의 정수를 입력으로 사용합니다.

상당히 순진한 솔루션이지만 시도한 모든 영리한 작업에는 더 많은 바이트가 있습니다. 거의 효과가있는 것은

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

차원이 1 인 경우 실패합니다 (입력은 차원을 포함하는 목록입니다).

— 나무가 아님
소스
1

J , 39 바이트

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

온라인으로 사용해보십시오!

heightLHS와 widthRHS에서 와 같이 두 가지 주장을 취 합니다.

— 마일
소스
평소와 같이 좋은 일. 재미있는 접근법도 있습니다.
— 요나
@Jonah 아니요, 수정을 사용하면 아이디어가 훨씬 좋습니다. 내 절반과 결합하면 ...
— 마일
1

VBA (엑셀), 161 바이트

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
— 레 모엘
소스
골프 서브 (139 바이트) :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
— 테일러 스콧
위의 익명의 즉시 창 함수 버전 (113 바이트) :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 바이트 152 바이트

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

온라인으로 사용해보십시오!

8 바이트를 제거해 주셔서 감사합니다.

— 표
소스
이 s기능을 사용해 본 적이 있습니까?
— BLT
s 함수는 스파이크 박스를 만들기 위해 호출하는 것입니다
— Mark
1
알았다. 공백과 s=비트 를 제거하면 152 바이트로 줄일 수 있습니다 . 익명의 기능이 허용됩니다.
— BLT
알아두면 좋은 기능
— Mark
0

dc , 123 바이트

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

가장 짧은 것과는 거리가 멀지 만 마지막 두 줄을 가져 와서 pi/2시계 방향으로 시계 방향으로 "똑바로" 회전 시키면 토템 폴 처럼 보입니다 .

공백으로 구분 된 두 정수로 입력을받습니다.

온라인으로 사용해보십시오!

— R. 캅
소스
1
현재 가장 긴 답변입니다. 나는 그것이 Java의 일이라고 생각했다.
— R. Kap
걱정하지 마십시오. 이제 Java 솔루션 이 있으며 더 길어집니다.
— Jakob
0

수학, 116 바이트

(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&
— J42161217
소스
Rotate[w,Pi]에 해당 w~Rotate~Pi한, o["/\\",#]에"/\\"~o~#
— 조나단 FRECH
;-) ... 나는 중위 표기법을 알고 난 정말이 경우 byte.In 1을 필요로 할 때 난 항상 그냥 가자 사용
— J42161217
2
나는 당신의 삽입 표기법에 대한 지식을 의심하지 않았다. 바이트 수를 줄이고 싶었습니다. 당신은 골프와 같은 정신으로 알고 있습니다.
— Jonathan Frech
0

C # (. NET 코어) , 188 바이트

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

바이트 수에는 다음이 포함됩니다.

using System.Linq;

온라인으로 사용해보십시오!

나는 명령별로 설명을 시작했지만 중간에 의미가 없어졌습니다 ... 기본 요점은 전체를 뾰족한 상자로 만든 다음 중간을 비우는 것입니다. Linq를 사용하기 위해 Linq를 사용했는데 표준 반복을 사용하면 더 짧을 수 있습니다.

다음은 가운데로 나가는 설명입니다 (가장 안쪽 명령).
먼저 전체 상자에 대한 행을 작성하고 단일 문자열로 연결하십시오.

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

그런 다음 각 문자를 한 행에 넣고 상자의 외곽선이 아닌 경우 공백으로 바꾸고 각 행에 대해 하나의 문자열로 다시 연결하십시오.

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

마지막으로 각 행을 가져 와서 줄 바꿈과 함께 연결하십시오 (행에 대한 컬렉션 생성 포함)

string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));
— 그제 고르 즈 푸와 스키
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.