파도의 진폭과주기가 주어지면 파도를 인쇄하십시오. 자세한 내용은 샘플 출력을 참조하십시오. 총 파형 수는주기와 같으며 각 파형의 높이는 진폭과 같습니다. 진폭과주기는 10보다 작습니다. 후행 공백은 무시할 수 있지만 선행 공백은 무시할 수 없습니다.

Sample Input
3 2

Sample Output
  3           3    
 232         232  
12321 12321 12321 12321
       232         232
        3           3  

Dyalog APL, 43 40 바이트

{⍉⊃⍪/⍺⍴⊂(⌽⍪⊢)(n,1-n←2×⍵)↑↑b⍴¨⍕¨b←a,1↓⌽a←⍳⍵}

{⍉⊃⍪/⍺⍴⊂(⌽⍪⊢)n(1-n←2×⍵)↑↑⍴∘⍕¨⍨a,1↓⌽a←⍳⍵}( 감사합니다, Moris Zucca )

이것은 진폭이 오른쪽 인수 ( ⍵)이고주기가 왼쪽 인수 ( ⍺) 인 2 차원 함수입니다 . 사용자 입력을 읽는 프로그램은 같은 수의 문자를 사용합니다.

Martin Büttner의 CJam 답변 에서 영감을 얻으십시오 .

{⍉⊃⍪/⍺⍴⊂(⌽⍪⊢)n(1-n←2×⍵)↑↑⍴∘⍕¨⍨a,1↓⌽a←⍳⍵}
                                   a←⍳⍵ ⍝ numbers 1 2 3, call them "a"
                                  ⌽     ⍝ reverse them: 3 2 1
                                1↓      ⍝ drop one: 2 1
                              a,        ⍝ prepend "a": 1 2 3 2 1
                         ⍴∘⍕¨⍨          ⍝ format a[i] and repeat it a[i] times:
                                        ⍝     (,'1') '22' '333' '22' (,'1')
                        ↑               ⍝ mix, i.e. obtain a character matrix:
                                        ⍝    ┌───┐
                                        ⍝    │1  │
                                        ⍝    │22 │
                                        ⍝    │333│
                                        ⍝    │22 │
                                        ⍝    │1  │
                                        ⍝    └───┘
             n(1-n←2×⍵)↑                ⍝ take a 2×⍵ by 1-2×⍵ matrix
                                        ⍝ (negative length extends backwards):
                                        ⍝    ┌─────┐
                                        ⍝    │  1  │
                                        ⍝    │  22 │
                                        ⍝    │  333│
                                        ⍝    │  22 │
                                        ⍝    │  1  │
                                        ⍝    │     │
                                        ⍝    └─────┘
        (⌽⍪⊢)                           ⍝ the reverse of it, vertically joined with it
                                        ⍝    ┌─────┐
                                        ⍝    │  1  │
                                        ⍝    │ 22  │
                                        ⍝    │333  │
                                        ⍝    │ 22  │
                                        ⍝    │  1  │
                                        ⍝    │     │
                                        ⍝    │  1  │
                                        ⍝    │  22 │
                                        ⍝    │  333│
                                        ⍝    │  22 │
                                        ⍝    │  1  │
                                        ⍝    │     │
                                        ⍝    └─────┘
     ⍺⍴⊂                                ⍝ take ⍺ copies
  ⊃⍪/                                   ⍝ join them vertically
 ⍉                                      ⍝ transpose

파이썬-135 자

A,F=map(int,raw_input().split());R=range
for y in R(-A+1,A):print"".join((" %s"%x)[-x<s*y<1]for s in(1,-1)for x in R(1,A)+R(A,-1,-1))*F

선행 공백이있는이 버전은 132 자입니다.

A,F=map(int,raw_input().split());R=range
for y in R(-A+1,A):print"".join((" %s"%x)[-x<s*y<1]for s in(1,-1)for x in R(A)+R(A,0,-1))*F

stdin에서 읽을 필요가 없거나 입력이 쉼표로 분리되어 있어도 상당히 짧을 수 있습니다

쉼표로 구분 된 입력의 경우 첫 번째 줄은

A,F=input();R=range

APL (77)

,/{×⍎⍵:⍵⋄' '}¨¨⊃∘↑∘⍕¨¨K⍴⊂(⊖M),⍨M←(2⍴N+N-1)↑(0 1↓M),⍨⌽M←(⌽⊖/¨M)×≥/¨M←⍳2⍴⊃N K←⎕

J, 87 자

프로그램으로 :

b=:]\@(]#~' '~:])(":@:>:@i.@-)
,.~^:(<:Y)(,.|.)@(' ',.~((<:({."1|."1)b),.b),' '$~2<:])X
        Y                                              X

다음과 같이 실행됩니다.

,.~^:(<:2)(,.|.)@(' ',.~((<:({."1|."1)b),.b),' '$~2#<:) 3
  3           3         
 232         232        
12321 12321 12321 12321 
       232         232  
        3           3   
,.~^:(<:4)(,.|.)@(' ',.~((<:({."1|."1)b),.b),' '$~2#<:) 2
 2       2       2       2       2       2       2       2      
121 121 121 121 121 121 121 121 121 121 121 121 121 121 121 121 
     2       2       2       2       2       2       2       2 

함수 F로 필요한 경우 5 자 이상입니다.

3 F 2
  3           3         
 232         232        
12321 12321 12321 12321 
       232         232  
        3           3   

하스켈 ( 226 225 222 220 214)

Haskell에서의 나의 시도 :

import List
n!k|n>k=p:n!(k+1)++[p]|0<1=[p]where p=(n-1)?" "++k?show k++(n-k)?" ">>=id
f[n,k]=k?(n!1++(2*n-1)?' ':map reverse(n!1)++[(2*n-1)?' '])>>=id
main=interact$unlines.transpose.f.map read.words
(?)=replicate

죄송합니다. (€)최적화되었습니다. 1 €에 3 바이트가 필요합니다! 각 바이트는 1 바이트 만 걸립니다.
사양을 만족하지 않는 "베타 버전"은 다음과 같습니다.

import List

-- Creates a single wave of numbers. k should be equal to 1
-- and is used for internal stuff,
wave n k|n==k=[peek]
        |otherwise = peek:wave n(k+1)++[peek] where
  peek=replicate(n-1)" "++replicate k(show k)++replicate(n-k)" ">>=id

-- Creates a full wave
-- k: number of waves, n: size of waves
fullWave[n,k]=unlines.transpose.concat.replicate k$wave n 1++map reverse(wave n 1)

main=interact$fullWave.map read.words

CJam, 45 바이트

CJam 은이 도전보다 훨씬 젊으 므로이 답변은 녹색 확인 표시를 사용할 수 없습니다 (marinus의 APL 답변으로 업데이트되어야 함). 그래도 이것은 여전히 ​​재미있는 작은 운동이었습니다.

r~:I2*,{)IS*I@I\-z-_a*+I~)>I(S*+}%_Wf%+r~*zN*

여기에서 테스트하십시오.

아이디어는 다음과 같이 반주기를 수직 으로 생성하는 것입니다 .

  1  
 22  
333  
 22  
  1  

(SE가 삼키는 다음 빈 줄). 그런 다음 복제되고 각 행이 반전되고 기간의 후반이 추가됩니다. 그런 다음 전체 기간이 횟수만큼 반복되고 궁극적으로 그리드가 수평을 따라 파동을 향하도록 바뀝니다.