• Custom User Avatar

    6 characters longer than my solution :D (ignoring the newlines added for legibility)

  • Custom User Avatar

    The sorting is not done on the same n (input length), so I don't think you're right in that it's O(n log n)

  • Custom User Avatar

    Hint #1 is very good.

  • Custom User Avatar

    nice, walrus is great

  • Custom User Avatar

    It's a variable assigned using the (relatively) new walrus operator := in Python; you can read more about it here for example:

    https://docs.python.org/3/whatsnew/3.8.html

    Basically it allows you to assign variables in the middle of expressions.

  • Custom User Avatar

    You could have written
    ''.join(' ' * ( abs(n // 2 - i)) + '*' * (n - 2 * abs(n // 2 - i)) + '\n' for i in range(n)) if n > 0 and n % 2 else None

    why have you chose variable t:= ?

  • Custom User Avatar

    This comment is hidden because it contains spoiler information about the solution

  • Custom User Avatar

    This comment is hidden because it contains spoiler information about the solution

  • Custom User Avatar

    This comment is hidden because it contains spoiler information about the solution

  • Custom User Avatar

    @quint Impressive, but looks overly mathematical for the task... I'd stay with the slower solution for the sake of readability.

  • Custom User Avatar

    agreed. also an edge case test: ",,treat"
    , is not alphabetical

  • Custom User Avatar

    yea, I changed the while to a for loop and the 6k one is faster almost always but the time difference is still in the same range and fluctuates wildly. I never realized that while loops are slower than for loops in python, ty for letting me know

  • Custom User Avatar

    you're comparing a while loop and a for one. In python, they behave differently about the perfs (while is slower) => those checks are meaningless in the current state.

  • Custom User Avatar

    also I have no idea why my reply got posted twice

  • Custom User Avatar

    hmm, the results of comparing the two often turns out to be wildly inconsistent in time difference but remains in the 1-10µs range, tho I found that the n = 19 and 1009 takes longer with 2k, n = 10000000019 takes less with the 2k one most of the time. Code used for testing:

    import timeit
    SETUP6K = '''
    def prime_checker6k(n):
        if n < 4:
            return n > 1
        if not (n % 2 and n % 3):
            return False
        for i in range(5, int(n ** 0.5)+1, 6):
            if not ((n % i) and (n % (i + 2))):
                return False
        return True
    '''
    SETUP2K = '''
    def prime_checker2k(n):
        if n == 2: return True
        if n%2 == 0 or n < 2: return False
        for i in range(3, int(n**.5)+1, 2):
            if n%i == 0: return False
        return True
    '''
    def bench(n):
        #print(f'Testing prime_checker2k and prime_checker6k with arg: {n}')
        a = timeit.timeit(stmt=f"prime_checker2k({n})", setup = SETUP2K, number = 1)
        b = timeit.timeit(stmt=f"prime_checker6k({n})", setup = SETUP6K, number = 1)
        #print(f'Time taken for prime_checker2k = {a}\t\tTime taken for prime_checker6k = {b}\t\t2k-6k = {a-b}\n')
        print(f'{"prime_checker2k" if a<b else "prime_checker6k"} is faster')
        print(f'6k-2k = {round(b-a,9)}')
    
    for _ in range(10):
      #bench(19)
      #bench(1009)
      bench(10000000019)
      print()
    
  • Loading more items...