eutectic

What a shallow and ignorant article.

Then no.

Did you use the GPT4 version?

And how much bromate (and nastier compounds) occurs naturally in vegetables we eat?

Bromate should decompose to bromide during baking. I wouldn't worry too much.

Box filtering should be pretty cheap; it is separable, and can be implemented with a moving average. Overall just a handful of operations per pixel.

I think it's extremely unlikely that rates of illness have gone up.

Something adaptive. Maybe AABB trees depending on the context.

Can you expand on this enigmatic comment?

It's a myth that household dust is mostly skin cells. It only makes up a small percentage.

I feel like quadtrees are almost never the best data structure for a given problem. The rare exception being HashLife.

I think square, circle, octagon would make the most sense. Or maybe diamond (rotated square) instead of octagon. That way adjacent stone would always touch.

orange down

green right

orange right

green down

green left

green down

orange left

green up

I think it's more the case that the benefits of flossing haven't been studied much, not that it's been thoroughly investigated and found not to work.

If you use binary search on the length of the substring then you can get to n log(n) expected time, independent of the input distribution.

There are many effective medicines for which the mechanism is unclear or disputed. Should we stop using them?

An actual solver in Python:

    import numpy as np
    from mip import Model, xsum, minimize, BINARY

    def solve(tiles):
        rotations = [[[] for _ in row] for row in tiles]
        rot_vars = [[[] for _ in row] for row in tiles]
        model = Model("rotaboxes")
        for i, row in enumerate(tiles):
            for j, tile in enumerate(row):
                for _ in range(3):
                    tile = tile.transpose((1, 0, 2))[::-1]
                    rotations[i][j].append(tile)
                    rot_vars[i][j].append(model.add_var(var_type=BINARY))
                model += (xsum(rot_vars[i][j]) == 1)
        costs = []
        for i, row in enumerate(tiles):
            for j, tile in enumerate(row):
                for (di, dj) in [(0, 1), (1, 0)]:
                    if (i + di >= len(tiles)) or (j + dj >= len(tiles[0])):
                        continue
                    for r0, t0 in enumerate(rotations[i][j]):
                        for r1, t1 in enumerate(rotations[i + di][j + dj]):
                            if di:
                                a, b = t0[-1], t1[0]
                            else:
                                a, b = t0[:,-1], t1[:,0]
                            n = np.square(a - b).mean()
                            d = np.square(a[1:] - a[:1]).mean() + np.square(b[1:] - b[:1]).mean()
                            e = 2. * n / (d + 0.01)
                            v = model.add_var(var_type=BINARY)
                            model += (v >= rot_vars[i][j][r0] + rot_vars[i + di][j + dj][r1] - 1)
                            costs.append(e * v)
        model.objective = minimize(xsum(costs))
        model.optimize()
        solution = [[[r for v, r in zip(vs, rs) if v.x >= 0.99][0] for vs, rs in zip(row0, row1)] for row0, row1 in zip(rot_vars, rotations)]
        return solution

I guess it's a Gaussian, by the central limit theorem.

I believe that the question of whether saturated fat is unhealthy is still an open question.

You can optimize the poses as part of the model.

I have my doubts that this will converge to anything meaningful.

I think it's supposed to be a bit scary, so you pay extra close attention.

If you have insurance-based healthcare then you need some mechanism to prevent a death spiral.

No, free molecular flow is a very different regime with very different behavior.

Not to be rude, but I found it a bit infantilizing. I would rather just have the information.

Mercaptans sound like a terrible rocket fuel; heavier than carbon, with less energy released.

I think the energy in TNT mostly comes from the desire of carbon and hydrogen to join forces with the oxygen, which has a much higher activation energy than nitrogen leaving of its own accord.

I don't know about beautiful, but I just came up with this small NFA matcher for the same problem:

    #include <stdlib.h>
    #include <string.h>

    int match(char* regex, char* text) {
        int n = strlen(regex);
        char* active = calloc(n + 1, 1);
        char* next_active = calloc(n + 1, 1);
        active[0] = 1;
        int found = 0;
        int anchor = regex[0] == '^';
        regex += anchor;
        do {
            for (int i = 0; i <= n; i++) {
                if (!active[i])
                    continue;
                if (regex[i] == '\0') {
                    found = 1;
                    goto DONE;
                } else if (regex[i + 1] == '*') {
                    next_active[i + 2] = 1;
                    if (regex[i] == '.' || regex[i] == *text)
                        next_active[i] = 1;
                } else if (regex[i] == '$' && regex[i + 1] == '\0') {
                    found = *text == '\0';
                    goto DONE;
                } else {
                    next_active[i + 1] = regex[i] == *text;
                }
            }
            char* tmp = next_active;
            next_active = active;
            active = tmp;
            active[0] = !anchor;
            memset(next_active, 0, n + 1);
        } while (*text++ != '\0');
    DONE:;
        free(active);
        free(next_active);
        return found;
    }

A neural network mapping spacetime coordinates to output values.

Reactive elements make stable compounds. e.g. sodium + chlorine -> sodium chloride.