Represent a polynomial using a list of its (real) coefficients, starting with the constant coefficient and going only as high as necessary, For example, 3x² - 5x +1 would be represented as the list [1.0, 5.0, 3.0] and x² - 2x as [0.0, -2.0, 0.0, 1.0]. Write a function eval of type real list * real -> real that takes a polynomial represented this way and a value for x and returns the value of that polynomial at the given x. For example, eval ( [1.0,5.0,3.0], 2.0) should evaluate to 23.0, because when x=2, 3x² + 5x + 1 = 23.

Represent a polynomial using a list of its (real) coefficients, starting with the constant coefficient and going only as high as necessary, For example, 3x² - 5x +1 would be represented as the list [1.0, 5.0, 3.0] and x² - 2x as [0.0, -2.0, 0.0, 1.0]. Write a function eval of type real list * real -> real that takes a polynomial represented this way and a value for x and returns the value of that polynomial at the given x. For example, eval ( [1.0,5.0,3.0], 2.0) should evaluate to 23.0, because when x=2, 3x² + 5x + 1 = 23.

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

Implement a function countMultiples in Python that: accepts a single argument, a 2-dimensional list (e.g, list of lists) containing non-negative integers, and returns the count of those integers that are multiples of 5 but that are not not multiples of 10. (e.g., 65 should be counted, but 80 should not be counted) sample usage: >>> countMultiples( [[1,2,3],[4,5],[6,7,8,9]] ) # 5 counts1
Consider the following problem: You are given a list of integers. Write a Python function that finds the longest increasing subsequence in the list. A subsequence is considered increasing if the elements are in ascending order, but they may not necessarily be contiguous. Your function should return the length of the longest increasing subsequence. For example, given the list [3, 4, 2, 8, 10, 5, 1], the longest increasing subsequence is [3, 4, 8, 10], so the function should return 4. Provide the implementation of the function step by step.
Create a function that takes the dimensions of two triangles (as arrays) and checks if the first triangle fits into the second one. Examples does TriangleFit([1, does TriangleFit([1, does TriangleFit([1, does TriangleFit([1, 1, 1], [1, 1, 1]) → true 1, 1], [2, 2, 2]) → true 2, 3], [1, 2, 2]) → false 2, 4], [1, 2, 6]) → false
Does it hold for lists? :Write a function holds_for_lists : ’a list -> ’b list -> (’a -> ’b -> bool) -> bool = that takes an ’a list, an ’b list, a function f: ’ a -> ’b ->bool and returns true if and only if • The two list are of the same length, and • (f a b) is true for all pairs a, b such that a is from the first list, b is from the second list, and a and b appear in the same position in their lists. (oCaml)
Question 2: Write a function that takes a list of distinct integers l, and an integer k. Your function then finds the index of the integer in l, whose removal from l results in a list whose sum is k. For example, given [3,6,4,1,5,2] and 18, your function should return index 0, which corresponds to 3 in the list. Because, when 3 is removed from the list, the sum of the remaining list [6,4,1,5,2] is 18. You can assume that the given problem is always solvable. """ def removeOne(l, k):
# 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)
Define a Haskell function filterTriples that, given a list of integer triples, removes those that are not in ascending order of size. Use list comprehension to implement the function. Example: filterTriples [(1,2,3), (6,5,4), (7,7,7)] ↝ [(1,2,3), (7,7,
Python Please Define a function max_run(lst: list) -> int to find the maximum run in a list. A run is a subsequence with identifical values. For example, in [1, 1, 2, 2, 3, 4, 4, 4, 2, 4, 4], the runs are [1, 1], [2, 2], [3], [4, 4, 4], [2], and [4, 4]. The longest run is [4, 4, 4], which has 3 elements. max_run([1, 1, 2, 2, 3, 4, 4, 4, 2, 4, 4]) should return 3. max_run([]) == 0, max_run([1, 2, 3]) = 1, and max_run([1, 2, 1, 1]) = 2.
Write a java function to find minimum moves required for making 2 List<Integer> equal. public int minimumOps(List<Integer> S, List<Integer> T){} The two possible moves are: shift(list) returns a new list after moving the front number to the back—i.e., [1, 2, 3 ,4 ] -----> [2, 3, 4, 1] reverse(list) returns the reverse of the list—i.e., [1, 2, 3, 4] -------> [4, 3, 2, 1] for example: consider S = {1, 2, 3, 4} and T = {2, 1, 4, 3}, we can see that T = shift ( shift( reverse( S ))) S = [1, 2 , 3 ,4] -----> [4, 3, 2, 1] ------>[3, 2, 1, 4] -------->[2, 1, 4, 3] = T = 3 moves total. But this is not the only way to transform S to T. To illustrate, here are some other sequence of operations : T = reverse(shift(shift(S))) T = shift(reverse(shift(S))) T = reverse(shift(shift(reverse(reverse(S)))))) Goal is to find the minimum moves on S list to form T list. Some more input/ output examples of length 5 minimumOps(List.of(1,2,3,4,5),…
Implement the function pairs, which takes in an integer n, and returns a new list of lists which contains pairs of numbers from 1 to n. Use a list comprehension. def pairs(n): """Returns a new list containing two element lists from values 1 to n >>> pairs (1) [[1,1]] >>> X = pairs (2) >>> X [[1, 1], [2, 2]] >>> pairs (5) [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]] >>> pairs (-1) [] '*** YOUR CODE HERE ***"
Implement a function pairsThatSum that accepts two arguments: 1. a target number2. a list of numbers the function then returns a list of tuple s that contains all pairs of numbers from the list that sum to the given target number. Note: the pair can be two numbers with the same value, e.g. (2,2) but these must be different items (have different locations) in the list. See the last example below. each pair should be reported only once (don't include a pair and its reverse), and each pair's values should be listed in the order that they occur in the list. E.g., the first example records the pair (0,3) instead of the pair (3,0) , because 0 occurs in the list before 4 . the list of pairs should be ordered by the order of the first value in the list, e.g., (0,3) comes before (1,2) because 0 comes before 1 in the list. (note: if you take the right approach, you won't have to do anything extra for this requirement) Below is an example of the output from the code: >>>…
Exercise 4 Define a function repeats of type 'a list -> bool so that repeats (L) is true if and only if the list L has two equal elements next to each other.