Write a function which return a list of all of the n element subset .pdf

•

0 likes•2 views

Write a function which return a list of all of the n element subset of a given set Implement in JAVA Question 3 Write a function that returns a list of all of the n-element subsets of a given set. For example, if the given set is [1,2,3] and n is 2, then the returned list should contain [1,2], [1,3], and [2,3]. The order of the elements is not important. Solution The program for this problem is as follows: Comments are included in the program for explaining the steps. A sample output is attached below the program. package com.temp; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * Program to find sublists of a list. * @author Rohit Phatak * */ public class subset { /** * This list will contain the resultant sublists. */ static List list = new ArrayList<>(); public static void main(String arg[]){ /** * Input a list comma separated. */ System.out.println(\"Enter a list : \"); Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); String[] sArr = s.split(\",\"); /** * Input a value of n. */ System.out.println(\"Enter value of n : \"); Integer n = scanner.nextInt(); /** * Check if value of n is greater than entered list. */ if(sArr.length < n){ System.out.println(\"Length of list is less than value of n\"); } else if(sArr.length > 0){ getSubsetList(sArr,n); System.out.println(\"List is as :\"); /** * Printing the sublists. */ for(String[] str : list){ String printVar = \"\"; for(String temps : str) printVar+=temps+\",\"; System.out.println(\"[\"+printVar.substring(0, printVar.length()-1)+\"]\"); } } else { System.out.println(\"Please enter atleast one element:\"); } scanner.close(); } /** * This method calls the recursive function which is used to obtain the sublists. * @param sArr * @param n * @return */ public static List getSubsetList(String[] sArr,Integer n){ List lista = new ArrayList<>(); sublist(sArr, 0, n, new String[n]); return lista; } /** * This is a recursive function. * This function will iterate over itself for finding the sublist. * * Parameters are as follows: * * @param arr -> List entered by the user. * @param n -> Value of sublist entered by user. * @param startPosition -> index to start creating the sublist. * @param result -> resultant sublist */ public static void sublist(String[] arr, int startPosition, int n, String[] result){ /** * Check for the value of n ==0. * If n==0 break from the recursion. */ if (n == 0){ /** * Add the sublist \'result\' in the list. */ list.add(result.clone()); return; } /** * Iterate through for loop starting from startPosition till length of list minus entered value n. */ for (int i = startPosition; i <= arr.length-n; i++){ /** * Here result is a temporary sublist. * This for loop adds an element to the temporary sublist in each iteration. * The element is added from the complete list entered by user. * Location of element is iTh index. */ result[result.length - n] = arr[i]; /** * After adding the element to the temporary sublist, the sublist an.

Education

*/
System.out.println("Enter value of n : ");
Integer n = scanner.nextInt();
/**
* Check if value of n is greater than entered list.
*/
if(sArr.length < n){
System.out.println("Length of list is less than value of n");
} else if(sArr.length > 0){
getSubsetList(sArr,n);
System.out.println("List is as :");
/**
* Printing the sublists.
*/
for(String[] str : list){
String printVar = "";
for(String temps : str)
printVar+=temps+",";
System.out.println("["+printVar.substring(0, printVar.length()-1)+"]");
}
} else {
System.out.println("Please enter atleast one element:");
}
scanner.close();
}
/**
* This method calls the recursive function which is used to obtain the sublists.
* @param sArr
* @param n
* @return
*/
public static List getSubsetList(String[] sArr,Integer n){
List lista = new ArrayList<>();
sublist(sArr, 0, n, new String[n]);
return lista;
}

/**
* This is a recursive function.
* This function will iterate over itself for finding the sublist.
*
* Parameters are as follows:
*
* @param arr -> List entered by the user.
* @param n -> Value of sublist entered by user.
* @param startPosition -> index to start creating the sublist.
* @param result -> resultant sublist
*/
public static void sublist(String[] arr, int startPosition, int n, String[] result){
/**
* Check for the value of n ==0.
* If n==0 break from the recursion.
*/
if (n == 0){
/**
* Add the sublist 'result' in the list.
*/
list.add(result.clone());
return;
}
/**
* Iterate through for loop starting from startPosition till length of list minus entered value
n.
*/
for (int i = startPosition; i <= arr.length-n; i++){
/**
* Here result is a temporary sublist.
* This for loop adds an element to the temporary sublist in each iteration.
* The element is added from the complete list entered by user.
* Location of element is iTh index.
*/
result[result.length - n] = arr[i];
/**

* After adding the element to the temporary sublist, the sublist and the updated start and
end positions are recurssed to itself.
*/
sublist(arr, i+1, n-1, result);
}
}
}
Sample output of the above program :
Enter a list :
1,2,3,5
Enter value of n :
2
List is as :
[1,2]
[1,3]
[1,5]
[2,3]
[2,5]
[3,5]

Similar to Write a function which return a list of all of the n element subset .pdf

Use the graph of the function f below to find the following. All local minimum values of f All values at which f has a local minimum If there is more than one answer, separate them with commas. All local minimum values of f All values at which f has a local minimum: Solution Dear student Thank you for using Chegg As per the given curve it is clear that the local minimum values of f are -3 & 0 Values of x when curve attain minimum values are x = -2,3.

Using Array Approach, Linked List approach, and Delete Byte Approach.pdf

fms12345

we using java code /** * DynamicArray.java * * Replace all //TODO tags with your code * * Note that below the "//TODO" tag there may be * something like "return null;", "return 0;", etc. * That line is just "stubbed in" so the class * will compile. When you add your code (one or many * statements), you will want to delete the "stubbed" line. * By "stubbed in" we mean "mocked" or "faked in" temporarily. * * When testing, construct using the static factory methods: DynamicList.newEmpty() DynamicList.fromGrowthFactor(growthFactor) DynamicList.from(arrayElements) */ package model.list; import java.lang.reflect.Array; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; import model.linearpub.DynamicList; import model.linearpub.StructureIterator; public class DynamicArray<E> implements DynamicList<E> { //--------------------------------- // Instance Variables //TODO - declare instance variable(s) //--------------------------------- // Private Constructors /** Constructs and returns new DynamicArray (no args constructor) */ private DynamicArray() { this(defaultGrowthFactor()); } /** Constructs and returns new DynamicArray with "aGrowthFactor" */ private DynamicArray(double aGrowthFactor) { //TODO -- this is the constructor that should //initialize the dynamic array as needed } //------------------------------------------------ public static double defaultGrowthFactor() { //TODO - replace 0 with a good growth factor return 0; } protected static int defaultInitialCapacity() { //TODO - replace 0 with a good initial capacity return 0; } //-------------------- List Statistics --------------------- /** * Return number of elements in this list. */ @Override public int size() { //TODO return 0; } /** * Return true is this list contains no elements. */ @Override public boolean isEmpty() { //TODO return false; } //------------------ Accessing Elements -------------------- /** * Return element at given index. * Throws IndexOutOfBoundsException if passed index is invalid. */ @Override public E get(int index) { //TODO return null; } /** * Return first element * Throws RuntimeException if list is empty */ @Override public E first() { //TODO return null; } /** * Return last element * Throws RuntimeException if list is empty */ @Override public E last() { //TODO return null; } /** * Return a new list containing the elements of this list * between the given index "start" (inclusive) and * the given index "stop" (exclusive). * Throws IndexOutOfBoundsException if either passed index is invalid. */ @Override public DynamicList<E> subList(int start, int stop) { //TODO return null; } /** * Return index of first matching element (where searchFct outputs true) * Return -1 if no match * Example usage (first list of integers, then employees): * index = list.find(eaInteger -> eaInteger == 10); * index = employeeList.find(employee -> employee .getFirstName().equals("Kofi.

we using java code DynamicArrayjava Replace all .pdf

gudduraza28

PLEASE MAKE SURE THE PROGRAM IS ASKING FOR INPUT FROM USER TO ADD OR REMOVE NAME. DO NOT HARD CODE NAME. AGAIN MAKE SURE THE PROGRAM IS ASKING FOR INPUT FROM USER TO ADD OR REMOVE NAME. PLEASE MAKE SURE THE CODE RUNS WITHOUT ANY ERRORS. Write a class that maintains the scores for a game application. Implement the addition and removal function to update the database. The gamescore.txt contains player’ name and score data record fields separated by comma. For Removal function, uses the name field to select record to remove the game score record. Use the List.java, LList.java, Dlink.java, GameEntry.java and gamescore.txt found below Read gamescore.txt to initialize the Linked list in sorted order by score. Ask the user to add or remove users to update the sorted linked list. Display “Name exist” when add an exist name to the list. Display “Name does not exist” when remove a name not on the list. List.java File: /** Source code example for \"A Practical Introduction to Data Structures and Algorithm Analysis, 3rd Edition (Java)\" by Clifford A. Shaffer Copyright 2008-2011 by Clifford A. Shaffer */ /** List ADT */ public interface List { /** * Remove all contents from the list, so it is once again empty. Client is * responsible for reclaiming storage used by the list elements. */ public void clear(); /** * Insert an element at the current location. The client must ensure that * the list\'s capacity is not exceeded. * * @param item * The element to be inserted. */ public void insert(E item); /** * Append an element at the end of the list. The client must ensure that * the list\'s capacity is not exceeded. * * @param item * The element to be appended. */ public void append(E item); /** * Remove and return the current element. * * @return The element that was removed. */ public E remove(); /** Set the current position to the start of the list */ public void moveToStart(); /** Set the current position to the end of the list */ public void moveToEnd(); /** * Move the current position one step left. No change if already at * beginning. */ public void prev(); /** * Move the current position one step right. No change if already at end. */ public void next(); /** @return The number of elements in the list. */ public int length(); /** @return The position of the current element. */ public int currPos(); /** * Set current position. * * @param pos * The position to make current. */ public void moveToPos(int pos); /** @return The current element. */ public E getValue(); } LList.java File: /** * Source code example for \"A Practical Introduction to Data Structures and * Algorithm Analysis, 3rd Edition (Java)\" by Clifford A. Shaffer Copyright * 2008-2011 by Clifford A. Shaffer */ // Doubly linked list implementation class LList implements List { private DLink head; // Pointer to list header private DLink tail; // Pointer to last element in list protected DLink curr; // Pointer ahead of current element int cnt; // Size of list // Constructors LList(int size) { th.

PLEASE MAKE SURE THE PROGRAM IS ASKING FOR INPUT FROM USER TO ADD OR.pdf

mallik3000

Write a program that will test a name) method no sorting routine from.docx

ajoy21

Please do parts labeled TODO /** * LinkedList.java * * Replace all //TODO tags with your code * * Note that below the "//TODO" tag there may be * something like "return null;", "return 0;", etc. * That line is just "stubbed in" so the class * will compile. When you add your code (one or many * statements), you will want to delete the "stubbed" line. * By "stubbed in" we mean "mocked" or "faked in" temporarily. * * When testing, construct using the static factory methods: LinkedList.newEmpty() LinkedList.from(arrayElements) */ package model.list; import java.lang.reflect.Array; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; import model.linearpub.DynamicList; import model.linearpub.StructureIterator; //This class is NOT java.util.LinkedList public class LinkedList implements DynamicList { //--------------------------------- // Instance Variables //TODO - declare instance variable(s) //--------------------------------- // Private Constructor /** Constructs and returns new LinkedList (no args constructor) */ private LinkedList() { } //-------------------- List Statistics --------------------- /** * Return number of elements in this list. */ @Override public int size() { //TODO return 0; } /** * Return true is this list contains no elements. */ @Override public boolean isEmpty() { //TODO return false; } //------------------ Accessing Elements -------------------- /** * Return element at given index. * Throws IndexOutOfBoundsException if passed index is invalid. */ @Override public E get(int index) { //TODO return null; } /** * Return first element * Throws RuntimeException if list is empty */ @Override public E first() { //TODO return null; } /** * Return last element * Throws RuntimeException if list is empty */ @Override public E last() { //TODO return null; } /** * Return a new list containing the elements of this list * between the given index "start" (inclusive) and * the given index "stop" (exclusive). * Throws IndexOutOfBoundsException if either passed index is invalid. */ @Override public DynamicList subList(int start, int stop) { //TODO return null; } /** * Return index of first matching element (where searchFct outputs true) * Return -1 if no match * Example usage (first list of integers, then employees): * index = list.find(eaInteger -> eaInteger == 10); * index = employeeList.find(employee -> employee .getFirstName().equals("Kofi")); */ @Override public int findFirst(Function searchFct) { //TODO return 0; } /** * Return index of last matching element (where searchFct outputs true) * E.g., if searching for employee with name "Kofi" and there is a match * at index=3 and index=8, findLast will return 8 (the last matching index). * Hint: start search at end of list and work backwards through list. * Return -1 if no match */ @Override public int findLast(Function searchFct) { //TODO return 0; } //------------------- Setting Elem.

Please do parts labeled TODO LinkedList.java Replace.pdf

aioils

LabProgram.java import java.util.NoSuchElementException; public class LinkedList { private class Node { private T data; private Node next; private Node prev; public Node(T data) { this.data = data; this.next = null; this.prev = null; } } private int length; private Node first; private Node last; private Node iterator; /**** CONSTRUCTORS ****/ /** * Instantiates a new LinkedList with default values * @postcondition */ public LinkedList() { first = null; last = null; iterator = null; length = 0; } /** * Converts the given array into a LinkedList * @param array the array of values to insert into this LinkedList * @postcondition */ public LinkedList(T[] array) { } /** * Instantiates a new LinkedList by copying another List * @param original the LinkedList to copy * @postcondition a new List object, which is an identical, * but separate, copy of the LinkedList original */ public LinkedList(LinkedList original) { } /**** ACCESSORS ****/ /** * Returns the value stored in the first node * @precondition <> * @return the value stored at node first * @throws NoSuchElementException <> */ public T getFirst() throws NoSuchElementException { if (isEmpty()){ throw new NoSuchElementException("The list is empty"); } return first.data; } /** * Returns the value stored in the last node * @precondition <> * @return the value stored in the node last * @throws NoSuchElementException <> */ public T getLast() throws NoSuchElementException { if (isEmpty()){ throw new NoSuchElementException("The list is empty"); } return last.data; } /** * Returns the data stored in the iterator node * @precondition * @return the data stored in the iterator node * @throw NullPointerException */ public T getIterator() throws NullPointerException { return iterator.data; } /** * Returns the current length of the LinkedList * @return the length of the LinkedList from 0 to n */ public int getLength() { return length; } /** * Returns whether the LinkedList is currently empty * @return whether the LinkedList is empty */ public boolean isEmpty() { return length == 0; } /** * Returns whether the iterator is offEnd, i.e. null * @return whether the iterator is null */ public boolean offEnd() { return iterator == null; } /**** MUTATORS ****/ /** * Creates a new first element * @param data the data to insert at the front of the LinkedList * @postcondition <> */ public void addFirst(T data) { Node newNode = new Node(data); if(isEmpty()){ first = newNode; last = newNode; } else{ newNode.next = first; first.prev = newNode; first = newNode; } length++; } /** * Creates a new last element * @param data the data to insert at the end of the LinkedList * @postcondition <> */ public void addLast(T data) { Node newNode = new Node(data); if(isEmpty()){ first = newNode; last = newNode; } else{ last.next = newNode; newNode.prev = last; last = newNode; } length++; } /** * Inserts a new element after the iterator * @param data the data to insert * @precondition * @throws NullPointerException */ public void addIter.

LabProgram.javaimport java.util.NoSuchElementException;public .pdf

fantasiatheoutofthef

Hi,I have added the methods and main class as per your requirement.pdf

annaelctronics

Functional Programming

Olexandra Dmytrenko

For each task, submit your source java code file.(1) Objective Im.pdf

dhavalbl38

please read below it will tell you what we are using /** * LinkedList.java * * Replace all //TODO tags with your code * * Note that below the "//TODO" tag there may be * something like "return null;", "return 0;", etc. * That line is just "stubbed in" so the class * will compile. When you add your code (one or many * statements), you will want to delete the "stubbed" line. * By "stubbed in" we mean "mocked" or "faked in" temporarily. * * When testing, construct using the static factory methods: LinkedList.newEmpty() LinkedList.from(arrayElements) */ package model.list; import java.lang.reflect.Array; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; import model.linearpub.DynamicList; import model.linearpub.StructureIterator; //This class is NOT java.util.LinkedList public class LinkedList<E> implements DynamicList<E> { //--------------------------------- // Instance Variables //TODO - declare instance variable(s) //--------------------------------- // Private Constructor /** Constructs and returns new LinkedList (no args constructor) */ private LinkedList() { } //-------------------- List Statistics --------------------- /** * Return number of elements in this list. */ @Override public int size() { //TODO return 0; } /** * Return true is this list contains no elements. */ @Override public boolean isEmpty() { //TODO return false; } //------------------ Accessing Elements -------------------- /** * Return element at given index. * Throws IndexOutOfBoundsException if passed index is invalid. */ @Override public E get(int index) { //TODO return null; } /** * Return first element * Throws RuntimeException if list is empty */ @Override public E first() { //TODO return null; } /** * Return last element * Throws RuntimeException if list is empty */ @Override public E last() { //TODO return null; } /** * Return a new list containing the elements of this list * between the given index "start" (inclusive) and * the given index "stop" (exclusive). * Throws IndexOutOfBoundsException if either passed index is invalid. */ @Override public DynamicList<E> subList(int start, int stop) { //TODO return null; } /** * Return index of first matching element (where searchFct outputs true) * Return -1 if no match * Example usage (first list of integers, then employees): * index = list.find(eaInteger -> eaInteger == 10); * index = employeeList.find(employee -> employee .getFirstName().equals("Kofi")); */ @Override public int findFirst(Function<E, Boolean> searchFct) { //TODO return 0; } /** * Return index of last matching element (where searchFct outputs true) * E.g., if searching for employee with name "Kofi" and there is a match * at index=3 and index=8, findLast will return 8 (the last matching index). * Hint: start search at end of list and work backwards through list. * Return -1 if no match */ @Override public int findLast(Function<E, Boolean> searchFct.

please read below it will tell you what we are using L.pdf

ankit11134

File LinkedList.java Defines a doubly-l.pdf

Conint29

please read the steps below and it will tell you what we using /** * DynamicArray.java * * Replace all //TODO tags with your code * * Note that below the "//TODO" tag there may be * something like "return null;", "return 0;", etc. * That line is just "stubbed in" so the class * will compile. When you add your code (one or many * statements), you will want to delete the "stubbed" line. * By "stubbed in" we mean "mocked" or "faked in" temporarily. * * When testing, construct using the static factory methods: DynamicList.newEmpty() DynamicList.fromGrowthFactor(growthFactor) DynamicList.from(arrayElements) */ package model.list; import java.lang.reflect.Array; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; import model.linearpub.DynamicList; import model.linearpub.StructureIterator; public class DynamicArray<E> implements DynamicList<E> { //--------------------------------- // Instance Variables //TODO - declare instance variable(s) //--------------------------------- // Private Constructors /** Constructs and returns new DynamicArray (no args constructor) */ private DynamicArray() { this(defaultGrowthFactor()); } /** Constructs and returns new DynamicArray with "aGrowthFactor" */ private DynamicArray(double aGrowthFactor) { //TODO -- this is the constructor that should //initialize the dynamic array as needed } //------------------------------------------------ public static double defaultGrowthFactor() { //TODO - replace 0 with a good growth factor return 0; } protected static int defaultInitialCapacity() { //TODO - replace 0 with a good initial capacity return 0; } //-------------------- List Statistics --------------------- /** * Return number of elements in this list. */ @Override public int size() { //TODO return 0; } /** * Return true is this list contains no elements. */ @Override public boolean isEmpty() { //TODO return false; } //------------------ Accessing Elements -------------------- /** * Return element at given index. * Throws IndexOutOfBoundsException if passed index is invalid. */ @Override public E get(int index) { //TODO return null; } /** * Return first element * Throws RuntimeException if list is empty */ @Override public E first() { //TODO return null; } /** * Return last element * Throws RuntimeException if list is empty */ @Override public E last() { //TODO return null; } /** * Return a new list containing the elements of this list * between the given index "start" (inclusive) and * the given index "stop" (exclusive). * Throws IndexOutOfBoundsException if either passed index is invalid. */ @Override public DynamicList<E> subList(int start, int stop) { //TODO return null; } /** * Return index of first matching element (where searchFct outputs true) * Return -1 if no match * Example usage (first list of integers, then employees): * index = list.find(eaInteger -> eaInteger == 10); * index = employeeList.find(emplo.

please read the steps below and it will tell you what we usi.pdf

aggarwalopticalsco

Implementation The starter code includes List.java. You should not change anything in List.java. Your task will be to create LinkedList.java, make LinkedList use generics and inherit from List, and complete several methods in LinkedList.java. Create LinkedList.java in IntelliJ. Add a main method to LinkedList.java containing the following code. Your program will not compile again. public static void main(String[] args) { LinkedList list = new LinkedList(); System.out.println(list.getHead()); System.out.println(list.getTail()); list.add("first"); list.add("middle"); list.add("last"); System.out.println(list.getHead().value); System.out.println(list.getTail().value); System.out.println(list); } The first issue is that your LinkedList class does not have a way of specifying what type of data it should store. You can fix this using Java Generics. Change the first line of your class to the following: LinkedList . Confirm that the first line in your main method no longer has an error. On the line that declares the LinkedList class, add extends List before the bracket that begins the class. The first line in your class will now have a compile error because LinkedList does not implement the methods required by the List abstract class. Press Ctrl-i to have IntelliJ insert stubs of these methods. Ensure that Copy JavaDoc is selected so you get JavaDoc comments which describe the method requirements, then click OK. Your code should now compile again. Next add fields for the head and tail. These will be of type Node. Create a getHead method which returns your head field, and a getTail method which returns your tail field. Run your main method now and you will see that there is a NullPointerException because the add method does not actually add anything to the list, so head and tail will always be null. Complete the method boolean add(T value) for which IntelliJ gave you a stub. You need to create a new node with value to add at the end of the list. This means you will need to connect it to the old tail and update tail to point to the node you created. Make sure that you handle the case where the list is empty and both head and tail should be set to the new node you've created. Note: For the full Map I assignment, add will need to prevent duplicate values being added to the list and should return true or false based on whether the value was added or not. For this lab, you can ignore this requirement and simply return true. Add a toString method to your LinkedList class. It should start at the head of your list and proceed through all the nodes in a loop, combining the values of each node with a comma between each and square brackets containing the whole thing. When you run your main method, the final thing printed should be: [first, middle, last] List.java: /** * Specification for a List ADT. * @author Shubham Chatterjee * @version 03/07/2019 * @param Type */ public abstract class List { /** * Appends the specified value to the end of this list. * * @para.

Implementation The starter code includes List.java. You should not c.pdf

maheshkumar12354

import java.util.LinkedList; import java.util.Random; import java.util.Scanner; /** * author * */ public class LinkedListTest { /** * param args */ public static void main(String[] args) { int M, N, Lower, Upper; Scanner scanner = null; try { LinkedList list1 = new LinkedList(); LinkedList list2 = new LinkedList(); LinkedList list3 = new LinkedList(); Random random = new Random(); scanner = new Scanner(System.in); System.out.print(\"Enter the Lower and Upper bounds:\"); Lower = scanner.nextInt(); Upper = scanner.nextInt(); System.out.print(\"Enter the N value to Insert list1:\"); N = scanner.nextInt(); System.out.print(\"Enter the M value to Insert list2:\"); M = scanner.nextInt(); for (int i = 1; i <= N; i++) { list1.add(random.nextInt((Upper - Lower) + 1) + Lower); } for (int i = 1; i <= M; i++) { list2.add(random.nextInt((Upper - Lower) + 1) + Lower); } System.out.println(\"list1: \" + list1); System.out.println(\"list2: \" + list2); System.out.println(\"Minimum elelment in list1 :\" + getMin(list1)); System.out.println(\"Minimum elelment in list2 :\" + getMin(list2)); System.out .println(\"Count Divisibles by 3 and 5 elelment in list1 :\" + countDivisibles(list1)); System.out .println(\"Count Divisibles by 3 and 5 elelment in list2 :\" + countDivisibles(list2)); System.out.println(\"Common Elements From list1 and list2:\" + getCommonList(list1, list2)); } catch (Exception e) { // TODO: handle exception } } /** * param list * return */ public static int getMin(LinkedList list) { int min = list.get(0); for (Integer integer : list) { if (min > integer) { min = integer; } } return min; } /** * param list * return */ public static int countDivisibles(LinkedList list) { int count = 0; for (Integer integer : list) { if (integer % 3 == 0 && integer % 5 == 0) { count++; } } return count; } /** * param list1 * param list2 * return */ public static LinkedList getCommonList(LinkedList list1, LinkedList list2) { LinkedList list = new LinkedList(); LinkedList listCommon = new LinkedList(); list = (list1.size() > list2.size()) ? list1 : list2; for (int i = 0; i < list.size(); i++) { Integer number = list.get(i); if (list2.contains(number) && list1.contains(number)) { listCommon.add(number); } } return listCommon; } } OUTPUT: Enter the Lower and Upper bounds:1 10 Enter the N value to Insert list1:10 Enter the M value to Insert list2:20 list1: [1, 4, 4, 6, 9, 4, 9, 5, 8, 5] list2: [5, 10, 10, 2, 1, 10, 8, 8, 8, 2, 6, 10, 6, 2, 5, 9, 6, 9, 6, 2] Minimum elelment in list1 :1 Minimum elelment in list2 :1 Count Divisibles by 3 and 5 elelment in list1 :0 Count Divisibles by 3 and 5 elelment in list2 :0 Common Elements From list1 and list2:[5, 1, 8, 8, 8, 6, 6, 5, 9, 6, 9, 6] Solution import java.util.LinkedList; import java.util.Random; import java.util.Scanner; /** * author * */ public class LinkedListTest { /** * param args */ public static void main(String[] args) { int M, N, Lower, Upper; Scanner scanner = null; try { LinkedList list1 = new LinkedList(); L.

import java.util.LinkedList; import java.util.Random; import jav.pdf

aquastore223

Help in JAVA: This program should input numerator and denominator from a file, create a Fraction object (reducing the fraction if necessary) and then save the fraction to an ArrayList. This list will then be sorted, and output. Make one method to input, create, and add to the ArrayList. Another method call to sort. And the third method to output the contents of the (sorted) ArrayList. The input file will consist of an (unknown) quantity of ints representing numerator denominator pairs, which may be negative or zero. You will need to think about your constructor - you will find it easier if you follow these rules 1. If both numerator and denominator are negative make them both positive 2. if the numerator is positive but the denominator is negative switch both so that the numerator is negative and the denominator positive 3. any other case leave as is. what I have so far: public static class Fraction { private int numerator; private int denominator; public Fraction() { numerator = 0; denominator = 1; } public Fraction(int n, int d) { int g = gcd(n, d); numerator = n/g; denominator = d/g; } public int getNumerator() { return numerator; } public void setNumerator(int n) { int d = denominator; int g = gcd(n, d); numerator = n / g; denominator= d/g; } public int getDenominator() { return denominator; } public void setDenominator(int d) { int n = numerator; int g = gcd(n, d); denominator = d / g; numerator= n/g; } public Fraction add(Fraction g) { int a = this.numerator; int b = this.denominator; int c = g.numerator; int d = g.denominator; Fraction v = new Fraction(a * d + b * c, b * d); return v; } public Fraction subtract(Fraction g) { int a = this.numerator; int b = this.denominator; int c = g.numerator; int d = g.denominator; Fraction v = new Fraction(a * d - b * c, b * d); return v; } public Fraction multiply(Fraction g) { int a = this.numerator; int b = this.denominator; int c = g.numerator; int d = g.denominator; Fraction v = new Fraction(a * c, b * d); return v; } public Fraction divide(Fraction g) { int a = this.numerator; int b = this.denominator; int c = g.numerator; int d = g.denominator; Fraction v = new Fraction(a * d, b * c); return v; } public String toString() { return numerator + \"/\" + denominator; } private int gcd(int int1, int int2) { int i = 0; int smallest=0; if (int2>0){ if (int1 < int2) { smallest=int1; } else{ smallest= int2; } for (i = smallest; i > 0; i--) { if ((int1 % i == 0) && (int2 % i == 0)) { break; } } } return i; } public int input(){ File inFile = new File(\"h7.txt\"); Scanner fileInput = null; try { fileInput = new Scanner(inFile); } catch (FileNotFoundException ex) { } fileInput.nextInt(); } public int sort(int input){ Collections.sort(); } public int output(){ System.out.println(); } } public static void main(String[] args) { } } Solution Fraction class is used to represents fractions. It is always used to reduced to lowest terms.If fraction is negative then the numerator will always be negative and all op.

Help in JAVAThis program should input numerator and denominator f.pdf

manjan6

in c language To determine the maximum string length, we need to create a new callback function that utilizes an alternative user data structure. This callback function should adhere to the same format as demonstrated in the example. The data provided to our callback consists of: A node containing the node->data pointer, which will store our string. A userdata argument, represented as (void *), capable of holding any desired content. We possess complete control over the content at this pointer location, as it will be whatever value we have passed. Consequently, we can: Establish a structure to store any pertinent values we require. Transmit the address of this structure into the function. use this code and just add your code where it says TO DO #include #include #include #include #include "LLGeneric.h" /** define the maximum length of a line that we can read */ #defineLINE_BUFFER_SIZE1024 /** * We can use this as our "user data" to help us calculate the maximum * length string * * Add anything else to this structure that you wish */ struct maxData { size_t maxLenSoFar; char *maxStringSoFar; }; /** * our "user function" or "callback" for printing. * * We know what "void *userdata" is going to be because it is * simply what we pass in at the call below, so it is safe to * cast back to a FILE * as that is what we passed it. * * This is called a "callback" as it "call back into" our own * code from within a generic routine. */ int myFindLongestStringNode(GenericListNode *node, int index, void *userdata) { /** * Add more code here. You will need to: * - convert the GenericListNode payload in the field "data" to your * known (char *) type * - conver the (void *) userdata into your known (struct maxData *) * type * - use the fact that you can examine and store the values provided * through the userdata to see what has been calculated by earlier * calls to this function and update based on what you see here, * in order to determine what the longest string is in the whole * set of nodes. */ return 1; } int doListActivities(GenericListNode *list) { /** create an instance of our structure for use as the user data */ struct maxData maxDataWorkingStruct; int nProcessed = 0; /** initialize our structure -- if you added fields, set them up here */ maxDataWorkingStruct.maxLenSoFar = 0; maxDataWorkingStruct.maxStringSoFar = NULL; /** * TO DO: Iterate using the callback, which should calculate what * the longest string in the list is */ nProcessed = lstPerformIterativeAction( list, /* pointer to the first list node */ myFindLongestStringNode, /* pointer to our function */ (void *) &maxDataWorkingStruct); /** print out the result */ printf("The longest string has %ld characters\n", maxDataWorkingStruct.maxLenSoFar); printf("The longest string is: %s\n", maxDataWorkingStruct.maxStringSoFar); return nProcessed; } /** **Tools provided below here you won't need to edit -- they **simply process the command line, and load and free the **generic linked list and the st.

in c languageTo determine the maximum string length, we need to .pdf

stopgolook

StackInterface An interface for the ADT stack. Do not modif.pdf

ARCHANASTOREKOTA

C++ problem Part 1: Recursive Print (40 pts) Please write the recursive List reverse print function, whose iterative version we wrote in class. Below are the function signatures for the functions you are going to need: public: /**Additional Operations*/ void print_reverse(); //Wrapper function that calls the reverse helper function to print a list in reverse //prints nothing if the List is empty private: void reverse(Nodeptr node); //Helper function for the public printReverse() function. //Recursively prints the data in a List in reverse. Why do we need the private helper function here? Since we are going to be reversing our list node by node, in a recursive fashion, we want to pass a one node at a time to our reverse function. However, since our nodes are private, we cannot access them if we call the function inside of main. Add these function signatures to your List.h file along with your other function prototypes inside the class definition. Make sure that you place the reverse function inside the private portion of your List class definition and the print_reverse function prototype to the public portion of your List class definition. Now, implement these two functions inside of List.h, under your section for additional operations. Important: Test each function carefully inside of your ListTest.cpp to make sure that it is working properly. Part 2: Adding an Index to Your List Nodes (20 pts) Next, you will add the following functions to your List.h /**Accessor Functions*/ int get_index(); //Indicates the index of the Node where the iterator is currently pointing //Nodes are numbered from 1 to length of the list //Pre: length != 0 //Pre: !off_end() ... int List::get_index() { //Implement the function here } /**Manipulation Procedures*/ void scroll_to_index(int index); //Moves the iterator to the node whose index is specified by the user //Pre: length != 0 ... void scroll_to_index(int index) { //Implement function here } Part 3: Implementing Search as Part of Your List (40 pts) Now, we are going to add two search functions to our List so that we can search for elements in our List. The first of these functions is going to be a simple linear search function. You will need to add the following function prototype and function definition to your List.h: /**Additional Operations*/ int linear_search(listitem item); //Searchs the list, element by element, from the start of the List to the end of the List //Returns the index of the element, if it is found in the List //Returns -1 if the element is not in the List //Pre: length != 0 ... int List::linear_search(listitem item) { //Implement the function here } You are also going to add a function to perform recursive binary search on your List. You will need to add the following function prototype and function definition to your List.h: int binary_search(int low, int high, listitem item); //Recursively searchs the list by dividing the search space in half //Returns the index of the element, if it is fo.

C++ problemPart 1 Recursive Print (40 pts)Please write the recu.pdf

callawaycorb73779

Why following sort does not work? (It does not sort last 2 - 3 numbers) //Sort order class SortNumbListener implements ActionListener { @Override public void actionPerformed(ActionEvent e) { Collections.sort(list); for(int i = 0; i < list.size(); i++) { textfield2.setText(list.toString()); } System.out.print(list + \"\ \"); } } Solution import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.ArrayList; import java.util.Collections; import java.util.List; import javax.swing.JTextField; public class SorAction { public JTextField textfield2; public List list; public SorAction() { // TODO Auto-generated constructor stub textfield2 = new JTextField(); list = new ArrayList(); list.add(20); list.add(12); list.add(32); list.add(3); new SortNumbListener().actionPerformed(new ActionEvent(\"\", 0, null)); } public static void main(String[] args) { try { new SorAction(); } catch (Exception e) { // TODO: handle exception e.printStackTrace(); } } class SortNumbListener implements ActionListener { @Override public void actionPerformed(ActionEvent e) { Collections.sort(list); textfield2.setText(list.toString()); System.out.print(list + \"\ \"); } } } OUTPUT: [3, 12, 20, 32] NOTE: please check the above example, sorting fine, but what is the need of loop, if you want to add the text to textbox use setText() method of textfield.

Why following sort does not work (It does not sort last 2 - 3 numbe.pdf

gopalk44

Labprogram.javaLinkedList.javaimport java.util.NoSuchElementEx.pdf

freddysarabia1

Similar to Write a function which return a list of all of the n element subset .pdf (20)