Implement the generator function scale (s, k), which yields elements of the given iterable s, scaled by k. As an extra challenge, try writing this function using a yield from statement! def scale (s, k): """Yield elements of the iterable s scaled by a number k. >>> s = scale ( [1, 5, 2], 5) >>> type (s) >>> list (s) [5, 25, 10] >>> m = scale (naturals (), 2) in range (5)] >>> [next (m) for [2, 4, 6, 8, 10] "*** YOUR CODE HERE ***"

Implement the generator function scale (s, k), which yields elements of the given iterable s, scaled by k. As an extra challenge, try writing this function using a yield from statement! def scale (s, k): """Yield elements of the iterable s scaled by a number k. >>> s = scale ( [1, 5, 2], 5) >>> type (s) >>> list (s) [5, 25, 10] >>> m = scale (naturals (), 2) in range (5)] >>> [next (m) for [2, 4, 6, 8, 10] "* YOUR CODE HERE *"

C++ for Engineers and Scientists

4th Edition

ISBN:9781133187844

Author:Bronson, Gary J.

Publisher:Bronson, Gary J.

Chapter5: Repetition Statements

Section5.5: A Closer Look: Loop Programming Techniques

Problem 12E: (Program) Write a program that tests the effectiveness of the rand() library function. Start by...

See similar textbooks

Similar questions

Write the value_equality method.Given the two expressions ? and ?, first compute the set of variables ? that appear in either ? or ?. Then, the idea consists in performing num_sample times the following test for equality: First, produce a variable assignment (a dictionary) mapping each variable in ? to a random value. Choose these random values from the gaussian distribution centered around 0 and with standard deviation 10 (for instance; any continuous distribution with infinite domain would work). You can obtain such numbers using random.gauss(0, 10). Then, compute the values of ? and ? with respect to that variable evaluation. If the values are closer than a specified tolerance tolerance, you consider ? and ? equal (for that variable valuation). Otherwise, you can stop and return that ? and ? are different. If you can repeat the process num_sample times, and ? and ? are considered equal every time, then you declare them equal. WRITE CODE IN PYTHON
Implement the buildDistributionArray function to take an array of scores, built by parseScores, as an argument. A grade distribution array of length 5 is returned. Loop through the scores array and tally up the number of A, B, C, D, and F scores using the standard scoring system (90 and above = A, 80‐89 = B, 70‐79 = C, etc.). Store these totals in a distribution array where the number of As is the first number, number of Bs is the second number, etc. Ex: ["45","78","98","83","86","99","59"] → [2, 2, 1, 0, 2] buildDistributionArray returns [0, 0, 0, 0, 0] when the scoresArray argument is empty.
Your tasks Implement the methods marked with ??? package percentiles: /** * Given a non-empty sequence of elements of type T, returns the smallest element e * in the sequence for which it holds that at least p percent of the elements in the sequence * are smaller or equal to e. * Note the special cases: * - when p == 0, the result should be the smallest element in the sequence * - when p == 100, the result should be the largest element in the sequence * If the sequence is empty, java.lang.IllegalArgumentException is thrown. * * For a sequence of length n, the method should make at most n*log(n) * [again, here log means base-2 logarithm] comparison operations between * the elements in the sequence. * Furthermore, assuming that comparison is a constant-time operation, * the whole method should run in O(n*log(n)) time. * Hint: you can assume that the "sorted" method of Seq performs at most n*log(n) comparisons for * sequences of…
Write a RECURSIVE method called “sequence” that takes a single int parameter (n) and returns the int value of the nth element of the sequence S = 2, 4, 6, 12, 22, 40, 74, 136, 250, 460, … Where S is defined by the recursive formula: For n >= 0S(0) = 2; // Base case 1S(1) = 4; // Base case 2S(2) = 6; // Base case 3S(N) = 2 * ( S(N-1)/2 + S(N-2)/2 + S(N-3)/2)
Write a method to return the reverse order for a list of space separated words. Example: "A sample sentence is required" would return "required is sentence sample A" I have this to start: class Solution: def reverse_words(self, input): # Your code goes here These are the tests: from solution import Solution import unittest class SolutionTests(unittest.TestCase): def test1(self): solution = Solution() self.assertEqual(solution.reverse_words("the quick brown fox"), "fox brown quick the") if __name__ == '__main__': unittest.main() Any help would be appreciated!
Please implement in Java implement a keyed bag in which the items to be stored are strings (perhaps people’s names) and the keys are numbers (perhaps Social Security or other identification numbers). So, the in- sertion method has this specification: public void insert(String entry, int key);// Precondition: size( ) < CAPACITY, and the // bag does not yet contain any item// with the given key.// Postcondition: A new copy of entry has// been added to the bag, with the given key. When the programmer wants to remove or retrieve an item from a keyed bag, the key of the item must be specified rather than the item itself. The keyed bag should also have a boolean method that can be used to determine whether the bag has an item with a specified key. In a keyed bag, the pro- grammer using the class specifies a particular key when an item is inserted. Here’s an implementation idea: A keyed bag can have two private arrays, one that holds the string data and one that holds the corresponding…
Implement the sieve of Eratosthenes: a function for computing prime numbers, known to the ancient Greeks. Choose an integer n. This function will compute all prime numbers up to, and including, n. First insert all numbers from 1 to n into a set. Then erase all multiples of 2 (except 2); that is, 4, 6, 8, 10, 12, ... . Erase all multiples of 3, that is, 6, 9, 12, 15, ... . Go up to ?⎯⎯√n. The remaining numbers are all primes. Make sure that you use functions in your solution, including a main function. Define def sieveOfEratosthenes(n) that receives the maximum value and returns a list of all prime numbers less than or equal to this value in main() print the list of prime numbers.
Interpreter.java is missing these methods in the code so make sure to add them: -print, printf: Exist, marked as variadic, call Java functions -getline and next: Exist and call SplitAndAssign -gsub, match, sub, index, length, split, substr, tolower, toupper: Exist, call Java functions, correct return Below is interpreter.java import java.util.ArrayList; import java.util.HashMap; import java.util.List; public class Interpreter { private HashMap<String, InterpreterDataType> globalVariables; private HashMap<String, FunctionDefinitionNode> functions; private class LineManager { private List<String> lines; private int currentLineIndex; public LineManager(List<String> inputLines) { this.lines = inputLines; this.currentLineIndex = 0; } public boolean splitAndAssign() { if (currentLineIndex < lines.size()) { String currentLine = lines.get(currentLineIndex);…
Implement the vacuum cleaning agent function in Python/Java for the scenario described below: Consider two-dimensional Boolean array of size m x n (m and n can each be equal to 4) where m is the number of rows, and n is the number of columns. Obtain numerical positive integer values for m and n as inputs from the user. Generate random numbers and scale them down to either a “0” or a “1” according to whether they represent “Clean” or “Dirty”, respectively. After filling the array with 0s or 1s, start at some random array position indicating the initial position of the vacuum cleaner. First check if at that current position, there is the presence of a “Dirt” or not determined by whether 0 or 1 is filled in at that initial position of the vacuum cleaner. If there is a “Dirt”, clean it, and if there is no “Dirt” do a No-operation. After this is done, generate random numbers modulo 4 to obtain random numbers 0, 1, 2, 3 indicating whether to take a left, right, up or down correspondingly. If…
Write functions (in Java) that draw Pyramid with “*” given height and stars variables. Make implementations for both iterative and recursive design. IterativePrintPyramid(int height) * * * * * * * * * * * * * * * * * * * * * * * * * RecursivePrintPyramid(int height, int stars) * * * ** * * * * * * * * * * * * * * * * * * * * 1-)void IterativePrintPyramid(int height){ } // end−of−IterativePrintPyramid -------------------------- 2-)void RecursivePrintPyramid(int height, int stars) { } // end−of−RecursivePrintPyramid
# write your implementation heredef maxProfitBrute(changes): """ it returns the indices of (i,j) indicating the day to buy and sell respectively to have the maximum profit in a list of prices per day in <changes>. Inputs: - changes: the list holding the changes in prices; the value whose index is k represents the change between day <k> and day <k+1> <changes> has at least a single change [two days] Output: - i: the index of the change before which we buy - j: the index of the change after which we sell - maxProfit: the value of the maximum profit Example: changes = [1,2] - that means the price started with <x>; - day 1: it became <x+1> - day 2: it became <x+3> In that case: (i,j) = (0,1) as we should buy at the first day, and sell after the third day """ # return the values return (0,0,0)
Complete the method below that prints all elements that are in both Set<String> s and Set<String> t. Each matching element should be followed by a space. What can I change to make it work? import java.util.Set;import java.util.Iterator; public class Sets{ public static void printMatches(Set<String> s, Set<String> t) { System.out.print("{ "); while(in.hasNext()){ String next = in.next(); { if((s.contains(next))&& (t.contains(next))){ System.out.print(next+" "); } } System.out.println("}"); }} import java.util.Set;import java.util.TreeSet;import java.util.Arrays; public class SetsTester{ public static void main(String[] args) { Set<String> set1 = new TreeSet<>(Arrays.asList("Bob", "Bill", "Sally")); Set<String> set2 = new TreeSet<>(Arrays.asList("Sam", "Bob", "Frank")); Sets.printMatches(set1, set2);…