Appearance
question:You are given a list of activities, each represented by a pair of integers `[start, end]`. Each activity starts at `start` and ends at `end`. You want to select the maximum number of non-overlapping activities that you can attend. Note that if `start` is equal to `end`, it means the activity is instantaneous and occupies only one time slot. Write a function `maxNonOverlappingActivities(activities)` that takes a list of activities and returns the maximum number of non-overlapping activities you can attend. **Input:** - A list of tuples, where each tuple `(start, end)` represents an activity. - 1 ≤ len(activities) ≤ 100 - 0 ≤ start < end ≤ 1000 **Output:** - An integer representing the maximum number of non-overlapping activities. **Example:** ```python def example(): activities = [(1, 3), (2, 4), (3, 5), (7, 8)] print(maxNonOverlappingActivities(activities)) # Output: 3 activities = [(0, 1), (3, 4), (1, 2), (5, 6)] print(maxNonOverlappingActivities(activities)) # Output: 4 ``` **Function signature:** `def maxNonOverlappingActivities(activities: List[Tuple[int, int]]) -> int:` **Explanation:** - In the first example: - You can attend activities (1, 3), (3, 5), and (7, 8) which are non-overlapping. - In the second example: - You can attend all activities as none of them overlap.
answer:from typing import List, Tuple def maxNonOverlappingActivities(activities: List[Tuple[int, int]]) -> int: # Sort the activities based on their end times activities.sort(key=lambda x: x[1]) # Initialize variables count = 0 last_end_time = -1 # Iterate through the sorted list of activities for start, end in activities: if start >= last_end_time: # If the start time of the current activity is greater or equal to the end time of the last attended activity count += 1 last_end_time = end return count
question:You are given a string consisting of lowercase alphabets and digits. Write a function that counts the number of vowels (a, e, i, o, u) and the number of digits in the string, and returns them as a tuple (number_of_vowels, number_of_digits). The function should be implemented as follows: - Define a function named `count_vowels_and_digits(string: str) -> tuple`. - The parameter `string` is a non-empty string consisting of lowercase alphabets and digits. - Return a tuple where the first element is the count of vowels and the second element is the count of digits.
answer:def count_vowels_and_digits(string: str) -> tuple: Counts the number of vowels and the number of digits in the given string. Parameters: string (str): The input string consisting of lowercase alphabets and digits. Returns: tuple: A tuple where the first element is the count of vowels and the second element is the count of digits. vowels = set('aeiou') num_vowels = 0 num_digits = 0 for char in string: if char in vowels: num_vowels += 1 elif char.isdigit(): num_digits += 1 return num_vowels, num_digits
question:You are given an array of integers. Your task is to find the smallest positive integer that is not the sum of a subset of the given array. Input: - The first line contains a single integer n (1 ≤ n ≤ 10^5), the number of elements in the array. - The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 10^9), the elements of the array. Output: - Print the smallest positive integer that is not the sum of a subset of the given array. Example: Input: 5 1 2 2 5 7 Output: 18 Explanation: - All sums of subsets from the given array are {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 19, 20, 21, 24}. The smallest positive integer not represented in this list is 18.
answer:def smallest_non_subset_sum(n, arr): Find the smallest positive integer that is not the sum of a subset of the given array. arr.sort() smallest_sum = 1 for num in arr: if num > smallest_sum: break smallest_sum += num return smallest_sum
question:Johan and Lara are playing a game with strings. Johan created a string and wants Lara to check whether the string can be transformed into a palindrome by rearranging its characters. Lara can only rearrange the characters but not change or remove any character. She needs your help to determine if it's possible. A palindrome is a string that reads the same forward and backward. For example, "radar", "level", and "anna" are palindromes. Given a string, determine if it can be rearranged to form a palindrome. The first line contains an integer t (1 le t le 1000). Then t test cases follow. The first line of each test case contains one integer n (1 le n le 100) – the length of the string. The second line contains a string of length n, consisting of lowercase Latin letters. For each test case output: "YES" if the string can be rearranged to form a palindrome, and "NO" otherwise. You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answers). **Example:** Input: ``` 3 6 aabbcc 5 abcba 4 abac ``` Output: ``` YES YES NO ```
answer:def can_form_palindrome(t, test_cases): results = [] for i in range(t): n, s = test_cases[i] char_count = {} for char in s: char_count[char] = char_count.get(char, 0) + 1 odd_count = sum(1 for count in char_count.values() if count % 2 != 0) if odd_count > 1: results.append("NO") else: results.append("YES") return results