삭제 된 stackoverflow 질문에서 누군가가 다음을 게시했습니다.

에 교류 패턴을 인쇄하는 프로그램이나 기능을 작성 *하고 #주어진 정수에 기반을 n. 몇 가지 예 :

입력 : n=1
출력 :

*

입력 n=5
출력 :

*####
###**
***##
###**
*####

입력 : n=8
출력 :

*#######
######**
***#####
####****
****####
#####***
**######
#######*

꽤 멋진 코드 골프 도전처럼 보였으므로 여기에 있습니다.

이러한 패턴은 어떻게 만들어 집니까?

첫 번째 줄은 단일으로 시작한 *다음 n-1후행으로 이어 #집니다.
두 번째 줄은 다음 두 가지를 포함 *하여, n-2선도의 양 #.
세 번째 줄은 세 개로 시작하고 *그 뒤에 n-3후행이 나타납니다 #.
기타

중간 ( n/2)에 도달하면 *위의 예에서 볼 수있는 의 양으로 다시 계산합니다 .

홀수 입력 번호의 경우 반전 된 라인 쌍 (첫 번째 및 마지막, 두 번째 및 다음 다음 등)은 정확히 동일합니다. 이 n=5예에서 첫 번째 줄과 마지막 줄은 *####; 마지막 줄과 두 번째 줄은 ###**입니다.
그러나 짝수의 입력 번호의 경우에는 반전 된 라인 쌍이 반전됩니다. 이 n=8예에서 첫 번째와 마지막 줄은 *#######및 #######*; 마지막 줄과 두 번째 줄은 ######**and **######; 기타

도전 규칙 :

• 및 대신 두 개의 고유 한 인쇄 가능 문자를 사용할 수 있습니다 . 당신은 사용할 수 있습니다 및 ; 그리고 ; 그리고 ; 당신이 사용한 것을 답에 적어주십시오.*#AB37<>
• n양의 정수 라고 가정 할 수 있습니다 ( >= 1)
• STDOUT으로 인쇄하는 대신 각 행 또는 2D 문자 행렬에 대한 문자열 목록 / 배열을 출력 할 수 있습니다.

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 사례 (처음 n=1부터 n=10)

*

*#
#*

*##
#**
*##

*###
##**
**##
###*

*####
###**
***##
###**
*####

*#####
####**
***###
###***
**####
#####*

*######
#####**
***####
###****
***####
#####**
*######

*#######
######**
***#####
####****
****####
#####***
**######
#######*

*########
#######**
***######
#####****
*****####
#####****
***######
#######**
*########

*#########
########**
***#######
######****
*****#####
#####*****
****######
#######***
**########
#########*

젤리 , 9 바이트

>þµoṚUÐeY

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

설명

>þ           Create a table of (x>y) over [1…n]×[1…n]:
               [0 1 1 1 1]
               [0 0 1 1 1]
               [0 0 0 1 1]
               [0 0 0 0 1]
               [0 0 0 0 0]
  µ          Take this array, and...
   oṚ        OR it with its reverse:
               [0 1 1 1 1]
               [0 0 1 1 1]
               [0 0 0 1 1]
               [0 0 1 1 1]
               [0 1 1 1 1]
    UÐe      Apply U (reverse) to even-indexed rows.
       Y     Join by newlines.

파이썬 2 , 62 바이트

lambda n:["%*s"%(i%2*2*n-n,"x"*min(i+1,n-i))for i in range(n)]

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

용도 x 와 공간.

행은 다음과 같이 계산됩니다.

"%-5s" % "x"      == "x    "
"%5s"  % "xx"     == "   xx"
"%-5s" % "xxx"    == "xxx  "
"%5s"  % "xx"     == "   xx"
"%-5s" % "x"      == "x    "

은 Using %*s지정하는 것은 사이에서 선택을 n하고 -n.

펄 6 , 57 바이트

{map ^$^a: {fmt -$a*(-1)**$_=>\*x($_+1 min$a-$_): "%*s"}}

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

Lynn의 Python answer 와 동일한 방법을 사용합니다 . *및 공간을 사용하여 출력 합니다.

MATL, 34 31 18 바이트

:t!>tPY|!"@X@oQ&P!

MATL Online에서 사용해보십시오

*에 0을 사용하고 #에 1을 사용합니다. Lynn의 젤리 답변을 기반으로 합니다.

더 오래된 대답, 31 바이트 :

2/tk:wXk:Ph"X@ot~XHh@Gy-hHQ&PY"

MATL Online에서 사용해보십시오

*에 1을 사용하고 #에 0을 사용합니다.

         % implicit input, say 5
2/       % divide input number by 2 [2.5]
tk       % make a copy and floor that [2.5, 2]
:        % create range 1 to the floored value [2.5, [1, 2]]
wXk      % bring out the division result and this time ceil it
         %  [[1, 2], 3]
:        % create range 1 to that [[1, 2], [1, 2, 3]]
Ph       % flip the last array and concatenate horizontally 
         %  [[1, 2, 3, 2, 1]]
"        % loop through the array
  X@o    % Is the current loop index odd? 1 for odd, 0 for even
  t~     % duplicate and logical negate that
  XH     % copy that value to clipboard H
  h      % and concatenate the values ([1 0] on odd iterations, [0 1] on even) 
  @      % push current value from array (say 2, then stack is [[0 1], 2)
  G      % push input again
  y-     % subtract current array value from input [[0 1], 2, 3]
  h      % concatenate those two [[0 1], [2, 3]]
  H      % get the stored value from clipboard H (1 for even iterations, 0 for odd) 
  Q      % increment that
  &P     % flip the array in that dimension: in even iterations, this flips
         %   across columns and hence inverts the two values. [[0 1], [3, 2]]
         %   in odd iterations, it's a no-op
  Y"     % run-length decoding - repeat the element from first array the number of times
         %  specified in the second array
         % implicit loop end, implicit output

APL (Dyalog Classic) , 18 바이트

⎕a[↑⊢∘⌽\(⊂>⊢⌊⌽)⍳⎕]

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

AB대신 출력*#

⎕ 평가 된 입력 n

⍳⎕ 벡터 0 1 ... n-1

⊢⌊⌽⌊그들 자신 ⊢과 반대편 ( ) 사이의 최소 ( ) ⌽- 열차 참조

⊂>⊢⌊⌽여기서 ⍳벡터 ⊂는 각각의 전체 보다 작은 전체 ( ) ⊢⌊⌽-부울 (0/1) 벡터의 벡터를 반환합니다.

⊢∘⌽\ 다른 모든 벡터를 반대로

↑ 매트릭스로 혼합

⎕a대문자 영어 알파벳, 'AB...Z'

⎕a[ ]교체 0 1로'A' 'B'

숯 , 21 바이트

≔⮌…⁰ＮθＥθ⭆蛧⟦μλ⟧κ⌊⟦κι

온라인으로 사용해보십시오! 사용 0및 1. 링크는 코드의 자세한 버전과 포함 §*#받는 출력을 변환하는 *과 #질문에. 설명:

    Ｎ                   Input number
  …⁰                    Range from 0
 ⮌                      Reversed
≔    θ                  Assign to `q`
      Ｅθ                Map over reversed range
        ⭆θ              Map over reversed range and join
           §⟦μλ⟧κ       Alternate between range and reversed range column
                 ⌊⟦κι   Minimum of range and reversed range row
          ›             Greater
                        Implicitly print each row on its own line

젤리 ,  12  15 바이트

n=1엣지 케이스 버그 수정 +3 :(

R«Ṛ$‘r⁸ṬUÐe0YE?

정수를 허용하는 전체 프로그램으로 0, 1for *및 for를 사용하여 OP에 정의 된대로 출력을 인쇄합니다 #.

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

어떻게?

R«Ṛ$‘r⁸ṬUÐe0YE? - Main Link: integer, n
R               - range -> [1,2,3,4,...,n]
   $            - last two links as a monad:
  Ṛ             -   reverse -> [n,...,4,3,2,1]
 «              -   minimum (vectorises) -> [1,2,3,4,...,4,3,2,1]
    ‘           - increment (vectorises) -> [2,3,4,5,...,5,4,3,2]
      ⁸         - chain's left argument, n
     r          - inclusive range (vectorises) -> [[2,3,...,n],[3,4,...n],[4,5,...n],[5,...n],...,[5,...n],[4,5,...n],[3,4,...n],[2,3,...,n]]
       Ṭ        - untruth (vectorises) -> [[0,1,1,...,1],[0,0,1,1,...,1],[0,0,0,1,...,1],[0,0,0,0,1,...,1],...,[0,0,0,0,1,...,1],[0,0,0,1,...,1],[0,0,1,1,...,1],[0,1,1,...,1]]
         Ðe     - apply to entries with even indices:
        U       -   upend              -> [[0,1,1,...,1],[1,1,...,1],[0,0,0,1,...,1],[1,...,1,0,0,0,0],...]
              ? - if...
             E  - ...condition: all equal? (only true when n=1, where we have [1,1])
           0    - ...then: zero
            Y   - ...else: join with newline characters
                - implicit print

젤리 , 15 바이트

r1«RR;ṬṖɗ€‘UÐeY

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

전체 프로그램.

*= 1
#=0

자바 10, 145 바이트

n->{var r=new char[n][n];for(int j=0,k;j<n;++j)for(k=0;k<n;)r[j][k]=k++<(j<n/2?j%2<1?j+1:n+~j:j%2>0?j:n-j)?j%2<1?'*':'#':j%2>0?'*':'#';return r;}

모든 삼항은 약간 지저분하지만 잘 작동합니다. 중첩 루프 및 기타 여러 가지를 평면화하려고 시도했지만 바이트 수만 늘 렸습니다. 여기에서 온라인으로 사용해보십시오 .

언 골프 드 :

n -> { // lambda taking an integer as output and returning a char[][]
    var r = new char[n][n]; // the output array; we make use of Java 10's var here (replace with char[][] for another 4 bytes to make this work in Java 8)
    for(int j = 0, k; j < n; ++j) // iterate over the lines
        for(k = 0; k < n; )       // iterate over the j'th line
            r[j][k] = // set the current character
                      k++ < // determine if we're in the first or second portion of the line:
                            (j < n/2 ? // for the first half of the output:
                                 j%2 < 1  // on even lines ...
                                 ? j + 1  // ... print the first symbol j+1 times ...
                                 : n + ~j // ... on odd lines, print it n-j-1 times.
                             : j%2 > 0 ?  // for the second half of the output, on odd lines ...
                                 j :      // ... print the first symbol j times ...
                                 n - j)   // ... on even lines, print it n-j times.
                      ? j%2 < 1 ? '*' : '#'  // for the first part of the line, use '*' on even lines, '#' otherwise
                      : j%2 > 0 ? '*' : '#'; // for the second part of the line, use '*' on odd lines, '#' otherwise
    return r; // return the completed array
}

Java 8 11, 179 127 바이트

n->{String r="",a,b;for(int j=0;j<n;b="#".repeat(j<n/2?n+~j:j),r+=(j++%2<1?a+b:b+a)+"\n")a="*".repeat(j<n/2?j+1:n-j);return r;}

여기에서 온라인으로 사용해보십시오 (TIO에는 아직 Java 11이 없으므로 이것은 동일한 바이트 수를 갖는 사용자 정의 메소드를 사용합니다String#repeat() ).

덕분에 Kevin Cruijssen무려 52 바이트의 골프를 에게 합니다!

언 골프 드 :

n -> { // lambda taking an int argument and returning a String
    String r = "", // the output String
           a,      // temporary String containing the '*'s
           b;      // temporary String containing the '#'s
    for(int j = 0; j < n; // loop over the lines
        b = "#".repeat( // repeat the '#' character ...
            j < n/2 ? n + ~j // ... n-j-1 times in the first half of the output ...
            : j), // ... j times in the second half
        r += (j++ % 2 < 1 ? a + b : b + a) + "\n") // assemble the j'th line and append it to the output: on even lines, the '*'s go first; on odd lines, the '#'s go first
        a = "*".repeat( // repeat the '*' character ...
              j < n/2 ? j + 1 // ... j+1 times in the first half of the output ...
              : n - j); // n-j times in the second half
    return r; // return the completed output
}

루아 ,  148133  바이트

function(n)t,a,b={},".","#"for i=1,n do r=i<n/2+1 and i or-~n-i s=a:rep(r)..b:rep(n-r)t[i]=i%2<1 and s:reverse()or s end return t end

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

@KevinCruijssen 및 @JoKing 덕분에 -15 바이트

function(n)
   t = {}; a = "."; b = "#"          -- initialize variables, output is in table
                                     -- strings are needed in variables for
                                     --   the str:rep and str:reverse syntax

   for i = 1, n do                          -- build the rows of the table
      r = i<=(n+1)/2 and i or n-i+1         -- logic used to count up then down
      str = a:rep(r)..b:rep(n-r)            -- append correct number of '.'s, fill
                                            --   in the rest with '#'s
      t[i]=i%2==0 and str:reverse() or str  -- logic used to control reversing
   end
   return t                                 -- return table
end

코 틀린 , 86 바이트

{n:Int->for(i in 0..n)println("%${i%2*2*n-n}s".format("x".repeat(Math.min(i+1,n-i))))}

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

x출력 기호로 공백을 사용합니다 . 린 답변 에서 파생

펄 5 + -pa -MPOSIX -M5.010, 58 바이트

say+sort{$|--}1x abs,2x("@F"-abs)for(1..ceil$_/=2),-$_..-1

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

C (gcc) , 104 99 바이트

h,j,k;f(i){char s[h=i++];for(j=0;k=++j>i/2?i-j:j,j<i;memset(memset(s,42,h)+j%2*k,35,h-k),puts(s));}

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

C (gcc) , 118 바이트

이 방법은 이길 수는 없지만 다른 접근 방식입니다 (또는 적어도 그렇게 생각합니다!) 문자열 조작 대신에 나는 $10^x-1$ 위에 $[1..n] = \{9, 99, 999, ...\}$그런 다음 적절한 패턴을 얻기 위해 곱할 수 있습니다. printf()그런 다음 오른쪽 정렬을 위해 제로 패딩을 수행합니다.

슬프게도, int최대 9 자리 (32 비트 플랫폼에서)까지 수행 할 수있는 충분한 범위 만 있으므로long 더 큰 패턴 . MP 산술을 기본적으로 사용하는 언어는 이것을 무언가에 사용할 수 있습니다.

제안에 대한 천장 고양이 덕분에.

h,j,k;p(h){h=h?10*p(--h):1;}f(i){for(j=0,h=i++;k=++j>i/2?i-j:j,j<i;printf("%0*d\n",h,~-p(k)*p(j%2*(h-k))));}

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

이것이 MP 산술과 함께 작동한다는 개념 증명 :

C # (모노 C # 컴파일러) , 187 바이트

( using System.Numerics;헤더에서 143 바이트 + 22 바이트 )

q=>{var r="";for(int j=0,h=q+1,k;j<q;r+=((BigInteger.Pow(10,k)-1)*BigInteger.Pow(10,j%2*(q-k))).ToString("D"+q)+"\n")k=++j>h/2?h-j:j;return r;}

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

Vim, 99 개의 키 입력

입력 인수로 vim을 시도하는 것은 항상 흥미 롭습니다. 매우 부자연 스럽기 때문에 놀라 울 정도로 짧지는 않습니다. 이것에 대한 다른 좋은 접근법이있을 것입니다.

입력 자체는 버퍼에있는 것으로 가정합니다. 레지스터는 비어 있다고 가정합니다. 편집기는 스크롤없이 결과를 포함 할 수있을만큼 키가 큰 것으로 가정합니다 (기술적으로는 일부 키를 눌렀을 때 비용을 피할 수 있음).

"nD@ni<cr><esc>MmaGddM
<c-v>'aI*<esc>qwgvjokoI*<esc>@wq@w<esc>
:set ve=all<cr>@nlh<c-v>@nkr#
:%s/ /#/g<cr>o<esc>
2Gqqdt#$p2j0@qq@q

설명

 | Buffer state (odd and even case):
 | 5                    6

"nD              read input into register n
@ni<cr><esc>     add n newlines
MmaGddM<c-v>'a   visual block select center row(s)
I*<esc>          prepend a column of *
qw               record macro w
  gvjoko         expand selection up and down
  I*<esc>
  @w             recurse
q
@w<esc>          run macro w and exit visual block select

 | Buffer state:
 | *                    *
 | **                   **
 | ***                  ***
 | **                   ***
 | *                    **
 |                      *

:set ve=all<cr>  move anywhere!
@nlh<c-v>@nkr#   add last column of #s

 | Buffer state:
 | *   #                *    #
 | **  #                **   #
 | *** #                ***  #
 | **  #                ***  #
 | *   #                **   #
 |                      *    #

:%s/ /#/g<cr>      replace spaces with #

 | Buffer state:
 | *####                *#####
 | **###                **####
 | ***##                ***###
 | **###                ***###
 | *####                **####
 |                      *#####

o<esc>2G           prep and jump to line 2
qqdt#$p2j0@qq@q    (effectively) flip every other onward

 | Buffer state:
 | *####                *#####
 | ###**                ####**
 | ***##                ***###
 | ###**                ###***
 | *####                **####
 |                      #####*

그리고 base64에서 실제 문자 (입력 input및 키 입력을 사용 keys하고를 사용하여 실행 vim -u NONE -s keys input)

Im5EQG5pDRtNbWFHZGRNFidhSSobcXdndmpva29JKhtAd3FAdxs6c2V0IHZlPWFsbA1AbmxoFkBua3IjOiVzLyAvIy9nDW8bMkdxcWR0IyRwMmowQHFxQHE=

R , 75 바이트

function(n)outer(1:n,1:n,function(x,y,a=x<y|x>n-y+1)+ifelse(x%%2,a,rev(a)))

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

• @Lynn 답변에서 영감을 얻었습니다.
• 함수지고 n파라미터로 그리고 매트릭스 복귀 0/1어디에 0대응 행 '*'과 1대응을 행'#'

K (ngn / k) , 22 바이트

{"*#"i|:/'i>/:i&|i:!x}

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

{ } 인수 기능 x

!x목록 (0;1;...;x-1)

i: 할당하다 i

i&|i최소값 ( &) i과 그 반대 ( |)

i>/: 보다 큼 (>i오른쪽 목록의 각 요소에 대해 )/: )-부울 행렬 (목록 목록)을 반환합니다.

i|:/'각 ( ') j in i, 역 ( |:-우리는 단항 이 :되도록 강제 해야합니다 |) 해당 요소 j 번 ( n f/ x적용f n 시간을x ). 효과적으로, 다른 모든 행을 반대로 바꾸십시오.

"*#" 문자열에서 행렬 요소를 인덱스로 사용 "*#"