Last commit cannot be located
Schema
5 columns, 1-100 of 1000 rows
Row details
task_id
(str)
rust_prompt
(str)
rust_code
(str)
rust_test_list
(str)
prediction
(str)
task_id
rust_prompt
task_18158
Given a string representing a date in the format 'YYYY-MM-DD', write a function `validate_date(date: String) -> bool` that checks if the date is valid. A date is considered valid if: 1. The year is between 1900 and 2100 (inclusive). 2. The month is between 1 and 12 (inclusive). 3. The day is valid for the given month and year (considering leap years). The function should return `true` if the date is valid, and `false` otherwise. For the purposes of this problem, assume that the input string will always be in the correct format.
task_18159
Implement a function that accepts a vector of numerical elements and returns the second highest value within that vector. If the vector has less than two unique elements, the function should return None.
task_18160
You are tasked with creating a function that simulates the execution of a script based on a sequence of events. The function should take in a vector of events and their corresponding actions, and return the final state of the script after processing all events. Each event can either be a standard event that triggers an action or a wait event that pauses the script execution until a certain condition is met. Your function should handle overlapping executions of the same script, ensuring that multiple instances can run concurrently if the conditions allow it. The input consists of a vector of events where each event is represented as a struct. Each event has a type ('event' or 'wait') and additional data. Your function should return a vector of states corresponding to each event processed in order. If an event is a 'wait' event, it should only be processed if the condition specified in the event data is met. If the condition is not met, the script execution for that event should be paused until the condition is satisfied. The output should reflect the final states of the events in the order they were provided.
task_18161
Implement a function `optimize_3d_model` that takes a 3D model represented as a struct containing vertices and polygons, and optimizes it by removing unnecessary vertices and polygons while maintaining the visual representation. The function should prioritize optimization based on the visual importance of the elements. The input model will have a structure like this: `struct Model { vertices: Vec<i32>, polygons: Vec<i32> }`. The function should return a new model with optimized vertices and polygons, keeping the most important ones intact. For simplicity, assume that a vertex or polygon with an importance level below a threshold of 5 is considered unnecessary and should be removed. The output model should maintain the same structure as the input.
task_18162
You are tasked with implementing a function that simulates the initialization of an I2C (Inter-Integrated Circuit) interface for communication between microcontrollers and peripheral devices. The function should take a unique ID and a configuration map as its inputs. The configuration map may contain the following keys: "frequency", which specifies the communication frequency for the I2C interface. The function should return a map containing the unique ID, the frequency (if specified), and a message indicating the setup status. If the frequency is not specified in the configuration, it should be set to `None`. Implement the function `initialize_i2c(unique_id: String, config: std::collections::HashMap<String, String>) -> std::collections::HashMap<String, String>`.
task_18163
You need to implement a function that takes a vector of student records and returns a vector of formatted student details. Each student record is represented as a struct containing the fields: `name`, `age`, `major`, `gpa`, and `courses`, where `courses` is a vector of tuples mapping course names to scores. The function should ensure that all fields are valid and handle any errors that arise due to invalid data. If a student record is invalid, it should be skipped in the output. The formatted student detail should be a string in the format: "Name: {name}, Age: {age}, Major: {major}, GPA: {gpa}, Courses: {course_list}" where `course_list` is a string of course names separated by commas.
task_18164
You are tasked with finding the best combination of challenges to complete based on a given set of preferences and combinations. Each challenge has a cost associated with it, determined by its index in the preferences list. The cost of a challenge is defined as its index in the preferences list. You are given a vector of challenge classes and a vector of combinations, where each combination is a vector of indices referring to the challenges. Your goal is to return the combination of challenges that has the lowest total cost. If no combination exists, return an empty vector. Implement the function 'find_best_challenge_combo(challbs: Vec<Type>, preferences: Vec<Type>, combinations: Vec<Vec<usize>>) -> Vec<usize>'.
task_18165
Given a string `s` consisting of alphabetic characters, implement a function that reverses the characters in the string and returns the reversed string as the output.
task_18167
Write a function `print_quantity_sentence(quantity: i32) -> String` that takes a discrete numerical quantity as an input and returns a coherent sentence presenting that specific integral figure. The sentence should be structured as: 'The quantity you have entered is X.', where X is the provided quantity.
task_18168
You are given a vector of integers representing a formula's components. Your task is to implement a function that counts how many unique integers are present in the vector. The function should return the count of these unique integers. For example, given the input vector [1, 2, 2, 3, 4, 4, 5], the output should be 5 as the unique integers are 1, 2, 3, 4, and 5.
task_18169
Implement a function `advanced_monotonic(l: Vec<&str>, strict: bool) -> bool` that checks if the elements of the vector `l` are monotonically ascending or descending. The function should ignore non-integer or non-float elements, converting strings that represent numbers into their numeric forms. If the `strict` parameter is set to `true`, no two consecutive elements should be equal for the sequence to be considered monotonic. If the vector becomes empty or contains only a single valid number after filtering, it should return `true`. If any element cannot be converted to a number, the function should return `false`.
task_18170
Write a function called `create_manager` that takes four parameters: `managerID` (an integer), `full_name` (a string), `years_of_experience` (an integer), and `departments_supervised` (a vector of strings). The function should return a hash map representing a manager with the given details. The hash map should have keys 'managerID', 'full_name', 'years_of_experience', and 'departments_supervised'.
task_18171
You are given two integers, `a` and `b`. Your task is to implement a function `calculate_modulo(a, b)` that returns the result of the modulo operation of `a` with respect to `b`. The modulo operation is defined as the remainder when `a` is divided by `b`. Note that `b` will always be a positive integer. You may assume that `a` can be any integer, including negative integers. For example, if `a = 10` and `b = 3`, the function should return `1` since `10 % 3 = 1`. Implement the function to achieve this functionality.
task_18172
You are tasked with implementing a Rust function that takes a vector of command templates and an index to select one of the templates. Your function should return the corresponding command string that would be executed based on the selected template. The command string should include the template name. If the index is out of bounds, the function should return an error message indicating that the selected index is invalid. Write a function `get_command_string(templates: Vec<String>, selected_index: i32) -> String` that implements this logic.
task_18173
Implement a function that removes all elements from an input vector that are divisible by the value of 7. The function should return a new vector containing only the elements that are not divisible by 7.
task_18174
You are tasked with creating a function that returns a vector of all available names of problem generators. The list of names is stored in a HashMap called `registered_gens`. Please implement a function that retrieves the keys from this HashMap and returns them as a vector. The input will be a HashMap `registered_gens` containing String keys representing the names of the generators. Your function should return a vector of these names in the order they were added to the HashMap.
task_18176
You are tasked with creating a Rust function that formats shipping addresses. The function should take a vector of structs, where each struct contains the fields `street_address`, `city`, `state`, and `postal_code`. The function should return a vector of formatted shipping addresses as strings, where each address is formatted as `street_address, city, state postal_code`. For example, if the input is `vec![Address { street_address: String::from("123 Main St"), city: String::from("Anytown"), state: String::from("CA"), postal_code: String::from("12345") }, Address { street_address: String::from("456 Elm St"), city: String::from("Othertown"), state: String::from("NY"), postal_code: String::from("54321") }]`, the output should be `vec![String::from("123 Main St, Anytown, CA 12345"), String::from("456 Elm St, Othertown, NY 54321")]`.
task_18177
You are tasked with implementing a pagination algorithm for a web application. The algorithm should take in the current page number and the limit of items per page, and then calculate the offset for fetching data based on the current page and limit. Write a function `calculate_offset` that takes in two parameters: - `page`: an integer representing the current page number (1-indexed) - `limit`: an integer representing the limit of items per page The function should calculate and return the offset for fetching data based on the current page and limit. The offset is calculated using the formula: `(page - 1) * limit`. Function signature: `fn calculate_offset(page: i32, limit: i32) -> i32`
task_18178
Implement a function that takes a String as input and returns the total count of vowels and consonants. Vowels are defined as the letters 'a', 'e', 'i', 'o', 'u' (case insensitive), and consonants are all other alphabetic characters. Non-alphabetic characters should be ignored in the count. The function should return a tuple containing the count of vowels and the count of consonants.
task_18179
Given a vector of integers, write a function that calculates the divergence of the vector based on the following formula: For each element in the vector, the divergence is calculated as the difference between the next element and the previous element, multiplied by a constant scale factor of 0.5. The divergence for the first and last elements should be defined as the difference with only their respective neighbor (i.e., the first element has no previous neighbor, and the last element has no next neighbor). Your function should return a new vector containing the divergence values for each corresponding element. The function should be defined as `fn calculate_divergence(arr: Vec<i32>) -> Vec<f32>:`.
task_18180
Given a vector of process IDs and a function that retrieves the process name for a given process ID, implement a function `get_process_names(pid_list: Vec<i32>) -> Vec<Option<String>>` that returns a vector of process names corresponding to the provided process IDs. If a process ID does not correspond to a valid process, return `None` for that ID. The function should handle any errors that may occur during the retrieval process gracefully by returning `None` for invalid process IDs. You can assume that process names are retrievable as strings. Your implementation should not access any external resources or databases.
task_18181
You are tasked with creating a function called `calculate_sum` that takes a vector of integers as input and returns the sum of the integers in that vector. The input vector can contain both positive and negative integers. If the input vector is empty, the function should return 0. Implement the function `calculate_sum(nums: Vec<i32>) -> i32`.
task_18182
You are given a string representation of a subscript operation used in array slicing in Rust. Your task is to implement a function that takes this string as input and returns a vector of the inferred slice values. The input string can contain ':' to represent a full slice, or can have specific indices like 'a:b' for slicing from index a to index b. If the input is not in the correct format, return an empty vector. Implement the function `infer_subscript_values(subscript: String) -> Vec<Option<i32>>`, where the output vector should contain the start, stop, and step values for the slice, or None if they are not specified. For instance, if the input is '1:5:2', the output should be [Some(1), Some(5), Some(2)]. If the input is '5:', the output should be [Some(5), None, None]. If the input is ':3', the output should be [None, Some(3), None]. If the input is invalid, return an empty vector.
task_18184
You are tasked with creating a function that calculates the average word length from a given string of text. Your function should take a single argument, which is the string to be processed. The function should perform the following steps:
1. Tokenize the text into words, considering any sequence of non-whitespace characters as a word.
2. Calculate the average length of the words in the string, rounded to two decimal places.
3. Return the average word length.
For example, given the string "The quick brown fox jumps over the lazy dog.", the function should return 3.57.
task_18185
You are given the coordinates of the center of an image you want to paste onto a canvas, the size of the image to be pasted, and the size of the canvas. Write a function `check_in_image(paste_image_location, paste_image_size, canvas_image_size)` that returns `true` if the pasted image would lie entirely within the canvas boundaries, and `false` otherwise. The input parameters are defined as follows:
- `paste_image_location`: a tuple of two integers `(x, y)` representing the x and y coordinates of the center of the image to be pasted.
- `paste_image_size`: a tuple of two integers `(width, height)` representing the width and height of the image to be pasted.
- `canvas_image_size`: a tuple of two integers `(canvas_width, canvas_height)` representing the width and height of the canvas.
Assume that the coordinates and sizes are positive integers and the image's center coordinates are based on a 1-indexed system.
task_18187
You are tasked with creating a function that simulates the installation of an extension. The function should take three boolean parameters: `user`, `symlink`, and `overwrite`. The function will return a String describing the installation process based on the parameters provided. The output String should follow these rules: 1) If `user` is true, the installation is for the current user, otherwise it is system-wide. 2) If `symlink` is true, the installation will use symlinking instead of copying the files. 3) If `overwrite` is true, previously-installed files will be overwritten. The output String should be formatted as follows: "Installing for [user/system] with [symlink/copy] option. [Overwriting previous files if applicable]." You can assume that the parameters will always be boolean values.
task_18188
Implement a function that checks if a given positive integer `n` is an Armstrong number. An Armstrong number (also known as a narcissistic number) for a given number of digits is a number that is equal to the sum of its own digits each raised to the power of the number of digits. For example, 153 is an Armstrong number because 1^3 + 5^3 + 3^3 = 153. Write a function `is_armstrong(n)` that returns `true` if `n` is an Armstrong number, and `false` otherwise.
task_18189
You are tasked with implementing a function that processes an input HashMap containing a vector of numerical values. The function should extract a subset of values from the vector based on provided indices, update the input HashMap with this subset, and generate group labels for the subset based on the specified number of groups. The function should have the following signature: `fn process_data(data: &mut HashMap<String, Vec<i32>>, num_groups: i32, indices: Vec<usize>) -> ()`. The operations to perform are as follows: 1. Extract values from 'values' in the input HashMap 'data' using the provided 'indices'. 2. Update 'data' with the extracted values under the key 'extracted_values'. 3. Create a vector of group labels for the extracted values, where each label corresponds to the respective group based on 'num_groups'. 4. Update 'data' with this vector of group labels under the key 'group_labels' and also include 'num_groups' in the HashMap. The function does not return anything but modifies the input HashMap in place.
task_18192
You are tasked with implementing a function that calculates the total size of files represented by a vector of file size integers. The function should return the cumulative size of all files in bytes. Each file size is provided as an integer in the vector, and you need to sum these integers to determine the total size.
Function Signature:
```rust
fn calculate_total_size(folders: Vec<i32>) -> i32 {
// implementation here
}
```
Example:
Given the vector of file sizes:
```rust
let file_sizes = vec![1000, 1500, 2000, 1800, 2500];
```
The function should return the total size of all files:
```rust
calculate_total_size(file_sizes) // Output: 9800
```
Explanation:
The total size is calculated as follows:
```
1000 + 1500 + 2000 + 1800 + 2500 = 9800 bytes
```
task_18193
You are tasked with creating a program to calculate the frequencies of musical notes in an octave using the equal temperament tuning system. The frequency of a note is calculated as a multiple of the frequency of the note A4 (440 Hz) according to the formula: \[ f = 2^{\left(\frac{n}{12}\right)} \times 440 \] where \( f \) is the frequency of the note, and \( n \) is the number of semitones away from A4. Your program should accept a musical note (A, A#, B, C, C#, D, D#, E, F, F#, G, G#) as input and return its frequency in Hertz. If the input is not a valid note, the program should return 'Invalid note'. The program should handle both uppercase and lowercase input.
task_18194
Given a string representing Rust source code, return a vector of all unique module names that are required (imported) by the given source code. The input string may contain various import statements, and you should extract the module names from them. The import statements can be of the form 'use module_name;' or 'use module_name::something;'. The output should be a vector of module names without any duplicates. If there are no import statements, return an empty vector.
task_18195
You are tasked with creating a function that simulates the launching of a task. The function should take in a string `task_name` representing the name of the task and an integer `task_id` which is a unique identifier for the task. The function should return a string in the format 'Task {task_name} with ID {task_id} has been launched successfully.' Implement the function `launch_task(task_name: String, task_id: i32) -> String`.
task_18196
Write a function `process_text` that takes a `String` as input and performs the following operations: 1. Convert the string into a byte array. 2. Calculate the sum of the bytes in the array. 3. Calculate the average value of the bytes. 4. Generate a reversed byte array. The function should return a tuple containing the sum of the bytes, the average value, and the reversed byte array. If the input is not a `String`, the function should panic with the message 'The input should be a string'. If the byte array is empty, panic with the message 'The byte array should not be empty'.
task_18197
You are tasked with translating a DNA sequence into its corresponding amino acid sequence using the genetic code. Write a function `translate_dna_to_protein(dna_sequence: String) -> String` that takes a DNA sequence as input and returns the corresponding protein sequence. The translation should follow the standard genetic code where each codon (a sequence of three nucleotides) corresponds to a specific amino acid. If the input DNA sequence is not a valid sequence (i.e., it contains characters other than 'A', 'T', 'C', 'G'), return an empty string. The function should ignore any incomplete codons at the end of the sequence. Here is the mapping of codons to amino acids: vec![("ATA", "I"), ("ATC", "I"), ("ATT", "I"), ("ATG", "M"), ("ACA", "T"), ("ACC", "T"), ("ACG", "T"), ("ACT", "T"), ("AAC", "N"), ("AAT", "N"), ("AAA", "K"), ("AAG", "K"), ("AGC", "S"), ("AGT", "S"), ("AGA", "R"), ("AGG", "R"), ("CTA", "L"), ("CTC", "L"), ("CTG", "L"), ("CTT", "L"), ("CCA", "P"), ("CCC", "P"), ("CCG", "P"), ("CCT", "P"), ("CAC", "H"), ("CAT", "H"), ("CAA", "Q"), ("CAG", "Q"), ("CGA", "R"), ("CGC", "R"), ("CGG", "R"), ("CGT", "R"), ("GTA", "V"), ("GTC", "V"), ("GTG", "V"), ("GTT", "V"), ("GCA", "A"), ("GCC", "A"), ("GCG", "A"), ("GCT", "A"), ("GAC", "D"), ("GAT", "D"), ("GAA", "E"), ("GAG", "E"), ("GGA", "G"), ("GGC", "G"), ("GGG", "G"), ("GGT", "G"), ("TCA", "S"), ("TCC", "S"), ("TCG", "S"), ("TCT", "S"), ("TTC", "F"), ("TTT", "F"), ("TTA", "L"), ("TTG", "L"), ("TAC", "Y"), ("TAT", "Y"), ("TAA", ""), ("TAG", ""), ("TGC", "C"), ("TGT", "C"), ("TGA", ""), ("TGG", "W"), ("CTA", "L"), ("CTC", "L"), ("CTG", "L"), ("CTT", "L")]
task_18198
Given a vector of integers, write a function `find_max_even` that returns the maximum even number from the vector. If there are no even numbers, return -1. The function should have the following signature: `fn find_max_even(nums: Vec<i32>) -> i32:`. The input `nums` is a vector of integers where `1 <= nums.len() <= 1000` and `-1000 <= nums[i] <= 1000`.
task_18199
You are tasked with implementing a function that checks if a given number is a valid Chemical Abstracts Service (CAS) Registry Number. A valid CAS RN must satisfy the following criteria: it consists of up to three parts separated by hyphens, where the first part contains up to 7 digits, the second part contains exactly 2 digits, and the last part is a single check digit that can be either a digit or 'X'. The check digit is calculated based on the sum of the digits in the first two parts. Implement a function `is_valid_cas(cas_number: String) -> bool` that returns `true` if the provided CAS number is valid according to these rules, and `false` otherwise. For example, '123-45-6' is valid, while '123-45-67' is not because the last part has more than one digit.
task_18200
You are given a vector of strings representing names of instance shapes available in a cloud infrastructure. Implement a function `filter_instance_shapes(instance_shapes: Vec<String>, filter_name: String) -> Vec<String>` that filters the vector of instance shapes and returns a new vector containing only the shapes that exactly match the provided filter name. If no shape matches the filter name, return an empty vector. The input parameters are as follows:
- `instance_shapes`: A vector of strings where each string represents an instance shape name.
- `filter_name`: A string representing the name to filter the instance shapes by.
Example:
Input: `instance_shapes = vec!["shape1".to_string(), "shape2".to_string(), "shape3".to_string(), "shape2".to_string()]`, `filter_name = "shape2".to_string()`
Output: `vec!["shape2".to_string(), "shape2".to_string()]`
task_18201
Given a vector of snakes represented as tuples, where each tuple contains four integers (xi1, yj1, xi2, yj2) representing the start and end points of the snakes, implement a function that merges adjacent snakes that are separated by a non-empty section of mismatching tokens and then trims each snake to involve only whole lines. A snake is represented by the tuple (xi1, yj1, xi2, yj2, itype) where 'itype' indicates the type of the snake. Return the modified vector of snakes after merging and trimming. The input will be a vector of tuples representing the snakes. The function should return a vector of tuples representing the revised snakes.
task_18202
You are tasked with maintaining a simple inventory system for a small retail store. The inventory is represented as a HashMap where the keys are item names (String) and the values are their respective quantities (i32). Your goal is to implement a single function called `manage_inventory` that takes a vector of operations and returns the current state of the inventory after executing each operation. The operations can be one of the following: 1. 'add item_name quantity' - adds the specified quantity of the item to the inventory (creates it if it doesn't exist). 2. 'remove item_name quantity' - removes the specified quantity of the item from the inventory. If the quantity to be removed is greater than the available quantity, it should not change the inventory. 3. 'check item_name' - returns the quantity of the specified item in the inventory. The function should return the final inventory as a HashMap at the end of processing all operations.
task_18203
You are given a vector of arguments representing a function call. Your task is to create a function that extracts specific arguments based on certain rules. The function should take a vector of arguments and two boolean flags: `include_buffers` and `remove_constants`. The function should return a new vector of arguments that meets the following criteria: 1. If `remove_constants` is true, remove the arguments at indices 0, 41, 42, 44, and 45 from the input vector. 2. If `include_buffers` is false, remove any argument that is a 'Load' type. 3. Keep all other arguments in the output vector. The input vector may contain integers, floats, or 'Load' type elements. Implement the function `extract_arguments(args: Vec<Argument>, include_buffers: bool, remove_constants: bool) -> Vec<f32>` where `Argument` is an enum representing either an integer, a float, or a 'Load' type. The output should be a vector of floats.
task_18204
Given a 2D matrix represented as a vector of vectors, write a function `one_norm(matrix: Vec<Vec<f32>>) -> f32` that computes the one-norm of the matrix. The one-norm of a matrix is defined as the maximum absolute column sum of the matrix. The input matrix will have dimensions N x M where 1 <= N, M <= 100, and the elements of the matrix will be floating point numbers ranging from -1000.0 to 1000.0. Return the one-norm as a float.
task_18205
You are tasked with implementing a function that computes the Jaccard similarity coefficient between two sets of integers. The function should take two vectors of integers as input and return the Jaccard similarity coefficient as an f32. The Jaccard similarity coefficient is calculated as the size of the intersection of the two sets divided by the size of their union. If both sets are empty, the function should return 0.0.
task_18206
Implement a function `compress(num: i32, shift: i32) -> i32` that takes an integer `num` and a non-negative integer `shift`, and returns the result of compressing `num` by right shifting it by `shift` bits using bitwise operations. The function should only return the compressed integer value.
task_18207
Given a vector of integers, your task is to sort them in ascending order using any sorting algorithm without utilizing built-in functions like `sort`. Additionally, your algorithm should work in-place, meaning that no additional data structures such as vectors should be used for auxiliary space. Implement the function `fn in_place_sort(arr: &mut Vec<i32>)` that takes a mutable reference to a vector of integers and sorts it in place.
task_18208
Given an unsorted array of integers, write a function that finds the smallest subarray that, if sorted, would make the entire array sorted. Return the subarray, its length, and the starting and ending indices of the subarray within the original array. If the array is already sorted, return an empty subarray, its length as 0, and indices as (-1, -1). The function should be able to handle cases where the input array has negative numbers, zeros, and positive numbers. The input array will have at least one element and at most 10^5 elements.
task_18210
You are tasked with creating a function that takes two inputs: a server address (a String) and an image name (also a String). The function should simulate fetching a list of tags associated with a given image name from a Docker registry server. Instead of actually making a network request, your function should return a predefined list of tags based on specific inputs according to the following rules: 1. If the server address is 'server1.com' and the image name is 'imageA', return vec!["v1.0", "v1.1"]. 2. If the server address is 'server1.com' and the image name is 'imageB', return vec!["latest", "stable"]. 3. If the server address is 'server2.com' and the image name is 'imageA', return vec!["v2.0", "v2.1", "v2.2"]. 4. If the server address is 'server2.com' and the image name is 'imageB', return an empty list vec![]. 5. For any other combinations of server address and image name, return vec!["no tags found"]. Your function should panic with the message 'Invalid input' if the server address or image name are empty strings.
task_18211
You are given a vector of genotypes represented as strings. Your task is to implement a function `most_common_genotype(genotypes: Vec<String>) -> String` that returns the most common genotype in the vector. If there is a tie, return any one of the most common genotypes. If the input vector is empty, return an empty string. The function should handle a variety of genotype formats and should not require any external resources.
task_18212
Given the maximum width and height of a screen, return the corresponding screen resolution in the format 'WIDTHxHEIGHT'. The resolution options are defined as follows: For widths of 800, 1024, 1280, 1366, and 1920, there are corresponding heights of 600, 768, 720, 1080, and 1200. For mobile screens, the dimensions are defined as 768, 720, and 1080 with heights of 1024, 1280, and 1920 respectively. If the provided width and height do not match any of the predefined resolutions, return the default values of 1920x1080 for desktops and 1080x1920 for mobile devices. Implement a function `get_screen_resolution(width: i32, height: i32) -> String` that takes two parameters: the width and height of the screen, and returns the appropriate resolution string.
task_18213
You are tasked with implementing a function that converts values between different units of measurement for length. The function should take a value, its current unit, and a target unit as inputs, and return the converted value. The supported units are 'meters' and 'feet'. If the provided units are not supported or if the conversion is not possible, the function should return an error. Implement the function `unit_convert(value: f32, current_unit: String, target_unit: String) -> Result<f32, String>`.
task_18214
You are tasked with implementing a simple register management system for a microcontroller. The system should allow users to define registers with specific names, sizes, and addresses, and then perform read and write operations on these registers. Your task is to implement a function `manage_registers(operations)` that takes a vector of operations as input. Each operation is a tuple where the first element is a string indicating the type of operation ('read', 'write', or 'list'), and the subsequent elements depend on the operation type. The function should return a vector of results corresponding to each operation: 1. For 'read' operations, the second element is the register name, and the result should be the current value of that register or None if it doesn't exist. 2. For 'write' operations, the second element is the register name and the third element is the value to write. The function should not return anything for 'write' operations. 3. For 'list' operations, the function should return a vector of all register names. If an invalid operation is provided, it should simply return None for that operation. The registers are predefined as follows: registers = vec![("porta", 1, 0x10), ("ddrb", 1, 0x11), ("portb", 1, 0x12), ("rcsta1", 1, 0x13), ("rcreg1", 1, 0x14), ("txsta1", 1, 0x15), ("txreg1", 1, 0x16)]. Ensure that the implementation handles all operations efficiently and appropriately.
task_18215
Implement a function that takes a `String` and an `i32` offset as parameters. The function should first reverse the string and then apply a simple letter-shift cipher (Caesar cipher) to each character in the reversed string using the provided offset. Only alphabetic characters should be encrypted, while non-alphabetic characters should remain unchanged. The function should return the final encrypted `String`.
task_18216
You are tasked with creating a Rust function that takes in a vector of names and a template string, and returns a vector of personalized messages using the template string. If a name is empty, it should default to 'User'. The function should replace the placeholder '<NAME>' in the template string with the corresponding name from the input vector. Implement the function `personalized_messages(names, template)` to achieve this.
**Input**
- `names` (vector of strings): A vector of names.
- `template` (string): A template string containing `<NAME>` as a placeholder for the name.
**Output**
- A vector of personalized messages where each message is the result of replacing `<NAME>` in the template string with the corresponding name from the input vector. If a name is empty, it should default to 'User'.
**Example**
```rust
let names = vec!["Alice".to_string(), "".to_string(), "Eve".to_string()];
let template = "Hello, <NAME>! Welcome.".to_string();
personalized_messages(names, template);
```
**Output**
```
vec!["Hello, Alice! Welcome.".to_string(), "Hello, User! Welcome.".to_string(), "Hello, Eve! Welcome.".to_string()]
```
task_18217
Implement a function that converts a positive integer to its corresponding lowercase Roman numeral representation or converts a lowercase Roman numeral back to its original integer form. The function should take two parameters: `number`, which can either be an integer (between 1 and 1000) or a Roman numeral string, and `conversion_type`, which should be either 'int_to_roman' or 'roman_to_int'. The function should return an error if the input doesn't meet the criteria for conversion. The output should be a string for Roman numerals or an integer for the converted integer value.
task_18218
Given a vector of integers representing IDs, write a function `process_ids` that processes the IDs. If the vector contains only one ID, return that ID as an integer. If the vector contains multiple IDs, return the vector of IDs. The function should take a vector of integers as input and return either a single integer or a vector of integers as output. You can assume the input vector will only contain positive integers.
task_18219
You are given a vector of integers representing counts of emails in different mailboxes. Write a function `get_total_email_count(email_counts: Vec<i32>) -> i32` that calculates the total number of emails across all mailboxes. The function should take one argument: a vector of integers where each integer represents the number of emails in a specific mailbox. The function should return a single integer representing the total number of emails.
Example:
Input: vec![10, 5, 20]
Output: 35
Input: vec![0, 0, 0]
Output: 0
Constraints:
- The input vector will have at least 1 and at most 100 integers.
- Each integer in the input vector will be between 0 and 1000 (inclusive).
task_18220
You are tasked with creating a function that generates a formatted audit log message based on user actions. The function should take in four parameters: a message (String), a user ID (String), a subject ID (String), and an optional context (String, defaulting to 'other'). The function should return a formatted string that follows the template: 'performed by {user_id} on {subject_id}: {context}: {message}'. Implement a function named `generate_audit_log` that adheres to this specification.
task_18221
You are tasked with creating a logging function that logs messages to the console. Your function should accept a log level (as a String), a message (as a String), and an arbitrary number of additional arguments. The log levels can be 'debug', 'info', 'warning', 'error', and 'critical'. The function should format the message by appending the log level and the additional arguments if provided. Implement the function `log_message(log_level: String, message: String, args: Vec<String>) -> String` that returns the formatted log message. The log level should be included in the output message, followed by the main message and any additional arguments, all separated by spaces. If no additional arguments are provided, just return the log level and the message.
task_18222
You are tasked with creating a function that collects and returns metrics from various services. The metrics are represented as a hash map, where each key is the name of the service and the corresponding value is its metric value. Your function should simulate the collection of metrics from two hardcoded services, 'service1' with a metric value of 150, and 'service2' with a metric value of 300. Implement a function `collect_metrics()` that returns this hash map of metrics.
task_18223
You are given a vector of strings representing file paths. Each file path contains a sample ID, which is the first part of the path, and you need to partition these files into a specified number of groups. Each group should contain files that share the same sample ID, and you should return a vector of groups where each group is a vector of file paths. If there are fewer unique sample IDs than the specified number of groups, the remaining groups should be empty. Implement the function `partition_files(files: Vec<String>, num_partitions: i32) -> Vec<Vec<String>>` that takes in the vector of file paths and the number of partitions and returns the required partitioned vector of file paths.
task_18224
Write a function that takes a vector of strings and a user-defined character. The function should identify all strings in the vector that start with the specified character, sort those strings in decreased lexicographic order, join them together with a pipe (|), and return the modified string. If there are no strings starting with the specified character, return the original, unmodified vector of strings. The function should only implement the specified behavior and handle edge cases appropriately.
task_18225
You are tasked with implementing a function that checks if a given location is valid based on specific criteria. The function `is_valid_location(location)` takes a `String` `location` as input and returns `true` if the location meets the following conditions: 1. The location must be a non-empty string. 2. The location must contain only alphabetic characters and spaces. 3. The length of the location must not exceed 100 characters. If the location does not meet any of these criteria, the function should return `false`. Implement the `is_valid_location` function to fulfill these requirements.
task_18226
You are tasked with creating a Rust function that processes a given configuration map for a web application and modifies it based on certain rules. The configuration map contains various settings for the web application, and your function needs to update the settings according to specific requirements. Your function should take a configuration map as input and perform the following modifications: 1. If the 'JSON_AS_ASCII' key is present in the map, its value should be set to `true`. 2. If the 'debug' key is not present in the map, it should be added with a value of `false`. Your function should return the modified configuration map. Function Signature: `fn process_config(config: std::collections::HashMap<String, bool>) -> std::collections::HashMap<String, bool>:`
task_18227
Given a vector of integers representing indices of a tree structure, implement a function `get_children()` that returns a vector of string representations of these indices, where each index is converted to a string prefixed with 'ID_'. The vector is zero-based indexed. For example, if the input vector is [0, 1, 2], the output should be ['ID_0', 'ID_1', 'ID_2'].
task_18229
Given two vectors of integers, determine if the first vector is a subset of the second vector. A vector `vec1` is considered a subset of another vector `vec2` if all elements in `vec1` are present in `vec2`, regardless of the order and frequency of occurrence. Implement a function `is_subset(vec1: Vec<i32>, vec2: Vec<i32>) -> bool` that returns `true` if `vec1` is a subset of `vec2`, and `false` otherwise.
task_18230
Implement a function `primes_in_array(array: Vec<i32>) -> Vec<bool>` that accepts a vector of integers and returns a vector of booleans. Each boolean in the output vector should indicate whether the corresponding integer in the input vector is a prime number (true) or not (false). The algorithm should correctly handle edge cases, including negative numbers, zero, and one. The solution should be optimized to handle large arrays and larger numbers efficiently.
task_18231
You are tasked with creating a function `generate_command` that constructs a command string for running an R script based on the provided parameters. The function takes three arguments: `depthfile` (a string representing the path to a .depth file), `nodes` (a vector of strings representing node IDs), and `mode` (a string that can be either 'view' or 'view-all'). The function should return a command string that follows the format for running the R script located at `../../RScripts/pileupVisualizer.R`. If the mode is 'view', the command should include the node IDs, whereas if the mode is 'view-all', the command should exclude the node IDs. The command string should be constructed as follows: 'Rscript ../../RScripts/pileupVisualizer.R --args {mode} {depthfile} {nodes}' (where {nodes} is a space-separated string of node IDs for the 'view' mode).
task_18232
You are tasked with implementing a function to simulate the basic operations of a hash table, specifically 'set', 'get', and 'remove'. Your function should take a vector of operations, where each operation is a tuple containing the operation type (either 'set', 'get', or 'remove') and the corresponding parameters. The function should return a vector of results for the 'get' operations, with `None` for any 'get' operation that does not find the specified key. The 'set' operation updates the value for an existing key or adds a new key-value pair if the key does not exist, and the 'remove' operation deletes the specified key if it exists. Implement a single function called `hash_table_operations(operations: Vec<(String, (String, i32))>) -> Vec<Option<i32>>` that processes these operations.
task_18233
You are given a vector of integers representing the scores of students in a test. Your task is to implement a function that calculates the average score and the number of students who scored above or equal to the average score. The function should return a tuple containing the average score (rounded to two decimal places) and the count of students who scored above or equal to this average.
Function Signature: `fn calculate_average_and_count(scores: Vec<i32>) -> (f32, i32):`
### Input
- A vector of integers `scores` where 1 <= scores.len() <= 1000 and 0 <= scores[i] <= 100.
### Output
- A tuple with the first element being the average score as a float (rounded to two decimal places) and the second element being the count of students who scored above or equal to the average score.
task_18234
You are tasked with creating a function to manage a game's high scores. The function should take a vector of tuples containing player names and scores, and return a vector of structs where each struct contains the player's name and score, ordered by the score in descending order. If two players have the same score, they should be ordered by their name in alphabetical order. Your task is to implement the `manage_high_scores` function with the following requirements:
- The input will be a vector of tuples, where each tuple contains a player's name (a `String`) and their score (an `i32`).
- The output should be a vector of structs, each containing `name` and `score` fields with corresponding values, sorted as specified above.
task_18235
Implement a function that takes a vector of strings as input and returns a hash map where each string is a key and its corresponding value is the count of alphabetic characters in that string. The input vector will always contain non-empty strings.
task_18236
You are given a graph represented by its number of nodes and edges. Write a function `get_graph_properties(nodes: i32, edges: i32) -> (i32, i32)` that returns a tuple containing the number of nodes and edges in the graph. The function should take two parameters: `nodes` which is an integer representing the total number of nodes in the graph (0 <= nodes <= 10^5), and `edges` which is an integer representing the total number of edges in the graph (0 <= edges <= 10^5). The function should simply return the input parameters as a tuple in the format (nodes, edges).
task_18237
You are tasked with implementing a Rust function that takes a vector of integers as input and returns the count of unique elements in the vector. You need to ensure that the function handles the input validation and returns the count of unique elements. However, if the input is not valid (i.e., not a vector or contains non-integer elements), the function should return an appropriate error. The function signature should be `fn count_unique_elements(arr: Vec<i32>) -> Result<i32, String>`. The input parameter `arr` is a vector of integers (0 <= len(arr) <= 1000), and the integers can range from -10^9 to 10^9. The output should be an integer representing the count of unique elements in the input vector.
task_18238
Construct a function that computes the aggregate count of consonants from a specified list of sentences. You should only consider sentences that do not start with a vowel, end with a consonant, do not contain numbers or special characters, and are at least 5 words long. The function should also be able to handle sentences with mixed case letters. Implement the function `count_consonants(sentences)` where `sentences` is a vector of strings. The function should return the total count of consonants from the valid sentences.
task_18239
You are tasked with creating a Rust function that processes a vector of required Rust packages and returns a HashMap containing the count of each package's major version. The major version of a package is defined as the first digit in its version number. If a package does not specify a version, it should be counted under the key `None` in the output HashMap. Implement the function `count_package_versions(packages)` which takes a vector of strings representing the required Rust packages. Each string is in the format 'package_name>=version_number'. Your function should return a HashMap where the keys are the major versions and the values are the counts of packages with those major versions. If no major version is specified, use `None` as the key for those packages.
task_18240
You are given a vector of integers representing the heights of buildings in a city skyline. Your task is to determine the maximum height of the buildings that can be viewed from the left side of the skyline. A building can be viewed from the left if it is taller than all the buildings to its left. Implement a function `max_viewable_height(buildings: Vec<i32>) -> i32` that takes a vector of integers `buildings` and returns the maximum height that can be seen from the left.
### Input
- `buildings`: A vector of integers `buildings[i]` (1 <= `buildings[i]` <= 10^4), representing the height of the i-th building. The length of buildings will be between 1 and 1000.
### Output
- An integer representing the maximum height of the buildings that can be viewed from the left.
task_18241
You are tasked with creating a Rust function that processes a configuration file represented as a vector of strings, where each string corresponds to a line in the file. The configuration file contains sections and entries. Each section has a name, and each entry within a section has a key and a value. Your function should perform the following tasks:
1. If a section's name starts with 'dependency_', the function should check if the dependency is found in the given HashMap of crate versions. If not found, it should skip that section.
2. If a section's name is 'dependencies', the function should iterate through the entries and update their values based on the provided HashMap of crate versions.
The function should return the modified configuration file as a vector of strings.
Write a Rust function `process_config_file(config_lines, CRATES_VERSION)` that takes the configuration lines as input and modifies them according to the rules mentioned above.
task_18242
You are given two hash maps, `map1` and `map2`. Your task is to implement a function called `merge_maps(map1, map2)` that merges these two hash maps into a new hash map. In the merged hash map, if a key appears in both hash maps, the value from `map2` should be used. Return the merged hash map.
task_18243
You are tasked with creating a Rust function that checks if a given user has a specified permission for a file in a simulated environment. The function should take two parameters: `user_permissions` (a vector of strings representing the permissions the user has) and `permission` (a string representing the type of permission to check). The function should return `true` if the user has the specified permission, and `false` otherwise. The possible values for the `permission` parameter are: 'read', 'write', and 'execute'. Implement the function `check_user_permission(user_permissions, permission)` according to the given requirements.
task_18244
You are tasked with implementing a Rust function that processes a response HashMap and returns a specific payment URL. The response HashMap contains information about a payment, and the function should extract the payment URL from the nested structure. Specifically, the payment URL is located under the keys 'info' and 'paymentUrl'. If the payment URL is available, the function should return it. If the payment URL is not present, the function should return a default URL 'https://defaultpayment.com'. Write the function `extract_payment_url(response: HashMap<String, HashMap<String, String>>) -> String` to accomplish this.
task_18245
You are tasked with filtering a vector of file paths based on a specified keyword. Implement a function called `filter_file_paths` that takes a vector of strings representing file paths and a keyword as inputs. The function should return a new vector containing only the file paths that include the specified keyword as a substring. If no file paths contain the keyword, return an empty vector. The function signature is: `fn filter_file_paths(file_paths: Vec<String>, keyword: String) -> Vec<String>`. For example, given the input `file_paths = vec!["/var/log/syslog".to_string(), "/usr/local/bin/script.sh".to_string(), "/home/user/data/file.txt".to_string()]` and `keyword = "user".to_string()`, the function should return `vec!["/home/user/data/file.txt".to_string()]`.
task_18246
You are given a vector of structs representing start entries of a race, where each struct contains details about a start entry such as its `id` and `name`. Write a function `get_start_entry_ids(start_entries: Vec<StartEntry>) -> Vec<i32>` that takes a vector of start entries and returns a vector containing the `id`s of all start entries. The output vector should maintain the order of the start entries as they appear in the input vector. If the input vector is empty, return an empty vector.
Define the `StartEntry` struct with `id` of type `i32` and `name` of type `String`.
task_18247
You are tasked with creating a function that processes a vector of payload values for different flight phases and determines the maximum payload from the vector. The function should then calculate the fuel required for each flight phase based on the maximum payload according to a predefined formula: fuel_required = maximum_payload * 0.5. The function will return a vector of fuel required for each flight phase based on the maximum payload. Write a function `calculate_fuel_with_max_payload(out_payloads)` that takes in a vector `out_payloads` containing payload data for different flight phases and returns the fuel required for each flight phase based on the maximum payload.
task_18248
Implement a function `create_json_object(name: String, age: i32, country: String) -> Result<String, String>` that takes in three parameters: `name`, `age`, and `country`. The function should validate the input data as follows: the `name` must only contain letters and spaces (no special characters or numbers), the `age` must be an integer, and the `country` must consist only of uppercase letters. If any of the validations fail, the function should return an `Err` with an appropriate message. If all validations pass, the function should return an `Ok` containing a JSON string representing the data in the format: {"Name": name, "Age": age, "Country": country}.
task_18249
Given a vector of integer labels, your task is to implement a function `calculate_entropy(labels: Vec<i32>) -> f32` that calculates the entropy of the labels using the formula: `-Sum(Prob(class) * log2(Prob(class)))` for each unique class in the labels. The function should first determine the frequency of each unique label, calculate their probabilities, and then compute the entropy. The input will be a vector of integers, and the output should be a float representing the entropy value. If the input vector is empty, return 0.0. Note that you can assume the input will always be valid (i.e., a vector of integers).
task_18250
You are tasked with creating a function that simulates the process of creating a match between two racers in a racing tournament. The function should take the following parameters: the IDs of the first and second racer (racer_1_id and racer_2_id), the maximum number of races (max_races), a unique match ID (match_id), and two boolean flags indicating whether each racer has confirmed or unconfirmed the match time (r1_confirmed, r2_confirmed, r1_unconfirmed, r2_unconfirmed). The function should return a struct representing the match details, including the input parameters and a status indicating whether the match is confirmed or unconfirmed based on the confirmation flags. If both racers have confirmed, the match status should be 'confirmed'; if either racer is unconfirmed, the status should be 'unconfirmed'.
task_18251
You are given a vector of integers representing the durations of tasks that need to be completed. Your goal is to find the minimum total time required to finish all tasks, where you can only complete one task at a time. Implement a function `min_total_time(durations: Vec<i32>) -> i32` that returns the minimum total time required to finish all the tasks. The function should take a vector of integers, `durations`, where each integer represents the duration of a task. The total time is the sum of the durations of all tasks. The vector will contain between 1 and 1000 integers, and each integer will be between 1 and 10^6.
task_18252
You are given a vector of boolean values representing the status of various tests. Each test can either pass (`true`) or fail (`false`). Your task is to implement a function `filter_tests(tests: Vec<bool>) -> (i32, i32)` that returns a tuple containing two integers: the number of tests that passed and the number of tests that failed. The input vector will always contain at least one test. For example, if the input is `[true, false, true]`, the output should be `(2, 1)` because there are 2 tests that passed and 1 test that failed.
task_18253
You are tasked with creating a program that simulates a simple game of rock-paper-scissors. The program should take two inputs, each representing a player's choice of either 'rock,' 'paper,' or 'scissors.' Your task is to write a Rust function `rock_paper_scissors(player1, player2)` that takes two strings, `player1` and `player2`, representing the choices of the two players, and returns the result of the game. If player 1 wins, return 'Player 1 wins.'. If player 2 wins, return 'Player 2 wins.'. If it's a tie, return 'It's a tie.'
task_18254
You are given a string representing an entry that contains the path to an image and its associated label, separated by a comma. Your task is to implement a function that extracts the image path and label from this entry and returns a hash map with the keys 'image_path' and 'label'. The 'image_path' should contain the path to the image, and 'label' should contain the corresponding label as an integer. For example, if the input is 'path/to/image.jpg,3', the output should be {'image_path': 'path/to/image.jpg', 'label': 3}. Write a function named 'extract_image_info' that takes a single argument 'entry' (a string) and returns the desired hash map.
task_18255
You are tasked with creating a Rust function that takes a string as input and formats it to be centered within a specified width, surrounded by a specified character. Write a Rust function called `format_centered` that takes three parameters: - `text` (String): The input text to be centered. - `width` (i32): The total width within which the text should be centered. - `fill_char` (char): The character to be used for filling the remaining space around the centered text. The function should return a new String that contains the input text centered within the specified width and surrounded by the fill character. If the width is less than the length of the text, the function should return the text itself without any padding.
task_18256
Given a vector of integers, create a function that separates the even and odd numbers from the vector, each in reverse order of their appearance in the original vector. The function should then merge these two vectors alternatingly, starting with the even numbers vector. Write a function called `split_and_merge` that takes a vector of integers as input and returns the merged vector.
task_18257
You are tasked with simulating a simple banking system. Create a function called `manage_bank_account` that accepts a vector of operations to perform on a bank account. Each operation is a tuple containing a string and a number. The string can be 'deposit', 'withdraw', or 'calculate_interest', and the number is the amount to deposit or withdraw, or the interest rate in decimal form for calculating interest. The function should return the final balance of the account after performing all the operations. The account starts with an initial balance of 0. Ensure that if a 'withdraw' operation is attempted and there are insufficient funds, the operation should be ignored. You should not need to create a struct for this task. The function signature should be: `fn manage_bank_account(operations: Vec<(String, f32)>) -> f32:`.
task_18258
Given a binary matrix `grid` of dimensions `n x n`, implement a function `shortest_path_binary_matrix(grid: Vec<Vec<i32>>) -> i32` that computes the length of the shortest unobstructed path from the top-left cell (0, 0) to the bottom-right cell (n - 1, n - 1). An unobstructed path means traversing through cells containing `0`, and all neighboring cells of the path must be 8-directionally connected. If no such path exists, return `-1`.
task_18259
You are given a vector of geo-location entities represented by structs. Each entity is defined by its `entity_id`, `state`, and geographical coordinates (`latitude` and `longitude`). Write a function that takes a vector of these entities and a zone defined by its name and coordinates (latitude and longitude). The function should return a vector of entity IDs for those entities that are within the defined zone based on the given coordinates. A simple rule for determining if an entity is within the zone is if its latitude and longitude are equal to the zone's coordinates. The function should be named `get_entities_in_zone`.
task_18260
You are tasked with implementing a function that takes a string as input and returns a hash map containing the count of each character in the string. The function should ignore spaces and be case insensitive, meaning 'A' and 'a' are considered the same character. If the input string is empty, return an empty hash map. Write a function `count_characters(s: String) -> HashMap<char, i32>` that fulfills these requirements.
task_18262
You are tasked with creating a function that simulates a timer. The function `timer(interval: i32)` takes an integer `interval` (in seconds) as an argument and returns a vector of timestamps (in seconds) at which the timer would trigger events. The timer should trigger events at `interval`, `2 * interval`, `3 * interval`, and so on, until a total duration of 60 seconds is reached. If `interval` is greater than 60 seconds, the function should return an empty vector. Implement the function with the following signature: `fn timer(interval: i32) -> Vec<i32>:`
task_18263
You are tasked with implementing a custom backpropagation function for a mathematical operation called MulAdd, which computes the result of the equation `result = x * y + z`. Your function should be able to take the inputs x, y, z, and the gradient of the output (dout) and compute the gradients with respect to the inputs. Specifically, you need to implement the following function: `custom_mul_add_bprop(x: f32, y: f32, z: f32, dout: f32) -> (f32, f32, f32)`, where the output is a tuple containing the gradients dx, dy, and dz respectively. The gradients should be computed as follows: dx = dout * y, dy = dout * x, dz = dout. Please ensure your implementation is correct by running the provided test cases.
task_18264
You are tasked with implementing a function that manages a list of test cases for a software project. The function should support adding test cases to a list and removing them by their index. You need to implement a function `manage_tests(operations)` where `operations` is a vector of tuples. Each tuple can be one of two types: `("add", test_case)` to add a test case to the list, or `("remove", index)` to remove a test case from the list at the specified index. The function should return the total number of test cases remaining in the list after performing all operations. Note that if an attempt to remove a test case at an invalid index is made, the operation should be ignored. Your function should not use any external resources or classes.
task_18266
Develop a function that takes a vector of strings as an argument and returns true if at least one word contains the vowel 'e' at the second character position (index 1). Otherwise, return false.
task_18267
Implement a function `bubble_sort(arr: Vec<i32>) -> Vec<i32>` that takes a vector of integers as input and returns a new vector containing the same integers sorted in ascending order using the bubble sort algorithm. Do not modify the input vector.
Select a cell to see row details