Suffolk FA Premier Cup stats & predictions

Finding More Information & Resources

• Official Suffolk FA Website - Stay updated with official announcements & schedules.
• Football Betting Forums - Engage in discussions & exchange tips with fellow enthusiasts around the world.
• Sports News Outlets - Access comprehensive coverage & expert commentary on all things football-related within England’s local leagues including detailed breakdowns post-match analyzing pivotal moments influencing results during each round played throughout this captivating tournament season!seanrbradley/DailyProgrammer<|file_sep|>/Hard-#113/README.md # [DailyProgrammer #113](https://www.reddit.com/r/dailyprogrammer/comments/1k7eh6/111113_challenge_113_hard_ludic_numbers/) Ludic numbers were discovered by John H.Wilson while playing around with [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes) which is used for finding prime numbers. The algorithm goes like this: 1) List all natural numbers starting from 1. 2) Cross out every second number (all even numbers). 3) Find next uncrossed number (now 3), count how many numbers are left uncrossed (9), then cross out every nth number (every third number). 4) Repeat step 3 until there are no more numbers left uncrossed. The remaining numbers are called Ludic numbers. Ludic numbers start like this: `1`, `3`, `5`, `7`, `9`, `11`, `13`, `15`, `21`, `25`, `27`, `33` ... # Part One Implement this algorithm using your favorite programming language. # Part Two Find out what happens if you don't cross out every second number (all even numbers). What do you get? Is it still ludic? # Solution ### Implementation python def sieve(nums): """The Sieve of Eratosthenes""" if len(nums) <= 1: return nums else: return [nums[0]] + sieve([x for i,x in enumerate(nums[1:]) if (i+1)%nums[0] != 0]) ### Solution python from itertools import count def ludic_numbers(): """Yields ludic numbers.""" nums = [] n = count(1) while True: n = next(n) nums.append(n) nums = sieve(nums) yield n This works fine up until about ludic number #100000 where we run out of memory trying to store all ludic numbers. Instead we could implement it using generators so that we only need to keep track of one number at time. python def ludic_numbers(): """Yields ludic numbers.""" nums = [] n = count(1) while True: n = next(n) nums.append(n) nums = sieve(nums) if len(nums) == 1: yield nums[0] ### Ludic Numbers without Removing Evens If we don't remove evens we get something similar but not quite ludic numbers: `1`, `2`, `5`, `6`, `9`, `10`, `13`, `14`, `17`, `18`, `21`, `22` ... <|file_sep|># [DailyProgrammer #125](https://www.reddit.com/r/dailyprogrammer/comments/1oq8ui/1125_challenge_125_easy_write_a_function_to_check/) Write a function that checks whether two strings are isomorphic or not. Two strings are isomorphic if there exists a one-to-one mapping possible between any two characters such that all occurrences of one character can be replaced by another character while preserving order. For example: * "egg" & "add" -> True * "foo" & "bar" -> False * "paper" & "title" -> True * "abcd" & "aabb" -> False # Solution ### Implementation python def isomorphic(a,b): """Checks if two strings are isomorphic""" return len(set(zip(a,b))) == len(set(a)) == len(set(b)) ### Explanation We can create pairs from two strings using zip() like so: python zip("egg","add") >> [('e', 'a'), ('g', 'd'), ('g', 'd')] We can see that all occurrences of 'e' map to 'a' all occurrences of 'g' map to 'd'. Therefore they are isomorphic. We can check whether two strings are isomorphic by checking whether: * There are no duplicate pairs. * There are no duplicate characters within string A. * There are no duplicate characters within string B. <|file_sep|># [DailyProgrammer #154](https://www.reddit.com/r/dailyprogrammer/comments/34bzv6/1142015_challenge_154_easy_coding_the_primes_of_god/) You probably know about prime numbers already so I won't go into detail about them but here's Wikipedia just in case: http://en.wikipedia.org/wiki/Prime_number The primes hold great significance in mathematics because they're like building blocks that make up all other natural numbers greater than one (excepting one itself). For example: 21 = 7 * 3 42 = 7 * 2 * 3 * 2 66 = 11 * 2 * 3 * And so on... ## Part One: Prime Factorization Write some code that takes an integer greater than one as input then outputs its prime factorization as follows: Input: **42** Output: **7 x 2 x 3 x 2** The output doesn't have to be formatted exactly like this example but it should show which primes multiply together to make up your input integer. Note: If there are repeated factors they should be repeated too (like how **42** has two **2**s). ## Part Two: Finding Primes Write some code that takes an integer greater than one as input then outputs all prime integers less than or equal to your input integer. Input: **10** Output: **[2,3,5,7]** ## Extra Credit Write some code that takes two integers greater than one as input then outputs all prime integers between those two inputs inclusive. Input: **10**, **20** Output: **[11,13,17,19]** # Solution ### Implementation python from itertools import takewhile from functools import reduce def primes(n): """Yields prime numbers up until n""" def is_prime(x): return x > 1 and reduce(lambda p,x: p*x > n or x**2 > n or n%x > 0, takewhile(lambda x: x**2 <= n, primes(int(x**0.5))), True) i = count(2) while True: x = next(i) if is_prime(x): yield x def prime_factorization(n): def factorize(n,p): return [p] + factorize(n//p,p) if n%p ==0 else [] return reduce(lambda l,x: l + factorize(n,x),primes(int(n**0.5)),[]) def primes_between(a,b): return filter(lambda x:x >= a, primes(b)) ### Explanation First we need an efficient way generate prime numbers up until n. For this we use trial division by testing divisibility only by previous primes up until square root of n. This method was described by Carl Friedrich Gauss around age twelve in his book Disquisitiones Arithmeticae (1801). Next we implement prime factorization by recursively dividing our input by previous primes until no more divisions can be made. We use reduce() so that we don't have build up huge lists when generating our prime factors. Finally we implement getting all primes between two integers by filtering out all primes less than our lower bound. <|file_sep|># [DailyProgrammer #212](https://www.reddit.com/r/dailyprogrammer/comments/5xvq7w/122112015_challenge_212_easy_enigma_machine_simulation/) One summer I decided I wanted learn more about WW II history so I read books about it. I learned about Alan Turing who helped break Enigma codes used by German forces. I also learned about how these codes were generated using Enigma machines. I decided I wanted build my own Enigma machine simulation since I was learning Python at the time. After reading lots about Enigma machines I came up with this solution which simulates basic Enigma machine behavior. It does not simulate plugboards or double stepping but it does simulate three rotors rotating at different speeds. This solution was posted at https://github.com/seanrbradley/enigma-machine-simulation but it wasn't featured on DailyProgrammer. So I thought it would be fun challenge others try implement their own Enigma machine simulation too! Here's my implementation: ## Rotors.py ## python from random import shuffle class Rotor(object): def __init__(self,wiring=None): if wiring == None: self.wiring = list(range(26)) shuffle(self.wiring) self.wiring_inv = self.wiring[:] self.position = random.randint(0,len(self.wiring)-1) self.position_offset = list(range(len(self.wiring))) self.position_offset_inv = self.position_offset[:]