Appearance
question:# Journal Article Citation Generator In this task, your assignment is to implement a function that automatically formats citations for journal articles based on given details such as author names, article title, journal name, volume number, issue number, and publication year, following a specific citation style (APA format). Task Description: Implement a function `generate_citation` that takes the details of a journal article and returns a properly formatted APA citation string. Function Signature: ```python def generate_citation(authors: list[str], title: str, journal: str, volume: int, issue: int, year: int, pages: str) -> str: ``` Input: * `authors` (List[str]): A list of author names, each as a string in the format "Last, First M.". * `title` (str): The title of the article. * `journal` (str): The name of the journal. * `volume` (int): The volume number of the journal. * `issue` (int): The issue number of the journal. * `year` (int): The year of publication. * `pages` (str): The page range of the article, e.g., "123-145". Output: * Returns a string representing the citation in APA format. Constraints: * 1 ≤ len(authors) ≤ 10 * 1 ≤ len(title) ≤ 200 * 1 ≤ len(journal) ≤ 100 * 1 ≤ volume ≤ 1000 * 1 ≤ issue ≤ 1000 * 1000 ≤ year ≤ 9999 * 1 ≤ len(pages) ≤ 10 Example: ```python authors = ["Smith, John A.", "Doe, Jane E."] title = "Investigating the Efficacy of Algorithms in Bioinformatics" journal = "Journal of Computational Biology" volume = 25 issue = 4 year = 2020 pages = "789-803" print(generate_citation(authors, title, journal, volume, issue, year, pages)) # Output: "Smith, J. A., & Doe, J. E. (2020). Investigating the efficacy of algorithms in bioinformatics. Journal of Computational Biology, 25(4), 789-803." ``` Key Directions: 1. Follow the APA citation style strictly. 2. Ensure the authors are formatted correctly with initials. 3. Title case the journal name, but use sentence case for the article title. 4. Properly format volume and issue numbers, including the appropriate punctuation, and page range. 5. Handle edge cases where some inputs might be empty, ensuring a robust function. Hints: 1. Pay attention to the handling of multiple authors. 2. Make sure to abbreviate the first names and middle initials correctly. 3. Ensure that punctuation and formatting are consistent with the APA standard.
answer:def generate_citation(authors: list[str], title: str, journal: str, volume: int, issue: int, year: int, pages: str) -> str: Returns an APA formatted citation for a journal article based on the provided details. def format_author(author): parts = author.split(", ") last_name = parts[0] first_and_middle = parts[1].split(" ") initials = " ".join([name[0] + "." for name in first_and_middle]) return f"{last_name}, {initials}" formatted_authors = ", & ".join([format_author(author) for author in authors]) formatted_title = title.capitalize() citation = (f"{formatted_authors} ({year}). {formatted_title}. " f"{journal}, {volume}({issue}), {pages}.") return citation
question:# Problem Statement In this coding challenge, you are required to implement a function that parses a boolean expression and computes its result. The expression will include variables, ands (denoted by '&'), ors (denoted by '|'), and nots (denoted by '!'). The variables will be either true ('1') or false ('0'). Objective Write a `Boolean Expression Evaluator` function `evaluate_expression(expression: str) -> int` to evaluate the given boolean expression. Input * `expression`: A string representing the boolean expression which includes binary values ('0' and '1'), logical operators ('&', '|', '!'), and parentheses for grouping. Output * An integer `1` if the evaluated result of the expression is true, otherwise `0`. Constraints * The length of `expression` is between 1 and 10^4 inclusive. * The expression will always be valid and properly parenthesized. * Operators symbols are directly adjacent to variables and parentheses, without spaces. * The solution should evaluate the expression efficiently. Requirements 1. Implement `evaluate_expression` to correctly interpret and evaluate the boolean expression. 2. Ensure that the evaluation follows the standard operator precedence: `!` has the highest precedence, followed by `&`, and `|`. # Example ```python evaluate_expression("1&0|1") # Output: 1 evaluate_expression("1&(0|0)") # Output: 0 evaluate_expression("!(1|0)&1") # Output: 0 evaluate_expression("!1|1") # Output: 1 ```
answer:def evaluate_expression(expression: str) -> int: def eval_not(val): return 1 if val == 0 else 0 def eval_and(val1, val2): return val1 & val2 def eval_or(val1, val2): return val1 | val2 def compute(operators, values): operator = operators.pop() if operator == '!': value = values.pop() values.append(eval_not(value)) else: right = values.pop() left = values.pop() if operator == '&': values.append(eval_and(left, right)) elif operator == '|': values.append(eval_or(left, right)) precedence = {'!': 3, '&': 2, '|': 1} operators = [] values = [] i = 0 while i < len(expression): if expression[i] == '1': values.append(1) elif expression[i] == '0': values.append(0) elif expression[i] in precedence: while (operators and operators[-1] != '(' and precedence[operators[-1]] >= precedence[expression[i]]): compute(operators, values) operators.append(expression[i]) elif expression[i] == '(': operators.append('(') elif expression[i] == ')': while operators[-1] != '(': compute(operators, values) operators.pop() # popping '(' i += 1 while operators: compute(operators, values) return values[0]
question:# Problem Statement Write a function `find_duplicates` that takes a list of integers and returns a new list containing the duplicates found in the input list, ordered by their first occurrence from the input. Additionally, implement a function `remove_duplicates` that removes any duplicates from the input list while maintaining the order of the first occurrence of each element. # Function Signatures ```python def find_duplicates(nums: list[int]) -> list[int]: pass def remove_duplicates(nums: list[int]) -> list[int]: pass ``` # Input - `nums`: A list of integers that may contain duplicates. # Output - `find_duplicates`: A list containing the first occurrence of each duplicate integer, in the order they first appeared. - `remove_duplicates`: The input list with duplicates removed, maintaining the order of first occurrence. # Constraints - The length of `nums` will be between 0 and 10^5. - The integers in the list will be in the range -10^6 to 10^6. # Example ```python >>> nums = [1, 2, 3, 1, 2, 4, 5] >>> find_duplicates(nums) [1, 2] >>> remove_duplicates(nums) [1, 2, 3, 4, 5] >>> nums = [] >>> find_duplicates(nums) [] >>> remove_duplicates(nums) [] >>> nums = [4, 5, 6, 5, 4, 7, 8, 8] >>> find_duplicates(nums) [5, 4, 8] >>> remove_duplicates(nums) [4, 5, 6, 7, 8] ``` # Hints - Consider using a set or a dictionary to track duplicates efficiently. - Pay attention to the order of elements while identifying duplicates and removing them.
answer:def find_duplicates(nums: list[int]) -> list[int]: seen = set() duplicates = [] for num in nums: if num in seen: if num not in duplicates: duplicates.append(num) else: seen.add(num) return duplicates def remove_duplicates(nums: list[int]) -> list[int]: seen = set() result = [] for num in nums: if num not in seen: seen.add(num) result.append(num) return result
question:# Data Normalization and Principal Component Analysis Implementation Assessment Context You are tasked with implementing data normalization techniques and enhancing a machine learning pre-processing pipeline with Principal Component Analysis (PCA). This will help ensure comprehension of aspects related to data transformation, feature scaling, and dimensionality reduction. Task 1. **Implement Data Normalization Techniques**: - Add support for Min-Max Normalization and Z-score Standardization techniques. - Ensure data is correctly transformed using these normalization techniques. 2. **Implement Principal Component Analysis (PCA)**: - Modify the `PCA` class to include methods for fitting the model on standardized data and transforming the original data into principal components. Expected Function Implementation 1. **Normalization Techniques (Min-Max, Z-score)**: ```python def min_max_normalize(data: np.ndarray) -> np.ndarray: # Your code here def z_score_standardize(data: np.ndarray) -> np.ndarray: # Your code here ``` 2. **Principal Component Analysis (PCA)**: - Implement the `fit` and `transform` methods in the `PCA` class: ```python class PCA: def __init__(self, n_components: int): self.n_components = n_components self.mean = None self.components = None def fit(self, data: np.ndarray): # Your code here def transform(self, data: np.ndarray) -> np.ndarray: # Your code here ``` 3. **Integration with Normalization**: - Ensure your modifications integrate seamlessly with the normalization and PCA transformation processes. Input and Output **Input**: - Data as a 2D NumPy array (features) - Number of components for PCA (integer) - Normalization technique to use ('min_max', 'z_score') **Output**: - Transformed data as a 2D NumPy array after normalization and PCA. Constraints - Inputs should only be valid NumPy arrays (features). - The number of components should be positive integers and less than the number of features. - Only valid normalization technique strings ('min_max', 'z_score') should be provided. Scenario Implement the required functions and modifications, and then integrate them to preprocess a given dataset. Validate the implementation to ensure correct data normalization and dimensionality reduction using PCA according to the described setup.
answer:import numpy as np def min_max_normalize(data: np.ndarray) -> np.ndarray: Apply Min-Max normalization to the data. min_val = np.min(data, axis=0) max_val = np.max(data, axis=0) return (data - min_val) / (max_val - min_val) def z_score_standardize(data: np.ndarray) -> np.ndarray: Apply Z-score standardization to the data. mean = np.mean(data, axis=0) std_dev = np.std(data, axis=0) return (data - mean) / std_dev class PCA: def __init__(self, n_components: int): self.n_components = n_components self.mean = None self.components = None def fit(self, data: np.ndarray): Fit the data using PCA, finding the principal components. self.mean = np.mean(data, axis=0) data_centered = data - self.mean covariance_matrix = np.cov(data_centered, rowvar=False) eigenvalues, eigenvectors = np.linalg.eigh(covariance_matrix) sorted_indices = np.argsort(eigenvalues)[::-1] self.components = eigenvectors[:, sorted_indices[:self.n_components]] def transform(self, data: np.ndarray) -> np.ndarray: Transform the data to the principal component space. data_centered = data - self.mean return np.dot(data_centered, self.components) def preprocess_data(data: np.ndarray, n_components: int, normalization: str) -> np.ndarray: Integrate normalization and PCA to preprocess the data. if normalization == 'min_max': normalized_data = min_max_normalize(data) elif normalization == 'z_score': normalized_data = z_score_standardize(data) else: raise ValueError("Normalization method must be 'min_max' or 'z_score'.") pca = PCA(n_components) pca.fit(normalized_data) return pca.transform(normalized_data)