cashlo

fun dithering(bitmap: Bitmap) {
    val height: Int = bitmap.getHeight()
    val width: Int = bitmap.getWidth()
    val colors = 3
    val threshold = 255/colors

    for (x in 0 until width) {
        for (y in 0 until height) {
            val pixel = bitmap.getPixel(x, y)
            var alpha = Color.alpha(pixel)

cashlo

#include <M5StickC.h>
#include "bugC.h"

#define sampleTime  0.005

float pitch  = 0.0F;
float roll  = 0.0F;
float yaw  = 0.0F;
float roll_offset = 0.0F;

cashlo

difference(){
    scale([1,1,0.3]){
        surface("YOUR FILE NAME GOES HERE", center=true);
    }
    cube([200,200,14], center=true);
}

cashlo

class GomokuBoard:
	def __init__(self, size=9):
		self.size = size
		self.board = [0]*(size*size)
		self.last_move = None
		self.total_moves = 0


	def clone_board(self):
		new_board = GomokuBoard(self.size)

cashlo

class GomokuSearchTree(Node):
	def __init__(self, parent, board, from_move, next_player, simulation_limit=1, exploration_constant=1):
		Node.__init__(self, parent=parent, simulation_limit=simulation_limit, exploration_constant=exploration_constant)
		self.board = board
		self.from_move = from_move
		self.next_player = next_player

	def create_from_move(self, move):
		new_board = self.board.clone_board()
		new_board.place_move(move, self.next_player)

cashlo

def check_board(self, test=False):
	if self.last_move is None:
		return Gomoku.IN_PROGRESS
	x = self.last_move%self.size
	y = self.last_move//self.size
	cell = self.board[self.last_move]

	min_x = max(0, x-4)
	min_y = max(0, y-4)

cashlo

def print(self):
	header = '   '
	for x in range(self.size):
		if self.last_move is not None and x == self.last_move%self.size:
			header += '▼ '
		else:
			header += f'{x+1} '
	print(header)

	for y in range(self.size):

cashlo

import math
import random

class Node:
	def __init__(self, parent=None, simulation_limit=1, exploration_constant=1):
		self.parent=parent
		self.reward = 0
		self.visit_count = 0
		self.possible_move_list = None
		self.expanded_children = {}

cashlo

from collections import defaultdict

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums_count_map = defaultdict(int)
        result_set = set()
        for n in nums:
            nums_count_map[n] += 1
        for n in nums_count_map:
            for m in nums_count_map:

cashlo

from scipy.io import loadmat
import numpy as np
import scipy.optimize as opt
import matplotlib.pyplot as plt

def sigmoid(z):
    return 1/(1+np.exp(-z))

def costFunctionReg(theta, X, y, lmbda):
    m = len(y)