교차 사각형 만들기

하나 이상의 정수를 입력하고 가운데를 가로 지르는 대각선으로 인쇄 가능한 문자로 만든 사각형을 출력해야합니다.

일반적인 아이디어는 출력이 대각선을 교차하는 중공 사각형이되도록하는 것입니다.

Input: 7
Output:
*******
*#   #*
* # # *
*  #  *
* # # *
*#   #*
*******

위의 예에서 '*'는 외부 상자를 나타내고 '#'는 대각선 십자가를 나타냅니다.

위의 예제는 두 개의 다른 문자를 사용하므로 출력이 어떻게 보이는지 쉽게 알 수 있으므로 프로그램은 하나의 문자 만 사용해야합니다.

입력

1 이상의 정수는 홀수입니다.

산출

중간을 가로 지르는 십자형으로 선택한 캐릭터로 구성된 사각형입니다.

• 십자가는 대각선이어야합니다
• 사각형은 함수를 통해 출력되거나 출력에 쓰여질 수 있습니다
• 후행 줄 바꿈은 괜찮습니다.
• 원하는 경우 그래픽, 다이어그램 또는 이미지로 출력 가능

예

Input: 1
Output:
*

Input: 3
Output:
***
***
***

Input: 5
Output:
*****
** **
* * *
** **
*****

Input: 7
Output:
*******
**   **
* * * *
*  *  *
* * * *
**   **
*******

명세서

• 기능 또는 전체 프로그램이 허용됩니다
• 선호하는 방법으로 입력을받을 수 있습니다
• 표준 허점은 허용되지 않습니다
• 프로그램 즉, 별도의 문없이 작동해야한다 using에이야 C#그들이 항목에 포함되어야합니다,
• 함수에서 출력하거나 결과를 인쇄 할 수 있습니다

이것은 코드 골프이므로 가장 짧은 솔루션이 승리합니다.

MATL , 20 19 17 바이트

2-:XdtP!+~TTYa1YG

MATL 온라인 에서 실험적으로 사용해 볼 수 있습니다 . 작동하지 않으면 페이지를 새로 고쳐야 할 수도 있습니다.

샘플 실행 :

ASCII 버전 : 19 바이트

2-:XdtP!+~TTYa~42*c

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

VBA Excel, 168 바이트

교수:

VBA의 도움으로 Excel이이 도전에 효과적이고 충분한 도구라는 것을 알았습니다. 다음과 같이 Excel 워크 시트를 설정하십시오.

예, 우리는 워크 시트의 셀을 픽셀로 사용하여 옛날처럼 작고 고전적인 사각형 모양의 픽셀을 사용합니다. 하하 ...

여기서는 셀 A1을 입력으로 사용하고 글꼴 색상을 빨간색으로 변경합니다. 왜 빨간? 빨간색은 3 글자 색상이므로 골프에 적합합니다. 직접 실행 창에서 다음 코드를 작성하고 실행하십시오.

N=[A1]:Range("A1",Cells(N,N)).Interior.Color=vbRed:Range("B2",Cells(N-1,N-1)).Clear:For i=1To N:Cells(i,i).Interior.Color=vbRed:Cells(i,N+1-i).Interior.Color=vbRed:Next

코드를 풀다 :

Sub A()
    N = [A1]
    Range("A1", Cells(N, N)).Interior.Color = vbRed
    Range("B2", Cells(N - 1, N - 1)).Clear

    For i = 1 To N
        Cells(i, i).Interior.Color = vbRed
        Cells(i, N + 1 - i).Interior.Color = vbRed
    Next
End Sub

단계별 설명 :

N = [A1]: Range("A1", Cells(N, N)).Interior.Color = vbRed

Range("B2", Cells(N - 1, N - 1)).Clear

범위 셀의 대각선을 통해 반복 : Cells(i, i).Interior.Color = vbRed

최종 단계 및 출력 : Cells(i, N + 1 - i).Interior.Color = vbRed

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

f=
n=>[...Array(n--)].map((_,i,a)=>a.map((_,j)=>i&&j&&n-i&&n-j&&i-j&&n-i-j?' ':'*').join``).join`
`
;

<input type=number min=1 step=2 oninput=  o.textContent=f(this.value)><pre id=o>

파이썬 2, 65 바이트

i=n=2**input()/2
while i:print bin((n>i>1or~-n)|n|i|n/i)[2:];i/=2

다음 과 같이 이진수를 출력하는 Jonathan Allan의 아이디어 를 사용합니다 .

11111
11011
10101
11011
11111

행은 비트 산술로 작성되고 2 진으로 표시됩니다. 각 부분은 나머지 부분에 있습니다. 이 부품은 다음을 통해 2 n(고정) 및 i(떨어짐) 제곱으로 생성됩니다

1. 왼쪽 1
2. 오른쪽 n
3. 대각선 i과n/i
4. n-1언제 i==1또는로 상단과 하단 i==n.

실제로, (1)과 (4)는 1시기 1<i<n와 n-1그 밖의 방식 으로 생산함으로써 결합됩니다 .

파이썬, 114110 96 90 바이트

완전히 변경 :

lambda n:[bin(sum(2**p for p in[range(n),{0,n-1,r,n-1-r}][0<r<n-1]))[2:]for r in range(n)]

1and를 사용하여 문자열, 문자 목록을 반환합니다 0.
TheBikingViking 덕분에 -6 바이트

이데온 에서 테스트

이전 파이썬 2 @ 110

def f(n):g=range(n);n-=1;print'\n'.join(''.join((c in(r,n-r,0,n)or r in(0,n))and'#'or' 'for c in g)for r in g)

이데온에서 테스트

자바 7 131 130 128 125 124 122 바이트

String c(int n){String r="";for(int i=n,j;n-->0;r+="\n")for(j=0;j<n;r+=i*j<1|n-i<2|n-j<2|i==j|i==n-++j?"*":" ");return r;}

@LeakyNun 덕분에 3 바이트가 절약 되었습니다 . @ OliverGrégoire
덕분에 주어진 바이트 챌린지 로 #의 빈 사각형 을 그 립니다 . @cliffroot
덕분에 2 바이트가 절약 되었습니다 .

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

class M{
  static String c(int n){
    String r = "";
    for(int i = n, j; n-- > 0; r += "\n"){
      for(j = 0; j < n;
            r += i < 1      // Responsible for the first horizontal line
               | j < 1      // Responsible for the first vertical line
               | n-i < 2    // Responsible for the last horizontal line
               | n-j < 2    // Responsible for the last vertical line
               | i == j     // Responsible for the top-left to bottom-right diagonal line
               | i == n-++j // Responsible for the top-right to bottom-left diagonal line (and increasing j)
             ? "*"
             : " ");
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c(1));
    System.out.println(c(3));
    System.out.println(c(5));
    System.out.println(c(7));
  }
}

산출:

*

***
***
***

*****
** **
* * *
** **
*****

*******
**   **
* * * *
*  *  *
* * * *
**   **
*******

Matlab, 68 66 64 58 바이트

그래픽 출력도 허용되므로 :

k=input('');[x,y]=ndgrid(abs(-k:k));spy(~(max(x,y)<k&x-y))

예를 들어 어떤 출력

ascii 전용 버전은 다음과 같습니다.

이것은 인덱싱을 사용하고 있습니다. 0,1,2,3,...

k=input('');[x,y]=ndgrid(abs(-k:k));[(max(x,y)==k|~(x-y))*42,'']

또는 색인 생성과 함께 1,3,7,...:

n=input('');k=1:n;m=eye(n);m([k,end-k+1])=1;[(m|flip(m'))*42,'']

C #, 112101 바이트

익명의 람다 문이나 표현이 C #에서는 허용된다는 것을 상기시켜 준 TheLethalCoder에게 감사드립니다.

n=>{var r="";for(int y=n--,x;y-->0;r+="*\n")for(x=0;x<n;r+=y%n*x<1|y==x|y==n-x++?"*":" ");return r;};

C #은 재미있는 골프 언어가 아니라고 누가 말했습니까?

로고, 155 바이트

함수로 구현 된 그래픽 솔루션

Alphabet Triangle에 대한 답을 수정 하고 약간의 각도를 변경했습니다. 이전과 마찬가지로 r한 줄의 문자를 그립니다. 이번에는이 b함수는 직선과 대각선을 하나씩 그리고 회전하고 4 번 반복하여 상자를 그립니다. 이로 인해 대각선이 서로 두 번 그려 지지만 별도로 처리하는 것보다 코드가 적었습니다. 이 답변은 짝수도 올바르게 처리합니다. 1앞으로 진행되는 것을 막기 위해 입력에 특별한 처리를 추가 해야했습니다.

b크기를 인수 로 사용하는 함수로 구현했습니다 .

pu
to r:n:b:l repeat:n[rt:b label "A lt:b if repcount>1[fd:l]] end
to b:s
repeat 4[rt 90
r:s 90-heading 20 rt 135
r:s 90-heading 20*sqrt 2 rt 45]
end

Calormen.com의 로고 인터프리터 에서 사용해보십시오 . 전화를 걸려면 회선을 추가 b하고 다음 형식으로 전화 하십시오.

b 7

... 또는 샘플러 플래터를 사용해보십시오.이 샘플러는 5, 7, 9, 11 크기의 네 가지 샘플을 그 사이에서 90도 회전시킵니다.

repeat 4[
  b repcount*2+3
  rt 90
]

R, 102 바이트

    n=scan();for(i in 1:n){for(j in 1:n){z=" ";if(i%in%c(1,n,n-j+1)|j%in%c(1,i,n))z="*";cat(z)};cat("\n")}

i == 1 | j == 1 | ...보다 % in %를 사용하여 조건을 표현하는 것이 더 효율적입니다.

하스켈 102 100 96 91 87 바이트

c s=unlines.f$f.(#)where f=(<$>[1..s]);x#y|elem y[1,s,x]||elem x[1,s,s-y+1]='*'|1>0=' '

• flawr 덕분에 2 바이트를 절약했습니다 .
• list comprehensions를 사용하여 4 바이트를 더 절약했습니다.
• flawr 의 개선과 함께 5 바이트 절약any
• 로 교체 any하여 4 바이트 절약elem

언 골프 버전 :

cross :: Int -> String
cross s = unlines $ map line [1..s]
    where line y = map (pos y) [1..s]
          pos y x | x == y = '*'
                  | x == s - y + 1 = '*'
                  | y `elem` [1, s] = '*'
                  | x `elem` [1, s] = '*'
                  | otherwise = ' '

나는 이것이 여전히 향상 될 수 있다고 확신하지만 이것이 지금까지 생각해 낸 것입니다.

구 버전:

c s=unlines.f$f.(#)where f=(<$>[1..s]);x#y|any(==y)[1,s,x]||any(==x)[1,s,s-y+1]='*'|1>0=' '

자바, 130 바이트

s->{for(int i=0;i<s;i++)for(int j=0;j<s;j++)System.out.print((s-1-i==j||i==j||i==0||j==0||i==s-1||j==s-1)?j==s-1?"*\n":"*":" ");};

테스트 프로그램

Consumer<Integer> consumer = s -> {
        for (int i = 0; i < s; i++) {
            for (int j = 0; j < s; j++) {
                System.out.print((s - 1 - i == j || i == j || i == 0 || j == 0 || i == s - 1 || j == s - 1) ? j == s - 1 ? "*\n" : "*" : " ");
            }
        }
    };

    consumer.accept(20);

C, 140 (121) 114 바이트

Quentin 덕분에 19 바이트.

이중 중첩 루프에서 하나의 루프로 전환하여 7 바이트가 절약됩니다.

main(a){scanf("%d",&a);for(int i=0;i<a*a;i++,i%a||puts(""))putchar(i/a&&i/a^a-1&&i%a&&-~i%a&&i%-~a&&i%~-a?32:42);}

골프 제안을 환영합니다.

PowerShell (133)

filter s($x){1..$x|%{$o="";$r=$_;1..$x|%{if($_-eq1-or$r-eq1-or$_-eq$x-or$r-eq$x-or$r-eq$_-or$r-1-eq$x-$_){$o+="*"}else{$o+="_"}};$o}}

어리석은 일이지만 충분히 잘 작동합니다.

s(11)
***********
**_______**
*_*_____*_*
*__*___*__*
*___*_*___*
*____*____*
*___*_*___*
*__*___*__*
*_*_____*_*
**_______**
***********

골프 제안은 분명히 환영합니다. PowerShell을 사용한 지 너무 오래되었습니다.

SILOS , 212 바이트

readIO 
a = i
lbla
a - 1
t = a
t + 1
t % i
t * a
b = i
lblb
b - 1
u = b
u + 1
u % i
u * b
u * t
v = a
v - b
u * v
v = a
v + b
v + 1
v % i
u * v
u |
if u c
print #
GOTO d
lblc
print .
lbld
if b b
printLine 
if a a

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

GNU sed, 117114 + 1 (r 플래그) = 115 바이트

p;/^0$/Q;/^000$/{p;q}
h;s/./ /3g;s/  $/00/
:f;/ 00 /!{G;h;s/\n.*//p;t;:}
s/^(0 *)0  ?( *)0/\1 0\20 /
tf;s/00/0/p;g

sed는 숫자를 기본적으로 지원하지 않기 때문에 입력은이 합의에 따라 단항으로 제공됩니다 . 정사각형의 후반은 홀드 공간에서 역순으로 저장된 첫 번째 반입니다.

운영:

sed -rf crossed_square.sed <<< "00000"

산출:

00000
00 00
0 0 0
00 00
00000

파이썬, 89 바이트

이것은 후퇴였습니다! 나는 파이썬의 거북이 모듈을 사용했습니다.

from turtle import*
n=input()
for i in[(n,n),(n,0),(0,n),(0,0),(n,0),(0,n),(n,n)]:goto(i)

n = 200 일 때의 결과는 다음과 같습니다.

스칼라 141 137 바이트

val s=args(0).toInt-1;val t=0 to s;print(t.map{x=>t.map{y=>if(x==0||x==s||y==0||y==s||x==y||x==s-y)"*" else " "}.mkString+"\n"}.mkString)

운영:

$ scala cross.scala 10

기술적으로 인쇄물을 제거하고 다음과 같이 갈 수 있습니다.

def c(n:Int)={val (s,t)=(n-1,0 to n-1);t.map{x=>t.map{y=>if(x==0||x==s||y==0||y==s||x==y||x==s-y)"*" else " "}.mkString+"\n"}.mkString}

함수 구문을 세는지 여부에 따라 135 또는 121 바이트가됩니다.

읽을 수있는 버전 :

def cross(n: Int) = {
   // Declares both s and t as variables with tuple expansion
   // s is the zero-based size and t is a range from 0 to s
   val (s,t) = (n-1, 0 to n-1)

   // Maps all rows by mapping the columns to a star or a space
   t.map { x =>
      t.map { y =>
        if (x == 0 || x == s || y == 0 || y == s || x == y || x == s-y) "*" 
        else " "
      }.mkString+"\n" // Concatenate the stars and spaces and add a newline
   }.mkString         // Concatenate the created strings
 }

Pyth, 27 25 바이트

jmsm?|qFKaLJ/Q2,dk}JKN\ Q

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

아마 골프 타기.

파이썬 2, 83 바이트

i=n=input()
while i:l=['* '[1<i<n]]*n;i-=1;l[0]=l[~0]=l[i]=l[~i]='*';print`l`[2::5]

행 문자 목록을 수정 *하여 첫 번째, 마지막, i 및 마지막 위치에 넣습니다. 첫 번째 행과 마지막 행은 all로 시작 *하고 나머지 행 은 모든 공백으로 시작 합니다. 짝수에도 적용됩니다. lambda표현은 수정보다는 아마 짧은,하지만 난이 방법을 좋아한다.

파이크, 28 24 23 바이트

]Ua]jshqjXq|0[j{|)Qt[)P

여기 사용해보십시오!

수학, 81 바이트

""<>#&/@Table[If[i^2==j^2||i^2==#^2||j^2==#^2,"*"," "],{i,-#,#},{j,-#,#}]&[(#-1)/2]&

중심에 원점이있는 좌표계를 작성하고 *s가 어디로 가야하는지 계산 합니다. 행당 하나씩 문자열 배열을 출력합니다.

자바 스크립트 ( 289,270 바이트)

function s(a){b=[];for(i=0;i<a;i++)if(b.push([]),0==i||i==a-1)for(j=0;j<a;j++)b[i].push("*");else for(j=0;j<a;j++)0==j||j==a-1?b[i].push("*"):j==i||a-1-j==i?b[i].push("*"):b[i].push(" ");c="";for(i=0;i<b.length;i++){for(j=0;j<b[i].length;j++)c+=b[i][j];c+="\n"}return c}

언 골프 드 :

function square(size){
str=[];

for(i=0;i<size;i++){
    str.push([]);
    if(i==0||i==size-1){
        for(j=0;j<size;j++){
            str[i].push("*");
        }
    }else{
        for(j=0;j<size;j++){
            if(j==0||j==size-1){
                str[i].push("*");
            }else if(j==i||size-1-j==i){
                str[i].push("*");
            }else{
                str[i].push(" ");
            }
        }
    }
}

out="";
for(i=0;i<str.length;i++){
    for(j=0;j<str[i].length;j++){
        out+=str[i][j];
    }
    out+="\n";
}
return out;
}

편집 : Philipp Flenker 덕분에 19 바이트를 절약했습니다.

Perl, 83 +1 = 84 바이트

-n플래그로 실행하십시오 .

$\="*
*";print$c="*"x($_+1);for$b(1..$_){@a=($")x$_;@a[$b-1,-$b]=(a,a);print@a}say$c

리터럴 개행은 \n또는 1 바이트 이상을 저장 $/합니다.

읽을 수있는 :

$\="*\n*";
print$c="*"x($_+1);
for$b(1..$_){
    @a=($")x$_;
    @a[$b-1,-$b]=(a,a);
    print@a
}
say$c

이 코드는 맨 위 줄을 인쇄하여 저장 $c한 다음 적절한 슬롯을 as 로 교체하여 많은 공간 을 인쇄 한 다음 맨 위 줄을 다시 인쇄합니다.

$\변수에 대한 할당 은 인터프리터에게 매번 후에 내용 (별표, 줄 바꿈 및 다른 별표)을 인쇄하도록 지시 print하지만, 이후에는 발생하지 않습니다 say.

SmileBASIC, 46 바이트

INPUT I
GBOX I,I,1,1GLINE 1,I,I,1GLINE 1,1,I,I

(아니요, SB는 1- 인덱싱 된 그래픽을 사용하지 않습니다 ...)

숯, 8 바이트 (비경쟁, 언어 날짜 도전 과제)

ＧＨ+↘↑↙Ｎ*

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명 : PolygonHollow명령에 대한 매개 변수로 사용될 때 +상자를 그리고 화살표는 대각선을 작성합니다. 이 다른 바로 가기 문자는하지만 유용 예를 들어이되고 재정의 할 필요가 Y에 해당 ↖↗↓하지만가 eqivalent 인 경우 ↗↓↖다음 Y+충분할 것입니다.

껍질 ( 135 바이트 ) :

 C(){ j=$(($1-1));for i in $(seq 0 $j);do dc<<<2o10i`echo $((1|2**$i|2**($j-$i)|2**$j|(($i==0||$i==$j))*(2**$j-1)))`p;done|tr 01 ' X';}

테스트 :

 C 1
 X

 C 3
 XXX
 XXX
 XXX

 C 5
 XXXXX
 XX XX
 X X X
 XX XX
 XXXXX

 C 7
 XXXXXXX
 XX   XX
 X X X X
 X  X  X
 X X X X
 XX   XX
 XXXXXXX

 C 9
 XXXXXXXXX
 XX     XX
 X X   X X
 X  X X  X
 X   X   X
 X  X X  X
 X X   X X
 XX     XX
 XXXXXXXXX

코 틀린 , 123 116 바이트

\ n으로 println으로 변경

{s:Int->val n=s-1
for(r in 0..n){for(c in 0..n)print(if(n-r==c||r==c||r<1||c<1||r==n||c==n)"#"
else " ")
println()}}

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