function js_escape($str) {
  $fn = function($matches) {
    $string = $matches[0];
    $offset = 0;
    $code = ord(substr($string, $offset, 1));
    if ($code >= 128) {        //otherwise 0xxxxxxx
      if ($code < 224) $bytesnumber = 2;                //110xxxxx
      else if ($code < 240) $bytesnumber = 3;        //1110xxxx
      else if ($code < 248) $bytesnumber = 4;    //11110xxx
      $codetemp = $code - 192 - ($bytesnumber > 2 ? 32 : 0) - ($bytesnumber > 3 ? 16 : 0);
      for ($i = 2; $i <= $bytesnumber; $i++) {
        $offset ++;
        $code2 = ord(substr($string, $offset, 1)) - 128;        //10xxxxxx
        $codetemp = $codetemp*64 + $code2;
      }
      $code = $codetemp;
    }
    if ($code < 256) {
      return sprintf("%%%02X", $code);
    } else {
      return sprintf("%%u%04X", $code);
    }
  }
  return preg_replace_callback("|[^ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./]|u", $fn, $str);
}

nielsm fucked around with this message at 12:36 on Feb 10, 2017

                            <a href="#" onClick="toDelete()">

                        function rec(deletestuff) {
                            $('#newCode').load('delete_selected.php' deletestuff);
                        }

                                        <input type="checkbox" name="selected[]" value="'.$file.'">

                            $('input[type=checkbox]').each(function () {
                                if(this.checked) {
                                    toDelete.push(this.id);
                                }
                            });

nielsm fucked around with this message at 09:27 on Apr 8, 2017

nielsm fucked around with this message at 22:12 on Apr 23, 2022

import random

class Node:
    def __init__(self, index):
        self.index = index
        self.edges = set()
        self.color = None

def allow_connection(n1, n2):
    # only allow connection if nodes are not already connected
    return n2 not in n1.edges and n1 not in n2.edges

def initial_connect_nodes(count, min_connections, max_connections):
    # make initial array of nodes
    nodes = [Node(i) for i in range(count)]
    # make a list of a random number of references to every node, one ref for each connection desired from that node
    to_connect = [node for node in nodes for _ in range(random.randint(min_connections, max_connections))]
    # shuffle the connection order
    random.shuffle(to_connect)
    # ensure that there is an even number of nodes, since we need to connect them in pairs
    if len(to_connect) % 2 == 1: to_connect.append(to_connect[0])
    # generate connections
    for i in range(0, len(to_connect) - 1, 2):
        # pick the front two nodes in the list
        n1, n2 = to_connect[i], to_connect[i+1]
        # check if the nodes are allowed to connect, find another node if not
        j = i + 1
        while not allow_connection(n1, n2):
            j += 1
            # fail if we run out of nodes (none of the remaining nodes are allowed for connection)
            if j >= len(to_connect): return None
            # swap current n2 candidate backwards in the array and pick a new one
            to_connect[i+1], to_connect[j] = to_connect[j], to_connect[i+1]
            n2 = to_connect[i+1]
        # connect the nodes
        n1.edges.add(n2)
        n2.edges.add(n1)
    return nodes

def colorize_nodes(nodes):
    # wash the colors off
    for n in nodes:
        n.color = None
    # begin painting
    nextcolor = 0
    for start_node in nodes:
        # if node is already colored, don't process
        if start_node.color is not None: continue
        # otherwise assign the next available color to it
        start_node.color = nextcolor
        nextcolor += 1
        # now visit all reachable nodes and paint them too
        stack = list(start_node.edges)
        while len(stack) > 0:
            # grab one node from the stack
            n = stack.pop()
            # if it's already painted skip it
            if n.color is not None: continue
            # otherwise paint it
            n.color = start_node.color
            # and push all nodes connected to it too
            stack.extend(n.edges)
    # the nextcolor variable will also be the count of unique colors assigned
    return nextcolor

nodes = None
tries = 0
while nodes is None:
    tries += 1
    nodes = initial_connect_nodes(10000, 1, 20)
num_colors = colorize_nodes(nodes)

print(f"Generated initial graph with {len(nodes)} nodes in {tries} tries, it has {num_colors} colors")
#for n in nodes:
#    edgeindexes = ', '.join(str(e.index) for e in n.edges)
#    print(f"Node {n.index} (color {n.color}) is connected to nodes: {edgeindexes}")

nielsm fucked around with this message at 23:08 on Feb 26, 2023