update_ledger: cluster #1 (2)
# 6231515421  (2021-11-01 16:34)
def update_ledger(ledger, transaction_list):
    '''
    If all transaction are good with this ledger status = [True, []]
    If not status = [False, transaction that fail]
    Transaction fail to update ledger when they can't money from one pocket to another
    '''
    sorted  = sorting_transaction(transaction_list)
    d = {}
    for x in ledger:
      d[x[0]] = x[1]
    b = True
    f = []
    for x in sorted:
      fm = x[0]
      to = x[1]
      am = x[2]
      if fm not in d and fm != '0'*64:
        f.append(x)
        b = False
      elif fm!= '0' * 64 and d[fm] < am:
        f.append(x)
        b = False
      else:
        if fm != '0'*64:
          d[fm] = d[fm] - am
        if to in d:
          d[to] = d[to] + am
        else:
          d[to] = am
    r = []
    for x in d:
      r.append([x,d[x]])
    return [r, [b, f]]

# (4)
# Sorting block in to chain

def sorting_transaction(transaction_list):
  l = []
  for x in transaction_list:
    l.append([x[3],x])
  l.sort()
  for i in range(len(l)):
    l[i] = l[i][1]
  return l

# (2)
# Hash all transaction into one hash string
# 6231516021  (2021-11-01 23:40)
def update_ledger(ledger, transaction_list):
    '''
    If all transaction are good with this ledger status = [True, []]
    If not status = [False, transaction that fail]
    Transaction fail to update ledger when they can't money from one pocket to another
    '''
    sorted  = sorting_transaction(transaction_list)
    d = {}
    for x in ledger:
      d[x[0]] = x[1]
    b = True
    f = []
    for x in sorted:
      fm = x[0]
      to = x[1]
      am = x[2]
      if fm not in d and fm != '0'*64:
        f.append(x)
        b = False
      elif fm!= '0' * 64 and d[fm] < am:
        f.append(x)
        b = False
      else:
        if fm != '0'*64:
          d[fm] = d[fm] - am
        if to in d:
          d[to] = d[to] + am
        else:
          d[to] = am
    r = []
    for x in d:
      r.append([x,d[x]])
    return [r, [b, f]]

# (4)
# Sorting block in to chain

def sorting_transaction(transaction_list):
  l = []
  for x in transaction_list:
    l.append([x[3],x])
  l.sort()
  for i in range(len(l)):
    l[i] = l[i][1]
  return l

# (2)
# Hash all transaction into one hash string
update_ledger: cluster #3 (2)
# 6431027721  (2021-11-01 23:58)
def update_ledger(ledger, transaction_list):
    o = copy_list(ledger)
    p = copy_list(transaction_list)
    q = {}
    m = []
    n = []
    p = sorting_transaction(p)
    for i in o:
        m.append(i[0])
    for i in o:
        q[i[0]] = i[1]
    for j in p:
        if j[0] not in m:
            if j[0] == "0"*64 and j[1] in m:
                q[j[1]] += j[2]
            elif j[0] == "0"*64 and j[1] not in m:
                q[j[1]]=j[2]
                m.append(j[1])
            elif j[0]!="0"*64:
                return[o,[False,j]]
                break
        elif j[0] in m:
            q[j[0]]=q[j[0]]-j[2]
            if q[j[0]] < 0:
                return[o,[False,j]]
                break
            q[j[1]] = q[j[1]]+j[2]
    for k in q:
        n.append([k,q[k]])
    return[n,[True,[]]]

def copy_list(li):
    return copy.deepcopy(li)

def sorting_transaction(transaction_list):
    a = copy_list(transaction_list)
    b = []
    for i in a :
        b.append([i[3], i])
    b.sort()
    c = []
    for j in b :
        c.append(j[1])

    return c

def copy_list(li):
    return copy.deepcopy(li)
# 6431149621  (2021-11-01 23:59) 
def update_ledger(ledger, transaction_list):
    p = copy_list(ledger)
    o = copy_list(transaction_list)
    m = {}
    s = []
    c = []
    o = sorting_transaction(o)
    for g in p:
        s.append(g[0])
    for g in p:
        m[g[0]] = g[1]
    for n in o:
        if n[0] not in s:
            if n[0] == "0"*64 and n[1] in s:
                m[n[1]] += n[2]
            elif n[0] == "0"*64 and n[1] not in s:
                m[n[1]]=n[2]
                s.append(n[1])
            elif n[0]!="0"*64:
                return[p,[False,n]]
                break
        elif n[0] in s:
            m[n[0]]=m[n[0]]-n[2]
            if m[n[0]] < 0:
                return[p,[False,n]]
                break
            m[n[1]] = m[n[1]]+n[2]
    for l in m:
        c.append([l,m[l]])
    return[c,[True,[]]]

def copy_list(li):
    return copy.deepcopy(li)

def sorting_transaction(transaction_list):
    s = copy_list(transaction_list)
    p = []
    for j in s :
        p.append([j[3], j])
    p.sort()
    b = []
    for k in p :
        b.append(k[1])

    return b

def copy_list(li):
    return copy.deepcopy(li)
update_ledger: cluster #4 (2)
# 6430092221  (2021-11-01 23:01) 
def update_ledger(ledger, transaction_list):
    '''
    If all transaction are good with this ledger status = [True, []]
    If not status = [False, transaction that fail]
    Transaction fail to update ledger when they can't money from one pocket to another
    '''
    output = []
    for i in ledger:
      output.append(list(i))
    all_pocket = []
    for i in ledger:
      all_pocket.append(i[0])
    status = True
    fail_txn = []
    all_transac = sorting_transaction(transaction_list)
    for i in all_transac:
      if i[0] == "0"*64: #free money
        if i[1] not in all_pocket:
          output.append([i[1],i[2]])
          all_pocket.append(i[1])
        else:
          for j in output:
            if j[0] == i[1]:
              j[1] += i[2]
      else:
        if i[0] not in all_pocket:
          status = False
          fail_txn = i
        elif i[1] not in all_pocket:
          output.append([i[1],i[2]])
          all_pocket.append(i[1])
        else:
          for j in output:
            if j[0] == i[0]:
              if j[1] >= i[2]:
                for k in output:
                  if k[0] == i[1]:
                    k[1] += i[2]
                  if k[0] == i[0]:
                    k[1] -= i[2]
              else:
                status = False
                fail_txn = i
    if not status:
      output = ledger

    return [output, [status, fail_txn]]

# (4)
# Sorting block in to chain

def sorting_transaction(transaction_list):
    return sorted(transaction_list,key=lambda x: x[3])

# (2)
# Hash all transaction into one hash string
# 6431029021  (2021-11-01 23:33) 
def update_ledger(ledger, transaction_list):
    output = []
    for i in ledger:
      output.append(list(i))
    all_pocket = []
    for i in ledger:
      all_pocket.append(i[0])
    volume = True
    space = []
    all_transac = sorting_transaction(transaction_list)
    for i in all_transac:
      if i[0] == "0"*64:
        if i[1] not in all_pocket:
          output += [[i[1],i[2]]]
          all_pocket += [i[1]]
        else:
          for j in output:
            if j[0] == i[1]:
              j[1] += i[2]
      else:
        if i[0] not in all_pocket:
          volume = False
          space = i
        elif i[1] not in all_pocket:
          output.append([i[1],i[2]])
          all_pocket.append(i[1])
        else:
          for j in output:
            if j[0] == i[0]:
              if j[1] >= i[2]:
                for k in output:
                  if k[0] == i[1]:
                    k[1] += i[2]
                  if k[0] == i[0]:
                    k[1] -= i[2]
              else:
                volume = False
                space = i
    if not volume:
      output = ledger

    return [output, [volume, space]]

#4

def sorting_transaction(transaction_list):
    return sorted(transaction_list,key=lambda x: x[3])

#2
update_ledger: cluster #7 (2)
# 6430041221  (2021-10-31 22:21) 
def update_ledger(ledger, transaction_list):
    '''
    If all transaction are good with this ledger status = [True, []]
    If not status = [False, transaction that fail]
    Transaction fail to update ledger when they can't money from one pocket to another
    '''
    tranlist = copy_list(transaction_list)
    sorttran = sorting_transaction(tranlist)
    ledg = copy_list(ledger)
    for i in sorttran:
        check = True
        if i[0] != "0" * 64:
            check2 = False
            for j in ledg:
                if j[0] == i[0]:
                    check2 = True
                    if j[1] >= i[2]:
                        j[1] -= i[2]
                    else:
                        return [ledger, [False, i]]
                    break
            if not check2:
                return [ledger, [False, i]]
        check3 = False
        for j in ledg:
            if j[0] == i[1]:
                j[1] += i[2]
                check3 = True
        if not check3:
            ledg.append([i[1], i[2]])

    return [ledg, [True, []]]


# Create a new block

def copy_list(li):
    return copy.deepcopy(li)

def sorting_transaction(transaction_list):
    tranlist = copy_list(transaction_list)
    tranlist.sort(key=lambda x: x[3])
    return tranlist


# (2)
# Hash all transaction into one hash string

def copy_list(li):
    return copy.deepcopy(li)
# 6431148021  (2021-11-01 23:51) 
def update_ledger(ledger, transaction_list):

    tranlist = copy_list(transaction_list)
    sortt = sorting_transaction(tranlist)
    ledg = copy_list(ledger)
    for b in sortt:
      check=True
      if b[0]!="0"*64:
        checkk = False
        for c in ledg:
          if c[0]==b[0]:
            checkk = True
            if c[1]>=b[2]:
              c[1]-=b[2]
            else:
              return [ledger,[False,b]]
            break
        if not checkk:
          return [ledger,[False,b]]
      checkkk = False
      for c in ledg:
        if c[0]==b[1]:
          c[1]+=b[2]
          checkkk=True
      if not checkkk:
        ledg.append([b[1],b[2]])
    return [ledg,[True,[]]]

# Create a new block

def copy_list(li):
    return copy.deepcopy(li)

def sorting_transaction(transaction_list):
    return transaction_list.sort()
# (2)
# Hash all transaction into one hash string

sorting_block: cluster #1 (2)
# 6430030321  (2021-11-01 17:31) 
def sorting_block(block_list):
    out = []
    prev_hash_dict = {}
    hash_dict = {}
    for i in range(len(block_list)):
        prev_hash_dict[i] = block_list[i][2]
        hash_dict[i] = block_list[i][3]
    for index,prev_hash in prev_hash_dict.items(): #first
        if prev_hash not in hash_dict.values():
            out.append(block_list[index])
            before_index = index
    for i in range(len(block_list)):
        for index,prev_hash in prev_hash_dict.items():
            if prev_hash == hash_dict[before_index]:
                out.append(block_list[index])
                before_index = index
    return out

#Q5
# 6431113021  (2021-11-01 23:58) 
def sorting_block(block_list):
    out=[]
    prev_hash_dict={}
    hash_dict={}
    for i in range(len(block_list)):
        prev_hash_dict[i] = block_list[i][2]
        hash_dict[i] = block_list[i][3]
    for index,prev_hash in prev_hash_dict.items(): #first
        if prev_hash not in hash_dict.values():
            out.append(block_list[index])
            before_index = index
    for i in range(len(block_list)):
        for index,prev_hash in prev_hash_dict.items():
            if prev_hash == hash_dict[before_index]:
                out.append(block_list[index])
                before_index = index
    return out
#2
sorting_block: cluster #3 (2)
# 6231515421  (2021-11-01 16:34) 
def sorting_block(block_list):
    next = {}
    prev = {}
    for x in block_list:
      hash = x[3]
      p = x[2]
      next[p] = hash
      prev[hash] = p
      if hash not in next:
        next[hash] = 'none'
      if p not in prev:
        prev[p] = 'none'
    l = []
    cur = ''
    for x in prev:
      if prev[x] == 'none':
        cur = x
        break
    if cur == '':
      cur = block_list[0][3]
    for i in range(len(block_list)):
      l.append(cur)
      cur = next[cur]
    r = []
    for x in l:
      for y in block_list:
        if y[3] == x:
          r.append(y)
          break
    return r

# (5)
# Check the chain that transaction is valid to what number block
# 6231516021  (2021-11-01 23:40) 
def sorting_block(block_list):
    next = {}
    prev = {}
    for x in block_list:
      hash = x[3]
      p = x[2]
      next[p] = hash
      prev[hash] = p
      if hash not in next:
        next[hash] = 'none'
      if p not in prev:
        prev[p] = 'none'
    l = []
    cur = ''
    for x in prev:
      if prev[x] == 'none':
        cur = x
        break
    if cur == '':
      cur = block_list[0][3]
    for i in range(len(block_list)):
      l.append(cur)
      cur = next[cur]
    r = []
    for x in l:
      for y in block_list:
        if y[3] == x:
          r.append(y)
          break
    return r

# (5)
# Check the chain that transaction is valid to what number block
sorting_block: cluster #7 (2)
# 6430051521  (2021-11-01 01:48) 
def sorting_block(block_list):
    use = copy_list(block_list)
    order_b = []
    for i in range(0,len(use)-1): #use #หาinitial
        found = False
        for k in range(0,len(use)):
            if i != k:
                if use[i][2] == use[k][3]:
                  found = True
            else: pass
        if not found:
            order_b.append(use[i])
            use.remove(use[i])
            out = True
            break
    while len(use)>0 :
      for e in use:
        if e[2] == order_b[-1][3]:
          order_b.append(e)
          use.remove(e)
          break
    return order_b

# (5)
# Check the chain that transaction is valid to what number block
# 6431106621  (2021-11-01 22:37) 
def sorting_block(block_list):
    b = copy_list(block_list)
    c = []
    for i in range(0,len(b)-1): #use #หาinitial
        found = False
        for k in range(0,len(b)):
            if i != k:
                if b[i][2] == b[k][3]:
                  found = True
            else: pass
        if not found:
            c.append(use[i])
            b.remove(use[i])
            out = True
            break
    while len(b)>0 :
      for e in b:
        if e[2] == order_b[-1][3]:
          c.append(e)
          b.remove(e)
          break
    return c

# (5)
# Check the chain that transaction is valid to what number block



update_ledger_sorting_block: cluster #6 (3)
# 6431013921  (2021-11-01 19:03)


def update_ledger(ledger, transaction_list):
 valid = True
 sorted_transaction = sorting_transaction(transaction_list)
 ledger_dict = {}
 for a,m in ledger: #build ledger dict
    ledger_dict[a] = m
 new_ledger_dict = copy.deepcopy(ledger_dict)
 for t in sorted_transaction:
    transferor = t[0]
 reciever = t[1]
 amount = t[2]
 if transferor in new_ledger_dict or transferor == '0'*64:
    if transferor != '0'*64:
        new_ledger_dict[transferor] -= amount
    if reciever in new_ledger_dict:
        new_ledger_dict[reciever] += amount
    else:
        new_ledger_dict[reciever] = amount
    if transferor != '0'*64 and new_ledger_dict[transferor] <0 :
        valid = False
        return [ledger,[False,t]]
 else:
    return [ledger,[False,t]]
 new_ledger = [[k,v] for k,v in new_ledger_dict.items()]
 return [new_ledger,[True,[]]]
#Part3-------------------------------------------------------------------------------------------

def sorting_block(block_list):
 out = []
 prev_hash_dict = {}
 hash_dict = {}
 for e in range(len(block_list)):
    prev_hash_dict[dict(e)] = block_list[e][2]
    hash_dict[e] = block_list[e][3]
 for j,k in hash_dict.values(): #first
    if k not in hash_dict.values():
        out.append(block_list[j])
        before_j = j
 for i in range(len(block_list)):
    for l,m in prev_hash_dict.items():
        if m == hash_dict[before_l]:
            out.append(block_list(l))
            before_l = l
 return out
#Part4-------------------------------------------------------------------------
#Q5

def sorting_transaction(transaction_list):
 seq = []
 out = []
 for t in transaction_list:
    seq.append([t[3],t])
    seq.sort()
 for e in seq:
    out.append(e[1])
 return out
#Q2
# 6431113021  (2021-11-01 23:58) 


def update_ledger(ledger, transaction_list):
    valid = True
    sorted_transaction = sorting_transaction(transaction_list)
    ledger_dict = {}
    for a,m in ledger: #build ledger dict
        ledger_dict[a] = m
    new_ledger_dict = copy.deepcopy(ledger_dict)
    for t in sorted_transaction:
        transferor = t[0]
        reciever = t[1]
        amount = t[2]
        if transferor in new_ledger_dict or transferor == '0'*64:
            if transferor != '0'*64:
                new_ledger_dict[transferor] -= amount
            if reciever in new_ledger_dict:
                new_ledger_dict[reciever] += amount
            else:
                new_ledger_dict[reciever] = amount
            if transferor != '0'*64 and new_ledger_dict[transferor] <0 :
                valid = False
                return [ledger,[False,t]]
        else:
            return [ledger,[False,t]]
        new_ledger=[[k,v] for k,v in new_ledger_dict.items()]
    return [new_ledger,[True,[]]]

#5

def sorting_block(block_list):
    out=[]
    prev_hash_dict={}
    hash_dict={}
    for i in range(len(block_list)):
        prev_hash_dict[i] = block_list[i][2]
        hash_dict[i] = block_list[i][3]
    for index,prev_hash in prev_hash_dict.items(): #first
        if prev_hash not in hash_dict.values():
            out.append(block_list[index])
            before_index = index
    for i in range(len(block_list)):
        for index,prev_hash in prev_hash_dict.items():
            if prev_hash == hash_dict[before_index]:
                out.append(block_list[index])
                before_index = index
    return out
#2

def sorting_transaction(transaction_list):
    k = []
    out = []
    for e in transaction_list:
        k.append(e[3])
    k.sort()
    for c in k:
        for n in transaction_list :
            if c in n :
                out.append(n)
    return out

#3
# 6430030321  (2021-11-01 17:31) 


def update_ledger(ledger, transaction_list):
    valid = True
    sorted_transaction = sorting_transaction(transaction_list)
    ledger_dict = {}
    for a,m in ledger: #build ledger dict
        ledger_dict[a] = m
    for t in sorted_transaction:
        transferor = t[0]
        reciever = t[1]
        amount = t[2]
        if transferor in ledger_dict or transferor == '0'*64:
            if transferor != '0'*64:
                ledger_dict[transferor] -= amount
            if reciever in ledger_dict:
                ledger_dict[reciever] += amount
            else:
                ledger_dict[reciever] = amount
            if transferor != '0'*64 and ledger_dict[transferor] <0 :
                valid = False
                return [ledger,[False,t]]
        else:
            return [ledger,[False,t]]
        new_ledger = [[k,v] for k,v in ledger_dict.items()]
    return [new_ledger,[True,[]]]

#Q4

def sorting_block(block_list):
    out = []
    prev_hash_dict = {}
    hash_dict = {}
    for i in range(len(block_list)):
        prev_hash_dict[i] = block_list[i][2]
        hash_dict[i] = block_list[i][3]
    for index,prev_hash in prev_hash_dict.items(): #first
        if prev_hash not in hash_dict.values():
            out.append(block_list[index])
            before_index = index
    for i in range(len(block_list)):
        for index,prev_hash in prev_hash_dict.items():
            if prev_hash == hash_dict[before_index]:
                out.append(block_list[index])
                before_index = index
    return out

#Q5

def sorting_transaction(transaction_list):
    seq = []
    out = []
    for t in transaction_list:
        seq.append([t[3],t])
    seq.sort()
    for e in seq:
        out.append(e[1])
    return out

#Q2