Biorąc pod uwagę amplitudę i okres fali, wydrukuj falę. Zobacz przykładowe wyniki, aby uzyskać więcej informacji. Całkowita liczba form fali równa się okresowi, a wysokość każdej fali równa się amplitudzie. Amplituda i okres są mniejsze niż 10. Możesz zignorować spacje końcowe, ale nie spacje wiodące.

Sample Input
3 2

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

Dyalog APL, 43 40 bajtów

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

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

Jest to funkcja dynamiczna z amplitudą jako prawym argumentem ( ⍵) i kropką jako lewym argumentem ( ⍺). Program odczytujący dane wprowadzone przez użytkownika wymagałby takiej samej liczby znaków.

Czerpiąc inspirację z odpowiedzi CJam Martina Büttnera :

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

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

Ta wersja z wiodącą spacją ma 132 znaki

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

Może być również znacznie krótszy, jeśli nie jest wymagany odczyt ze standardowego wejścia lub nawet jeśli dane wejściowe są oddzielone przecinkami

W przypadku wprowadzania oddzielanego przecinkami pierwszy wiersz staje się

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 znaków

Jako program:

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

działa w ten sposób:

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

Jest 5 dodatkowych znaków, jeśli potrzebujemy go jako funkcji F:

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

Haskell ( 226 225 222 220 214)

Moja próba w 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

Przepraszam chłopaki, (€)jest zoptymalizowany, zajmuje trzy bajty za jeden €, w przeciwieństwie do! który zajmuje tylko jeden bajt.
Oto „wersja beta”, która nie spełnia specyfikacji:

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 bajtów

CJam jest znacznie młodszy od tego wyzwania, więc ta odpowiedź nie kwalifikuje się do zielonego znacznika wyboru (który powinien być zaktualizowany do odpowiedzi APL marinusa). To było jednak wciąż fajne ćwiczenie.

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

Sprawdź to tutaj.

Chodzi o to, aby wygenerować pół kropki w pionie , tak jak:

  1  
 22  
333  
 22  
  1  

(Plus następny pusty wiersz, który połyka SE). To jest następnie duplikowane, każdy wiersz jest odwracany, a druga połowa okresu jest dołączana. Następnie cała rzecz jest powtarzana przez liczbę okresów, a ostatecznie siatka jest transponowana, aby zorientować falę wzdłuż linii poziomej.