Freestyle Sparring

mylist = [("yellow", 1), ("blue", 2), ("yellow", 3), ("blue", 4), ("red", 1)]


def group(lst, result={}):
    {result[c].append(n) if c in result else result.update({c: [n]}) for c, n in lst}
    return result


print(group(mylist))

package kata

func SumLetters(a string, b string) bool {
  return len(a) == len(b) && len(a) > 0
}

const { createHash } = require("node:crypto");

const databaseUser = [
  {
    email: "tvorchesky@mail.com",
    password:
      "6827ef24aa9c59195dc19cbc2b597f6d" /* password nya adalah Taralolet123, udah di enkripsi pakai MD5 */,
  },
];

const md5 = (value) => createHash("md5").update(value).digest("hex");

function login(userEmail, userPassword) {
  return Boolean(
    databaseUser.find(
      ({ email, password }) =>
        userEmail === email && password === md5(userPassword)
    )
  );
}

def dumbRockPaperScissors(p1,p2,rpc={"Rock":"Paper","Paper":"Scissors","Scissors":"Rock"}):
    if p1 in rpc[p2]: return "Player 1 wins"
    if p2 in rpc[p1]: return "Player 2 wins"
    return "Draw"
 

text=lambda d="description",k="Kata or Kumite",r="return",s="symbols": f"Compress large text - {d} of this {k} in small code.\nThis {k} {d} has 462 {s} in 3 line, without title. You should wrote function, {r} this text, but you should use less {s} in you'r code that this text. Simple solution - just {r} \"\"\"source text\"\"\". More smart variant is: do mark often word as special {s} and replace his before {r}.\nHow small code can be? Can you wrote more compressing? Let's check it!"

def kimite(grid):
    rows, cols = len(grid), len(grid[0])
    # Burn method. Less optimal that Djikstra, but simple.
    hotmap=[[None for c in range(cols)] for r in range(rows)]
    hotmap[0][0]=grid[0][0] # first point
    changed=True
    itr=0
    while changed:
        changed=False
        for r in range(rows):
            for c in range(cols):
                d=[]
                for y in [r-1,r+1,r]:
                    for x in [c-1,c+1,c]:
                        if (x>=0)and(y>=0) and (x<cols)and(y<rows) and ((x==c)or(y==r)) and (hotmap[y][x]!=None):
                            d.append(hotmap[y][x])
                if len(d)>0:
                    k=grid[r][c]+min(d)
                    if (hotmap[r][c]!=None) and (hotmap[r][c]<k):
                        k=hotmap[r][c]
                    if k!=hotmap[r][c]:
                        changed=True
                        hotmap[r][c]=k
        itr+=1
    print('Iteration for search '+str(itr))
    #print(hotmap)
    total_cost = hotmap[-1][-1]
    return total_cost

#include <vector>    
#include <numeric>

template <typename T = double>
int sum(const std::vector<T>& v) {
   return v.size() == 0   ? -1
          : std::accumulate(v.begin(), v.end(), 0);
}

class OperationError(Exception):
    def __init__(self, message):            
        super().__init__(message)

def matrix(matrix=list, operation=str, location=tuple, writedata=None):
    def op_write(i,j):
        matrix[i][j] = writedata
        return matrix
    op={"read":lambda i,j: matrix[i][j], "write":op_write}
    try:
        if not operation in op: raise OperationError("That is not a valid operation for this system.")
        return op[operation](location[0],location[1])
    except Exception as e:
        print(e)
        return -1