Sherlock and The Beast

In terms of improvements, a few obvious things. Generally, as with many Python questions here, I would suggest you read and implement the Python Style Guide, PEP-0008, particularly:

• Naming conventions (function and variable names should be lowercase_with_underscores); and
• Whitespace (e.g. if i<3: should be if i < 3:).

Although this was written for Hacker Rank, you should still not have running code at the top level of the script. Instead, I suggest you wrap the top section in a function (e.g. def create_items():) and then add:

if __name__ == "__main__":
    sherlock_and_the_beast(create_items())

The context does, however, place some restrictions - I was going to suggest that you gave a meaningful prompt to raw_input, but the Hacker Rank grader gets confused!

You could use the for: else: construct to simplify your final loop:

for j in range(i/3, 0, -1):
    if (i - (3 * j)) % 5 == 0:
        print int('5' * (3 * j) + '3' * (i % (3 * j)))
        break
else:
    print -1

Is there any improvement that can be done to the code?

Yes. The other answers do have very good points, but I don't want to repeat them. I only could add that renaming your i variable to n would match the task description better.

Is there any optimization?

You don't need any loop at all! We only need to distinguish four cases:

• N is divisible by 3 exactly
• N is divisible by 3 with remainder 1 and is at least 10
• N is divisible by 3 with remainder 2 and is at least 5
• else there is no decent number with N digits

So we can simplify the code to

def decent_number(n):
    rem = n % 3
    threes = ((3 - rem) % 3) * 5
    fives = n - threes
    if fives < 0:
        return -1
    else:
        return int("5"*fives + "3"*threes)

for line in lines
    print decent_number(int(line))

On top of the comment from jonrsharpe, I'd like to point out a few things about the code to generate the initial list :

• you do not need to initialise a to 0 first : this line can be removed.
• you do not need to provide 0 as a first argument to range as it is the default behavior
• you don't even need the variable a at all
• we usually call _ the variables whose value is not going to be used

A this stage, you have :

items=[]
for _ in range(int(raw_input(''))):
    items.append(int(raw_input('')))

Then, you can use list comprehension to write this in a concise way :

items=[int(raw_input('')) for _ in range(int(raw_input('')))]

Finally, because of the way this is going to be used, you do not even need to actually build the list : you could just use generator expression :

items = (int(raw_input('')) for _ in range(int(raw_input(''))))

Even without deducing a general algorithm, here's how I would have written it, in Python as well:

def largest_decent_number_of_length(N):
    for num_threes in xrange(0, N, 5):
        num_fives = length - num_threes
        if num_fives % 3 == 0:
            return "5" * num_fives + "3" * num_threes
    else:
        return "-1"

if __name__ == "__main__":
    T = raw_input('')
    for _ in range(0, T):
        N = raw_input('')
        print largest_decent_number_of_length(N)

This solution to me is more clear because it doesn't do magic with modulo to determine the case we are in, and incorporates some points which I feel are important for clear code.

First of all, as jonrsharpe also mentioned: if you want to do code executing at the top level, do it in an if __name__ == "__main__": section. This will only execute when directly run, but not when imported. However, this is something python specific, and in another language you would have to do this in a different fashion.

Second: The variable names are quite specific, num_threes and num_fives are more clear than i and j. I could have gone overboard, and have written number_of_threes but that would have made the names overly long, and thus less readable for such a short piece of code. The T and N however are quite short, but they are a direct translation from the document. I could have named them num_challenges and challenge, but that isn't necessary---assuming the reader also read the challenge itself. Another thing I always try to do is make function names read like descriptions, especially when the variables are filled in. This doesn't work often, but in the cases where you can, I believe it makes code more readable. "print largest decent number of length N" sounds like a clear task to me.

Third: After reading this, you should be able to follow my logic---I hope. The largest number will start with 5s, followed by 3s --- interchanging a 5 and a 3 would make the number smaller. Also, less 3s means more 5s, so we start with as few 3s as possible, and add as few as possible while still satisfying the second requirement (num_threes % 5 == 0). For each of these options, we check if the number of fives also satisfies the requirements, and if so, we print the number.

Fourth: we don't print the number, but return it, making the function reusable. (Not that important in this case, but I would just like to mention it). The main loop is concerned with reading numbers, and printing results. The function is concerned with finding the answer. The responsibilities are separated.

Fifth: The value returned is in both cases of the same type (a string, twice). Returning a string instead of a number is an arbitrary choice, however one that followed quite easily from the manipulations involved. One could decide to make it an integer instead, by writing return int("5" * num_fives + "3" * num_threes) and return -1. Both are a viable solution, and if I had to extend on this I would probably choose to go for wrapping the int(...) around it. However, the most important thing is that the function returns items of only one type.

Sixth: One of the nice things of python is the for...else construct. The else portion is executed when break/return is not called from within the loop. Using this, you don't have to use a variable flag that gets set on each point where you break from the loop. I admit it is a weird feature and it took me quite some time to get used to it, but it is ideally suited for the loops where you try to find an item satisfying a condition. If you found it, you can just break. If you haven't found it, the else will be executed instead.

I am surprised no one said this.

you have too many new lines, someone did mention that you need to use whitespace correctly. You actually have newlines in the middle of an if then elif else block which I think should cause issues

so this is your code

a=0
items=[]

a=int(raw_input(''))
for i in range(0,a):
    items.append(int(raw_input('')))



def Sherlock_and_The_Beast(items):
    for i in items:

        if i<3:
            print -1
        elif i%3==0:
            print int(str(5)*i)
        elif i==5:
            print int(str(3)*i)

        else:
            flag=False
            for j in range(i/3,-1,-1):
                if (i-(3*j))%5==0:
                    flag=True
                    print int(str(5)*(3*j)+str(3)*(i-(3*j)))
                    break
            if not flag:
                print -1




Sherlock_and_The_Beast(items)

and this is what it should look like

items=[]

a=int(raw_input(''))
for i in range(0,a):
    items.append(int(raw_input('')))

def Sherlock_and_The_Beast(items):
    for i in items: 
        if i<3:
            print -1
        elif i%3==0:
            print int(str(5)*i)
        elif i==5:
            print int(str(3)*i)
        else:
            flag=False
            for j in range(i/3,-1,-1):
                if (i-(3*j))%5==0:
                    flag=True
                    print int(str(5)*(3*j)+str(3)*(i-(3*j)))
                    break
            if not flag:
                print -1

Sherlock_and_The_Beast(items)

I also got rid of an unneeded declaration of the a variable, pretty much the next statement gives that variable a value, so just create the variable there instead