Appearance
question:Based on the following specification, write code in Python for an LRU Cache: When the cache size is 2: - Key 1 is inserted. - Key 1 is accessed again. - Key 2 is inserted. - Key 3 is inserted, which evicts Key 1 - Key 4 is inserted, which evicts Key 2. - Key 1 is inserted again, which is essentially an update. Here is a similar problem from LeetCode: https://leetcode.com/problems/lru-cache/description/ The code should pass the following test cases: ```python import unittest class TestLRUCache(unittest.TestCase): def test_001_insert_access(self): cache = LRUCache(2)
answer:class LRUCache: def __init__(self, capacity: int): self.cache = {} self.order = [] self.capacity = capacity def get(self, key: int) -> int: if key in self.cache: # Update order to mark this key as recently used self.order.remove(key) self.order.append(key) return self.cache[key] return -1 def put(self, key: int, value: int) -> None: if key in self.cache: # Update the value and mark as recently used self.cache[key] = value self.order.remove(key) else: if len(self.cache) >= self.capacity: # Evict the least recently used key lru_key = self.order.pop(0) del self.cache[lru_key] # Add the new key-value pair self.cache[key] = value # Update the usage order for the key self.order.append(key)
question:I have a non-empty list of tuples where each tuple represents a person's first name and last name. I need help with writing a function to output a new list of tuples containing just the names of the people who are over a given age. Assuming we already have a dictionary mapping names to ages, I will be passing this dictionary and a list of tuples, and the minimum age to the function. The function will return a list of tuples where the full name is concatenated into a single string and a boolean indicating if the person is over the minimum age. Please provide one function to solve this problem. # Example Usage ```python def filter_names_by_age(name_age_dict, name_tuples, min_age): # code here # Example usage: name_age_dict = {'John Doe': 30, 'Jane Doe': 25, 'Alice Johnson': 40} name_tuples = [('John', 'Doe'), ('Jane', 'Doe'), ('Alice', 'Johnson')] min_age = 30 result = filter_names_by_age(name_age_dict, name_tuples, min_age) print(result) # Expected output: [('John Doe', True), ('Alice Johnson', True)] ``` This is the code I have written so far: ```python def filter_names_by_age(name_age_dict, name_tuples, min_age): full_names = [] for first_name, last_name in name_tuples: full_name = f"{first_name} {last_name}" if full_name in name_age_dict and name_age_dict[full_name] > min_age: full_names.append((full_name, True)) return full_names ``` What can be improved in my code?
answer:def filter_names_by_age(name_age_dict, name_tuples, min_age): Filter and return a list of tuples with full names and a boolean indicating if the person is over the minimum age. Parameters: name_age_dict (dict): Dictionary with full names as keys and ages as values. name_tuples (list of tuples): List of tuples with (first name, last name). min_age (int): Minimum age to filter the names. Returns: list of tuples: List of tuples with full name and boolean (True if over min age). result = [] for first_name, last_name in name_tuples: full_name = f"{first_name} {last_name}" if full_name in name_age_dict: is_over_age = name_age_dict[full_name] >= min_age result.append((full_name, is_over_age)) return result
question:Write a program that checks if a series of numbers are prime or not Step 1: Write a helper function primeChecker() that checks if a single number is prime Step 2: Use the primeChecker() to write main program that takes an arbitrary list of integers and prints out whether each one is prime or not Solution: ```python def primeChecker(x): if x < 2: return False # keep dividing by numbers from 2 upto the square root of the number for i in range(2, int(x**0.5) + 1): if x % i == 0: return False return True def main(): # Create a dummy list of numbers numList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 100] for num in numList: if primeChecker(num): print(f"{num} is a prime number") else: print(f"{num} is not a prime number") if __name__ == "__main__": main() ``` The code is correct, but the design has room for improvements. What are some potential improvements?
answer:def primeChecker(x): Check if a number is a prime. Args: x (int): The number to check. Returns: bool: True if the number is a prime, False otherwise. if x < 2: return False for i in range(2, int(x ** 0.5) + 1): if x % i == 0: return False return True def check_primes(numbers): Check a list of numbers to determine if each one is prime. Args: numbers (list): List of integers to check. Returns: list: List of tuples where each tuple contains the number and a boolean indicating if it is prime. return [(num, primeChecker(num)) for num in numbers]
question:Here is a list of 100 items. Please develop a system to randomly select 25 of these items. The system should be 1- Generate a random number between 1-25. 2 - Use that number to select the first item on the list. 3 - Then generate another random number between 1 and the remaining items to select the second item. 4 - This process is repeated until the 25 items are selected. Here is a list of 100 items: https://gist.github.com/afhaque/29f0f4f374dc6744e8857ed6a6c57897 This approach is an in-efficient way to select a random subset of items from a larger set. A more efficient approach is a Reservoir Sampling algorithm (https://en.wikipedia.org/wiki/Reservoir_sampling). However, I want to illustrate the inefficiency of this method so I still want you to create the system using this approach. Please provide a code in Python to accomplish this task. Also, note that I agree with you that the Reservoir Sampling algorithm would be more efficient. However, I want to explicitly implement the inefficient method you described for pedagogical purposes. Can't we use the "random" library in python and create a function that returns a random index of the remaining items and use this function to select the 25 items?
answer:import random def inefficient_sample_25_items(items): Select 25 items randomly from a list of 100 items using an inefficient method. selected_items = [] remaining_items = items.copy() for i in range(25): random_index = random.randrange(0, len(remaining_items)) selected_items.append(remaining_items.pop(random_index)) return selected_items