กำหนดขนาดและระยะเวลาของคลื่นให้พิมพ์คลื่น ดูตัวอย่างผลลัพธ์สำหรับรายละเอียดเพิ่มเติม จำนวนรูปแบบคลื่นทั้งหมดเท่ากับระยะเวลาและความสูงของแต่ละคลื่นเท่ากับความกว้าง ความกว้างและระยะเวลาน้อยกว่า 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 )

นี่คือฟังก์ชัน dyadic ที่มีแอมพลิจูดเป็นอาร์กิวเมนต์ที่ถูกต้อง ( ⍵) และระยะเวลาเป็นอาร์กิวเมนต์ซ้าย ( ⍺) โปรแกรมที่อ่านอินพุตของผู้ใช้จะมีจำนวนอักขระเหมือนกัน

วาดแรงบันดาลใจจากคำตอบ CJam ของ 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 ตัวอักษร

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 

มันคือ 5 ตัวอักษรเพิ่มเติมถ้าเราต้องการมันเป็นฟังก์ชั่น F:

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

Haskell ( 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

ขออภัยพวก(€)มันถูกปรับให้เหมาะกับมันใช้เวลาสามไบต์ต่อหนึ่ง€เมื่อเทียบกับ! ซึ่งใช้เวลาหนึ่งไบต์เท่านั้น
นี่คือ "รุ่นเบต้า" ที่ไม่เป็นไปตามข้อกำหนด:

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 อายุน้อยกว่าความท้าทายนี้มากดังนั้นคำตอบนี้จึงไม่มีสิทธิ์สำหรับเครื่องหมายถูกสีเขียว (ซึ่งควรปรับปรุงให้เป็นคำตอบ APL ของ marinus) นี่เป็นการออกกำลังกายเล็ก ๆ น้อย ๆ ที่สนุก

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

ทดสอบที่นี่

ความคิดคือการสร้างครึ่งเวลาในแนวตั้งเช่น:

  1  
 22  
333  
 22  
  1  

(บวกแถวที่ว่างถัดไปซึ่ง SE กลืน) ซึ่งจะเป็นการทำซ้ำแต่ละแถวจะถูกย้อนกลับและจะมีการต่อท้ายช่วงครึ่งหลัง จากนั้นสิ่งทั้งปวงจะถูกทำซ้ำตามจำนวนของจุดและท้ายที่สุดแล้วตารางจะถูกย้ายเพื่อปรับทิศทางคลื่นตามแนวนอน