Drucken Sie die Welle unter Berücksichtigung der Amplitude und Periode für eine Welle. Weitere Informationen finden Sie in der Beispielausgabe. Die Gesamtzahl der Wellenformen entspricht der Periode und die Höhe jeder Welle entspricht der Amplitude. Amplitude und Periode sind kleiner als 10. Sie können die nachgestellten Leerzeichen ignorieren, jedoch nicht die führenden Leerzeichen.

Sample Input
3 2

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

Dyalog APL, 43 40 Bytes

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

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

Dies ist eine dyadische Funktion mit der Amplitude als rechtem Argument ( ⍵) und der Periode als linkem Argument ( ⍺). Ein Programm, das Benutzereingaben liest, benötigt die gleiche Anzahl von Zeichen.

Zeichnung Inspiration von Martin Büttner CJam Antwort :

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

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

Diese Version mit einem führenden Leerzeichen ist 132 Zeichen

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

Sie kann auch erheblich kürzer sein, wenn das Lesen von stdin nicht erforderlich ist oder wenn die Eingabe durch Kommas getrennt ist

Bei kommagetrennten Eingaben wird die erste Zeile

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 Zeichen

Als Programm:

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

läuft so:

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

Es sind noch 5 Zeichen, wenn wir es als Funktion F brauchen:

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

Haskell ( 226 225 222 220 214)

Mein Versuch in 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

Sorry Leute, (€)ist weg optimiert, es dauert drei Bytes für einen Euro im Gegensatz zu! Das dauert nur ein Byte.
Hier ist eine "Beta-Version", die die Spezifikation nicht erfüllt:

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 Bytes

CJam ist viel jünger als diese Herausforderung, daher ist diese Antwort nicht für das grüne Häkchen geeignet (das übrigens auf die APL-Antwort von Marinus aktualisiert werden sollte). Dies war jedoch immer noch eine lustige kleine Übung.

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

Teste es hier.

Die Idee ist, eine halbe Periode vertikal zu erzeugen :

  1  
 22  
333  
 22  
  1  

(Plus die nächste leere Zeile, die SE schluckt). Dies wird dann dupliziert, jede Zeile wird umgekehrt und die zweite Hälfte der Periode wird angehängt. Dann wird das Ganze durch die Anzahl der Perioden wiederholt, und schließlich wird das Gitter transponiert, um die Welle entlang der Horizontalen auszurichten.