Repasando Python. Mi solución a "New Cities - SENDGRID"

No estoy muy convencido. Habría que repasar la lista de las conexiones filtradas, por si pueden generar agrupaciones. Pero resuelve la cuestión.

https://py.checkio.org/mission/node-subnetworks/solve/

= = = = = = = = = =

import re

# -------------------
# pasar lista a cadena
# -------------------
def pasarLista(listado):
    cadena=[]   
    for subcadena in listado:
        for item in subcadena:
            cadena.append(item)
    return "".join(cadena) # envía la cadena.
   
def filtro(listado,quitar):
    cadena=[]
    for subcadena in listado:
        if (not subcadena[0] in quitar and not subcadena[1] in quitar):
            cadena.append(subcadena)
    return cadena

# ----------------
# función problema
# ----------------
def subnetworks(net, crushes):
  
    suma = 0
   
    # 1/ Construir una cadena con las conexiones.
    # hay una conexión a la fuente.
    cadena=pasarLista(net)
    cadena2=filtro(net,crushes)
   
    # 2/ Quitar los que estén en crushes - poner guiones.
    cadenaCrushes="".join(sorted([i for i in crushes]))
    cadenaNodos=re.sub("["+cadenaCrushes+"]",r"-",cadena)
    # cadenaNodos=re.sub("["+cadenaCrushes+"]",r"-","BABBACCDHHFDCACBACSE")
   
    # 3/ Obteniendo lista de grupos en cadenaNodos
    # unicos --> grupos de un solo nodo
    # conjunto --> cadena agrupando nodos
    conjunto=[j for i in cadena2 for j in i]
    unicos=[i for i in cadenaNodos.split("-") if len(i)==1]
   
    #4/ A partir de la cadena conjunto
    # si único está en la lista conjunto, quitar de único
    for j in conjunto:
        if j in unicos:
            unicos.remove(j)
           
    # print(cadena,cadenaCrushes,cadenaNodos,unicos,conjunto)
    # print(cadena2)
    # print(len(cadena2)+len(unicos))
   
    # La solución es la suma de los nodos filtrados +
    # los nodos que se han quedado sueltos en único
    # a menos de que tenga que hacer algo más en CONJUNTO
   
    return len(cadena2)+len(unicos)

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert subnetworks([
            ['A', 'B'],
            ['B', 'C'],
            ['C', 'D']
        ], ['B']) == 2, "First 2"
    assert subnetworks([
            ['A', 'B'],
            ['A', 'C'],
            ['A', 'D'],
            ['D', 'F'],
        ], ['A']) == 3 , "Second 3"
    assert subnetworks([
            ['A', 'B'],
            ['B', 'C'],
            ['C', 'D']
        ], ['C', 'D']) == 1, "Third 1"
    assert subnetworks([
            ['A', 'B'],
            ['A', 'C'],
            ['A', 'D'],
            ['D', 'F'],
            ['B', 'C'],
        ], ['A']) == 2, "Second-BIS 2"
    print('Done! Check button is waiting for you!')

Repasando Python. Mi solución a "node disconnected users - SENDGRID"

def disconnected_users(net, users, source, crushes):
 
    suma=0 #total de mail-pigeons
    conectado={} #Diccionario de conectados o no...
 
    # print (net) 
    # 1/ marca la fuente como 1, el nodo roto como -1 y los demás como ceros.
    for i in users:
        conectado[i]=(i in source)-(i in crushes)
     
    # 2/ Busca en las listas si está al lado de uno conectado. Si lo está, le pone un uno.
    # hay una conexión a la fuente.
    for h in range(0,2): # dos pasadas al menos lo aseguran. Parecen estar las listas ordenadas, pero ¿y si no lo están?
        for j in net:
            for k in range(0,2): #límite superior 1
                # Si el otro es 1 y este es cero, lo cambia a uno. Si era 1 lo deja, y si era -1 tb lo deja.
                conectado[j[(k!=1)]]=(conectado[j[(k!=1)]]==1)-(conectado[j[(k!=1)]]==-1)+(conectado[j[k]]==1 and conectado[j[(k!=1)]]==0)
                # print(j,conectado[j[(k!=1)]],conectado) 
 
   # 3/ Sumo los valores de los que NO están en el diccionario
    for clave, valor in users.items():
        suma+=(conectado[clave]!=1)*valor
             
    # print("Suma: "+str(suma))
 
    return suma

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert disconnected_users([
        ['A', 'B'],
        ['B', 'C'],
        ['C', 'D']
    ], {
        'A': 10,
        'B': 20,
        'C': 30,
        'D': 40
    },
        'A', ['B']) == 90, "First"

    assert disconnected_users([
        ['A', 'B'],
        ['B', 'D'],
        ['A', 'C'],
        ['C', 'D']
    ], {
        'A': 10,
        'B': 0,
        'C': 0,
        'D': 40
    },
        'A', ['B']) == 0, "Second"

    assert disconnected_users([
        ['A', 'B'],
        ['A', 'C'],
        ['A', 'D'],
        ['A', 'E'],
        ['A', 'F']
    ], {
        'A': 10,
        'B': 10,
        'C': 10,
        'D': 10,
        'E': 10,
        'F': 10
    },
        'C', ['A']) == 50, "Third"

    print('Done. Try to check now. There are a lot of other tests')

Repasando python. Solución a "Stressful subject - SENDGRID"

def is_stressful(subj):
    """
        recoognise stressful subject       
    """
    stwords=["help","asap","urgent"]
    condition = False
    if subj==subj.upper(): condition = True
    if subj[-3:]=="!!!": condition = True
    # filtrando caracteres y quedándose con letras
    newSubj1=[]
    for a in subj.upper():
        if a.isalpha():
            newSubj1.append(a)
    # Quitando caracteres repetidos
    newSubj2=[]
    for indice, a in enumerate(newSubj1):
        if not (indice>1 and a==newSubj1[indice-1]):
            newSubj2.append(a)
    newSubj2Str="".join(newSubj2)
    print(newSubj2Str)
    # Reconociendo palabras de stwords
    for a in stwords:
        if newSubj2Str.find(a.upper())>=0:
            condition = True
    return condition

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert is_stressful("Aquí hay una HHHELLLLPPPP!!!")==True,"Mine"
    assert is_stressful("Hi") == False, "First"
    assert is_stressful("I neeed HELP") == True, "Second"
    print('Done! Go Check it!')