Failing test cases on Set! on Kattis

I'm trying to solve a problem on Kattis called Set!. It can be viewed here.

This is my solution:

from sys import stdin
ls=[]
ls_output=[]
ls_final=[]
ls_answer=[]
output=''
for i in stdin:
    ls+=i.split()
ls1=dict(list(enumerate(ls,1)))
dc={v:k for k,v in ls1.items()}
ls_values=list(ls1.values())

for i in range(len(ls_values)):
    for j in range(i+1,len(ls_values)):
        for k in range(j+1,len(ls_values)):
               ls_output.append([ls[i],ls[j],ls[k]])

for m in ls_output:
    if all(len(set([m[0][n], m[1][n], m[2][n]])) in [1, 3] for n in range(4))\
    and m[0]!=m[1]!=m[2]!=m[0]:
        ls_final.append(m)

if ls_final:
    for x in ls_final:
        for y in x:
            ls_answer.append(dc[y])
    for z in range(0,len(ls_answer),3):
        output+=f'{ls_answer[z]} {ls_answer[z+1]} {ls_answer[z+2]}\n'
else:
    output+="no sets"
print(output)

For some reason, it always fails the 8th test case (passing 7/31 cases). I cannot figure out what's wrong with the code as it looks correct to me, as a beginner. (I'm not asking for anyone to optimize my code. I know that it could be improved and be made more efficient, beautified. But that is not my main point. Also, please do not provide a solution from some GitHub repo. I'm interested in learning only from what I coded here. And yes, I've already tried consulting Chat-you-know-who)

#Updated the code according to a suggestion to do away with dictionaries and prevent the duplicates problem. Still had the same result (8th test case failed).

from sys import stdin
ls=[]
ls_output=[]
ls_final=[]
ls_answer=[]
output=''
for i in stdin:
    ls+=i.split()
#enumerated ls1 and then unpacked the tuples to form ls2
ls2=[]
ls1=list(enumerate(ls,1))
list(ls2.extend(item) for item in ls1)
##ls1=dict(list(enumerate(ls,1)))
##ls_keys=list(ls1.keys())
##
####dc={v:k for k,v in ls1.items()}
##ls_values=list(ls1.values())

for i in range(len(ls)):
    for j in range(i+1,len(ls)):
        for k in range(j+1,len(ls)):
               ls_output.append([ls[i],ls[j],ls[k]])

for m in ls_output:
    if all(len(set([m[0][n], m[1][n], m[2][n]])) !=2 for n in range(4)):
        ls_final.append(m)

if ls_final:
    for x in ls_final:
        for y in x:
            ls_answer.append(ls2[ls2.index(y)-1])  ##ls2=[1,3SOP,2,2DOP,3,1STP..]
    for z in range(0,len(ls_answer),3):
        output+=f'{ls_answer[z]} {ls_answer[z+1]} {ls_answer[z+2]}\n'
else:
    output+="no sets"
print(output)

Edit:

This is the correct solution (thanks to @ggorlen), keeping parts of my original code (dictionary) while eliminating other data structures/ possibility of duplicates being indexed wrongly. The code is more concise and solves all test cases now.

from sys import stdin
stdin=open('std.txt','r')
ls=[]
ls_final=[]
output=''
for i in stdin:
    ls+=i.split()
ls1=dict(list(enumerate(ls,1)))

for i in range(len(ls)):
    for j in range(i+1,len(ls)):
        for k in range(j+1,len(ls)):
               acc=[]
               acc.append(ls1[i+1])
               acc.append(ls1[j+1])
               acc.append(ls1[k+1])
               if all(len(set([acc[0][n], acc[1][n], acc[2][n]])) !=2 for n in range(4)):
                   ls_final.append([i+1,j+1,k+1])
ls_final=[j for i in ls_final for j in i]

if ls_final:   
    for z in range(0,len(ls_final),3):
        output+=f'{ls_final[z]} {ls_final[z+1]} {ls_final[z+2]}\n'
else:
    output+="no sets"
print(output)

Your fundamental logic looks correct. Although you've discounted simplifying and refactoring your code, that's exactly what I did to pass the tests.

Here's my solution, which starts with your solution and strips out unnecessary intermediate steps and data structures:

from sys import stdin


found = False
cards = []

for line in stdin:
    cards.extend(line.split())

for i in range(len(cards)):
    for j in range(i + 1, len(cards)):
        for k in range(j + 1, len(cards)):
            x, y, z = cards[i], cards[j], cards[k]

            if all(len(set([x[i], y[i], z[i]])) != 2 for i in range(4)):
                found = True
                print(i + 1, j + 1, k + 1)

if not found:
    print("no sets")

My hunch was that using the card's index information directly would handle duplicates. This constraint isn't discussed in the description, leaving open the possibility that it could account for the hidden failures.

Your approach, using a dict to map each card to its index, will fail in the presence of duplicates as two cards will both map to the same index. In my version, duplicate cards still preserve their separate indices.

Morals of the story:

1. Try to solve problems directly, with a minimum of steps. Every step and piece of complexity added introduces a potential failure point.
2. Don't be too hasty to reject refactoring as a tool to fix logical problems. Simplification can reveal hidden characteristics that may not be obvious in a complex design.
3. Revisit the problem constraints to consider edge cases like duplicates. As Kelly mentions, coding challenges that are ostensibly modeled after real-life domains often break rules in those domains, as appears to be the case here, since Set isn't supposed to have duplicate cards.
4. Format your code with Black and adhere to PEP-8. Smushed-together style makes the logic less comprehensible.