Cho biên độ và khoảng thời gian cho một sóng, in sóng. Xem đầu ra mẫu để biết thêm chi tiết. Tổng số dạng sóng bằng với chu kỳ và chiều cao của mỗi sóng bằng biên độ. Biên độ và chu kỳ nhỏ hơn 10. Bạn có thể bỏ qua các khoảng trắng ở cuối nhưng không phải là các khoảng trắng ở đầu.

Sample Input
3 2

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

APL Dyalog, 43 40 byte

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

{⍉⊃⍪/⍺⍴⊂(⌽⍪⊢)n(1-n←2×⍵)↑↑⍴∘⍕¨⍨a,1↓⌽a←⍳⍵}( Cảm ơn, Moris Zucca )

Đây là một hàm dyadic với biên độ là đối số bên phải ( ⍵) và khoảng thời gian là đối số bên trái ( ⍺). Một chương trình đọc đầu vào của người dùng sẽ có cùng số lượng ký tự.

Rút ra một số cảm hứng từ câu trả lời CJam của Martin Büttner :

{⍉⊃⍪/⍺⍴⊂(⌽⍪⊢)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

Python - 135 ký tự

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

Phiên bản này với không gian hàng đầu là 132 ký tự

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

Nó cũng có thể ngắn hơn đáng kể nếu không cần phải đọc từ stdin hoặc ngay cả khi đầu vào được phân tách bằng dấu phẩy

Đối với đầu vào được phân tách bằng dấu phẩy, dòng đầu tiên trở thành

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 ký tự

Là một chương trình:

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

chạy như thế này:

,.~^:(<: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 

Đó là thêm 5 ký tự nếu chúng ta cần nó dưới dạng hàm F:

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

Haskell ( 226 225 222 220 214)

Thử của tôi ở 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

Xin lỗi các bạn, (€)được tối ưu hóa đi, phải mất ba byte cho một € trái ngược với! mà chỉ mất một byte mỗi.
Đây là "Phiên bản beta", không thỏa mãn thông số kỹ thuật:

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 byte

CJam trẻ hơn rất nhiều so với thử thách này, vì vậy câu trả lời này không đủ điều kiện cho dấu kiểm màu xanh lá cây (cần được cập nhật để trả lời APL của marinus). Đây vẫn là một bài tập nhỏ vui vẻ.

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

Kiểm tra nó ở đây.

Ý tưởng là tạo ra một nửa thời gian theo chiều dọc , như vậy:

  1  
 22  
333  
 22  
  1  

(Cộng với hàng trống tiếp theo mà SE nuốt). Điều này sau đó được nhân đôi, mỗi hàng được đảo ngược và nửa sau của giai đoạn được nối thêm. Sau đó, toàn bộ điều được lặp lại bởi số lượng thời gian, và cuối cùng, lưới được hoán vị để định hướng sóng dọc.