solucao_exercicio_encontre_o_primeiro_duplicado.py

"""
-> É uma lista de listas de números inteiros
-> As listas internas tem o tamanho de 10 elementos
-> As listas internas contém números entre 1 a 10 e eles podem ser duplicados

Exercício

-> Crie uma função que encontra o primeiro duplicado considerando o segundo
    número como a duplicação. Retorne a duplicação considerada.
        Requisitos:
            A ordem do número duplicado é considerada a partir da segunda
            ocorrência do número, ou seja, o número duplicado em si.
            Exemplo:
                [1, 2, 3, ->3<-, 2, 1] -> 1, 2 e 3 são duplicados (retorne 3)
                [1, 2, 3, 4, 5, 6] -> Retorne -1 (não tem duplicados)

            Se não encontrar duplicados na lista, retorne -1
"""
lista_de_listas_de_inteiros = [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [9, 1, 8, 9, 9, 7, 2, 1, 6, 8],
    [1, 3, 2, 2, 8, 6, 5, 9, 6, 7],
    [3, 8, 2, 8, 6, 7, 7, 3, 1, 9],
    [4, 8, 8, 8, 5, 1, 10, 3, 1, 7],
    [1, 3, 7, 2, 2, 1, 5, 1, 9, 9],
    [10, 2, 2, 1, 3, 5, 10, 5, 10, 1],
    [1, 6, 1, 5, 1, 1, 1, 4, 7, 3],
    [1, 3, 7, 1, 10, 5, 9, 2, 5, 7],
    [4, 7, 6, 5, 2, 9, 2, 1, 2, 1],
    [5, 3, 1, 8, 5, 7, 1, 8, 8, 7],
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
]


def encontra_primeiro_duplicado(param_lista_de_inteiros):
    numeros_checados = set()
    primeiro_duplicado = -1

    for numero in param_lista_de_inteiros:
        if numero in numeros_checados:
            primeiro_duplicado = numero
            break

        numeros_checados.add(numero)

    return primeiro_duplicado


for lista_de_inteiros in lista_de_listas_de_inteiros:
    print(lista_de_inteiros, encontra_primeiro_duplicado(lista_de_inteiros))


"""
Os resultados devem ser:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] -1
[9, 1, 8, 9, 9, 7, 2, 1, 6, 8] 9
[1, 3, 2, 2, 8, 6, 5, 9, 6, 7] 2
[3, 8, 2, 8, 6, 7, 7, 3, 1, 9] 8
[4, 8, 8, 8, 5, 1, 10, 3, 1, 7] 8
[1, 3, 7, 2, 2, 1, 5, 1, 9, 9] 2
[10, 2, 2, 1, 3, 5, 10, 5, 10, 1] 2
[1, 6, 1, 5, 1, 1, 1, 4, 7, 3] 1
[1, 3, 7, 1, 10, 5, 9, 2, 5, 7] 1
[4, 7, 6, 5, 2, 9, 2, 1, 2, 1] 2
[5, 3, 1, 8, 5, 7, 1, 8, 8, 7] 5
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1] -1
"""

Luiz, td bem?

Eu havia chegado, incialmente, há um resultado com duas funções:

def pnd(lista_imputada):
for list in lista_imputada:
retorno = ret(list)
print(retorno)

def ret(list):
new_list = []
for n in list:
if n in new_list:
return n
if n not in new_list:
new_list.append(n)
if len(new_list) == 10:
return -1

pnd(lista_de_listas_de_inteiros)

Mas depois de ver sua solução, vi que excluindo a primeira função e só chamando o print pelo laço for como vc fez, eu conseguiria um código bem curto também, com a mesma quantidade de linhas do seu:

def ret(list):
new_list = []
for n in list:
if n in new_list:
return n
if n not in new_list:
new_list.append(n)
if len(new_list) == 10:
return -1

for list in lista_de_listas_de_inteiros:
print(list, ret(list))

O que acha? Só n usei o set...

Lembrando código mais curto nem sempre é sinônimo de código melhor... Ás vezes, dividir em mais funções é melhor porque talvez você possa reutilizar essas funções noutros locais. Além disso, funções menores são mais fáceis de testar... Ou seja, eu acho que sua ideia de duas funções é até melhor.

Olá professor.
Cheguei num resultado, embora minha função não use 'return', mas 'print', através do seguinte código:

def finder(lista_mae):
for i, v in enumerate(lista_mae):
lista_check = []
duplicado = -1
for n in lista_mae[i]:
if n in lista_check:
if lista_check != set(lista_check):
duplicado = n
print(f'Lista: {lista_mae[i]}. Primeiro Duplicado: {duplicado}')
break
lista_check.append(n)
if set(lista_check) == set(lista_de_listas_de_inteiros[i]):
print(f'Lista: {lista_mae[i]}. Sem duplicados ({duplicado})')

finder(lista_de_listas_de_inteiros)

Notei que no do sr a função vai dentro de um laço 'for' além do uso do 'return', porém não consigo fazê-lo encaixar no meu código.
No meu só é preciso colocar a lista mãe na função que ela faz o resto.

Olá Professor

fiz dessa forma seguindo algumas dicas postadas acima

def lista_check(lista):
numero = set()
for i in lista:
if i in numero:
return i
numero.add(i)
return -1

for list in lista_de_listas_de_inteiros:
print(list, lista_check(list))

Eu fiz um pouco diferente só iterando com o for:

contagem = 0
num = []
for valor in lista_de_listas_de_inteiros:
for i in valor:
contagem +=1
if contagem <=9:
if i in num:
print(f'O primeiro número duplicado da lista é {i}')
contagem = 0
num = []
break
else:
num.append(i)
else:
print('-1')
contagem = 0
num = []

Olá, eu resolvi de forma diferente, não utilizei a função set( ), mas depois de ver a correção a intenção foi a mesma. eu criei uma lista auxiliar e foi adicionando os números lá quando ela achava o primeiro repetido parava.

def procura_repetidos(listas):
    lista_aux = []
    print()
    for lista in listas:
        print(f'estou percorendo está lista{lista}')
        for n in lista:
            if n in lista_aux:
                print(f"repetido {n}")
                break
            else:
                lista_aux.append(n)
        if len(lista_aux) == len(lista):
             print('esta lista não possui repetidos') 
        lista_aux = []                
        print()    

procura_repetidos(listas)

sta
Olá Alisson, só um duvida no seu código !

if len(lista_aux) == len(lista):
print('esta lista não possui repetidos')
lista_aux = []

A contagem da lista auxiliar for igual a contagem da lista, por que não haveriam números repetidos ?

def find_duplicate(tabela):

    for pos, lista in enumerate(tabela):
        lista_set = set()
        for n in lista:
            cont1 = len(lista_set)
            lista_set.add(n)
            if cont1 == len(lista_set):
                print(f' Na Lista {pos+1}\t O número duplicado é {n}')
                break
        else:
            print(f' Na Lista {pos+1}\t Não há número duplicado [-1] ')

find_duplicate(lista_de_listas_de_inteiros)

Eis minha solução para o problema:

lista_de_listas_de_inteiros = [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [9, 1, 8, 9, 9, 7, 2, 1, 6, 8],
    [1, 3, 2, 2, 8, 6, 5, 9, 6, 7],
    [3, 8, 2, 8, 6, 7, 7, 3, 1, 9],
    [4, 8, 8, 8, 5, 1, 10, 3, 1, 7],
    [1, 3, 7, 2, 2, 1, 5, 1, 9, 9],
    [10, 2, 2, 1, 3, 5, 10, 5, 10, 1],
    [1, 6, 1, 5, 1, 1, 1, 4, 7, 3],
    [1, 3, 7, 1, 10, 5, 9, 2, 5, 7],
    [4, 7, 6, 5, 2, 9, 2, 1, 2, 1],
    [5, 3, 1, 8, 5, 7, 1, 8, 8, 7],
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
]

def find_duplicate(number_list: list[int]) -> int:
    unique_numbers = set()
    for number in number_list:
        if number in unique_numbers:
            return number
        unique_numbers.add(number)
    return -1


def main()-> None:
    for list in lista_de_listas_de_inteiros:
        print(f"find_duplicate({list}) -> {find_duplicate(list)} ")


if __name__ == "__main__":
    main()

Minha solução ficou assim:

lista_de_listas_de_inteiros = [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [9, 1, 8, 9, 9, 7, 2, 1, 6, 8],
    [1, 3, 2, 2, 8, 6, 5, 9, 6, 7],
    [3, 8, 2, 8, 6, 7, 7, 3, 1, 9],
    [4, 8, 8, 8, 5, 1, 10, 3, 1, 7],
    [1, 3, 7, 2, 2, 1, 5, 1, 9, 9],
    [10, 2, 2, 1, 3, 5, 10, 5, 10, 1],
    [1, 6, 1, 5, 1, 1, 1, 4, 7, 3],
    [1, 3, 7, 1, 10, 5, 9, 2, 5, 7],
    [4, 7, 6, 5, 2, 9, 2, 1, 2, 1],
    [5, 3, 1, 8, 5, 7, 1, 8, 8, 7],
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
]

def duplicados(lista):
    cont = 1
    for i in lista:
        for c in lista[cont:]:
            if i == c:
                return i
        cont += 1
    return -1

for b in lista_de_listas_de_inteiros:
    print (b , duplicados(b))

É interessante ver que cada pessoa pensa de uma forma totalmente diferente da outra. Muito legal.

Primeiro tinha feito um code que só conseguia verificar se a duplicata estivesse no índice seguinte. Então, como a maioria das listas tem a duplicata como número seguinte ( [9, 9], [2, 2,], [7, 7,] ) achei que estivesse certo mas depois vi que precisava dessa lista de 'check'. Enfim, acho que consegui...

def duplicado(lista):
  check = []
  for numero in lista:
    if numero in check:
      return f' Nº duplicado: {numero}'   
      
    check.append(numero)
  
  return -1

for valor in lista_listas_de_inteiros:
  print(valor, duplicado(valor))

Após horas queimando a cabeça obtive este resultado simples e econômico. Ufa!

listas = [
            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
            [9, 1, 8, 9, 9, 7, 2, 1, 6, 8],
            [1, 3, 2, 2, 8, 6, 5, 9, 6, 7],
            [3, 8, 2, 8, 6, 7, 7, 3, 1, 9],
            [4, 8, 8, 8, 5, 1, 10, 3, 1, 7],
            [1, 3, 7, 2, 2, 1, 5, 1, 9, 9],
            [10, 2, 2, 1, 3, 5, 10, 5, 10, 1],
            [1, 6, 1, 5, 1, 1, 1, 4, 7, 3],
            [1, 3, 7, 1, 10, 5, 9, 2, 5, 7],
            [4, 7, 6, 5, 2, 9, 2, 1, 2, 1],
            [5, 3, 1, 8, 5, 7, 1, 8, 8, 7],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
        ]

def search_duplicates(lista: list) -> int:
    if len(set(lista)) == len(lista):
        return -1

    checados = set()
    for x in lista:
        if x not in checados:
            checados.add(x)
        else:
            return x

for lista in listas:
    print(lista, search_duplicates(lista))

Cheguei ao resultado, mas ao invés de return, utilizei print.

def check():
    for internal_list in list:
        checked_numbers = []
        duplicated_numbers = []
        for number in internal_list:
            if number not in checked_numbers:
                checked_numbers.insert(9, number)
            else:
                duplicated_numbers.insert(9, number)
        if duplicated_numbers:
            print(duplicated_numbers[0])
        else:
            print(-1)


check()

A minha solução funcionou mas tem um pessoal aqui que fez de uma forma mais simples. Fiz duas funções e o resultado é uma lista com todos os repetidos ou -1.
com certeza vou melhorar o que fiz.

Eu fiz diferente do que foi pedido, ficou bem maior, eu queria usar algumas coisas, como cores, que era algo que eu já estava começando a esquecer.
Mas tem algumas "gambiarras" que vou melhorar.

lista = [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [9, 2, 8, 3, 4, 7, 9, 1, 8, 4],
    [4, 1, 1, 6, 9, 0, 3, 4, 2, 5],
    [5, 4, 6, 2, 2, 8, 4, 9, 4, 8],
    [7, 8, 6, 4, 0, 8, 1, 2, 3, 5],
    [8, 9, 5, 0, 3, 1, 1, 4, 6, 8]
]
a = 'Os elementos repetidos estão em vermelho.'
print('=-' * len(a))
print(a.center(80))
print('=-' * len(a))
existe = []
def sublistas(listaq):
    existe.clear()
    for v, elemento in enumerate(listaq):
        if len(existe) == 0:
            print('[', end='')
            existe.append(8676643433145569869)
        if elemento in existe:
            if v != 9:
                print(f'\033[31m{elemento}\033[m', end=',')
            else:
                print(f'\033[31m{elemento}\033[m', end='')
        else:
            if len(existe) > 0:
                existe.append(elemento)
                if v != 9:
                    print(f'\033[34m{elemento}\033[m', end=',')
                else:
                    print(f'\033[34m{elemento}\033[m', end='')
        if v == 9:
            print(']')

for s in range(len(lista)):
    sublistas(lista[s])

`

Olá professor

def find_duplicate(lista):
    for i in lista:
        i = set(i)
        if len(i) != 10: 
            print(f"na lista {i} tem {10-len(i)} números repetidos")
        else:
            print(f"na linha {i} não tem itens repetidos")

find_duplicate(lista_de_listas_de_inteiros)

eu realizei meu código dessa maneira

A minha ficou dessa maneira aqui, muito louco ver que tem muito jeito de chegar em um resultado, muito bom!!!
Lembrando que no meu resultado, apenas mostra a resposta sem a lista do lado como o professor fez, mas ao menos eu cheguei no resultado. kkkkk

def numero_repetidos_em_listas_sublistas(lista):
    para_return = []
    for numero_da_sublista, index_de_lista in enumerate(lista):
        sublista = index_de_lista

        for index_sublista, valor_sublista in enumerate(sublista):
            if index_sublista <= 8:
                if sublista[index_sublista] == sublista[index_sublista + 1]:
                    para_return += f'{sublista[index_sublista]}'
                    break
            else:
                para_return += ([-1])
    return (para_return)

verificar_lista = numero_repetidos_em_listas_sublistas(lista_de_listas_de_inteiros)
print(verificar_lista)

Minha Solução =>
Sei q esta um pouco mais complexo doque precisaria, mas eu tbm fiz umas alteracaoes tipo acrescentando um gerador aleatorio de listas raondomicas...

import random as rd

def gerador_lista(qtd:int, tamanho:int)->list:
    """Gera uma lista de numeros randomicas com uma quantidade QTD com TAMANHO elementos"""
    lista_local = []
    listatemp = []
    for _ in range(0, qtd):
        for _ in range(0, tamanho):
            listatemp.append(rd.randint(0, 9))
        lista_local.append(listatemp)
        listatemp = []
    return lista_local

def busca_repetido(lista: list)->list:
    """"Recebe uma lista, busca o primeiro elemento repetido
    e retorna uma lista (a,b) onde a é o elemento repetido e 
    b é a posicao na lista do elemento repetido."""
    lista_repetidos = [-1]
    d_temp = -1
    for index,valor in enumerate(lista):
        for i,v in enumerate(lista):
            d = len(lista)-i
            if (i != index) and (valor == v) and (i>index) and d>d_temp:
                d_temp = d
                lista_repetidos.clear()
                lista_repetidos.append([i,v])
    return lista_repetidos


lista_main = gerador_lista(500,8) #gera 500 listas de 8 elementos

for i in lista_main:
    lista_busca = busca_repetido(i)
    print(i, lista_busca)