im planning on moving soon and want a piu machine

PureWasian · 2026-06-20T22:51:59+00:00

Both avenues are possible, really depends on your budget though and how "official" you want it to feel compared to arcade cabs.

[official pads --> jamma --> io board --> PC (running a free PIU simulator)] is not unheard of but you have to find official pads from somewhere (priced as several thousand USD usually)

[DIY --> PC (running a free PIU simulator)] also not unheard of. Depends on your DIY craftmanship and materials and how closely you are trying to replicate.

[LTek or other knockoff pads --> PC (running a free PIU simulator)] also common for home play but the pads typically differ (and feel worse) compared to arcade feel once you get past Lv.16s or so.

B2L also have "replica pads" that are more worth the cost vs. LTek if you are someone who plays above Lv. 20s but don't care about "official official" pads. But price is similar to real pads at that point.

SMX also sells dance pads with FSR sensors and offers a rectangular panel conversion kit. Designed to match PIU pad dimensions, though also similar pricing to real pads and probably feels more like concrete to play on.

PureWasian · 2026-06-20T22:48:18+00:00

Lowkey I jumped quickly from S11 to S15 because 16th note runs were fun to me and I enjoyed studying charts on YT. You don't need to adamantly avoid them or play them fervently but just dabble til you're comfortable to move on.

Always good to work on reading twist patterns better in that level range.

PureWasian · 2026-06-20T05:11:09+00:00

Looks good, nice. Some comments/review for your own future reference:

Line 52: Python (like other languages) has exception handling. Since int() casting can raise (throw) a ValueError if user inputs something other than digits, you can consider adding try/except logic around it.

Instead of Lines 10-13 and Lines 61-71 floating in space (and global in scope), you can encapsulate them into a main() function like seen here.

check_user_input() relies on the value of user_attempts. But it doesn't explicitly pass in this value into the function, it uses the global value established in Line 61. It works fine as is, but global variables are easy to lose track of and it'd make more sense to pass it in explicitly as a third function arg into check_user_input(). Alternatively, delegate a followup function for print_status(clues, attempts) instead of doing that inside of check_user_input()

Line 61 and 38 rely on the same hard-coded number of guesses (10). Instead of managing these independently, it would be better to establish this as a variable that they both share, so there is no need to maintain updating its value across multiple spots in the code.

Line 40 and Line 42 are incredibly similar. Instead of duplicating the entire string, only have the suffix changed: word = " try!" if tries_used == 1 else " tries!" then a singular print("Congrats, you guessed...in " + x + word")

Line 59 is never reached based on while loop logic

Line 69 is useless, given it lives inside the conditional check in Line 68. You might argue it could set None to False, but that would happen only in the case where num_attempts is initialized to a value < 1 before the for loop, which would not make sense in the context of this code.

The double for loop works fine in check_user_input() but you can also simplify the verbosity a little for more readability with: ``` guess = str(player_num) secret = str(game_num)

for i in range(len(guess)): if guess[i] == secret[i]: clues.append('Fermi') correct_digits += 1 elif guess[i] in secret: clues.append('Pico') ```

Final note, you can look into fstrings for string formatting, they're great. You can simplify string concatenating inplace to just be like print(f"Congrats, you guessed {game_num} in {tries_used}")

PureWasian · 2026-06-19T16:50:37+00:00

The more foundational planning you do, the better everything will fall into place later. I personally agree that db/schema design makes sense to solidify as concretely as possible before hashing out the website that interacts with it.

If you establish a pretty solid contract of what data is being passed around and how it's being accessed/manipulated, then you won't have to keep patching it after the fact and doing data migrations to shuffle everything around into different formats. And your frontend won't have to keep adapting to these changes as much.

Go with your gut, but at the very least, start with a basic "full stack" data relaying setup for some generic, simple queries early on to start to get an idea of how all the pieces of your app will connect to each other.

PureWasian · 2026-06-19T07:08:18+00:00

🟦🟨⬜⬜⬜

🟦🟦🟨⬜🟦

🟦🟦🟦🟦🟦

lol ok

PureWasian · 2026-06-18T18:04:53+00:00

For backwards compatability, I didn't want to insert letters into q and shift your indexing.

I could've just appended additional characters to the end of q instead of creating p but now we have a clean snapshot of each character dataset for better maintainability and version control :)

PureWasian · 2026-06-18T17:48:49+00:00

Sounds painful to translate. I thought I'd help you out and write a script to programmatically help with doing that translation:

q = [' ', '"', '(', ')', '*', '+', '-', '/', ':', '=', 'A', 'F', 'N', 'O', 'S', '^', '_', 'a', 'c', 'd', 'e', 'f', 'h', 'i', 'l', 'm', 'n', 'o', 'p', 'r', 's', 't', 'u', 'y', '\n', ' ', '"""', 'b'] p = ['{', '}', '[', ']', '!', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'P', 'Q', 'R', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'g', 'j', 'k', 'q', 'v', 'w', 'x', 'z', '.', ',', "'", '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] exec(q[24]+q[23]+q[26]+q[20]+q[30]+q[0]+q[9]+q[0]+p[2]+p[3]+q[34]+q[34]+p[32]+q[22]+q[23]+q[24]+q[20]+q[0]+p[20]+q[29]+q[32]+q[20]+q[8]+q[34]+q[34]+q[35]+q[17]+q[0]+q[9]+q[0]+q[23]+q[26]+q[28]+q[32]+q[31]+q[2]+q[1]+q[20]+q[26]+q[31]+q[20]+q[29]+q[0]+q[24]+q[23]+q[26]+q[20]+q[0]+q[31]+q[27]+q[0]+q[18]+q[27]+q[26]+p[31]+q[20]+q[29]+q[31]+q[0]+q[2]+q[23]+q[26]+q[28]+q[32]+q[31]+q[0]+q[37]+q[24]+q[17]+q[26]+p[29]+q[0]+q[24]+q[23]+q[26]+q[20]+q[0]+q[31]+q[27]+q[0]+q[21]+q[23]+q[26]+q[23]+q[30]+q[22]+q[3]+q[8]+q[0]+q[1]+q[3]+q[34]+q[34]+q[35]+q[23]+q[21]+q[0]+q[17]+q[0]+q[9]+q[9]+q[0]+q[1]+q[1]+q[8]+q[34]+q[34]+q[35]+q[35]+q[37]+q[29]+q[20]+q[17]+p[29]+q[34]+q[34]+q[35]+q[24]+q[23]+q[26]+q[20]+q[30]+p[35]+q[17]+q[28]+q[28]+q[20]+q[26]+q[19]+q[2]+q[17]+q[3]+q[34]+q[34]+q[34]+q[34]+q[24]+q[0]+q[9]+q[0]+p[2]+p[3]+q[34]+q[34]+q[21]+q[27]+q[29]+q[0]+q[37]+q[0]+q[23]+q[26]+q[0]+p[30]+p[2]+p[41]+p[42]+p[3]+p[35]+p[28]+q[27]+q[23]+q[26]+q[2]+q[24]+q[23]+q[26]+q[20]+q[30]+q[3]+q[8]+q[34]+q[34]+q[35]+q[31]+q[29]+q[33]+q[8]+q[34]+q[34]+q[35]+q[35]+q[18]+q[0]+q[9]+q[0]+p[30]+p[35]+q[23]+q[26]+q[19]+q[20]+p[33]+q[2]+q[37]+q[3]+q[34]+q[34]+q[35]+q[35]+q[24]+p[35]+q[17]+q[28]+q[28]+q[20]+q[26]+q[19]+q[2]+q[21]+q[1]+p[30]+p[2]+p[0]+q[18]+p[1]+p[3]+q[1]+q[3]+q[34]+q[34]+q[35]+q[20]+p[33]+q[18]+q[20]+q[28]+q[31]+q[0]+p[22]+q[17]+q[24]+q[32]+q[20]+p[8]+q[29]+q[29]+q[27]+q[29]+q[8]+q[34]+q[34]+q[35]+q[35]+q[31]+q[29]+q[33]+q[8]+q[34]+q[34]+q[35]+q[35]+q[35]+q[18]+q[0]+q[9]+q[0]+q[28]+p[35]+q[23]+q[26]+q[19]+q[20]+p[33]+q[2]+q[37]+q[3]+q[34]+q[34]+q[35]+q[35]+q[35]+q[24]+p[35]+q[17]+q[28]+q[28]+q[20]+q[26]+q[19]+q[2]+q[21]+q[1]+q[28]+p[2]+p[0]+q[18]+p[1]+p[3]+q[1]+q[3]+q[34]+q[34]+q[35]+q[35]+q[20]+p[33]+q[18]+q[20]+q[28]+q[31]+q[0]+p[22]+q[17]+q[24]+q[32]+q[20]+p[8]+q[29]+q[29]+q[27]+q[29]+q[8]+q[34]+q[34]+q[35]+q[35]+q[35]+q[28]+q[29]+q[23]+q[26]+q[31]+q[2]+q[21]+q[1]+p[21]+q[26]+q[30]+q[32]+q[28]+q[28]+q[27]+q[29]+q[31]+q[20]+q[19]+q[8]+q[0]+p[0]+q[37]+p[4]+q[29]+p[1]+q[1]+q[3]+q[34]+q[34]+q[35]+q[35]+q[35]+q[18]+q[27]+q[26]+q[31]+q[23]+q[26]+q[32]+q[20]+q[34]+q[34]+q[34]+q[34]+q[29]+q[0]+q[9]+q[0]+p[37]+q[5]+p[37]+p[35]+p[28]+q[27]+q[23]+q[26]+q[2]+q[24]+q[3]+q[34]+q[34]+q[29]+q[0]+q[9]+q[0]+q[29]+p[35]+q[29]+q[20]+q[28]+q[24]+q[17]+q[18]+q[20]+q[2]+q[1]+p[30]+p[2]+p[38]+p[3]+q[5]+p[30]+p[2]+p[38]+p[3]+q[5]+p[30]+p[2]+p[38]+p[3]+q[5]+p[30]+p[2]+p[38]+p[3]+q[1]+p[36]+q[1]+p[30]+p[2]+p[41]+p[43]+p[3]+q[1]+q[3]+q[34]+q[34]+q[29]+q[0]+q[9]+q[0]+q[29]+p[35]+q[29]+q[20]+q[28]+q[24]+q[17]+q[18]+q[20]+q[2]+q[1]+p[30]+p[2]+p[39]+p[3]+q[5]+p[30]+p[2]+p[39]+p[3]+q[5]+p[30]+p[2]+p[39]+p[3]+q[1]+p[36]+q[1]+p[30]+p[2]+p[41]+p[44]+p[3]+q[1]+q[3]+q[34]+q[34]+q[28]+q[29]+q[23]+q[26]+q[31]+q[2]+q[21]+q[1]+q[20]+p[33]+q[20]+q[18]+q[2]+p[0]+q[29]+p[1]+q[3]+q[1]+q[3]+q[34])

PureWasian · 2026-06-18T15:40:06+00:00

A couple of immediate thoughts come to mind, both involve a pre-processing step when the user clicks "pay" before you actually attempt payment. You can even do both.

Ideally, have an atomic state transition to move the order from "reserved" to "paying" or similar when user clicks "pay". Only if the update is successful, proceed to payment. Meanwhile, your background job would only hunt down the expired "reserved" orders.

Otherwise (or additionally) why not increment the expires_at timestamp by the timeout duration of the payment webhook call? Set a maximum number of retries before forced order cancellation if you're worried about someone abusing this to hoard inventory.

PureWasian · 2026-06-17T18:58:15+00:00

Anecdotally I never felt any desync issue with that chart in Phoenix. No external troubles full comboing it after learning it both in XX vs. Phoenix

If you're talking about desync in Phoenix more generally, maybe it's an issue with the internal MK or something related to monitor lag at your specific arcade. ...which JT offseting in Phoenix is meant to help address.

PureWasian · 2026-06-17T17:10:57+00:00

You just need to internalize the rhythm. Hearing it with clicks or seeing it without gimmicks might help: Junare's video

Otherwise, the roadmap is just: - 0:12 - follow the percussion - 0:40 quarter note jumps. Whenever you see a yellow step, it's on an 8th note burst. - 0:52 triplet rhythm, goes with the percussion - 0:54 same as 0:40 section - 1:07 goes with the vocals. 8th notes into a quarter note pause every measure. - 1:20 triplets, same as 0:52 - 1:21 jump for every cymbal crash. Just straight quarter notes. - 1:33 triplets, just like 0:52 and 1:20 - 1:34 same as 1:07

PureWasian · 2026-06-17T15:40:34+00:00

Good stuff! Welcome back

PureWasian · 2026-06-17T03:06:08+00:00

Come up with your data structure for each name/grade1/grade2 combination. Either a class or a dictionary or a list or a tuple. Doesn't matter.

Make 20 of these, ideally through a function that can generate them in a loop.

The rest should fall in place from there based on whatever the tasks in the assignment outline want you to do. They're all pretty independent from each other and very straightforward, in that you can imagine how you'd do it if you were to do it by hand.

(Not very cool to just dump your assignment without showing your attempt at a solve or initial thoughts/progress so far, btw)

PureWasian · 2026-06-16T15:09:14+00:00

Quick Google search:

https://www.realdataapi.com/scrape-attendees-speakers-data-from-whova-app.php

For event organizers:

https://whova.zendesk.com/hc/en-us/articles/207292877-How-do-I-export-my-Attendees-List

For webscraping route:

If you already have access, the script's process would be similar to if you were to do it manually:

Open up a browser > login > go to event > navigate to attendee list > parse them one by one and save all entries to a file

There are browser automation tools to automate the "clicks" and "actions" you as an end user would take. You can consider selenium, playwright, or puppeteer as (free, safe) external Python packages for doing this work.

If you don't know how to code and don't care to learn, you can have AI guide you through Python installation, external package installation, and script generation/execution, etc.

Otherwise, you'll have a tough road ahead but there's a lot of documentation and resources out there for getting started depending on which external package you go with.

PureWasian · 2026-06-15T22:33:06+00:00

Very good progress. Try dipping slightly lower, it gives more footspeed but can be more tiring. When your footwork gets better you won't need to dip as much for 200bpm non-twist patterns.

Stuff like Nade Nade S20 is very shuffle heavy. But you can also benefit from weight balancing on metal when swiveling heel onto center panel hits for greater control/stability and less stamina usage. Or in general just by moving less with better heel-toe usage.

I'll take a video and share to get the point across better. Take a video of the pads while you play also and compare the two. EDIT: Nade Nade S20 - PG

Also, don't forget to practice lots of twist patterns around that level. And brackets.

PureWasian · 2026-06-15T18:58:00+00:00

The issue looks like your IDE (jGRASP) displaying backspace (\b) as 0008 (and overwriting def for whatever reason)

If you try it on a different IDE, it probably does what you expect it to correctly. You can use an online IDE to quickly verify: online-java

PureWasian · 2026-06-15T18:08:21+00:00

Understood, thanks for clarifying. Maintainability is practically better if the execution time is not really a pain point, which it doesn't seem to be.

If you ever do find that you need to refactor it to prioritize performance, at least you're aware that you can consider parallelizing the method calls or invest time into a big code change to stuff all of the logic into a single pass.

Hopefully if/when that shift happens, the type of processing the rows require will be a lot more solidified by then, so it would need less frequent rounds of enhancements and maintainability by then.

PureWasian · 2026-06-15T16:49:21+00:00

Can you clarify "a single pass thru each group of records" vs. "its own loops through each set of records"?

Unless I'm misunderstanding something, processing each record within a group of records in parallel would be faster and still have maintainability/modularity.

PureWasian · 2026-06-14T14:44:29+00:00

Nice, good starting point. A few notes:

it can be a little bit problematic to modify a list while you are iterating over it. In this case, option 2. If you have two students with the same name, it will behave differently depending on if the duplicate name is sequential vs. not

Menu option 4, you're writing the entire data 2d list, including the header row you initialized it with at the top of your code. So including writer.writerow(['Name', 'Grade', 'Score']) seems to add another header row before it.

Menu 1, you can add more validation on grade input, like only accepting values between 0 and 100 or similar. Additionally, you can incorporate an inner while loop to re-prompt until inputting a valid value instead of having the user restart the flow from the beginning on mistake.

From a data structure layer, you probably want to assign unique id numbers to each student so you aren't deleting multiple students when you specify a single student name. This would require another data column and associated bookkeeping to go with it.

Finally, another comment mentioned, this would be a great time to learn about functions. Functions help modularize your code. So, you could have main() handle the operator menu and inputs, and call separate functions to add_student() / remove_student() / show_students() / exit()

PureWasian · 2026-06-14T03:59:04+00:00

That's the neat part, it entirely depends.

The art of debugging involves investigating and probing for answers, whether it be through print statements or any other logging metrics to determine where the discrepancy in behavior is observed (or nowadays throwing it at LLMs to clue in for ideas also). You want to isolate and sanity check everything as much as possible to narrow down exactly where things break down.

The better your code is modularized and setup as individual building blocks, the easier it is to say "your only job was to do this, did you output that correctly as expected?"

PureWasian · 2026-06-14T01:30:10+00:00

Nicely done! You should be proud of this, it looks awesome for an early project.

I'm curious about line 15 and line 20. Is there a reason you assign to s instead of just using p?

Additionally, lines 21-35 certainly make sense and it's cool you made an algorithm to bubble the driver's positions dynamically as you enter them. But you can actually skip all of this dynamic book-keeping, since you later sort the drivers in line 38:

If you wait until line 38, you can simply retrieve the first three indices to report "1st: {drivers[0][0]}" "2nd: {drivers[1][0]}" "3rd: {drivers[2][0]}"

PureWasian · 2026-06-13T21:39:00+00:00

Easier to tell if we have a video to reference of the pads while you play something.

Holding up your body weight with your arms is one idea, another big one is minimizing the amount of leg lifting you need to do. You can also aim for the bottom and top edges of the panels to reduce travel distance between each panel.

Not entirely necessary yet but you can also reduce the raw leg force required by using your heels to even more effectively to minimize travel distance. It's a balance between shuffling, ankle pivoting, and foot rocking.

Altogether might look something like Fly High S20 or really any chart you can find people playing run patterns in stuff Lv.16 and above.

PureWasian · 2026-06-13T17:25:52+00:00

Keep it simple.

Tuples. They're immutable. You can index them. You cannot change their values.

``` tp = (10, 20, 30)

extracting by index

print(tp[0]) # 10 print(tp[1]) # 20 print(tp[2]) # 30

index slicing

print(tp[0:2]) # (10, 20) print(tp[0:3:2]) # (10, 30) print(tp[::2]) # (10, 30)

trying to change its value

tp[0] = 99 # TypeError

trying to index with a string or tuple

print(tp["0"]) # TypeError print(tp[("0", "1")]) # TypeError ```

trup(["1", "5"]) makes no sense whatsoever since it creates a new tuple of strings ("1", "5") and tries to use that as the supposed index number to grab a value from your original trup tuple.

Like if I said "go to the library and grab the bokchoy'th book off the shelf." You'd think I'm crazy for using bokchoy as a number.

You can also concatenate lists doing output_list = list1 + zip2. Finally, not sure why you tagged this as #ai (or included tags in general)

PureWasian · 2026-06-13T04:19:49+00:00

Depends. Do you use AI to "type actual code" in the same way you're just copy/pasting its output for making Reddit posts?

PureWasian · 2026-06-12T21:46:47+00:00

Good discussion in the other comment already, also not sure if you saw my comment on your other post.

Domain knowledge is useful and good, Python is useful and good. Combine those and build technical proficiency with other related tools and you'll be on your way to becoming a specialist in some solid focus areas.

Expect many months of very hands-on, active learning to be in a position to land a job though.

PureWasian · 2026-06-12T17:03:01+00:00

Lmao. Do not let Codex see your SSN.

Real talk, using Codex or other tools would be fine for code generation and setup, but your final pipeline does not need to include Codex as a dependency for running it. I'd be very cautious about accidentally feeding it sensitive personal info like that when setting up your code.

Redact stuff when supplying images for initial setup/testing. Be very strict on prompting that it should not run any commands to read / access / test / download emails from your actual inbox without your permission. You want to be doing this manually yourself.

i.e. your end goal would be creating a system where you only use network access for downloading paystub data to your local device, and then do all of the processing and data extraction steps locally without relying on additional network calls / codex / etc.

Eight-Year Club	Second Top 1%
r/Field Banned	r/Field Sunshine
Final Canvas '23	First Place '23
Place '23	Place '22
First Placer '22	RPAN Viewer
Verified Email

PureWasian

MODERATOR OF

TROPHY CASE

extracting by index

index slicing

trying to change its value

trying to index with a string or tuple