< PREVIOUS KATA
NEXT KATA >

## Task:

You have to write a function `pattern` which returns the following Pattern(See Examples) upto desired number of rows. 

* Note:`Returning` the pattern is not the same as `Printing` the pattern.

## Parameters:
    
    pattern(        n        ,        y        );
                    ^                 ^         
                    |                 |         
             Term upto which   Number of times  
              Basic Pattern     Basic Pattern   
                should be         should be     
                 created          repeated      
                                 vertically    
    
* Note: `Basic Pattern` means what we created in Complete The Pattern #12 i.e. a `simple X`.

## Rules/Note:

* The pattern should be created using only unit digits.
* If `n < 1` then it should return "" i.e. empty string.
* If `y <= 1` then the basic pattern should not be repeated vertically.
* `The length of each line is same`, and is equal to the length of longest line in the pattern.
* Range of Parameters (for the sake of CW Compiler) :
  + `n ∈ (-∞,50]`
  + `y ∈ (-∞,25]`
* If only one argument is passed then the function `pattern` should run as if `y <= 1`.
* The function `pattern` should work when extra arguments are passed, by ignoring the extra arguments.
   
   
## Examples:

#### Having Two Arguments:

##### pattern(4,3):

        1     1
         2   2 
          3 3  
           4   
          3 3  
         2   2 
        1     1
         2   2 
          3 3  
           4   
          3 3  
         2   2 
        1     1
         2   2 
          3 3  
           4   
          3 3  
         2   2 
        1     1
       
##### pattern(10,2):

        1                 1
         2               2 
          3             3  
           4           4   
            5         5    
             6       6     
              7     7      
               8   8       
                9 9        
                 0         
                9 9        
               8   8       
              7     7      
             6       6     
            5         5    
           4           4   
          3             3  
         2               2 
        1                 1
         2               2 
          3             3  
           4           4   
            5         5    
             6       6     
              7     7      
               8   8       
                9 9        
                 0         
                9 9        
               8   8       
              7     7      
             6       6     
            5         5    
           4           4   
          3             3  
         2               2 
        1                 1



#### Having Only One Argument:

##### pattern(25):

        1                                               1
         2                                             2 
          3                                           3  
           4                                         4   
            5                                       5    
             6                                     6     
              7                                   7      
               8                                 8       
                9                               9        
                 0                             0         
                  1                           1          
                   2                         2           
                    3                       3            
                     4                     4             
                      5                   5              
                       6                 6               
                        7               7                
                         8             8                 
                          9           9                  
                           0         0                   
                            1       1                    
                             2     2                     
                              3   3                      
                               4 4                       
                                5                        
                               4 4                       
                              3   3                      
                             2     2                     
                            1       1                    
                           0         0                   
                          9           9                  
                         8             8                 
                        7               7                
                       6                 6               
                      5                   5              
                     4                     4             
                    3                       3            
                   2                         2           
                  1                           1          
                 0                             0         
                9                               9        
               8                                 8       
              7                                   7      
             6                                     6     
            5                                       5    
           4                                         4   
          3                                           3  
         2                                             2 
        1                                               1
        
        
>>>LIST OF ALL MY KATAS<<<

Difficulty: introductory

Starter code:

def pattern(n, y=1, *_):
	

Solutions:
def pattern(n, *y):
    if n < 1:
        return ""
    y = y[0] if y and y[0] > 0 else 1
    result = []
    for j in range(1, n + 1):
        line = " " * (j - 1) + str(j % 10) + " " * (n - j)
        result.append(line + line[::-1][1:])
    return "\n".join(((result + result[::-1][1:-1]) * y)) + "\n" + result[0]

def pattern(n, y=1, *a):
    if n < 1: return ''
    l, y  = 2*n-1, max(1,y)
    sngl  = ['{}{}{}'.format(x%10, ' '*(l-2*x), x%10 if x!=n else '').center(l) for x in range(1,n+1)]
    cross = sngl + sngl[:-1][::-1]
    return '\n'.join( cross + cross[1:]*(y-1) )

def pattern(n,y = 1, *args):
    if n < 1:
        return ""
    if y < 1:
        y = 1

    p = [" "*i + str((i+1)%10) + " "*(2*n-3-2*i) + str((i+1)%10) + " "*i for i in range(n-1)] + \
        [" "*(n-1) + str(n%10) + " "*(n-1)] + \
        [" "*i + str((i+1)%10) + " "*(2*n-3-2*i) + str((i+1)%10) + " "*i for i in range(n-2,-1,-1)]

    return "\n".join(p + p[1:]*(y-1))

m,r=lambda s:s+s[-2::-1],lambda s,n:s+s[1:]*n
pattern=lambda n,v=1,*a:'\n'.join(r(m(list(m(' '*(i-1)+str(i%10)+' '*(n-i))for i in range(1,n+1))),v-1))

def pattern(n, y=1, *_):
    y = y if y>1 else 1
    s1 = '1'+ ' '*(2*n-3) + '1'
    s2 = '\n'+'\n'.join(' '*i+str(i+1)[-1]+' '*(2*n-2*i-3)+str(i+1)[-1]+' '*i for i in range(1,n-1))
    s3 = '\n'+' '*(n-1) +str(n)[-1]+' '*(n-1)+'\n'
    return '' if n<1 else s1+(s2+s3+s2[::-1]+s1)*y

def pattern(n,y=1,*args):
    p = ["".join([" " * (i - 1), str(i % 10), " " * (n - i)]) for i in range(1,n+1)]
    p = ["".join([i, i[-2::-1]]) for i in p]
    p += p[-2::-1]
    return "\n".join(p + p[1:] * (y - 1))

def pattern(n, y=1, *_):
    if n < 1:
        return ''
    ans, p, y = [], [], max(y, 1)
    for i in range(1, n+1):
        t = [' '] * (n * 2 - 1)
        t[i - 1] = t[n * 2 - 1 - 1 - i + 1] = str(i % 10)
        p.append(''.join(t))
    p += p[:-1][::-1]
    for _ in range(y):
        ans += p[1:] if ans else p
    return '\n'.join(ans)

def pattern(n, m=1, *args):
    if n < 1:
        return ""
    m = max(m, 1)
    r = ["{0}{1}{2}{1}{0}".format(" " * (i - 1), i % 10, " " * ((n - i) * 2 - 1)) for i in range(1, n)]
    r = r + ["{0}{1}{0}".format(" " * (n - 1), n % 10)] + r[::-1]
    return "\n".join(r + r[1:] * (m - 1))

def pattern(*args):
    n=args[0]
    y=args[1] if len(args)>=2 else 0
    res=""
    for count in range(max(1,y)):
        for i in range(n):
            if count>=1 and (i+1)==1:
                continue
            elif (i+1)!=n:
                res+=" "*i+str((i+1)%10)+" "*((n-1-i)*2-1)+str((i+1)%10)+" "*i+"\n"
            else:
                res+=" "*i+str((i+1)%10)+" "*i+"\n"
        for i in range(n-2,-1,-1):
            if (i+1)!=n:
                res+=" "*i+str((i+1)%10)+" "*((n-1-i)*2-1)+str((i+1)%10)+" "*i+"\n"
    return res[:-1]