e0qdk

What upside down thing with a banana??

There was a viral video/meme maybe a decade ago about how monkeys peel bananas (might have actually been an orangutan or gorilla in the one I saw; been too long since I've seen it) where they peel it from the end opposite of how people are usually shown doing it. I'm guessing they mean that? Basically, instead of bending the stem bit (from where the bananas bunch up), you can pinch the tip at the other end and the peel splits open very easily -- it's easier to do, especially if the banana is still a bit on the greener side of ripeness and the stem part is flexible. (I tried it after seeing it and switched to peeling them from the "bottom" myself.)

What back bit?

There is a little black fibrous part of most Cavendish bananas near the tip I was describing; many people do not like eating it and avoid it.

Also…veins?

I'm not sure what they mean either.

I don't know if there are any existing implementations that work well enough yet for it to actually be relaxing, but it might be possible to set up a hands-free IF experience by hooking up speech-to-text and text-to-speech tools to the game.

Can Z3 account for lost bits? Did it come up with just one solution?

It gave me just one solution the way I asked for it. With additional constraints added to exclude the original solution, it also gives me a second solution -- but the solution it produces is peculiar to my implementation and does not match your implementation. If you implemented exactly how the bits are supposed to end up in the result, you could probably find any other solutions that exist correctly, but I just did it in a quick and dirty way.

This is (with a little clean up) what my code looked like:

#!/usr/bin/env python3

import z3

rand1 = 0.38203435111790895
rand2 = 0.5012949781958014
rand3 = 0.5278898433316499
rand4 = 0.5114834443666041

def xoshiro128ss(a,b,c,d):
    t = 0xFFFFFFFF & (b << 9)
    r = 0xFFFFFFFF & (b * 5)
    r = 0xFFFFFFFF & ((r << 7 | r >> 25) * 9)
    c = 0xFFFFFFFF & (c ^ a)
    d = 0xFFFFFFFF & (d ^ b)
    b = 0xFFFFFFFF & (b ^ c)
    a = 0xFFFFFFFF & (a ^ d)
    c = 0xFFFFFFFF & (c ^ t)
    d = 0xFFFFFFFF & (d << 11 | d >> 21)
    return r, (a, b, c, d)

a,b,c,d = z3.BitVecs("a b c d", 64)
nodiv_rand1, state = xoshiro128ss(a,b,c,d)
nodiv_rand2, state = xoshiro128ss(*state)
nodiv_rand3, state = xoshiro128ss(*state)
nodiv_rand4, state = xoshiro128ss(*state)

z3.solve(a >= 0, b >= 0, c >= 0, d >= 0,
  nodiv_rand1 == int(rand1*4294967296),
  nodiv_rand2 == int(rand2*4294967296),
  nodiv_rand3 == int(rand3*4294967296),
  nodiv_rand4 == int(rand4*4294967296)
  )

I never heard about Z3

If you're not familiar with SMT solvers, they are a useful tool to have in your toolbox. Here are some links that may be of interest:

• https://en.wikipedia.org/wiki/Satisfiability_modulo_theories
• https://en.wikipedia.org/wiki/Z3_Theorem_Prover

Edit: Trying to fix formatting differences between kbin and lemmy
Edit 2: Spoiler tags and code blocks don't seem to play well together. I've got it mostly working on Lemmy (where I'm guessing most people will see the comment), but I don't think I can fix it on kbin.

Frames Per Stratum

If I understand the problem correctly, this is the solution:

I solved it with Z3. Took less than a second of computer time, and about an hour of my time -- mostly spent trying to remember how the heck to use Z3 and then a little time debugging my initial program.

I feel that one. I've had the programming equivalent of writer's block on my main hobby project for over a month now. Good luck!

Not sure, but I just checked and I have upwards of 3700 unfinished MIDI files I've authored over the past 20+ years -- more than 8MB of data. A lot of that is multiple drafts of the same songs (e.g. one song might have 3~5 variants from a single session where I was experimenting and kept all of the drafts as separate files, and sometimes I came back to an idea and experimented with it again and again like that over a period of years). I also tend to keep a lot of my musical doodles.

There's a couple dozen pieces in there that I think might be worth the effort of going back to and finishing someday, maybe; everything else is just my musical research notes, basically.

What I'd do is set up a simple website that uses a little JavaScript to rewrite the date and time into the page and periodically refresh an image under/next to it. Size the image to fit the remaining free space of however you set up the iPad, and then you can stick anything you want there (pictures/reminder text/whatever) with your favorite image editor. Upload a new image to the server when you want to change the note. The idea with an image is that it's just really easy to do and keeps the amount of effort to redo layout to a minimum -- just drag stuff around in your image editor and you'll know it'll all fit as expected as long as you don't change the resolution (instead of needing to muck around with CSS and maybe breaking something if you can't see the device to check that it displays correctly).

There's a couple issues to watch out for -- e.g. what happens if the internet connection/server goes down, screen burn-in, keeping the browser from being closed/switched to another page, keeping it powered, etc. that might or might not matter depending on your particular circumstances. If you need to fix all that for your circumstances, it might be more trouble than just buying something purpose built... but getting a first pass DIY version working is trivial if you're comfortable hosting a website.

Edit: If some sample code that you can use as a starting point would be helpful, let me know.

My guess is that if browsers as we know them weren't invented, HyperCard would've become the first browser eventually. No idea where things would progress from there or if it'd have been better or worse than the current clusterfuck. Maybe we'd all be talking about our "web stacks" instead of websites, and have various punny tools like "pile" and "chimney" and "staplr". Perhaps PowerPoint would've turned into a browser to compete with it.

If browsers were invented but JavaScript specifically was not, we'd probably all be programming sites in some VB variant like VBScript (although it might be called something different).

I had somewhat limited time this past week, but wanted to keep working through my backlog of unfinished shows, so I pulled up the short (6 episode) series Looking Up At The Half-Moon and watched that. I think I dropped this after episode 2 the first time I tried it, but finished it this time.

The show is a hospital drama + romance, which seems unusual for anime. I don't think I've watched any other anime set almost entirely in a hospital before -- scenes, yes, but not the whole show. I'm not generally into medical drama so I haven't really gone looking though; this is one I went into blind originally.

Guess which novel shows up again! Yup, it's Night on the Galactic Railroad. I feel like I'm seeing this book everywhere now, and this show quotes from it directly; one of the characters has pretty much memorized it. Something I noticed from the quotes is that one of the characters (in the novel) is named Campanella -- which should ring bells for anyone who's played the Trails series... No idea if there's actually a connection there, but I thought it was interesting.

The show strained my suspension of disbelief with how a number of characters acted, but did some things I found interesting as well. The doctor's characterization did not go in quite the direction I expected, and there were a number of other surprises throughout. Episode 5 in particularly really went somewhere I wasn't expecting. I kind of feel like I should write more about that... but it would all be spoilers.

You can't really, as others have pointed out, but I like Philip K Dick's definition of reality: "Reality is that which, when you stop believing in it, doesn’t go away."

GPT4-Vision can do it, sort of. It doesn't have a particularly great understanding of what's going on in a scene, but it can be used for some interesting stuff. I posted a link a few weeks back to an example from DALL-E Party, which hooks up an image generator and an image describer in a loop: https://kbin.social/m/[email protected]/t/661021/Paperclip-Maximizer-Dall-E-3-GPT4-Vision-loop-see-comment

merde posted a link in the comments there to the goatpocalypse example -- https://dalle.party/?party=vCwYT8Em -- which is even more fun.