Consider the following algorithm to find all the prime numbers less than a givenpositive number NStart with all the numbers in an array a[] ={2,3,4,5,...,N-1}.Now, keeping a[0]=2, filter out of this array all other numbers that are divisibleby 2 to leave {2,3,5,7,9,11,13,15,17...}Next, keeping a[1]=3, filter out of the remainder of the array, all numbers thatare divisible by 3, leaving {2,3,5,7,11,13,17,...}At the ith iteration, keep a[i], and filter from a[i+l],..., a[L-1], all numbersthat are divisible by a[i], where L is the current length of the array.By the end of this process, all the numbers remaining in the array are primenumbers.Using the filter pattern discussed in the notes, write a C program thatimplements this algorithm. (There are many algorithms to find prime numbers- the question asks for the implementation of the above algorithm, in order topractise the use of the filter pattern.

#include <stdio.h>#include <stdlib.h> int main(){ int n; printf("Enter the…

Consider the following algorithm to find all the prime numbers less than a given positive number N Start with all the numbers in an array a[] ={2,3,4,5,...,N-1}. Now, keeping a[0]=2, filter out of this array all other numbers that are divisible by 2 to leave {2,3,5,7,9,11,13,15,17...} Next, keeping a[1]=3, filter out of the remainder of the array, all numbers that are divisible by 3, leaving {2,3,5,7,11,13,17,...} At the ith iteration, keep a[i], and filter from a[i+1],...,a[L-1], all numbers that are divisible by a[i], where L is the current length of the array. By the end of this process, all the numbers remaining in the array are prime numbers. Using the filter pattern discussed in the notes, write a C program that implements this algorithm. (There are many algorithms to find prime numbers - the question asks for the implementation of the above algorithm, in order to practise the use of the filter pattern.

Consider the following algorithm to find all the prime numbers less than a given positive number N Start with all the numbers in an array a[] ={2,3,4,5,...,N-1}. Now, keeping a[0]=2, filter out of this array all other numbers that are divisible by 2 to leave {2,3,5,7,9,11,13,15,17...} Next, keeping a[1]=3, filter out of the remainder of the array, all numbers that are divisible by 3, leaving {2,3,5,7,11,13,17,...} At the ith iteration, keep a[i], and filter from a[i+1],...,a[L-1], all numbers that are divisible by a[i], where L is the current length of the array. By the end of this process, all the numbers remaining in the array are prime numbers. Using the filter pattern discussed in the notes, write a C program that implements this algorithm. (There are many algorithms to find prime numbers - the question asks for the implementation of the above algorithm, in order to practise the use of the filter pattern.

Programming Logic & Design Comprehensive

9th Edition

ISBN:9781337669405

Author:FARRELL

Publisher:FARRELL

Chapter6: Arrays

Section: Chapter Questions

Problem 17RQ

See similar textbooks

Similar questions

Given an array of integers arr, sort the array by performing a series of pancake flips. In one pancake flip we do the following steps: Choose an integer k where 1 <= k <= arr.length. Reverse the sub-array arr[0...k-1] (0-indexed). For example, if arr = [3,2,1,4] and we performed a pancake flip choosing k = 3, we reverse the sub-array [3,2,1], so arr = [1,2,3,4] after the pancake flip at k = 3. Print out the k-values corresponding to a sequence of pancake flips that sort arr. Example 1: Input: arr = [3,2,4,1] Output: 4, 2, 4, 3 Explanation: We perform 4 pancake flips, with k values 4, 2, 4, and 3. Starting state: arr = [3, 2, 4, 1]. After 1st flip (k = 4): arr = [1, 4, 2, 3] After 2nd flip (k = 2): arr = [4, 1, 2, 3] After 3rd flip (k = 4): arr = [3, 2, 1, 4] After 4th flip (k = 3): arr = [1, 2, 3, 4], which is sorted. Another potential solution is: Output = 3, 4, 2, 3, 1, 2, 1, 1 with a similar explanation. All potential solutions that solve the problem are…
Let A be an array of numbers. In the maximum sub-array problem, your goal is to determine the sub-array A[x . . . y] of consecutive terms for which the sum of the entries is as large as possible. For example, if A = [−2, −3, 4, −1, −2, 1, 5, −3], the maximum sub-array is [4, −1, 2, 1, 5], and the largest possible sum is S = 4 − 1 − 2 + 1 + 5 = 7. Suppose A = [1, 2, −4, 8, 16, −32, 64, 128, −256, 512, 1024, −2048]. Determine S, the largest possible sum of a sub-array of A.
You are given an arrayof colors (reds, whites, and blues), in no particular order. Sort them into the order of redsfollowed by whites followed by blues.a. Devise an efficient algorithm to solve this problem.b. What is your algorithm's time complexity?For example, if red is represented by 2, white represented by 4 and blue is represented by 6,your input and output array could be of following form:Input: [ 4 6 2 4 2 6 4 2 6 4 4 2 4 ]Output: [ 2 2 2 2 4 4 4 4 4 4 6 6 6]
You're given an array arr. Apply the following algorithm to it: find intervals of consecutive prime numbers and consecutive non-prime numbers; replace each such interval with the sum of numbers in it; if the resulting array is different from the initial one, return to step 1, otherwise return the result. Input A non-empty integer array such that: -10000 ≤ arr[i] ≤ 10000 1 ≤ arr.length ≤ 1000 Output An integer array. Examples For arr = [1, 2, 3, 5, 6, 4, 2, 3] the result should be [21, 5]: [1, 2, 3, 5, 6, 4, 2, 3] --> [(1), (2 + 3 + 5), (6 + 4), (2 + 3)] --> [1, 10, 10, 5] [1, 10, 10, 5] --> [(1 + 10 + 10), (5)] --> [21, 5] For arr = [-3, 4, 5, 2, 0, -10] the result should be [1, 7, -10]: [-3, 4, 5, 2, 0, -10] --> [(-3 + 4), (5 + 2), (0 + -10)] --> [1, 7, -10] Solve it in C# please
Given an integer array [A], efficiently find a descending sorted triplet such that: A[i]> A[i]> A[k] and 0 <=i<j <k <n, where n is the array size. For example, Input: A[] = {9, 1, 6, 7, 3, 4, 5) Output: Any one of the following triplets: (9, 7,5) (9, 7, 4) (9, 7, 3) (9, 6, 5) (9, 6, 4) (9, 6, 3) a) Design a brute-force algorithm to solve this problem complexity of your solution b) Design a more efficient algorithm to do the same task with less complexity and analyse the complexity of your solution. c) Develop a python code to implement your efficient algorithm. depend on the correctness of the code, indentation, comments, test-case] d) Prepare a brief report (250 words) comparing the two algorithms
Write a program that reads an array A of N elements containing only 0's and 1's. Your program should find the position of a 0 and replace it with a 1 to get the longest continuous sequence of 1's. Let this position of 0 be called P. Print P if such a 0 exists and print -1 if the original array A contains only 1's. Assume the array indexing starts from 0.
Let B be an array that is of size n >= 6 containing integers from 1 to n-5, inclusive, with exactly five repeated. Describe an O(n) algorithm for finding the five integers in B that are repeated.
Given an integer n and an array a of length n, your task is to apply the following mutation to a: Array a mutates into a new array b of length n. For each i from 0 to n - 1, b[i] = a[i - 1] + a[i] + a[i + 1]. If some element in the sum a[i - 1] + a[i] + a[i + 1] does not exist, it should be set to 0. For example, b[0] should be equal to 0 + a[0] + a[1].
You have an array of n real numbers and another integer s. Find out whether the array contains two elements whose sum is s. (For example, for the array 5, 9, 1, 3 and s = 6, the answer is yes, but for the same array and s = 7, the answer is no.) Design an algorithm for this problem with a better than quadratic time efficiency.
Let's say that B is an array with a size of n > 6 that has integers from 1 to n-5, inclusive, in it. There are exactly five repeats in B. Explain how to find the five numbers in B that are the same.
You are given an array of integers (both positive and negative). Find thecontiguous sequence with the largest sum. Return the sum.EXAMPLEInput: 2, -8, 3, -2, 4, -10Output: 5 ( i. e • , { 3, -2, 4} )
1. Consider the algorithm for the sorting problem that sorts an array by counting,for each of its elements, the number of smaller elements and then uses thisinformation to put the element in its appropriate position in the sorted array:ALGORITHMComparisonCountingSort(A[0..n − 1])//Sorts an array by comparison counting//Input: Array A[0..n//Output: Array S[0..n− 1] of orderable values− 1] of A’s elements sorted// in nondecreasing orderfor i ← 0 to nCount− 1 do[i]←0for i ← 0 to n − 2 dofor j ← i +1 to n − 1 doif A[i] < A[j ]Count[j ]← Count[j ] + 1else Count[i]← Count[i] + 1for i ←0 to n−1 doS[Count[i]]←A[i]return Sa. Apply this algorithm to sorting the list 60, 35, 81, 98, 14, 47.b. Is this algorithm stable?c. Is it in-place?