i need output like this:
1 2 3 4 5
2 2 3 4 5
3 3 3 4 5
4 4 4 4 5
5 5 5 5 5
this is what i can do but it's not right
size=int(input())
for row in range(1,size+1):
for col in range(1,size+1):
print(row,end=' ')
print(col)
only use forloop
You can do:
size = int(input())
for i in range(1, size+1):
print(' '.join(str(max(i, j)) for j in range(1, size+1)))
Example for size of 9:
1 2 3 4 5 6 7 8 9
2 2 3 4 5 6 7 8 9
3 3 3 4 5 6 7 8 9
4 4 4 4 5 6 7 8 9
5 5 5 5 5 6 7 8 9
6 6 6 6 6 6 7 8 9
7 7 7 7 7 7 7 8 9
8 8 8 8 8 8 8 8 9
9 9 9 9 9 9 9 9 9
It however doesn't print nicely for double digits:
1 2 3 4 5 6 7 8 9 10
2 2 3 4 5 6 7 8 9 10
3 3 3 4 5 6 7 8 9 10
4 4 4 4 5 6 7 8 9 10
5 5 5 5 5 6 7 8 9 10
6 6 6 6 6 6 7 8 9 10
7 7 7 7 7 7 7 8 9 10
8 8 8 8 8 8 8 8 9 10
9 9 9 9 9 9 9 9 9 10
10 10 10 10 10 10 10 10 10 10
So you can find the number of digits, and pad the strings:
import math
max_n = 10
digits = int(math.log10(max_n))+1
for i in range(1, max_n+1):
print(' '.join(str(max(i, j)).rjust(digits) for j in range(1, max_n+1)))
1 2 3 4 5 6 7 8 9 10
2 2 3 4 5 6 7 8 9 10
3 3 3 4 5 6 7 8 9 10
4 4 4 4 5 6 7 8 9 10
5 5 5 5 5 6 7 8 9 10
6 6 6 6 6 6 7 8 9 10
7 7 7 7 7 7 7 8 9 10
8 8 8 8 8 8 8 8 9 10
9 9 9 9 9 9 9 9 9 10
10 10 10 10 10 10 10 10 10 10
Single loop:
size=int(input())
for i in range(1, size + 1):
print(' '.join([str(max([i, j])) for j in range(1, size + 1)]))
Here is an easy to understand example :
num = int(input("Input a number : "))
for i in range(1, num+1):
row = ""
for j in range(1, num+1):
row += " " + str(j if j > i else i)
print(row)
I make a list for each row. If the row number is i then the row starts with i i's. After that it counts up to the given size.
size = int(input())
for row in range(1, size + 1):
lst = [row] * row + list(range(row + 1, size + 1))
print(' '.join([str(i) for i in lst]))
Output for size = 5:
1 2 3 4 5
2 2 3 4 5
3 3 3 4 5
4 4 4 4 5
5 5 5 5 5
A solution following your code's logic:
for row in range(1,size+1):
cnt = 1
for col in range(1,size+1):
if(cnt < row):
printNum = row
else:
printNum = cnt
cnt = cnt + 1
if(printNum > 9):
print(printNum,end=' ')
else:
print(printNum,end=' ')
print("\n")
Yet another variation:
size = input()
width = len(size)
size = int(size)+1
for i in range(1, size):
print(*(f'{max(i, j):>{width}}' for j in range(1, size)))
This does it:
size=int(input())
for col in range(1,size+1):
for row in range(1,size+1):
if row <= col:
print(col, end=' ')
else:
print(row, end=' ')
print()
It's not the most elegant answer but it works for any size.
Walrus to rescue. For Python 3.8+
(size := int(input("Input a number : ")) + 1)
for i in range(1, size):
print(' '.join(str(max(i, j)) for j in range(1, size)))
Result:
Enter a number : 5
1 2 3 4 5
2 2 3 4 5
3 3 3 4 5
4 4 4 4 5
5 5 5 5 5
# write a program to traverse every element of the two-dimensional array in Python.
dt = [ [1, 2, 3, 4, 5], [2, 2, 3, 4, 5], [3, 3, 3, 4, 5 ], [4, 4, 4, 4, 5], [5, 5, 5, 5, 5] ]
# Use for loop to print the entire elements of the two dimensional array.
for x in dt: # outer loop
for i in x: # inner loop
print(i, end = " ") # print the elements
print()
This code will give you output like this:
1 2 3 4 5
2 2 3 4 5
3 3 3 4 5
4 4 4 4 5
5 5 5 5 5
but you have to input the array manually
Related
1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 7 6 5 4 3 2 1
1 2 3 4 5 6 6 5 4 3 2 1
1 2 3 4 5 5 4 3 2 1
1 2 3 4 4 3 2 1
1 2 3 3 2 1
1 2 2 1
1 1
How can I code this in python?
So far this is my code but I can't figure out the spaces.
number = int(input("enter a number to create your triangle: "))
for col in range(number,0,-1):
for row in range(1,col):
print(row, end=" ")
if col<number:
print(" "*(row*2), end="")
for row in range(col-1,0,-1):
print(row, end=" ")
print()
Instead of looping multiple times, you could create a base list containing all numbers as strings, iterate once to print each row and the reverse:
number = 9
base = [str(n) for n in range(1, number+1)]
for i, idx in enumerate(range(len(base)-1, 0, -1)):
if i == 0:
print(' '.join(base + base[::-1]))
base[idx] = ' '
print(' '.join(base + base[::-1]))
Out:
1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 7 6 5 4 3 2 1
1 2 3 4 5 6 6 5 4 3 2 1
1 2 3 4 5 5 4 3 2 1
1 2 3 4 4 3 2 1
1 2 3 3 2 1
1 2 2 1
1 1
As I've pointed in this comment, using all "power" of print() and unpacking you can make it really easy.
By default all arguments passed to print() will be separated with space, so we can just unpack there range from 1 to current index, string of spaces and reverse range from current index to 1:
number = int(input("enter a number to create your triangle: "))
for i, n in enumerate(range(number, 0, -1)):
print(*range(1, n + 1), *(" " * (i * 2)), *range(n, 0, -1))
Output:
1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 7 6 5 4 3 2 1
1 2 3 4 5 6 6 5 4 3 2 1
1 2 3 4 5 5 4 3 2 1
1 2 3 4 4 3 2 1
1 2 3 3 2 1
1 2 2 1
1 1
Important notice: Code above will work properly only for number below 10.
I am trying to write the code but not getting how to achieve expected output
Causing issue with space and not able to make proper judgement how to get exact spaces after every iteration
My code :
n=15
cnt=0
lst=[str(' ') for x in range(1,n+1)]
initial_length=len(''.join(lst))
print(initial_length)
for row in range(1,n+1):
lst[cnt-1]=str(row)
cnt=cnt-1
print(' '.join(lst))
Output of above code is not as expected output
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
6 5 4 3 2 1
7 6 5 4 3 2 1
8 7 6 5 4 3 2 1
9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
11 10 9 8 7 6 5 4 3 2 1
12 11 10 9 8 7 6 5 4 3 2 1
13 12 11 10 9 8 7 6 5 4 3 2 1
14 13 12 11 10 9 8 7 6 5 4 3 2 1
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
Expected output :
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
6 5 4 3 2 1
7 6 5 4 3 2 1
8 7 6 5 4 3 2 1
9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
11 10 9 8 7 6 5 4 3 2 1
12 11 10 9 8 7 6 5 4 3 2 1
13 12 11 10 9 8 7 6 5 4 3 2 1
14 13 12 11 10 9 8 7 6 5 4 3 2 1
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
Another approximation, by knowing the quantity of spaces in advance using a recursive function:
def findDigits(N):
if N <= 1:
return N
# Changing number to string
s = str(N)
# Add length of number to total_sum
return len(s) + findDigits(N - 1)
def print_inverse_pyramid(n):
# Calculate number of total digits until n
total_digits = findDigits(n)
# Print the pyramid
for row in range(1, n + 1):
total_digits -= len(str(row))
l_r = [str(i) for i in range(row, 0, -1)]
print(" " * (total_digits + (n - row)) + " ".join(l_r))
print_inverse_pyramid(15)
You have to account for larger digits taking up more space, which means that when creating the list that contains spaces, you need to multiply the space by how many digits are in that number which you can get by len(str(number)):
n = 15
# create a list containing how many spaces each number will take up
# in reverse order because the figure is reverse
lst = [' ' * len(str(x)) for x in range(n, 0, -1)]
# go over each number
for x in range(1, n + 1):
# replace the digit in its place from end
# by the string represantion of itself
lst[-x] = str(x)
# print joined list
print(' '.join(lst))
Also:
I strongly suggest following PEP 8 - Style Guide for Python Code. Function and variable names should be in snake_case, class names in CapitalCase. Don't have space around = if it is used as a part of keyword argument (func(arg='value')) but have space around = if it is used for assigning a value (variable = 'some value'). Have space around operators (+-/ etc.: value = x + y(except here value += x + y)). Have two blank lines around function and class declarations. Object method definitions have one blank line around them.
Quick and dirty: 'looking' at the last line
n = 15
def serie(n):
return ' '.join([str(j) for j in range(n, 0, -1)])
maxlen = len(serie(n))
for i in range(1, n +1):
s = serie(i)
print(" " * (maxlen - len(s)) + s)
With math, computing the length as the sum of the int of the log10 of values and adding for the spaces
import math
n = 15
def lenserie(n):
return sum(map(lambda i : int(math.log(i, 10)) + 1 ,range(1, n+1))) + (n-1)
maxlen = lenserie(n)
for i in range(1, n+1):
print(" " * (maxlen - lenserie(i)) + " ".join([str(i) for i in range(i, 0, -1)]))
Here is my code which prints a particular number pattern. I want my number pattern to be in perfect triangular arrangement like:
a = int(input('Enter number: '))
base = a
while base > 0:
for j in range(1, a + 1):
print(' ' * (2 * j - 2), end = '')
for i in range(1, base + 1):
print(str(i), end = ' ')
print()
base -= 1
The output:
Enter number: 5
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
Enter number: 7
1 2 3 4 5 6 7
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
The program works fine for numbers < 10 but when I input a number > 10 it gives a distorted pattern.
For example:
Enter number: 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
So is there a way to make the pattern right?
If you want to have the same result for two digit numbers, you have to format your string. Here how it also works for two digit results:
a = int(input('Enter number: '))
base = a
while base > 0:
for j in range(1, a + 1):
print(' ' * (2 * j - 2), end = '')
for i in range(1, base + 1):
print('{0:>2}'.format(str(i)), end = ' ')
print()
base -= 1
Result for 15:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
Some adjustments and str.rjust will do the trick:
a = base = 15
while base > 0:
for j in range(a):
print(' ' * 3 * j, end='')
for i in range(base):
print(str(i+1).rjust(3), end='')
print()
base -= 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
You might use rjust method of str, it does:
Return a right-justified string of length width. Padding is done using
the specified fill character (default is a space).
Simple example usage:
numbers = [1, 10, 10, 1000, 10000]
for n in numbers:
print(str(n).rjust(5))
Output:
1
10
10
1000
10000
Note that rjust requires at least one argument: width, if original str is shorther than width leading spaces (or other characters if specified) will be added to get str of length equal to width, otherwise original str will be returned.
I am trying to create a number grid specifically using for loops. My code is as follows
def draw_grid (num):#x represents row y representes column
for x in range (num):
print(x+1, end= ' ' )
print()
for y in range (num):
print(y+1, end= ' ' )
And my ouput results as this when I draw a grid of 10 for example.
1
1 2 3 4 5 6 7 8 9 10 2
1 2 3 4 5 6 7 8 9 10 3
1 2 3 4 5 6 7 8 9 10 4
1 2 3 4 5 6 7 8 9 10 5
1 2 3 4 5 6 7 8 9 10 6
1 2 3 4 5 6 7 8 9 10 7
1 2 3 4 5 6 7 8 9 10 8
1 2 3 4 5 6 7 8 9 10 9
1 2 3 4 5 6 7 8 9 10 10
1 2 3 4 5 6 7 8 9 10
I have tried manipulating it several different ways but I cannot discern what is creating the 1 at the top and the 2-10 on the rightmost column? Should my Y value be coded differently?
Here is what is happening
def draw_grid (num):#x represents row y representes column
for x in range (num):
print(x+1, end= ' ' )
print()
for y in range (num):
print(y+1, end= ' ' )
In your outer loop you are printing x + 1 on every iteration with no newline, end = ' ' and then printing a new line, print(). On your first iteration its printing 1 with no newline followed by a newline from print() and then it enters your inner loop and is printing 1-10 again with no new line at the end. Now when the second iteration of your outer loop occurs it prints 2, that's going to be printed right after all the y values followed by print() and the process repeats.
What you want is this most likely
def draw_g(num):
for x in range(num):
for y in range(num):
print(y + 1, end = ' ')
print()
draw_g(10)
Here we are only using our outer loop to determine the amount of rows, times we will print all the values in our inner loop. For our first iteration we print all the values of y + 1 in range(num) once that is completed we use print() to advance to the next line and then the second iteration of of outer loop takes place, this repeats for x in range(num)
. And the result is this.
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
for j in range(10):
for i in range(10):
print(j,end=" ")
My results are bunched together and I need to have 10 numbers per line. I cant use a print("0123456789"). I have tried print(j,j,j,j,j,j,j,j,j) and I get the results that I'm looking for but I'm sure this isn't the proper way to write the code.
If print(j,j,j,j,j,j,j,j,j) works then you simply need to add another print() after each iteration:
for j in range(10):
for i in range(10):
print(j,end=" ")
print()
Output:
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4 4
5 5 5 5 5 5 5 5 5 5
6 6 6 6 6 6 6 6 6 6
7 7 7 7 7 7 7 7 7 7
8 8 8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9 9
Or simply:
for j in range(10):
print(" ".join(str(j) * 10))
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4 4
5 5 5 5 5 5 5 5 5 5
6 6 6 6 6 6 6 6 6 6
7 7 7 7 7 7 7 7 7 7
8 8 8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9 9
Why are you using a nested for loop when you can use a single for loop:
for i in range(10):
print('{} '.format(i) * 10)
This is similar to Malik Brahimi's solution, except it doesn't put a space after the last digit on each line:
for i in range(10):
print(' '.join([str(i)]*10))
output
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4 4
5 5 5 5 5 5 5 5 5 5
6 6 6 6 6 6 6 6 6 6
7 7 7 7 7 7 7 7 7 7
8 8 8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9 9
Just for fun, here's another way to do it with a single loop, this time using a format string with numbered fields.
fmt = ('{0} ' * 10)[:-1]
for i in range(10):
print(fmt.format(i))