X or Not?

You are not logged in.

Please Log In for full access to the web site.
Note that this link will take you to an external site (https://shimmer.mit.edu) to authenticate, and then you will be redirected back to this page.

Write a program which, given a 2-D array containing 0s and 1s, determines whether or not there are 1s on the diagonals and 0s everywhere else. This pattern should look like an "X" made of 1s. If the array is an "X", you should print "X". Otherwise, print "not an X".

You may assume that the array is a square and contains only 0s and 1s. You may not assume that the array's length is a certain parity.1

The first line of your program should set up a variable array to hold the input array. For example:

array = [[1,0,1],
         [0,1,0],
         [1,0,1]]

Your program should print "X" for this input, since the elements on the diagonals are all 1s, and all other elements are 0s.

More Examples

These arrays are "X"s:

[[1,0,0,1],
 [0,1,1,0],
 [0,1,1,0],
 [1,0,0,1]]

[[1]]

[[1,0,0,0,0,0,1],
 [0,1,0,0,0,1,0],
 [0,0,1,0,1,0,0],
 [0,0,0,1,0,0,0],
 [0,0,1,0,1,0,0],
 [0,1,0,0,0,1,0], 
 [1,0,0,0,0,0,1]]

These arrays are not "X"s:

[[1,0,0,1],
 [0,1,0,0],
 [0,1,1,0],
 [1,0,0,1]]

[[0]]

[[1,0,0,1,1,0,1],
 [0,1,0,1,0,1,0],
 [0,0,1,0,1,0,0],
 [0,0,0,1,0,0,0],
 [0,0,1,0,1,0,0],
 [0,1,0,0,0,1,0], 
 [1,0,0,0,0,0,1]]

You may upload your file for testing:

A Python Error Occurred:

Error on line 5 of question tag.
    csq_soln="""

NameError: name 'logging' is not defined. Did you forget to import 'logging'

Solutions

array = [[1,0,1],
         [0,1,0],
         [1,0,1]]
<p>valid = True
length = len(array) # Using assumption that input array is square</p>
<p>for row_ix in range(length):
for col_ix in range(length):
if row_ix == col_ix or row_ix + col_ix == length:
# on one of the diagonals
if array[row_ix][col_ix] == 0:
valid = False
elif array[row_ix][col_ix] == 1:
valid = False</p>
<p>if valid:
print("X")
else:
print("not an X")</p>


Here I used the clever fact that, if an element is on the diagonal slanted down to the left (this way: / ), then the sum of their indices is equal to the length of the array.

If I believed that the input arrays would be very large, I could have optimized this code by printing `"not an X"` and stopping my iteration<footnote>As of now, the only way we have to "stop iteration" is to create a boolean variable and add it to the conditionals. You can also use what's called a <a href="https://www.tutorialspoint.com/python/python_break_statement.htm" target="_blank">break statement</a>.</footnote> _as soon as_ I detected any non-X-like feature of the input.

You'll be able to improve upon this solution once we learn about functions! It would be natural to write a function called `is_diagonal` to determine whether a certain row and column lies on a diagonal.

-------

Here's another solution with a slightly different, more incremental approach:



<p>array = [[1,0,1],
[0,1,0],
[1,0,1]]</p>
<p>valid = True
length = len(array)</p>
<h1>First build up a list of the locations of cells on the diagonals</h1>
<p>diagonals = []
for row_ix in range(length):
for col_ix in range(length):
if row_ix == col_ix: # diagonal this way: <br/>
# store the locations as tuples
diagonals.append((row_ix, col_ix))
if row_ix + col_ix == length: # diagonal this way: /
diagonals.append((row_ix, col_ix))</p>
<h1>Now go through each element and check it's a 1 if it's on a diagonal; otherwise 0</h1>
<p>for row_ix in range(length):
for col_ix in range(length):
if (row_ix, col_ix) in diagonals and array[row_ix][col_ix] == 0:
# a 0 on the diagonal
valid = False
if not (row_ix, col_ix) in diagonals and array[row_ix][col_ix] == 1:
# a 1 on the nondiagonal
valid = False</p>
<p>if valid:
print("X")
else:
print("not an X")</p>

This solution requires additional memory to store the diagonals list. The first solution would likely always be preferred for that reason, unless building up the diagonals list is useful for code elsewhere. 
</showhide>



<div id="cs_footnotes" style="display:none;"></div>