We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Practice
  2. Algorithms
  3. Warmup
  4. Diagonal Difference
  5. Discussions

Diagonal Difference

  • sagemode + 4 comments

    I got your point, you are thinking in a very broad perspective applying it in a situation where memory is a constraint. Here it is not! Python takes 0.01 seconds to execute the above program unlike Java(0.1 - 0.29 seconds) that's why I stated it being very powerful. It is good to think in your terms where memory is getting wasted, but not here.

    To your point "The same exact solution is easily accomplished in Java, but it still relies on saving unneeded values to an array which, as has already been pointed out, is actually a less optimal solution because it needlessly stores n^2 - 2n integers in arrays." Even in the below solution you are saving every input into curInput n^2 times which contradicts your point.

    for(int j = 0; j < numInputs; j++){
   for(int k = 0; k < numInputs; k++){
      cin >> curInput;
      if(j == k){
        leftD += curInput;
      }
      if(j+k == (numInputs-1)){
        rightD += curInput;
      }
   }
 }

    Yours Java equivalent solution to Python looks so hard to read.

    Look at this Python solution:

    n = int(input().strip())
dSumLeft = 0
dSumRight = 0
for i in range(n):
    matrixRow = input().split()
    dSumLeft += int(matrixRow[i])
    dSumRight += int(matrixRow[-(i + 1)])

    Simple and Powerful!

    We need to learn and understand the balance required between performance and memory usage.

    • AllisonP + 2 comments

      I'd first like to note that this discussion thread is about a Java solution, and somebody just randomly posted a Python solution in it to demonstrate that the solution could be done without nesting loops (which is not an argument that anyone was making).

      1. Sure, Python is an easy to use and arguably powerful--I never said it wasn't; however, the use of dynamic language magic tends to make things slow, which one of the many reasons Python is generally referred to as a slow language (though improvements have been made over the last 15 years). I'm really not sure what you are using to benchmark but, though Java has a high startup cost, it will almost always execute faster than Python.
      2. As data sets get large, memory is always a constraint; saving n^2 values to an array when only 2n are needed is not a scalable solution.
      3. Please re-read my comment, as I did not contradict my own point at all. Saving a value from an input stream to a single register (which is an optimization any good compiler should make on this code) and then repeatedly overwriting it is not in any way the same as reading the n^2 values as a chunk, breaking the chunk down into n^2 components, storing n^2 values, and reloading and summing the 2n you actually need.
      4. The purpose of my comment was simply to point out that the same solution is accomplishable in Java, because your comment incorrectly stated that Java couldn't read and break up a line the way that Python can and implied that is what makes Python a powerful tool. So I wrote a Java version of the Python poster's code, and pointed out why I still deem it not a good or scalable solution.
      • sagemode + 0 comments

        It's not quite right to say Java's performance is better than Python or viceversa, as one is better than other in different areas. I would like to repeat the following things again -

        1. It is good to think in your terms where memory is getting wasted, but "not here". I am a game developer and believe me I know exactly when one should be worrying about memory.
        2. I agree to the point of yours that saving a value into a single register is better than reading n^2 values as a chunk. But, is it arguably bad? Though we have better readability, and also it is easy to code. Again, believe me it is not!
      • danielhernanrico + 0 comments

        Sorry, I came 3 years later. Buy I want to poin out that the problem ask for a function that take an array.

        Touching anything in main is contrary to the excercise spirit. The program have an array in some place. The excercise main is there to make a mashed input and to test the answer. In python are better solutions to test a function ( or a class or a completet lib by the way) but this is the aproach used here.

        So, you can do something in the line you do. For example you can make it whit iterators that take care of reading the file until needed and storing only the numbers you need and consuming them, that would be an interesting answer, but not what the problem is about.

    • manasveemittal + 1 comment
      #!/bin/python

import sys


'''
n = int(raw_input().strip())
a = []
for a_i in xrange(n):
    a_temp = map(int,raw_input().strip().split(' '))
    a.append(a_temp)
z1,z2 = 0,0
for x1 in range(n):    
    z1 += a[x1][x1]
for x1 in range(n):
    z2 += a[x1][n-x1-1]

print z1,z2
'''
n = int(input().strip())
dSumLeft = 0
dSumRight = 0
for i in range(n):
    matrixRow = input().split()
    dSumLeft += int(matrixRow[i])
    dSumRight += int(matrixRow[-(i + 1)])
print dSumLeft-dSumRight

      neither my code , nor yours is printing, please point the error

      • marttidumangeng + 3 comments

        try this

        #!/bin/python

import sys

n = int(raw_input().strip())
dSumLeft  = 0
dSumRight  = 0
for i in range(n):
    matrixRow = map(int,raw_input().strip().split(' '))
    dSumLeft += int(matrixRow[i])
    dSumRight += int(matrixRow[n-i-1])
print abs(dSumLeft - dSumRight)
        • christopher_bir1 + 1 comment

          Here is a python 3 version below: 

          n = int(input().strip())
dSumLeft  = 0
dSumRight  = 0
for i in range(n):
    matrixRow = list(map(int,input().strip().split(' ')))
    dSumLeft += int(matrixRow[i])
    dSumRight += int(matrixRow[n-i-1])
print(abs(dSumLeft - dSumRight))
        • ak311 + 0 comments

          plz explain

        • toaa_kama2354 + 0 comments

          Actually the above solution was not working for me, so I did the solution without taking the input as it was already described in the main function.

          def diagonalDifference(a):
    # Complete this function  
    sum1  = 0
    sum2  = 0
    for i in range(n):
        sum1 += int(a[i][i])
        sum2 += int(a[i][n-i-1])
    return abs(sum1 - sum2)
    • CodeRanger_121 + 0 comments

      hi i am a beginner in python can anyone explain me , how have they input 2D list in Python from the user ....

      for a_i in range(n): a_t = [int(a_temp) for a_temp in input().strip().split(' ')] a.append(a_t)

    • h150040481 + 0 comments

      That python code was brilliant