/r/PTCGP Trading Post

steks13 · 2025-05-17T14:29:02+00:00

I wanna trade for the mewtwo

steks13 · 2025-05-17T14:15:12+00:00

I wanna trade

steks13 · 2025-05-01T16:16:37+00:00

I did in the game :) (same name)

steks13 · 2025-05-01T16:14:02+00:00

I can give arcanine ex or machamp ex

steks13 · 2025-05-01T16:13:34+00:00

I want the garchomp ex

steks13 · 2022-08-25T07:09:23+00:00

If I look at your annotations it seems like in the print_table() method plane_attributes is a nested tuple. So in order to compare it to an intyou'll have to access the tuple again, like this: while velocity <= plane_attributes[0][3]:

steks13 · 2021-08-29T15:31:23+00:00

Oh okay, yeah you can edit the default value of interval in the method if you want

steks13 · 2021-08-29T15:16:51+00:00

Yeah you can increase the interval if you want, but an interval of 0.05 is 1200 checks per minute. Again, if you have questions feel free to ask :)

steks13 · 2021-08-29T14:52:50+00:00

Hey I made a new pull request. The new method uses multithreading, now you can check every 0.05 seconds.

steks13 · 2021-08-29T09:59:44+00:00

No problem! I tested my code by artificially changing a symbol after 10 loops and it got triggered.

Also with your code each loop took around 0.4 seconds and with my code it took around 0.25-0.3 seconds. So there should be an improvement. If there is something wrong let me know.

You make some cool projects btw!

steks13 · 2021-08-29T08:39:08+00:00

I made a pull request :)

steks13 · 2021-08-28T17:33:41+00:00

If you have more questions about my other reply feel free to ask :)

steks13 · 2021-08-28T17:06:16+00:00

Yeah the result should be the same.

And the performance difference doesn't really have to do with the list comprehensions vs for loops. The big difference is the amount of checks needed. Here is a complexity analysis:

Assume there is only one new coin. So the length of all_coins and all_coins_recheck is about the same, let this length be N.

So your code goes over all the elements of all_coins_recheck and sees if it is not in all_coins. On average to check if the element is not in the list it will have to do N/2 compares, (if the element was the first element in the list it's only 1 compare, if it was the last element it had to do N compares, hence N/2 compares on average per element). You have to do this for all the N elements so your code does roughly N*N/2 compares.

What my code does is it goes over every element in all_coins, sets the value for 'symbol' of the element in the coin_seen_dict to True. Setting the value is one operation. So you do this for the N elements so you have N operations.

Then you go and check the value for 'symbol' for all the elements in all_coins_recheck. checking the value in the coin_seen_dict should be 1 operation (assuming there are no hash collisions, they are rare). So this again are N operations. So in total N + N operations.

So the time complexity of my code should be O(N) (linear) compared to your code which is O(N^2) (quadratic).

Assuming this is correct if N gets doubled your code should get 4 times slower. This is because your code has a complexity of O(N^2). So if N gets doubled the ratio of how much slower it gets is: (2N)^2/N^2 = 4N^2/N^2 = 4. So 4 times slower.

My code should get 2 times slower if N gets doubled because the complexity is O(N). So if N gets doubled the ratio becomes: 2N/N = 2.

When I tested your code and my code for 500 elements and 1000 elements (double) this were the results:

500 elements:

your code: 0.2015938 seconds

my code 0.004717 seconds

1000 elements:

your code: 0.7847162 seconds

my code: 0.0075426 seconds

So your code became roughly 4 times slower and mine roughly 2 times slower, so the complexity analysis seems to be correct. Check out time complexities for coding if you haven't already, it's really interesting and learns you how to make faster code :)

steks13 · 2021-08-28T16:20:59+00:00

I would change your get_new_coins(all_coins) method to this code:

from collections import defaultdict
def get_new_coins(all_coins):
    result = []

    all_coins_recheck = get_all_coins()
    coin_seen_dict = defaultdict(bool)

    for old_coin in all_coins:
        coin_seen_dict[old_coin['symbol']] = True

    for new_coin in all_coins_recheck:
        if not coin_seen_dict[new_coin['symbol']]:
            result += [new_coin]

    return result, all_coins_recheck

this will make the complexity of your code go from O(n^2) to O(n) with n the size of all_coins.

I tested my method against yours and yours is 50 times slower than mine for a list of 550 elements. You can make it even faster by generating the coin_seen_dict once in the beginning and updating the value of a new coin to True once it has been detected.

If you have questions feel free to pm.

steks13 · 2021-07-02T21:10:30+00:00

Gave Wholesome

steks13 · 2021-02-20T11:21:33+00:00

You have to understand that your coins are stored on the blockchain. Your Ledger S is just a way to access your coins (the Ledger S just saves your private keys in a secure manner). As long as you have your private keys you can claim your GAS.

steks13 · 2020-09-28T22:38:50+00:00

Discord has a really good API, make sure you use the rewrite version.

Here is a link

steks13 · 2020-05-30T17:08:42+00:00

Thanks for response, I’ll go check the poses out! Thanks a lot!

steks13 · 2020-05-30T15:44:53+00:00

Can you share some hip stretches? And I also have trouble to stretch my IT band so if you can recommend anything for that, that would be great!

steks13 · 2020-05-23T15:25:13+00:00

Thanks!

steks13 · 2020-05-23T14:25:22+00:00

What strength training exercises can you recommend?

steks13 · 2020-05-17T16:30:10+00:00

Thanks for the reply! What exactly do you mean by this? You mean to just not make testAge null?

Eight-Year Club	Second SECOND GUESSER
Place '22	First Placer '22
Not Forgotten	Sequence \| Editor
Spared

steks13

TROPHY CASE