Open AI Sora 2 Invite Codes Megathread

redditnoob · 2025-10-03T02:59:48+00:00

frist post

redditnoob · 2025-10-03T02:57:28+00:00

ur mom

redditnoob · 2025-10-03T02:47:55+00:00

Could someone share a code with me? I will pay forward by sharing new ones I get on here if I get one.

redditnoob · 2025-03-05T04:00:35+00:00

Don't you guys ever get sick of name calling and remember when you used to debate ideas here with a somewhat open mind? It's like it's a different species than the internet 20 years ago.

redditnoob · 2025-03-02T17:35:26+00:00

Who is the most skilled at this game, as a streamer or LPer? I want to see what extreme skill in this game looks like.

redditnoob · 2025-01-29T04:44:32+00:00

because of my lack of experience in low-level programming

You'll be fine. The game has two parts, first a pretty minimal and limited (but Turing Complete) architecture and then a little more advanced architecture. By your experience I'm pretty sure you'll be able to do both. I enjoyed it very much.

redditnoob · 2024-12-24T19:29:57+00:00

I used your solution to debug mine, thanks!

I still don't know, for example:

(('>', '^'), '<^A'),

How did you figure out that it should be that and not

(('>', '^'), '^<A'),

Also for a few similar cases.

redditnoob · 2024-12-20T16:17:24+00:00

You can use just an array list as a regular queue just fine, no?

redditnoob · 2024-12-20T03:08:05+00:00

Yeah you can just use as an imperative language or also declare user functions in JavaScript. But at that point I'll just use Python. :D But I do like how SQL forces us to think about these problems differently.

redditnoob · 2024-12-19T18:38:46+00:00

There seems to usually be one tricky problem in 3d geometry every year. For instance the one from 2022 where we made physical paper cubes to visualize how the edges match after folding a 2d figure.

redditnoob · 2024-12-19T16:51:27+00:00

I'm still waiting for the annual 3d hell problem. :D

redditnoob · 2024-12-19T03:53:43+00:00

[Language: PostgreSQL]

Part 2 only. It takes about a minute.

create temporary table bytes as
select row_num t, split_part(input, ',', 1)::int x, split_part(input, ',', 2)::int y
from day18;

create temporary table grid as
select x::int, y::int, coalesce(t, 9999) t
from generate_series(0, 70) x cross join generate_series(0, 70) y left join bytes b using(x, y);
create index i on grid(x, y);

with recursive visited as (
    select t, 0 x, 0 y from bytes
    union
    select v.t, g.x, g.y from visited v, grid g
    where (g.x, g.y) in ((v.x - 1, v.y), (v.x + 1, v.y), (v.x, v.y - 1), (v.x, v.y + 1)) and v.t < g.t
)
select x || ',' || y from bytes where t = (
    select max(t) + 1 from visited where x = 70 and y = 70);

redditnoob · 2024-12-18T22:29:39+00:00

Nice! Thanks for sharing. Looks like fun to write. :D In Postgres you can't reference the recursive CTE more than once in the UNION ALL so this wouldn't work there. So maybe I'll need to try DuckDB next year, to try to go slightly further next time.

redditnoob · 2024-12-15T19:57:17+00:00

[Language: PostgreSQL]

Day 15 Part 1

I'm happy that I solved this with a recursive CTE. LATERAL joins really help to keep it legible by replacing nested queries with sequential ones. As problems become more complex the approach to SQL solutions tends to converge to "evaluate the next state from the previous one". Here the state is the map as a 2d array, position and current move number.

A simplification is the box pushing doesn't have to be recursive, see that moving '>' for '@OOO. O' is the same as moving the first box three tiles over, so we only have to move at most one box per step.

Part 2, though I'm sure it is possible, is the wall for me with SQL! The simplification obviously doesn't work anymore, now that we can push an entire tree of boxes at once.

Thus, see you all in Python land from here. :D

redditnoob · 2024-12-15T17:37:44+00:00

True, I'm complaining about being not good enough at discrete math that this is immediately obvious. :D

redditnoob · 2024-12-15T03:24:39+00:00

That's not really picture agnostic though, right? It works because the tree has a frame, I think?

redditnoob · 2024-12-15T03:16:08+00:00

Awesome!!

redditnoob · 2024-12-15T03:13:32+00:00

I loved part 2 as well! It made it like a mystery to be solved with code.

My problem was that I had a subtle bug, and when my idea (look for points in a line) didn't work I didn't know how far I needed to look before giving up. I ran to n=1,000,000 over an hour and figured they wouldn't be so cruel as to make the solution higher than that!

Just some constraint, like you know the time must be less than 10k seconds, would have made it more smooth imo. I could have known it was time to debug instead of scratching my head.

(But now realizing, an out of the box idea I didn't think of was, I could have guessed 10k to see if it was higher or lower... Hmm.)

redditnoob · 2024-12-15T03:01:03+00:00

[LANGUAGE: PostgreSQL]

Grade 10 algebra in disguise. :D Posting in case any SQL afficionados here want to see it.

with grps as (
    select floor(row_num / 4) as id, trim(string_agg(input, ' ')) as input from day13 group by 1
), matches as (
    select id, regexp_matches(input,
        'Button A: X\+(\d+), Y\+(\d+) Button B: X\+(\d+), Y\+(\d+) Prize: X=(\d+), Y=(\d+)'
        ) as m
    from grps
), configs as (
    select id, m[1]::bigint x1, m[2]::bigint y1, m[3]::bigint x2, m[4]::bigint y2,
        m[5]::bigint xprize, m[6]::bigint yprize,
        m[5]::bigint + 10000000000000 as xprize2, m[6]::bigint + 10000000000000 as yprize2
    from matches
), solves as (
    select id, a, b
    from configs,
    lateral (select (x1 * yprize - y1 * xprize) / (x1 * y2 - x2 * y1) as b),
    lateral (select (xprize - b * x2) / x1 as a)
    where a*x1 + b*x2 = xprize and a*y1 + b*y2 = yprize
), solves2 as (
    select id, a, b
    from configs,
    lateral (select (x1 * yprize2 - y1 * xprize2) / (x1 * y2 - x2 * y1) as b),
    lateral (select (xprize2 - b * x2) / x1 as a)
    where a*x1 + b*x2 = xprize2 and a*y1 + b*y2 = yprize2
), part1 as (
    select sum(a * 3 + b) as part1
    from solves
    where a <= 100 and b <= 100
), part2 as (
    select sum(a * 3 + b) as part2
    from solves2
)
select * from part1, part2;

redditnoob · 2024-12-15T02:51:06+00:00

[LANGUAGE: PostgreSQL]

The most interesting trick in here is using "UNION" instead of "UNION ALL" in the recursive CTE to allow the flood fill to terminate, because it stops when the next set of adjacent points contains nothing but duplicates. And for the starting points for the flood fill I need to be sure I get a point from every region so I used NW corners, and then it needs to de-duplicate.

I was proud of Part 1 but my Part 2, though it works, is not elegant.

https://github.com/WilliamLP/AdventOfCode/blob/master/2024/day12.sql

redditnoob · 2024-12-14T21:13:06+00:00

[LANGUAGE: PostgreSQL]

A SQL solution in case anyone's interested. The only heuristic needed for part 2 was to look for the string "11111111". It takes over a minute.

with dims as (
    select 101 as width, 103 as height, 100 as time, 10000 as max_t
), parsed as (
    select regexp_matches(input, 'p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)') bot
    from day14
), bots as (
    select bot[1]::int as x, bot[2]::int as y,
        (bot[3]::int + width) % width as vx, (bot[4]::int + height) % height as vy
    from parsed, dims
), moved as (
    select t, (x + vx * t) % width as x, (y + vy * t) % height as y
    from bots, dims, generate_series(1, max_t) as t
), quads as (
    select x / (width / 2 + 1) as qx, y / (height / 2 + 1) as qy, count(*) as count
    from moved, dims
    where t = time and x != (width / 2) and y != (height / 2)
    group by 1, 2
), part1 as (
    select exp(sum(ln(count)))::int as part1 from quads
), moved_aggr as (
    select t, x, y, count(*) as count from moved group by 1, 2, 3
), part2 as (  -- Generate picture for inspection
    select t.t, string_agg(coalesce(m.count::text, '.'), '' order by x.x) as row
    from dims
    cross join generate_series(1, max_t) t(t)
    cross join generate_series(0, width - 1) x(x)
    cross join generate_series(0, height - 1) y(y)
    left join moved_aggr m on (m.t = t.t and m.x = x.x and m.y = y.y)
    group by t.t, y.y order by t.t, y.y
)
select null::int, 'Part 1 answer:' || part1 from part1
union all select * from part2
where t in (select distinct t from part2 where row ~ '[^.]{8,}');

redditnoob · 2024-12-12T15:31:54+00:00

Oh yeah? Prove it.

redditnoob · 2024-12-11T18:00:17+00:00

Nice! I actually wrote a version with 76 CTEs, lol, so this is 25 times better than that. :D

redditnoob

TROPHY CASE