When writing a member function of the HAMT class- the member function.pdf
•
0 likes•2 views
When writing a member function of the HAMT class, the member function can access resources directly (eg, self._item) and/or call other member functions to get work done, depending on preference and clarity. Beginning with the hamt_hw.py file, find all the member functions with undefined bodies (I've written pass in each). Finish writing these functions so that they work as described in their comments. Do not change any existing code in the file except the definitions of the previously undefined functions and the testing code at the bottom. When wrting the new functions, you may add helper methods or new parameters with default values if you wish. At the bottom of the supplied file is some indented code which is executed whenever you run the supplied file directly. This is a good place to do your testing. Write your test cases here so that I can see them. Leave all your testing code indented so that it only runs when __name__ == '__main__'. HERE IS hamt_hw.py # This implementation requires objects in the set be hashable. # Resulting trie will have expected log height if hash is random. # In this implementaiton the root node always has _item == None from functools import reduce class hamt: DEG = 4 # Children per node (can be set to any power of 2) BITS = 2 # Should be log2(DEG), bits needed to select child MASK = 0b11 # Should be BITS one-bits def __init__(self, item = None, children = None): self._item = item if children == None: self._children = [None] * hamt.DEG # List of DEG Nones else: self._children = children # returns copy of self node with child i set to node x def _updatechild(self, i, x): updatedchildlist = list(self._children) # copy self's child list updatedchildlist[i] = x # update child i return hamt(self._item, updatedchildlist) # build and return new node # Returns reference to new root if change made, else None def _add(self, item, hashbits): if self._item == item: # This node matches item. Return None to indicate no change. return None else: # Continue search using hashbits to pick direction child_num = hashbits & hamt.MASK if self._children[child_num] == None: # item not in trie. Add it as new leaf node. return self._updatechild(child_num, hamt(item)) else: # Ask appropriate child to add item, receive updated reference shiftedhashbits = hashbits >> hamt.BITS newchild = self._children[child_num]._add(item, shiftedhashbits) if newchild == None: return None else: return self._updatechild(child_num, newchild) def add(self, item): # Pass item and hashbits to private recursive helper return self._add(item, hash(item)) # Returns True if trie has no items, else False. Rutime O(1). def empty(self): pass # Returns True if item in trie, else False. Expected rutime O(log n). def contains(self, item): pass # Returns number of items in trie. Runtime O(n). def __len__(self): pass # Returns HAMT that is union of self and other. Expected rutime O(n log n). def union(self, other): pass # Adds self's item string to acc list, then ask each chil.
Report
Share
Report
Share
Download to read offline
![When writing a member function of the HAMT class, the member function can access resources
directly (eg, self._item) and/or call other member functions to get work done, depending on
preference and clarity.
Beginning with the hamt_hw.py file, find all the member functions with undefined bodies (I've
written pass in each). Finish writing these functions so that they work as described in their
comments. Do not change any existing code in the file except the definitions of the previously
undefined functions and the testing code at the bottom. When wrting the new functions, you may
add helper methods or new parameters with default values if you wish.
At the bottom of the supplied file is some indented code which is executed whenever you run the
supplied file directly. This is a good place to do your testing. Write your test cases here so that I
can see them. Leave all your testing code indented so that it only runs when __name__ ==
'__main__'.
HERE IS hamt_hw.py
# This implementation requires objects in the set be hashable.
# Resulting trie will have expected log height if hash is random.
# In this implementaiton the root node always has _item == None
from functools import reduce
class hamt:
DEG = 4 # Children per node (can be set to any power of 2)
BITS = 2 # Should be log2(DEG), bits needed to select child
MASK = 0b11 # Should be BITS one-bits
def __init__(self, item = None, children = None):
self._item = item
if children == None:
self._children = [None] * hamt.DEG # List of DEG Nones
else:
self._children = children
# returns copy of self node with child i set to node x](https://image.slidesharecdn.com/whenwritingamemberfunctionofthehamtclass-thememberfunction-230314132509-812f81fd/85/When-writing-a-member-function-of-the-HAMT-class-the-member-function-pdf-1-320.jpg)
![def _updatechild(self, i, x):
updatedchildlist = list(self._children) # copy self's child list
updatedchildlist[i] = x # update child i
return hamt(self._item, updatedchildlist) # build and return new node
# Returns reference to new root if change made, else None
def _add(self, item, hashbits):
if self._item == item:
# This node matches item. Return None to indicate no change.
return None
else:
# Continue search using hashbits to pick direction
child_num = hashbits & hamt.MASK
if self._children[child_num] == None:
# item not in trie. Add it as new leaf node.
return self._updatechild(child_num, hamt(item))
else:
# Ask appropriate child to add item, receive updated reference
shiftedhashbits = hashbits >> hamt.BITS
newchild = self._children[child_num]._add(item, shiftedhashbits)
if newchild == None:
return None
else:
return self._updatechild(child_num, newchild)](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
Please help me get this Mind - tap homework to validateProgramming.pdf
Please help me get this Mind - tap homework to validate
Programming Exercise 5.7
Complete the implementation of the link-based set defined in the new class named LinkedSet
that implements a set type using linked nodes.
Hint: Much of the code in the LinkedBag class from your solution of the linkedbag.py file in
Programming Exercise 5.5 can be reused.
In the linkedset.py file, complete the following:
Complete the accessor methods:
isEmpty(), returns true if len(self) == 0, or false otherwise.
__len__, returns the number of items in self.
__str__, returns the string representation of self.
__iter__, supports iteration over a view of self.
__add__, returns anew set containing the contents of self and other
clone, return a copy of self.
__eq__, returns true if self equals other, or false otherwise
count, return the numer of instance of item in self.
Complete the mutator methods:
clear, makes self become empty.
add, adds item to self and ignores the item if its already in the set.
Check array memory and increase it if necessary
remove, removes item from self if it's in self.
Check precondition and raise KeyError if necessary
Search for the node containing the target item, probe will point to the target node, and trailer will
point to the one before it, if it exists.
Unhook the node to be deleted, either the first one or one thereafter.
Decrement logical size
To test your program run the test method in the testset.py file.
Your program's output should look like the following:
Grading
Write your Python code in the code editor. Use the Run button to execute and run the code. To
review your progress, open up the "Tasks" panel on the left to view the curated list of tasks for
the project.
Once you are happy with the test results, click Submit and then the Confirm button to submit
your project for grading.
+++.Linkedbag.py+++
Reuse your solution from Programming Exercise 5.5 as your starter file
"""
from node import Node
from abstractbag import AbstractBag
class LinkedBag(AbstractBag):
def __init__(self,sourceCollection = None):
self._items = None
AbstractBag.__init__(self, sourceCollection)
def __iter__(self):
cursor = self._items
while not cursor is None:
yield cursor.data
cursor = cursor.next
def add(self, item):
self._items = Node(item, self._items)
self._size += 1
def append(self, item):
node = Node(item, None)
if self.isEmpty():
self._items = node
else:
cursor = self._items
while cursor.next != None:
cursor = cursor.next
cursor.next = node
self._size +=1
+++Linkedset.py+++
from node import Node
import copy
class LinkedSet(object):
"""A link-based set implementation."""
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
#add the items in the LinkedSet
self.head = None
self.temp = self.head
self.count = 0
for num in sourceCollection[::-1]:
#check if the first element is None
if self.head is None:
self.temp = Node(num)
self.head = self.temp
.
BackgroundIn many applications, the composition of a collection o.pdf
Background:
In many applications, the composition of a collection of data items changes over time. Not only
are new data items added and existing ones removed, but data items may be duplicated. A list
data structure is a member of the general category of abstract data types called containers, whose
purpose is to hold other objects. In C++, lists are provided in the Standard Template Library.
However, for this assignment you will design and write your own linked list implementation to
support the ADT operations specified below.
Objective:
Design and implement the specifications for a List Abstract Data Type where the items in the list
are unsorted.
Requirements:
Define a list and develop a set of operations for creating and manipulating a list that satisfies the
list ADT specification.
List ADT Specification
Structure: The list elements are of ItemType. The list has a property called the current position
which designates the position of the last element accessed by GetNextItem during an iteration
through the list. Only ResetList and GetNextItem alter the current position.
Definitions (provided by the user):
MAX_ITEMS: A constant specifying the maximum capacity of items allowed on the list
Item Type: Class encapsulating the type of items in the list
RelationType: An enumeration type that consists of LESS, GREATER, EQUAL
Member function of ItemType that must be included:
RelationType ComparedTo(ItemType Item)
Function: Determines the ordering of two ItemType objects based on their keys
Precondition: Self and item have their key members initialized
Postcondition:
Function value = LESS if the key of self is less than the key of item
= GREATER if the key of self is greater than the key of item
= EQUAL if the keys are equal
Operations (provided by Unsorted List ADT)
Make Empty
Function: Initializes list to empty state
Preconditions: None
Postcondition: List is empty
Boolean IsFull
Function: Determines whether list is full
Preconditions: List has been initialized
Postcondition: Function value = (list is full)
int GetLength
Function: Determines the number of elements in list
Preconditions: List has been initialized
Postcondition: Function value = number of elements in list
ItemType GetItem(Item Typeitem, Boolean& found)
Function: Get list element whose key matches item’s key (if present)
Preconditions: List has been initialized
Key member of item is initialized
Postcondition: If there is an element someItem whose keymatches item’s key, then found =
true and copy of someItemis returned; otherwise found = false and item is returned
List is unchanged
PutItem(ItemType item)
Function: Puts item into list
Preconditions: List has been initialized
List is not full
Item is not in list
Postcondition: Item is in the list
DeleteItem(ItemType item)
Function: Deletes the element whose key matches item’s key
Preconditions: List has been initialized
Postcondition: One and only one element in list has a key matching item’s key
ResetList
Function: Initializes current p.
Required to augment the authors Binary Search Tree (BST) code to .docx
The document provides instructions for augmenting a Binary Search Tree (BST) class to support new operations like returning the nth element, rank of an element, median element, and determining if the tree is perfect or complete. It explains that these operations could be done with in-order traversal but would be inefficient. Instead, each node should store the size of its subtree to guide searches more efficiently. The BST class code is provided to test the augmented operations on.
Program Specifications Develop an inventory management system for an e.docx
Program Specifications
Develop an inventory management system for an electronics store. The inventory system should have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not contain any virtual function and/or use of dynamic_cast mechanism or point deductions will apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>, restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product restocking is true somehow indicate it using "special effects" such as ***** or whatever effect you'd like.
Cost : take an integer as its only parameter representing the quantity (how many product to be sold) and return the total cost (price * quantity parameter).
class InventorySystem: (minimum implementation s.
Due November 22 2021 This assignment is worth 20 of your .pdf
Due: November 22, 2021 This assignment is worth 20% of your final grade. Late penalties - up to
1 week late - 10% - 10% per day there after to a maximum of 50% Assignment Completion In
order to for this assignment to be considered completed you must submit: - a completed analysis
of functions listed for (part A) - a successful run for part C (green check for part C in actions) Note:
Assignment completion is the minimum requirements for your assignment. It does not mean you
will receive full marks. Assignment Objectives: In this assignment, you will: - Complete an analysis
of multiple related functions for a class - Implement hash tables Restrictions As this assignment is
about implementing data structures, you are not allowed to make use of any python libraries or
use builtin python data structures and functions unless otherwise stated. Overview In this
assignment you will look at several implementations of a Table. There are three tasks:1. Analyze
the member functions of the class SortedTable (code for this is provided below). This table is
created using a sorted list. It is not necessarily implemented well. You will analyze the listed
functions. 2. Offer suggestions on how to make the SortedTable more efficient. After analyzing the
functions, look at how it is done and come up with some changes that will make the code more
efficient 3. Implement a Hash table - using chaining for collision resolution - using linear probing
for collision resolution Table functions overview We will explore 3 ways to implement a Table.
Each method will have a different internal structure but the functionality will be the same. A table
stores a set of key-value pairs which are also referred to as records The following specification
describes an overview of the general functionalities of the table but it does not specify any
specifics in terms of implementation. In otherwords, it describes what it can do but doesn't specify
any internal data strctures [ text { def _init_(self, capacity }=32 text { ) : } ] The initializer for the
table defaults the initial table capacity to 32. It creates a list with capacity elements all initialized to
None. def insert(self, key, value): This function adds a new key-value pair into the table. If a record
with matching key already exists in the table, the function does not add the new key-value pair and
returns False. Otherwise, function adds the new key-value pair into the table and returns True. If
adding a record will cause the table to be "too small" (defined in each class), the function will grow
to acommodate the new record. def modify(self, key, value): This function modifies an existing
key-value pair into the table. If no record with matching key exists in the table, the function does
nothing and returns False. Otherwise,function modifies the existing value into the one passed into
the function and returns True. def remove(self, key): This function removes the key-value pair with
the matching key. If no record with matchi.
Adding methods to the ListBag classIn the file ListBag.py, add the.pdf
Adding methods to the ListBag class
In the file ListBag.py, add the methods described below to the ListBag class, and then add code
to test these methods. You should not add any new instance variables (fields) to the class.
def isEmpty(self)
This method should return True if the ListBag is empty, and False otherwise.
def numOccur(self, item)
This method should return the number of times that the parameter item occurs in the called
ListBag. For example, if b1 represents the bag
{7, 5, 3, 5, 7, 2, 7}, then b1.numOccur(2) should return 1, b1.numOccur(7) should return 3, and
b1.numOccur(20) should return 0.
def addItems(self, other)
This method should attempt to add to the called ListBag all of the items found in the parameter
other. As a result, your method should use method calls to access the internals of that bag. See
our implementation of the containsAll() method for an example of this.
def equals(self, other)
This method should determine if the called ListBag is equal to the parameter other. Two bags are
equal if they contain the same items. The location of the items in the bags does not matter (e.g.,
{5, 6, 6, 7} is equal to {7, 6, 5, 6}), but bags that are equal must have the same number of
occurrences of each item (e.g., {5, 6, 6, 7} is not equal to {5, 6, 7}). The method should return
True if the two bags are equal, and False otherwise (including cases in which the parameter is
None). Your method should use method calls to access the internals of that bag. See our
implementation of the containsAll() method for an example of this. You are strongly encouraged
you to have yourequalsmethod take advantage of one of the other methods that you are
implementing for this problem.
def unionWith(self, other)
This method should create and return an ListBag containing one occurrence of any item that is
found in either the called object or the parameter other. For full credit, the resulting bag should
not include any duplicates. For example, if b1 represents the bag {2, 2, 3, 5, 7, 7, 7, 8} and b2
represents the bag {2, 3, 4, 5, 5, 6, 7}, then b1.unionWith(b2) should return an ListBag
representing the bag {2, 3, 4, 5, 6, 7, 8}. If there are no items in either bag, the method should
return an empty ListBag. As a result, your method should use method calls to access the internals
of that bag. See our implementation of the containsAll() method for an example of this.
---------------------------------------------------------------------------------------------------------------
# An implementation of a Bag Class using a list.
from random import randrange
class ListBag:
# Default, no-arg constructor - creates a new, empty ArrayBag with
# the default maximum size.
def __init__ (self):
self.items = None
self.numItems = 0
# add - adds the specified item to the Bag.
def add(self, item):
if item is None:
print(\"Added item is illegal\")
else:
if self.items is None:
self.items = []
self.items.append(item)
self.numItems += 1
else:
self.items.append(item)
self.nu.
File handling in pythan.pptx
File handling in Python allows programs to read from and write to files stored on the file system. There are different modes for opening files, such as read ("r"), write ("w"), and append ("a"). Common file operations include reading, writing, updating, deleting, and creating files. Files can be opened, read from and written to, then closed. Python supports various data types that can be read from or written to files, such as text, binary, images, and audio files. File handling is an important part of building applications that need to persist data.
written in c- please answer the 4 questions and write the functions ba.pdf
written in c, please answer the 4 questions and write the functions based on the given code.
Thank you
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switc.
Recommended
Please help me get this Mind - tap homework to validateProgramming.pdf
Please help me get this Mind - tap homework to validate
Programming Exercise 5.7
Complete the implementation of the link-based set defined in the new class named LinkedSet
that implements a set type using linked nodes.
Hint: Much of the code in the LinkedBag class from your solution of the linkedbag.py file in
Programming Exercise 5.5 can be reused.
In the linkedset.py file, complete the following:
Complete the accessor methods:
isEmpty(), returns true if len(self) == 0, or false otherwise.
__len__, returns the number of items in self.
__str__, returns the string representation of self.
__iter__, supports iteration over a view of self.
__add__, returns anew set containing the contents of self and other
clone, return a copy of self.
__eq__, returns true if self equals other, or false otherwise
count, return the numer of instance of item in self.
Complete the mutator methods:
clear, makes self become empty.
add, adds item to self and ignores the item if its already in the set.
Check array memory and increase it if necessary
remove, removes item from self if it's in self.
Check precondition and raise KeyError if necessary
Search for the node containing the target item, probe will point to the target node, and trailer will
point to the one before it, if it exists.
Unhook the node to be deleted, either the first one or one thereafter.
Decrement logical size
To test your program run the test method in the testset.py file.
Your program's output should look like the following:
Grading
Write your Python code in the code editor. Use the Run button to execute and run the code. To
review your progress, open up the "Tasks" panel on the left to view the curated list of tasks for
the project.
Once you are happy with the test results, click Submit and then the Confirm button to submit
your project for grading.
+++.Linkedbag.py+++
Reuse your solution from Programming Exercise 5.5 as your starter file
"""
from node import Node
from abstractbag import AbstractBag
class LinkedBag(AbstractBag):
def __init__(self,sourceCollection = None):
self._items = None
AbstractBag.__init__(self, sourceCollection)
def __iter__(self):
cursor = self._items
while not cursor is None:
yield cursor.data
cursor = cursor.next
def add(self, item):
self._items = Node(item, self._items)
self._size += 1
def append(self, item):
node = Node(item, None)
if self.isEmpty():
self._items = node
else:
cursor = self._items
while cursor.next != None:
cursor = cursor.next
cursor.next = node
self._size +=1
+++Linkedset.py+++
from node import Node
import copy
class LinkedSet(object):
"""A link-based set implementation."""
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
#add the items in the LinkedSet
self.head = None
self.temp = self.head
self.count = 0
for num in sourceCollection[::-1]:
#check if the first element is None
if self.head is None:
self.temp = Node(num)
self.head = self.temp
.
BackgroundIn many applications, the composition of a collection o.pdf
Background:
In many applications, the composition of a collection of data items changes over time. Not only
are new data items added and existing ones removed, but data items may be duplicated. A list
data structure is a member of the general category of abstract data types called containers, whose
purpose is to hold other objects. In C++, lists are provided in the Standard Template Library.
However, for this assignment you will design and write your own linked list implementation to
support the ADT operations specified below.
Objective:
Design and implement the specifications for a List Abstract Data Type where the items in the list
are unsorted.
Requirements:
Define a list and develop a set of operations for creating and manipulating a list that satisfies the
list ADT specification.
List ADT Specification
Structure: The list elements are of ItemType. The list has a property called the current position
which designates the position of the last element accessed by GetNextItem during an iteration
through the list. Only ResetList and GetNextItem alter the current position.
Definitions (provided by the user):
MAX_ITEMS: A constant specifying the maximum capacity of items allowed on the list
Item Type: Class encapsulating the type of items in the list
RelationType: An enumeration type that consists of LESS, GREATER, EQUAL
Member function of ItemType that must be included:
RelationType ComparedTo(ItemType Item)
Function: Determines the ordering of two ItemType objects based on their keys
Precondition: Self and item have their key members initialized
Postcondition:
Function value = LESS if the key of self is less than the key of item
= GREATER if the key of self is greater than the key of item
= EQUAL if the keys are equal
Operations (provided by Unsorted List ADT)
Make Empty
Function: Initializes list to empty state
Preconditions: None
Postcondition: List is empty
Boolean IsFull
Function: Determines whether list is full
Preconditions: List has been initialized
Postcondition: Function value = (list is full)
int GetLength
Function: Determines the number of elements in list
Preconditions: List has been initialized
Postcondition: Function value = number of elements in list
ItemType GetItem(Item Typeitem, Boolean& found)
Function: Get list element whose key matches item’s key (if present)
Preconditions: List has been initialized
Key member of item is initialized
Postcondition: If there is an element someItem whose keymatches item’s key, then found =
true and copy of someItemis returned; otherwise found = false and item is returned
List is unchanged
PutItem(ItemType item)
Function: Puts item into list
Preconditions: List has been initialized
List is not full
Item is not in list
Postcondition: Item is in the list
DeleteItem(ItemType item)
Function: Deletes the element whose key matches item’s key
Preconditions: List has been initialized
Postcondition: One and only one element in list has a key matching item’s key
ResetList
Function: Initializes current p.
Required to augment the authors Binary Search Tree (BST) code to .docx
The document provides instructions for augmenting a Binary Search Tree (BST) class to support new operations like returning the nth element, rank of an element, median element, and determining if the tree is perfect or complete. It explains that these operations could be done with in-order traversal but would be inefficient. Instead, each node should store the size of its subtree to guide searches more efficiently. The BST class code is provided to test the augmented operations on.
Program Specifications Develop an inventory management system for an e.docx
Program Specifications
Develop an inventory management system for an electronics store. The inventory system should have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not contain any virtual function and/or use of dynamic_cast mechanism or point deductions will apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>, restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product restocking is true somehow indicate it using "special effects" such as ***** or whatever effect you'd like.
Cost : take an integer as its only parameter representing the quantity (how many product to be sold) and return the total cost (price * quantity parameter).
class InventorySystem: (minimum implementation s.
Due November 22 2021 This assignment is worth 20 of your .pdf
Due: November 22, 2021 This assignment is worth 20% of your final grade. Late penalties - up to
1 week late - 10% - 10% per day there after to a maximum of 50% Assignment Completion In
order to for this assignment to be considered completed you must submit: - a completed analysis
of functions listed for (part A) - a successful run for part C (green check for part C in actions) Note:
Assignment completion is the minimum requirements for your assignment. It does not mean you
will receive full marks. Assignment Objectives: In this assignment, you will: - Complete an analysis
of multiple related functions for a class - Implement hash tables Restrictions As this assignment is
about implementing data structures, you are not allowed to make use of any python libraries or
use builtin python data structures and functions unless otherwise stated. Overview In this
assignment you will look at several implementations of a Table. There are three tasks:1. Analyze
the member functions of the class SortedTable (code for this is provided below). This table is
created using a sorted list. It is not necessarily implemented well. You will analyze the listed
functions. 2. Offer suggestions on how to make the SortedTable more efficient. After analyzing the
functions, look at how it is done and come up with some changes that will make the code more
efficient 3. Implement a Hash table - using chaining for collision resolution - using linear probing
for collision resolution Table functions overview We will explore 3 ways to implement a Table.
Each method will have a different internal structure but the functionality will be the same. A table
stores a set of key-value pairs which are also referred to as records The following specification
describes an overview of the general functionalities of the table but it does not specify any
specifics in terms of implementation. In otherwords, it describes what it can do but doesn't specify
any internal data strctures [ text { def _init_(self, capacity }=32 text { ) : } ] The initializer for the
table defaults the initial table capacity to 32. It creates a list with capacity elements all initialized to
None. def insert(self, key, value): This function adds a new key-value pair into the table. If a record
with matching key already exists in the table, the function does not add the new key-value pair and
returns False. Otherwise, function adds the new key-value pair into the table and returns True. If
adding a record will cause the table to be "too small" (defined in each class), the function will grow
to acommodate the new record. def modify(self, key, value): This function modifies an existing
key-value pair into the table. If no record with matching key exists in the table, the function does
nothing and returns False. Otherwise,function modifies the existing value into the one passed into
the function and returns True. def remove(self, key): This function removes the key-value pair with
the matching key. If no record with matchi.
Adding methods to the ListBag classIn the file ListBag.py, add the.pdf
Adding methods to the ListBag class
In the file ListBag.py, add the methods described below to the ListBag class, and then add code
to test these methods. You should not add any new instance variables (fields) to the class.
def isEmpty(self)
This method should return True if the ListBag is empty, and False otherwise.
def numOccur(self, item)
This method should return the number of times that the parameter item occurs in the called
ListBag. For example, if b1 represents the bag
{7, 5, 3, 5, 7, 2, 7}, then b1.numOccur(2) should return 1, b1.numOccur(7) should return 3, and
b1.numOccur(20) should return 0.
def addItems(self, other)
This method should attempt to add to the called ListBag all of the items found in the parameter
other. As a result, your method should use method calls to access the internals of that bag. See
our implementation of the containsAll() method for an example of this.
def equals(self, other)
This method should determine if the called ListBag is equal to the parameter other. Two bags are
equal if they contain the same items. The location of the items in the bags does not matter (e.g.,
{5, 6, 6, 7} is equal to {7, 6, 5, 6}), but bags that are equal must have the same number of
occurrences of each item (e.g., {5, 6, 6, 7} is not equal to {5, 6, 7}). The method should return
True if the two bags are equal, and False otherwise (including cases in which the parameter is
None). Your method should use method calls to access the internals of that bag. See our
implementation of the containsAll() method for an example of this. You are strongly encouraged
you to have yourequalsmethod take advantage of one of the other methods that you are
implementing for this problem.
def unionWith(self, other)
This method should create and return an ListBag containing one occurrence of any item that is
found in either the called object or the parameter other. For full credit, the resulting bag should
not include any duplicates. For example, if b1 represents the bag {2, 2, 3, 5, 7, 7, 7, 8} and b2
represents the bag {2, 3, 4, 5, 5, 6, 7}, then b1.unionWith(b2) should return an ListBag
representing the bag {2, 3, 4, 5, 6, 7, 8}. If there are no items in either bag, the method should
return an empty ListBag. As a result, your method should use method calls to access the internals
of that bag. See our implementation of the containsAll() method for an example of this.
---------------------------------------------------------------------------------------------------------------
# An implementation of a Bag Class using a list.
from random import randrange
class ListBag:
# Default, no-arg constructor - creates a new, empty ArrayBag with
# the default maximum size.
def __init__ (self):
self.items = None
self.numItems = 0
# add - adds the specified item to the Bag.
def add(self, item):
if item is None:
print(\"Added item is illegal\")
else:
if self.items is None:
self.items = []
self.items.append(item)
self.numItems += 1
else:
self.items.append(item)
self.nu.
File handling in pythan.pptx
File handling in Python allows programs to read from and write to files stored on the file system. There are different modes for opening files, such as read ("r"), write ("w"), and append ("a"). Common file operations include reading, writing, updating, deleting, and creating files. Files can be opened, read from and written to, then closed. Python supports various data types that can be read from or written to files, such as text, binary, images, and audio files. File handling is an important part of building applications that need to persist data.
written in c- please answer the 4 questions and write the functions ba.pdf
written in c, please answer the 4 questions and write the functions based on the given code.
Thank you
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switc.
Written in C- requires linked lists- Please answer the 4 questions and.pdf
Written in C, requires linked lists. Please answer the 4 questions and show the output. Thank
you!
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c.
Written in C- requires linked lists- Please answer the 4 questions and (1).pdf
Written in C, requires linked lists. Please answer the 4 questions and show the output. Thank
you!
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c.
I need help with this code working Create another project and add yo.pdf
I need help with this code working Create another project and add your jar file in this project. In
the main method of App class of this second project test your MyArrayList class. It is mandatory
to follow the instructions to get full credit. You need to perform the following actions. 1. Create
five strings, A1",,'B2",,'C3",'D4",'E5" 2. Save these Strings in your MyArrayList 3. Print a
message "Displaying List" 4. Display the list 5. Insert another String in your MyArrayList at
location 2 6. Print a message "Inserting Item" 7. Display the list 8. Remove String at location 0 9.
Print a message "Removing Item" 10. Display the list 11. Print a message "Setting a String" 12.
Set a new String in location 1 13. Display the list 14. Check whether "D4" is present in the list or
not, print an appropriate message 15. Find the index of "E5" in your list, print an appropriate
message 16. Print a message "Emptying List" 17. Empty the list 18. Print the size of the list
These steps check most of your MyArrayList functionality. I will also perform my own checks of
your code while grading. Deliverable: a. Copy the utils.jar file in your project folder. b. Make a
zip file of full project, not the src folder only or java files only. c. Submit the zip file. Grading
Rubric: The project is not submitted as required: 0 points
st.java J MyArrayList.java 2 J App.java 2 J MyFile.java 2 rc >J MyArrayList.java >q&
MyArrayList > get(int) public class MyArrayList implements MyList \{ Object [] obj = new
Object [1]; int size; public int size()\{ return size; \} public object get(int index) if (index <0
index >= size ){// throw new indexo return obj [index]; \} return index; // this should be deleted
after public void add (Object 0 ) \{ //if this test fails there is a space in the array. // it will pass
itself. if ( size == obj. length ){ Object [] obj2 = new 0 bject [obj. length 2]; for(int i=0;i<0bj.
length; i++){ obj2[i]=obj [i] ; \} obj=obj2; \} obj [ size ]=0; size++; \} public void add(int index,
Object o) \{ if(index > size || index <0 ) \{ throw new IndexOut0fBoundsException(index); \} if
(size == obj. length ){ Object [] obj2 = new Object [obj. length 2 ]; for(int i=0;i<0bj. length;
i++){ obj 2[i]=obj[i]; \} obj=obj2; \} if (index i=size;i>= index; i){ nhi [i=nhii1 : Ln 16, Col 56
Spaces: 4 UTF-8 LF \{\} Java
In this lab you will add an interface to the MyUtils project, and implement it in your
MyArrayList class in the MyUtils project. You will test the newly added functionality of your
MyArrayList class in another project. The UML for the Interface is as follows S Description of
methods Following method are self-explanatory: size(), get(int index), add (object o), remove
(int index), and isEmpty). Below is the description of all other methods. void add(int index,
Object o) inserts the given reference of object o at location index, making all entries move down
a spot. void remove (Object o) removes the first occurrence of object o in the list, moving all
entries .
-- Write the compiler used- Visual studio or gcc -- Reminder that your.pdf
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c)
{
case 'a':
// input item record from user
printf("\nEnter item name: ");
fgets(itemName_input, sizeof(itemName_input), s.
please follow all instructions and answer the inbedded questions- and.pdf
please follow all instructions and answer the inbedded questions, and written in C pls
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c)
{
case 'a'.
ex 2.pdf
The document discusses Python functions. Some key points covered include:
1) Functions allow you to organize and reuse code, take in parameters, and return values.
2) Functions are defined using the def keyword and called by name.
3) Parameters pass information into functions as arguments, while arguments are the specific values passed during a function call.
4) Functions can take an arbitrary number of positional and keyword arguments using *args and **kwargs.
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
python3 HashTable
Solution
main.py
from ChainingHashTable import ChainingHashTable
def TestHashTable():
h_table = ChainingHashTable(5)
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
h_table[10] = \"Mouse\"
h_table[5] = \"Rat\"
h_table[2] = \"Dog\"
h_table[1] = \"Cat\"
h_table[3] = \"Rhino\"
h_table[9] = \"Eagle\"
h_table[14] = \"Condor\"
h_table[4] = \"Hawk\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
print()
for i in range(10):
if i in h_table:
print(h_table[i],end = \" \")
print()
del h_table[5]
del h_table[2]
del h_table[9]
h_table[4] = \"Falcon\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
def main():
TestHashTable()
main()
ChainingHashTable.py
from OrderedList import OrderedList
from Node import Node
class ChainingHashTable:
def __init__(self, size):
self.__size = size
self.__count = 0
self.__slots = [OrderedList()] * self.__size
self.__deleted = \"\\0\"
def hash_function(self, key, size):
return key % size
def rehash(self, old_hash,size):
return (old_hash + 1) % size
def get_data(self):
return self.__count
def getitem(self, key):
start_slot = self.hash_function(key,len(self.__slots))
position = start_slot
while self.__slots[position] != None:
if self.__slots[position] == key:
return self.__data[position]
else:
position = self.rehash(position, len(self.__slots))
if position == start_slot:
return None
return None
def __getitem__(self, key):
return self.get(key)
def put(self, key, value):
hash_value = self.hash_function(key,len(self.__slots))
if self.__slots[hash_value] == None or \\
self.__slots[hash_value] == self.__deleted:
self.__slots[hash_value] = key
self.__data[hash_value] = data
elif self.__slots[hash_value] == key:
self.__data[hash_value] = data
else:
next_slot = self.rehash(hash_value, len(self.__slots))
while self.__slots[next_slot] != None\\
and self.__slots[next_slot] != self.__deleted \\
and self.__slots[next_slot] != key:
next_slot = self.rehash(next_slot,len(self.__slots))
if next_slot == hash_value:
return
if self.__slots[next_slot] == None or \\
self.__slots[next_slot] == self.__deleted:
self.__slots[next_slot] = key
self.__data[next_slot] = data
else:
self.__data[next_slot] = data
def __setitem__(self, key, value):
return self.put(key, value)
def delete(self, key):
start_slot = self.hash_function(key, len(self.__slots))
position = start_slot
key_in_slot = self.__slots[position]
while key_in_slot != None:
if key_in_slot == key:
self.__slots[position] = self.deleted
self.__data[position] = self.deleted
return None
else:
position = self.rehash(position, len(self.__slots))
key_in_slot = self.__slots[position]
if position == start_slot:
return None
def __delitem__(self, key):
return self.delete(key)
def __len__(self):
count = 0
for value in self.__slots:
if value != None and value != self.__deleted:
count += 1
return count
def __contains__(self, key):
return self.getitem(key) != None
def __str__(self):
count = 0
for x in self.__slots:
print.
UNIT- 2 PPDS R20.pptx
This document discusses functions in Python including defining functions, calling functions, passing arguments to functions, default arguments, returning values from functions, and exception handling. It provides examples of defining functions using the def keyword, calling functions, passing positional and keyword arguments to functions, setting default values for arguments, and returning values. It also discusses exceptions, try/except blocks, and user-defined exceptions.
レガシーコード改善ガイド
This document describes an InMemoryDirectory class that is used to store elements in memory and generate an index. The class initializes with an empty array to store elements. The add_element method adds a new element to the array and updates the index. The generate_index method was deprecated. The element_count and element methods return the size of the elements array and a specific element respectively. Unit tests are provided to test the functionality.
Functions2.pdf
The document discusses functions in Python. It defines a function as a block of code that performs a specific task and can be called when needed. Functions make code reusable, readable, and help divide programs into modular pieces. The document covers built-in functions, user-defined functions, passing arguments to functions, scope of variables, mutable and immutable objects, and functions available in Python libraries like math and string functions.
show code and all classes with full implementation for these Program S.pdf
show code and all classes with full implementation for these Program Specifications.
Example products ( camcorder, dvd player, blueray player, tv, camera, xbox 360, ps4, Wii,
laptops, iphone, battery, smart phones, computer desktop, printer, usb, mouse)
Develop an inventory management system for an electronics store. The inventory system should
have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically
store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object
info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not
contain any virtual function and/or use of dynamic_cast mechanism or point deductions will
apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member
initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as
a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke
the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must
explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>,
restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product
restocking is true somehow indicate it using "special effects" such as ***** or wh.
-- Reminder that your file name is incredibly important- Please do not.docx
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a list of game items
like you'd see in a folder.
// Each item has this information: item's name, game's name, type of item, item ID.
// The struct 'itemRecord' holds information of one item. Variety is an enum.
// An array of structs called 'list' is made to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use string library functions.
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable: 4996) // for Visual Studio
Only
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
};
struct itemRecord list[MAX_ITEMS]; // declare list of items
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already implmented
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation:
int add(char* itemName_input,
char* gameName_input,
char* variety_input,
unsigned int idNumber_input); // 10 points
void sort(); // 10 points
int delete(unsigned int idNumber_input); // 10 points
void load(char* fileName); // 10 points
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from
file (if it exists). Initially there will be no file.
char choice = 'i'; // initialized to a dummy
value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove an item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file
(overwrites file, if it exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int idNumber_input, add_result = 0;
char variety_input[20];
switch (c)
{
case 'a':
// input item record from user
printf("\nEnter item name: ").
In C pls -- Write your name here -- Write the compiler used- Visual st.docx
In C pls
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a list of game items
like you'd see in a folder.
// Each item has this information: item's name, game's name, type of item, item ID.
// The struct 'itemRecord' holds information of one item. Variety is an enum.
// An array of structs called 'list' is made to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use string library functions.
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable: 4996) // for Visual Studio
Only
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
};
struct itemRecord list[MAX_ITEMS]; // declare list of items
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already implmented
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation:
int add(char* itemName_input,
char* gameName_input,
char* variety_input,
unsigned int idNumber_input); // 10 points
void sort(); // 10 points
int delete(unsigned int idNumber_input); // 10 points
void load(char* fileName); // 10 points
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from
file (if it exists). Initially there will be no file.
char choice = 'i'; // initialized to a dummy
value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove an item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file
(overwrites file, if it exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int idNumber_input, add_result = 0;
char variety_input[20];
swi.
Please answer the 4 questions using C- The expected output is shown be.docx
Please answer the 4 questions using C. The expected output is shown below. Thank you!
---------------------------------------------------------------------------------------------------
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a list of game items
like you'd see in a folder.
// Each item has this information: item's name, game's name, type of item, item ID.
// The struct 'itemRecord' holds information of one item. Variety is an enum.
// An array of structs called 'list' is made to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use string library functions.
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable: 4996) // for Visual Studio
Only
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
};
struct itemRecord list[MAX_ITEMS]; // declare list of items
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already implmented
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation:
int add(char* itemName_input,
char* gameName_input,
char* variety_input,
unsigned int idNumber_input); // 10 points
void sort(); // 10 points
int delete(unsigned int idNumber_input); // 10 points
void load(char* fileName); // 10 points
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from
file (if it exists). Initially there will be no file.
char choice = 'i'; // initialized to a dummy
value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove an item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file
(overwrites file, if it exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
.
Do the following picSolutionHere is the solution for the .pdf
Do the following pic:
Solution
Here is the solution for the first 2 problems in the pic:
#include
using namespace std;
template
class Dec
{
public:
//hasDuplicate function that returns true if the private data member has an item that appears
twice or more in the list.
bool hasDuplicate();
//eraseAll function to remove all items which are equal to the item specified in the function
parameter.
void eraseAll(ElementType element);
//isLessThan function to determine if another Dec object is greater than the Dec object itself.
//If the summation of all items from the Dec object itself is less than the summation of all
//items from another Dec object, return true, otherwise, return false.
bool isLessThan(Dec other);
//push_second function to add an item after the first item if there are more than one items.
void push_second(ElementType element);
private:
vector dec;
};
template
bool Dec::hasDuplicate()
{
for(vector::iterator ot = dec.begin(); ot != dec.end(); ot++)
for(vector::iterator it = dec.begin() + ot + 1; it != dec.end(); it++)
if(*it == *ot)
return true;
return false;
}
template
bool Dec::isLessThan(Dec other)
{
int sum1 = 0, sum2 = 0;
for(vector::iterator it = dec.begin(); it != dec.end(); it++)
sum1 += *it;
for(vector::iterator it = other.dec.begin(); it != other.dec.end(); it++)
sum2 += *it;
return sum1 < sum2;
}.
Chapter 05.DS_StoreChapter 05arraybag.pyFile array.docx
Chapter 05/.DS_Store
Chapter 05/arraybag.py
"""
File: arraybag.py
Author: Ken Lambert
"""
from arrays import Array
class ArrayBag(object):
"""An array-based bag implementation."""
# Class variable
DEFAULT_CAPACITY = 10
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
self._items = Array(ArrayBag.DEFAULT_CAPACITY)
self._size = 0
if sourceCollection:
for item in sourceCollection:
self.add(item)
# Accessor methods
def isEmpty(self):
"""Returns True if len(self) == 0, or False otherwise."""
return len(self) == 0
def __len__(self):
"""Returns the number of items in self."""
return self._size
def __str__(self):
"""Returns the string representation of self."""
return "{" + ", ".join(map(str, self)) + "}"
def __iter__(self):
"""Supports iteration over a view of self."""
cursor = 0
while cursor < len(self):
yield self._items[cursor]
cursor += 1
def __add__(self, other):
"""Returns a new bag containing the contents
of self and other."""
result = ArrayBag(self)
for item in other:
result.add(item)
return result
def __eq__(self, other):
"""Returns True if self equals other,
or False otherwise."""
if self is other: return True
if type(self) != type(other) or \
len(self) != len(other):
return False
for item in self:
if not item in other:
return False
return True
# Mutator methods
def clear(self):
"""Makes self become empty."""
# Exercise
pass
def add(self, item):
"""Adds item to self."""
# Check array memory here and increase it if necessary
# Exercise
self._items[len(self)] = item
self._size += 1
def remove(self, item):
"""Precondition: item is in self.
Raises: KeyError if item in not in self.
Postcondition: item is removed from self."""
# Check precondition and raise if necessary
if not item in self:
raise KeyError(str(item) + " not in bag")
# Search for the index of the target item
targetIndex = 0
for targetItem in self:
if targetItem == item:
break
targetIndex += 1
# Shift items to the left of target up by one position
for i in range(targetIndex, len(self) - 1):
self._items[i] = self._items[i + 1]
# Decrement logical size
self._size -= 1
# Check array memory here and decrease it if necessary
# Exercise
Chapter 05/arrays.py
"""
File: arrays.py
An Array is a restricted list whose clients can use
o ...
Program Specifications in c++ Develop an inventory management system f.docx
Program Specifications in c++
Develop an inventory management system for an electronics store. The inventory system should have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not contain any virtual function and/or use of dynamic_cast mechanism or point deductions will apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>, restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product restocking is true somehow indicate it using "special effects" such as ***** or whatever effect you'd like.
Cost : take an integer as its only parameter representing the quantity (how many product to be sold) and return the total cost (price * quantity parameter).
class InventorySystem: (minimum implement.
Program Specifications in c++ Develop an inventory management syste.docx
Program Specifications in c++
Develop an inventory management system for an electronics store. The inventory system should have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not contain any virtual function and/or use of dynamic_cast mechanism or point deductions will apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>, restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product restocking is true somehow indicate it using "special effects" such as ***** or whatever effect you'd like.
Cost : take an integer as its only parameter representing the quantity (how many product to be sold) and return the total cost (price * quantity parameter).
class InventorySystem: (minimum implement.
Files that you must write and turn in Please do not turn in.pdf
Files that you must write and turn in (Please do not turn in other files!!):
sequence2.h: The header file for the new sequence class. Actually, you don't have to write much
of this file. If some of your member functions are implemented as inline functions, then you may
put those implementations in this file too. By the way, you might want to compare this header file
with your first sequence header file sequence1.h, the new version no longer has a CAPACITY
constant because the items are stored in a dynamic array that grows as needed. But there is a
DEFAULT_CAPACITY constant, which provides the initial size of the array for a sequence created
by the default constructor.
sequence2.cpp: The implementation file for the new sequence class. You will write all of this file,
which will have the implementations of all the sequence's member functions
sequence2.h
#ifndef MAIN_SAVITCH_SEQUENCE_H
#define MAIN_SAVITCH_SEQUENCE_H
#include <cstdlib> // Provides size_t
namespace main_savitch_4
{
class sequence
{
public:
// TYPEDEFS and MEMBER CONSTANTS
typedef double value_type;
typedef std::size_t size_type;
static const size_type DEFAULT_CAPACITY = 30;
// CONSTRUCTORS and DESTRUCTOR
sequence(size_type initial_capacity = DEFAULT_CAPACITY);
sequence(const sequence& source);
~sequence( );
// MODIFICATION MEMBER FUNCTIONS
void resize(size_type new_capacity);
void start( );
void advance( );
void insert(const value_type& entry);
void attach(const value_type& entry);
void remove_current( );
void operator =(const sequence& source);
// CONSTANT MEMBER FUNCTIONS
size_type size( ) const;
bool is_item( ) const;
value_type current( ) const;
void operator +=(const sequence& source);
void operator +(const sequence& source);
value_type operator[](size_type index) const;
private:
value_type* data;
size_type used;
size_type current_index;
size_type capacity;
};
}
#endif
sequence2.cpp
#include "sequence2.h"
#include <algorithm>
#include <cassert>
namespace main_savitch_4 {
// CONSTRUCTORS AND DESTRUCTOR
sequence::sequence(size_type initial_capacity) {
data = new value_type[initial_capacity];
capacity = initial_capacity;
used = 0;
current_index = 0;
}
sequence::sequence(const sequence& source) {
data = new value_type[source.capacity];
capacity = source.capacity;
used = source.used;
current_index = source.current_index;
std::copy(source.data, source.data + used, data);
}
sequence::~sequence() {
delete[] data;
}
// MODIFICATION MEMBER FUNCTIONS
void sequence::resize(size_type new_capacity) {
if (new_capacity == capacity)
return;
if (new_capacity < used)
new_capacity = used;
value_type* new_data = new value_type[new_capacity];
std::copy(data, data + used, new_data);
delete[] data;
data = new_data;
capacity = new_capacity;
}
void sequence::start() {
if (used > 0)
current_index = 0;
}
void sequence::advance() {
if (is_item())
++current_index;
}
void sequence::insert(const value_type& entry) {
if (size() == capacity)
resize(capacity * 2);
if (!is_item()) // No current item, so insert.
What sometimes makes implementation of activity-based costing difficul.pdf
What sometimes makes implementation of activity-based costing difficult in service industries is
a. that a larger proportion of overhead costs are company-wide costs. b. attempting to reduce or
eliminate non-value-added activities. c. the labelling of activities as value-added. d. identifying
activities, activity cost plus, and cost drivers..
What type of loss of genetic diversity occurred in the situation descr.pdf
What type of loss of genetic diversity occurred in the situation described below:
A weasel population is experiencing low reproductive success over 10-15 years. Dr. Trimble
tests this weasel population for genetic relatedness among microsatellite loci. He finds that
weasels with high relatedness also resulted in low reproductive success.
Group of answer choices
A. Bottleneck effect
B. Inbreeding depression
C. Random genetic drift
D. None of the above.
More Related Content
Similar to When writing a member function of the HAMT class- the member function.pdf
Written in C- requires linked lists- Please answer the 4 questions and.pdf
Written in C, requires linked lists. Please answer the 4 questions and show the output. Thank
you!
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c.
Written in C- requires linked lists- Please answer the 4 questions and (1).pdf
Written in C, requires linked lists. Please answer the 4 questions and show the output. Thank
you!
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c.
I need help with this code working Create another project and add yo.pdf
I need help with this code working Create another project and add your jar file in this project. In
the main method of App class of this second project test your MyArrayList class. It is mandatory
to follow the instructions to get full credit. You need to perform the following actions. 1. Create
five strings, A1",,'B2",,'C3",'D4",'E5" 2. Save these Strings in your MyArrayList 3. Print a
message "Displaying List" 4. Display the list 5. Insert another String in your MyArrayList at
location 2 6. Print a message "Inserting Item" 7. Display the list 8. Remove String at location 0 9.
Print a message "Removing Item" 10. Display the list 11. Print a message "Setting a String" 12.
Set a new String in location 1 13. Display the list 14. Check whether "D4" is present in the list or
not, print an appropriate message 15. Find the index of "E5" in your list, print an appropriate
message 16. Print a message "Emptying List" 17. Empty the list 18. Print the size of the list
These steps check most of your MyArrayList functionality. I will also perform my own checks of
your code while grading. Deliverable: a. Copy the utils.jar file in your project folder. b. Make a
zip file of full project, not the src folder only or java files only. c. Submit the zip file. Grading
Rubric: The project is not submitted as required: 0 points
st.java J MyArrayList.java 2 J App.java 2 J MyFile.java 2 rc >J MyArrayList.java >q&
MyArrayList > get(int) public class MyArrayList implements MyList \{ Object [] obj = new
Object [1]; int size; public int size()\{ return size; \} public object get(int index) if (index <0
index >= size ){// throw new indexo return obj [index]; \} return index; // this should be deleted
after public void add (Object 0 ) \{ //if this test fails there is a space in the array. // it will pass
itself. if ( size == obj. length ){ Object [] obj2 = new 0 bject [obj. length 2]; for(int i=0;i<0bj.
length; i++){ obj2[i]=obj [i] ; \} obj=obj2; \} obj [ size ]=0; size++; \} public void add(int index,
Object o) \{ if(index > size || index <0 ) \{ throw new IndexOut0fBoundsException(index); \} if
(size == obj. length ){ Object [] obj2 = new Object [obj. length 2 ]; for(int i=0;i<0bj. length;
i++){ obj 2[i]=obj[i]; \} obj=obj2; \} if (index i=size;i>= index; i){ nhi [i=nhii1 : Ln 16, Col 56
Spaces: 4 UTF-8 LF \{\} Java
In this lab you will add an interface to the MyUtils project, and implement it in your
MyArrayList class in the MyUtils project. You will test the newly added functionality of your
MyArrayList class in another project. The UML for the Interface is as follows S Description of
methods Following method are self-explanatory: size(), get(int index), add (object o), remove
(int index), and isEmpty). Below is the description of all other methods. void add(int index,
Object o) inserts the given reference of object o at location index, making all entries move down
a spot. void remove (Object o) removes the first occurrence of object o in the list, moving all
entries .
-- Write the compiler used- Visual studio or gcc -- Reminder that your.pdf
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c)
{
case 'a':
// input item record from user
printf("\nEnter item name: ");
fgets(itemName_input, sizeof(itemName_input), s.
please follow all instructions and answer the inbedded questions- and.pdf
please follow all instructions and answer the inbedded questions, and written in C pls
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a linked list of game
items like you'd see in a folder.
// Each item has this information: item name, game name, type of item, item ID.
// The struct 'itemRecord' holds the information of one item. Variety is an enum.
// A linked list of structs called 'list' is declared to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use all string library functions.
// You will have to write your functions from scratch by looking at what is
expected to be passed into them in the pre-existing functions
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
struct itemRecord* next; // pointer to next node
};
struct itemRecord* list = NULL; // declare linked list
'list'
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already pre-implemented last homework
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation: add, sort, delete, load
// Implement your own headers.
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from file (if it exists).
Initially there will be no file.
char choice = 'i'; // initialized to a dummy value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove a item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file (overwrites file if it
exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int itemId_input, add_result = 0;
char itemtype_input[20];
switch (c)
{
case 'a'.
ex 2.pdf
The document discusses Python functions. Some key points covered include:
1) Functions allow you to organize and reuse code, take in parameters, and return values.
2) Functions are defined using the def keyword and called by name.
3) Parameters pass information into functions as arguments, while arguments are the specific values passed during a function call.
4) Functions can take an arbitrary number of positional and keyword arguments using *args and **kwargs.
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
python3 HashTable
Solution
main.py
from ChainingHashTable import ChainingHashTable
def TestHashTable():
h_table = ChainingHashTable(5)
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
h_table[10] = \"Mouse\"
h_table[5] = \"Rat\"
h_table[2] = \"Dog\"
h_table[1] = \"Cat\"
h_table[3] = \"Rhino\"
h_table[9] = \"Eagle\"
h_table[14] = \"Condor\"
h_table[4] = \"Hawk\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
print()
for i in range(10):
if i in h_table:
print(h_table[i],end = \" \")
print()
del h_table[5]
del h_table[2]
del h_table[9]
h_table[4] = \"Falcon\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
def main():
TestHashTable()
main()
ChainingHashTable.py
from OrderedList import OrderedList
from Node import Node
class ChainingHashTable:
def __init__(self, size):
self.__size = size
self.__count = 0
self.__slots = [OrderedList()] * self.__size
self.__deleted = \"\\0\"
def hash_function(self, key, size):
return key % size
def rehash(self, old_hash,size):
return (old_hash + 1) % size
def get_data(self):
return self.__count
def getitem(self, key):
start_slot = self.hash_function(key,len(self.__slots))
position = start_slot
while self.__slots[position] != None:
if self.__slots[position] == key:
return self.__data[position]
else:
position = self.rehash(position, len(self.__slots))
if position == start_slot:
return None
return None
def __getitem__(self, key):
return self.get(key)
def put(self, key, value):
hash_value = self.hash_function(key,len(self.__slots))
if self.__slots[hash_value] == None or \\
self.__slots[hash_value] == self.__deleted:
self.__slots[hash_value] = key
self.__data[hash_value] = data
elif self.__slots[hash_value] == key:
self.__data[hash_value] = data
else:
next_slot = self.rehash(hash_value, len(self.__slots))
while self.__slots[next_slot] != None\\
and self.__slots[next_slot] != self.__deleted \\
and self.__slots[next_slot] != key:
next_slot = self.rehash(next_slot,len(self.__slots))
if next_slot == hash_value:
return
if self.__slots[next_slot] == None or \\
self.__slots[next_slot] == self.__deleted:
self.__slots[next_slot] = key
self.__data[next_slot] = data
else:
self.__data[next_slot] = data
def __setitem__(self, key, value):
return self.put(key, value)
def delete(self, key):
start_slot = self.hash_function(key, len(self.__slots))
position = start_slot
key_in_slot = self.__slots[position]
while key_in_slot != None:
if key_in_slot == key:
self.__slots[position] = self.deleted
self.__data[position] = self.deleted
return None
else:
position = self.rehash(position, len(self.__slots))
key_in_slot = self.__slots[position]
if position == start_slot:
return None
def __delitem__(self, key):
return self.delete(key)
def __len__(self):
count = 0
for value in self.__slots:
if value != None and value != self.__deleted:
count += 1
return count
def __contains__(self, key):
return self.getitem(key) != None
def __str__(self):
count = 0
for x in self.__slots:
print.
UNIT- 2 PPDS R20.pptx
This document discusses functions in Python including defining functions, calling functions, passing arguments to functions, default arguments, returning values from functions, and exception handling. It provides examples of defining functions using the def keyword, calling functions, passing positional and keyword arguments to functions, setting default values for arguments, and returning values. It also discusses exceptions, try/except blocks, and user-defined exceptions.
レガシーコード改善ガイド
This document describes an InMemoryDirectory class that is used to store elements in memory and generate an index. The class initializes with an empty array to store elements. The add_element method adds a new element to the array and updates the index. The generate_index method was deprecated. The element_count and element methods return the size of the elements array and a specific element respectively. Unit tests are provided to test the functionality.
Functions2.pdf
The document discusses functions in Python. It defines a function as a block of code that performs a specific task and can be called when needed. Functions make code reusable, readable, and help divide programs into modular pieces. The document covers built-in functions, user-defined functions, passing arguments to functions, scope of variables, mutable and immutable objects, and functions available in Python libraries like math and string functions.
show code and all classes with full implementation for these Program S.pdf
show code and all classes with full implementation for these Program Specifications.
Example products ( camcorder, dvd player, blueray player, tv, camera, xbox 360, ps4, Wii,
laptops, iphone, battery, smart phones, computer desktop, printer, usb, mouse)
Develop an inventory management system for an electronics store. The inventory system should
have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically
store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object
info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not
contain any virtual function and/or use of dynamic_cast mechanism or point deductions will
apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member
initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as
a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke
the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must
explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>,
restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product
restocking is true somehow indicate it using "special effects" such as ***** or wh.
-- Reminder that your file name is incredibly important- Please do not.docx
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a list of game items
like you'd see in a folder.
// Each item has this information: item's name, game's name, type of item, item ID.
// The struct 'itemRecord' holds information of one item. Variety is an enum.
// An array of structs called 'list' is made to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use string library functions.
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable: 4996) // for Visual Studio
Only
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
};
struct itemRecord list[MAX_ITEMS]; // declare list of items
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already implmented
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation:
int add(char* itemName_input,
char* gameName_input,
char* variety_input,
unsigned int idNumber_input); // 10 points
void sort(); // 10 points
int delete(unsigned int idNumber_input); // 10 points
void load(char* fileName); // 10 points
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from
file (if it exists). Initially there will be no file.
char choice = 'i'; // initialized to a dummy
value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove an item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file
(overwrites file, if it exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int idNumber_input, add_result = 0;
char variety_input[20];
switch (c)
{
case 'a':
// input item record from user
printf("\nEnter item name: ").
In C pls -- Write your name here -- Write the compiler used- Visual st.docx
In C pls
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a list of game items
like you'd see in a folder.
// Each item has this information: item's name, game's name, type of item, item ID.
// The struct 'itemRecord' holds information of one item. Variety is an enum.
// An array of structs called 'list' is made to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use string library functions.
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable: 4996) // for Visual Studio
Only
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
};
struct itemRecord list[MAX_ITEMS]; // declare list of items
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already implmented
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation:
int add(char* itemName_input,
char* gameName_input,
char* variety_input,
unsigned int idNumber_input); // 10 points
void sort(); // 10 points
int delete(unsigned int idNumber_input); // 10 points
void load(char* fileName); // 10 points
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from
file (if it exists). Initially there will be no file.
char choice = 'i'; // initialized to a dummy
value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove an item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file
(overwrites file, if it exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
void executeAction(char c)
{
char itemName_input[MAX_NAME_LENGTH], gameName_input[MAX_NAME_LENGTH];
unsigned int idNumber_input, add_result = 0;
char variety_input[20];
swi.
Please answer the 4 questions using C- The expected output is shown be.docx
Please answer the 4 questions using C. The expected output is shown below. Thank you!
---------------------------------------------------------------------------------------------------
// Write your name here
// Write the compiler used: Visual studio or gcc
// Reminder that your file name is incredibly important. Please do not change it.
// Reminder that we are compiling on Gradescope using GCC.
// READ BEFORE YOU START:
// You are given a partially completed program that creates a list of game items
like you'd see in a folder.
// Each item has this information: item's name, game's name, type of item, item ID.
// The struct 'itemRecord' holds information of one item. Variety is an enum.
// An array of structs called 'list' is made to hold the list of items.
// To begin, you should trace through the given code and understand how it works.
// Please read the instructions above each required function and follow the
directions carefully.
// You should not modify any of the given code, the return types, or the
parameters. Otherwise, you risk getting compilation errors.
// You are not allowed to modify main().
// You can use string library functions.
// WRITE COMMENTS FOR IMPORANT STEPS IN YOUR CODE.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma warning(disable: 4996) // for Visual Studio
Only
#define MAX_ITEMS 15
#define MAX_NAME_LENGTH 25
typedef enum { Health = 0, Equip, Etc } itemType; // enum type
struct itemRecord { // struct for item details
char itemName[MAX_NAME_LENGTH];
char gameName[MAX_NAME_LENGTH];
itemType variety;
unsigned int itemID;
};
struct itemRecord list[MAX_ITEMS]; // declare list of items
int count = 0; // the number of items
currently stored in the list (initialized to 0)
// functions already implmented
void flushStdIn();
void executeAction(char);
void save(char* fileName);
void display();
// functions that need implementation:
int add(char* itemName_input,
char* gameName_input,
char* variety_input,
unsigned int idNumber_input); // 10 points
void sort(); // 10 points
int delete(unsigned int idNumber_input); // 10 points
void load(char* fileName); // 10 points
int main()
{
char* fileName = "Item_List.txt";
load(fileName); // load list of items from
file (if it exists). Initially there will be no file.
char choice = 'i'; // initialized to a dummy
value
do
{
printf("\nEnter your selection:\n");
printf("\t a: add a new item\n");
printf("\t d: display item list\n");
printf("\t r: remove an item from list\n");
printf("\t s: sort item list by ID\n");
printf("\t q: quit\n");
choice = getchar();
flushStdIn();
executeAction(choice);
} while (choice != 'q');
save(fileName); // save list of items to file
(overwrites file, if it exists)
return 0;
}
// flush out leftover '\n' characters
void flushStdIn()
{
char c;
do c = getchar();
while (c != '\n' && c != EOF);
}
// ask for details from user for the given selection and perform that action
.
Do the following picSolutionHere is the solution for the .pdf
Do the following pic:
Solution
Here is the solution for the first 2 problems in the pic:
#include
using namespace std;
template
class Dec
{
public:
//hasDuplicate function that returns true if the private data member has an item that appears
twice or more in the list.
bool hasDuplicate();
//eraseAll function to remove all items which are equal to the item specified in the function
parameter.
void eraseAll(ElementType element);
//isLessThan function to determine if another Dec object is greater than the Dec object itself.
//If the summation of all items from the Dec object itself is less than the summation of all
//items from another Dec object, return true, otherwise, return false.
bool isLessThan(Dec other);
//push_second function to add an item after the first item if there are more than one items.
void push_second(ElementType element);
private:
vector dec;
};
template
bool Dec::hasDuplicate()
{
for(vector::iterator ot = dec.begin(); ot != dec.end(); ot++)
for(vector::iterator it = dec.begin() + ot + 1; it != dec.end(); it++)
if(*it == *ot)
return true;
return false;
}
template
bool Dec::isLessThan(Dec other)
{
int sum1 = 0, sum2 = 0;
for(vector::iterator it = dec.begin(); it != dec.end(); it++)
sum1 += *it;
for(vector::iterator it = other.dec.begin(); it != other.dec.end(); it++)
sum2 += *it;
return sum1 < sum2;
}.
Chapter 05.DS_StoreChapter 05arraybag.pyFile array.docx
Chapter 05/.DS_Store
Chapter 05/arraybag.py
"""
File: arraybag.py
Author: Ken Lambert
"""
from arrays import Array
class ArrayBag(object):
"""An array-based bag implementation."""
# Class variable
DEFAULT_CAPACITY = 10
# Constructor
def __init__(self, sourceCollection = None):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
self._items = Array(ArrayBag.DEFAULT_CAPACITY)
self._size = 0
if sourceCollection:
for item in sourceCollection:
self.add(item)
# Accessor methods
def isEmpty(self):
"""Returns True if len(self) == 0, or False otherwise."""
return len(self) == 0
def __len__(self):
"""Returns the number of items in self."""
return self._size
def __str__(self):
"""Returns the string representation of self."""
return "{" + ", ".join(map(str, self)) + "}"
def __iter__(self):
"""Supports iteration over a view of self."""
cursor = 0
while cursor < len(self):
yield self._items[cursor]
cursor += 1
def __add__(self, other):
"""Returns a new bag containing the contents
of self and other."""
result = ArrayBag(self)
for item in other:
result.add(item)
return result
def __eq__(self, other):
"""Returns True if self equals other,
or False otherwise."""
if self is other: return True
if type(self) != type(other) or \
len(self) != len(other):
return False
for item in self:
if not item in other:
return False
return True
# Mutator methods
def clear(self):
"""Makes self become empty."""
# Exercise
pass
def add(self, item):
"""Adds item to self."""
# Check array memory here and increase it if necessary
# Exercise
self._items[len(self)] = item
self._size += 1
def remove(self, item):
"""Precondition: item is in self.
Raises: KeyError if item in not in self.
Postcondition: item is removed from self."""
# Check precondition and raise if necessary
if not item in self:
raise KeyError(str(item) + " not in bag")
# Search for the index of the target item
targetIndex = 0
for targetItem in self:
if targetItem == item:
break
targetIndex += 1
# Shift items to the left of target up by one position
for i in range(targetIndex, len(self) - 1):
self._items[i] = self._items[i + 1]
# Decrement logical size
self._size -= 1
# Check array memory here and decrease it if necessary
# Exercise
Chapter 05/arrays.py
"""
File: arrays.py
An Array is a restricted list whose clients can use
o ...
Program Specifications in c++ Develop an inventory management system f.docx
Program Specifications in c++
Develop an inventory management system for an electronics store. The inventory system should have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not contain any virtual function and/or use of dynamic_cast mechanism or point deductions will apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>, restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product restocking is true somehow indicate it using "special effects" such as ***** or whatever effect you'd like.
Cost : take an integer as its only parameter representing the quantity (how many product to be sold) and return the total cost (price * quantity parameter).
class InventorySystem: (minimum implement.
Program Specifications in c++ Develop an inventory management syste.docx
Program Specifications in c++
Develop an inventory management system for an electronics store. The inventory system should have the following functionalities:
BuildInventory: read a text file containing electronics products information and dynamically store them in an array of pointers.
ShowInventory: display all inventory items.
UpdateInventory: ask for item id and quantity. If found display cost and update Product object info (reduce Product's quantity and potentially update restocking flag).
Terminate: save current inventory to a text file.
This programming assignment illustrates the following concepts:
Text file reading and writing.
Arrays of pointers and dynamic memory allocations with new and delete.
Inheritance.
C++ type casting: static_cast.
NOTE: This assignment is not about polymorphism or dynamic_cast! Your program should not contain any virtual function and/or use of dynamic_cast mechanism or point deductions will apply. You will have opportunity to use polymorphism in the next assignment.
Class Design
You need at least three classes.
class InventoryItem (minimum implementation specified below) - This is the base class.
Protected member data: item id (integer) and restocking (bool).
Public static data:
const integer (item id): initialize to 9999.
const bool (restocking): initialize to false.
Constructors
Default constructor: initialize item id and restocking using the default static data with member initializer syntax.
Non-default constructor: take 2 parameters.
Destructor: output "InventoryItem <item id> with <true/false> restocking destroyed ..."
Public member functions:
mutator/accessor for restocking, item id.
Display : to show InventoryItem item id and restocking (true/false). item id must be displayed as a 4-digit integer with leading 0s if < 1000.
class Product : derived from InventoryItem class (minimum implementation specified below).
Private member data: name (string), quantity (integer) and price (double).
Public static data:
const string (name): "No Product".
const int (quantity): 0
const double (price): 0.99
Constructors (use member initializer syntax)
Default constructor: set member data to static data's default values above. Must explicitly invoke the base class' default constructor.
Non-default constructor: take five parameters (id, restocking, name, quantity and price). Must explicitly invoke the base class' non-default constructor.
Destructor: output "Product: <item id>, Name<name>, quantity<quantity>, price <price>, restocking<true/false> destroyed ...".
Public member functions:
accessors/mutators for name, quantity, price.
Display: invoke Display from base class, then display its own data. NOTE: If the product restocking is true somehow indicate it using "special effects" such as ***** or whatever effect you'd like.
Cost : take an integer as its only parameter representing the quantity (how many product to be sold) and return the total cost (price * quantity parameter).
class InventorySystem: (minimum implement.
Files that you must write and turn in Please do not turn in.pdf
Files that you must write and turn in (Please do not turn in other files!!):
sequence2.h: The header file for the new sequence class. Actually, you don't have to write much
of this file. If some of your member functions are implemented as inline functions, then you may
put those implementations in this file too. By the way, you might want to compare this header file
with your first sequence header file sequence1.h, the new version no longer has a CAPACITY
constant because the items are stored in a dynamic array that grows as needed. But there is a
DEFAULT_CAPACITY constant, which provides the initial size of the array for a sequence created
by the default constructor.
sequence2.cpp: The implementation file for the new sequence class. You will write all of this file,
which will have the implementations of all the sequence's member functions
sequence2.h
#ifndef MAIN_SAVITCH_SEQUENCE_H
#define MAIN_SAVITCH_SEQUENCE_H
#include <cstdlib> // Provides size_t
namespace main_savitch_4
{
class sequence
{
public:
// TYPEDEFS and MEMBER CONSTANTS
typedef double value_type;
typedef std::size_t size_type;
static const size_type DEFAULT_CAPACITY = 30;
// CONSTRUCTORS and DESTRUCTOR
sequence(size_type initial_capacity = DEFAULT_CAPACITY);
sequence(const sequence& source);
~sequence( );
// MODIFICATION MEMBER FUNCTIONS
void resize(size_type new_capacity);
void start( );
void advance( );
void insert(const value_type& entry);
void attach(const value_type& entry);
void remove_current( );
void operator =(const sequence& source);
// CONSTANT MEMBER FUNCTIONS
size_type size( ) const;
bool is_item( ) const;
value_type current( ) const;
void operator +=(const sequence& source);
void operator +(const sequence& source);
value_type operator[](size_type index) const;
private:
value_type* data;
size_type used;
size_type current_index;
size_type capacity;
};
}
#endif
sequence2.cpp
#include "sequence2.h"
#include <algorithm>
#include <cassert>
namespace main_savitch_4 {
// CONSTRUCTORS AND DESTRUCTOR
sequence::sequence(size_type initial_capacity) {
data = new value_type[initial_capacity];
capacity = initial_capacity;
used = 0;
current_index = 0;
}
sequence::sequence(const sequence& source) {
data = new value_type[source.capacity];
capacity = source.capacity;
used = source.used;
current_index = source.current_index;
std::copy(source.data, source.data + used, data);
}
sequence::~sequence() {
delete[] data;
}
// MODIFICATION MEMBER FUNCTIONS
void sequence::resize(size_type new_capacity) {
if (new_capacity == capacity)
return;
if (new_capacity < used)
new_capacity = used;
value_type* new_data = new value_type[new_capacity];
std::copy(data, data + used, new_data);
delete[] data;
data = new_data;
capacity = new_capacity;
}
void sequence::start() {
if (used > 0)
current_index = 0;
}
void sequence::advance() {
if (is_item())
++current_index;
}
void sequence::insert(const value_type& entry) {
if (size() == capacity)
resize(capacity * 2);
if (!is_item()) // No current item, so insert.
Similar to When writing a member function of the HAMT class- the member function.pdf (20)
Written in C- requires linked lists- Please answer the 4 questions and.pdf
Written in C- requires linked lists- Please answer the 4 questions and.pdf
Written in C- requires linked lists- Please answer the 4 questions and (1).pdf
Written in C- requires linked lists- Please answer the 4 questions and (1).pdf
I need help with this code working Create another project and add yo.pdf
I need help with this code working Create another project and add yo.pdf
-- Write the compiler used- Visual studio or gcc -- Reminder that your.pdf
-- Write the compiler used- Visual studio or gcc -- Reminder that your.pdf
please follow all instructions and answer the inbedded questions- and.pdf
please follow all instructions and answer the inbedded questions- and.pdf
cbse class 12 Python Functions2 for class 12 .pptx
cbse class 12 Python Functions2 for class 12 .pptx
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
show code and all classes with full implementation for these Program S.pdf
show code and all classes with full implementation for these Program S.pdf
-- Reminder that your file name is incredibly important- Please do not.docx
-- Reminder that your file name is incredibly important- Please do not.docx
In C pls -- Write your name here -- Write the compiler used- Visual st.docx
In C pls -- Write your name here -- Write the compiler used- Visual st.docx
Please answer the 4 questions using C- The expected output is shown be.docx
Please answer the 4 questions using C- The expected output is shown be.docx
Do the following picSolutionHere is the solution for the .pdf
Do the following picSolutionHere is the solution for the .pdf
Chapter 05.DS_StoreChapter 05arraybag.pyFile array.docx
Chapter 05.DS_StoreChapter 05arraybag.pyFile array.docx
Program Specifications in c++ Develop an inventory management system f.docx
Program Specifications in c++ Develop an inventory management system f.docx
Program Specifications in c++ Develop an inventory management syste.docx
Program Specifications in c++ Develop an inventory management syste.docx
Files that you must write and turn in Please do not turn in.pdf
Files that you must write and turn in Please do not turn in.pdf
More from aadyaenterprisesnoid
What sometimes makes implementation of activity-based costing difficul.pdf
What sometimes makes implementation of activity-based costing difficult in service industries is
a. that a larger proportion of overhead costs are company-wide costs. b. attempting to reduce or
eliminate non-value-added activities. c. the labelling of activities as value-added. d. identifying
activities, activity cost plus, and cost drivers..
What type of loss of genetic diversity occurred in the situation descr.pdf
What type of loss of genetic diversity occurred in the situation described below:
A weasel population is experiencing low reproductive success over 10-15 years. Dr. Trimble
tests this weasel population for genetic relatedness among microsatellite loci. He finds that
weasels with high relatedness also resulted in low reproductive success.
Group of answer choices
A. Bottleneck effect
B. Inbreeding depression
C. Random genetic drift
D. None of the above.
What would you expect to see in regions of the DNA where housekeeping (1).pdf
What would you expect to see in regions of the DNA where housekeeping genes are located?
(Choose all that apply: pts deducted for including incorrect responses) Extensive methylation of
lysine residues on the histones Larger spacing between the nucleosomes Fewer CpG islands
within the genes and therefore less methylation Acetylation of the histones in the adjacent
nucleosomes.
What wioutal be the site af L - heneth neid- How many Biochs will this.pdf
What wioutal be the site af L = heneth neid? How many Biochs will this message be broken inte?
thow your work. How many padding bits will be present? Show your work..
What type of systems focus providing information to financial executiv.pdf
What type of systems focus providing information to financial executives in a timely manner?
Financial information systems Management information systems Transaction-processing systems
Marketing information systems Question 12 (3 points) Saved What is the use of multiple
authentication factors called? Physical security Intrusion detection system Multi-Factor
Authentication VPN.
what type of ownership will be dissolved if one person becomes insolve.pdf
what type of ownership will be dissolved if one person becomes insolvent A sole proprietor B
Partnership C Private company D Public company?
Employees stakeholder within A Macro B Micro C Global environment or D none?
Controlling includes A establishing positions and relationships B measuring work C Directing
others D forecasting?
Stakeholders include all of the below except A customer B competitor C employees D all of the
above?
Identify the two types of managerial thinking A coercive B visionary C theory X and Y D none?
Identify the term which the phrases refers resources are not wasted A efficiency B effectiveness
C a and b D neither a and b?
Partners have the following characters A free to make decision and change B the public is invited
to purchase partner insolv C can be dissolved as a result of an individual partner insolvent D it is
not influenced by the withdrawal of members?
Corparate social performace policy decisions can reflect differing viewpoints A reactive and
proactive B accommodative C defensive D all of the above?.
What was Jeffrey Skilling's opinion of Bethany McLean- a- That she was.pdf
What was Jeffrey Skilling's opinion of Bethany McLean? a. That she was a smart and skilled
reporter b. That she was unethical c. That she did not understand Enron or its business d. Both a
and c What was Intel's original proposal on the flawed chips? a. To replace them only for
computer users who had to do calculations b. None of the above c. To replace them without
questions d. To replace them only for a fee.
What structure is he pointing to here- The beige colored sheet that co.pdf
What structure is he pointing to here? The beige colored sheet that covers the inside surface of
the back of the eve. optic nerve retina. ootic disk cornea nastinesst What does it do? transduces
light into action potentials focuses light onto the back of the eye nourishes the retina reflects light
back at the retina to improve night vision.
What would seasons be like on Uranus at a location close to the north.pdf
What would seasons be like on Uranus at a location close to the north pole? This location would
experience constant darkness for over one quarter of the year and constant sunlight for over one
quarter of the year, with shorter periods when the Sun rises and sets between. Because Uranus
rotates on its side as it orbits, the northern hemisphere always faces the Sun and experiences
summer. The other hemisphere is always dark and experiences winter. The seasons would be the
same as seasons in Earth's polar regions, except the average temperature would be much cooler
due to Uranus' greater distance from the Sun. There are no seasons on Uranus because it orbits
too far from the Sun..
What types of management issues currently exist due to the Information.pdf
What types of management issues currently exist due to the Information Age? How can
learning about systematic and scientific management help managers navigate these current
management issues?
NOTE: We are between The Radium Girls and There is Nothing for You Here..
What type of muscle action is occurring from A to B assuming that the.pdf
What type of muscle action is occurring from A to B assuming that the appropriate muscles are
activated? None of the included answers is correct Concentric Eccentric Isokinetic Isometric.
What type of unconformity lies between units A and D in cross section.pdf
What type of unconformity lies between units A and D in cross section 1 ? Disconformity
Angular Unconformity Nonconformity What type of unconformity lies between units N and L in
cross section1? Disconformity Angular Unconformity Nonconformity Cross Section 1.
What was Lifard Co's cash flow from assets during 2022- Use Exhibit I-.pdf
What was Lifard Co's cash flow from assets during 2022? Use Exhibit I. Frhibit 1 (Use for
Problems 2.8, 2.9,2.10, 2.11,3.15, 3.16, 3.17) Lirard Co. Balaace Sheets as of December 31,2021
aad 2022 (S in millions) What was Lizard Co.'s change in net working capital for 20227 Use
Exhibitl. Exhibit I (Use for Problems 2.8 , 2.9 , 2.10 , 2.11 , 3.15 , 3.16 , 3.17 ) Liratd Co.
Balance Sheets as of December 31,2021 and 2022 (S in millions).
What use of the water should take precedent- Is the use of water to pr.pdf
What use of the water should take precedent? Is the use of water to produce energy more
important than other uses, such as to allow the migration of fish to their spawning grounds?
What are some other advantages and disadvantages of hydroelectric dams? Can you provide
specific examples of dams that have either solved or created problems?.
what type of histogram is this SEX-F Frequency.pdf
This histogram shows the frequency of responses for a variable called SEX, where the possible values are F (for Female). The histogram indicates that some number of observations in a dataset had a value of F for the SEX variable. In just one bar or bin, it shows the count or frequency of observations that fell into that category of F for the SEX variable.
What type of front is located between letters E and F -Multiple Choice.pdf
What type of front is located between letters E and F ? Multiple Choice cold front Warm front
oceluded front stationary front.
Where is the posterior (dorsal) root locited in the sequence of struct.pdf
Where is the posterior (dorsal) root locited in the sequence of structures through which
sensorylimpubes pass as they enter the spital cord and travel toward the brain? between the
spinal nerve and posterior (dorsal) root between the posterior (dorsal) root and posterioe gyy
hom between the posterior (dorsal)root and3hite column between the anterior (ventral) root and
posterior (dorsal) root ganglion.
What was Lizard Co-'s cash flow from assets during 2022- Use Exhibit I.pdf
What was Lizard Co.'s cash flow from assets during 2022? Use Exhibit I. Exhibit I (Use for
Problems 2.8, 2.9,2.10, 2.11, 3.15, 3.16,3.17) Lizard Co. Balance Sheets as of December 31,2021
and 2022 ( S in millions) What was the return on equity for Lizard Co. for 2022? Use Exhibit.
Exhibit I (Use for Problems 2.8, 2.9,2.10 Lizard Co. Balance Sheets as of December 31, 2021
and 2022 ( S in millions).
What was the relative concentration of Solution X (high- medium or low.pdf
The document asks what the relative concentration of Solution X was, whether it was high, medium, or low, and to explain the reasoning for the determination.
What type of relationship is implemented between the following two ent (1).pdf
What type of relationship is implemented between the following two entities: Student = ( SSN ,
name ) SportTeam = ( SportID, SportName, Description, ... ) For example, Sport team can be
Basketball team, Tennis team, ..., assuming a student can be in more than one sport teams. One-
to-many relationship One-to-one relationship Many-to-many relationship None of the above.
More from aadyaenterprisesnoid (20)
What sometimes makes implementation of activity-based costing difficul.pdf
What sometimes makes implementation of activity-based costing difficul.pdf
What type of loss of genetic diversity occurred in the situation descr.pdf
What type of loss of genetic diversity occurred in the situation descr.pdf
What would you expect to see in regions of the DNA where housekeeping (1).pdf
What would you expect to see in regions of the DNA where housekeeping (1).pdf
What wioutal be the site af L - heneth neid- How many Biochs will this.pdf
What wioutal be the site af L - heneth neid- How many Biochs will this.pdf
What type of systems focus providing information to financial executiv.pdf
What type of systems focus providing information to financial executiv.pdf
what type of ownership will be dissolved if one person becomes insolve.pdf
what type of ownership will be dissolved if one person becomes insolve.pdf
What was Jeffrey Skilling's opinion of Bethany McLean- a- That she was.pdf
What was Jeffrey Skilling's opinion of Bethany McLean- a- That she was.pdf
What structure is he pointing to here- The beige colored sheet that co.pdf
What structure is he pointing to here- The beige colored sheet that co.pdf
What would seasons be like on Uranus at a location close to the north.pdf
What would seasons be like on Uranus at a location close to the north.pdf
What types of management issues currently exist due to the Information.pdf
What types of management issues currently exist due to the Information.pdf
What type of muscle action is occurring from A to B assuming that the.pdf
What type of muscle action is occurring from A to B assuming that the.pdf
What type of unconformity lies between units A and D in cross section.pdf
What type of unconformity lies between units A and D in cross section.pdf
What was Lifard Co's cash flow from assets during 2022- Use Exhibit I-.pdf
What was Lifard Co's cash flow from assets during 2022- Use Exhibit I-.pdf
What use of the water should take precedent- Is the use of water to pr.pdf
What use of the water should take precedent- Is the use of water to pr.pdf
what type of histogram is this SEX-F Frequency.pdf
what type of histogram is this SEX-F Frequency.pdf
What type of front is located between letters E and F -Multiple Choice.pdf
What type of front is located between letters E and F -Multiple Choice.pdf
Where is the posterior (dorsal) root locited in the sequence of struct.pdf
Where is the posterior (dorsal) root locited in the sequence of struct.pdf
What was Lizard Co-'s cash flow from assets during 2022- Use Exhibit I.pdf
What was Lizard Co-'s cash flow from assets during 2022- Use Exhibit I.pdf
What was the relative concentration of Solution X (high- medium or low.pdf
What was the relative concentration of Solution X (high- medium or low.pdf
What type of relationship is implemented between the following two ent (1).pdf
What type of relationship is implemented between the following two ent (1).pdf
Recently uploaded
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
Advanced Java[Extra Concepts, Not Difficult].docx
This is part 2 of my Java Learning Journey. This contains Hashing, ArrayList, LinkedList, Date and Time Classes, Calendar Class and more.
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
Types of Herbal Cosmetics its standardization.
Physiology and chemistry of skin and pigmentation, hairs, scalp, lips and nail, Cleansing cream, Lotions, Face powders, Face packs, Lipsticks, Bath products, soaps and baby product,
Preparation and standardization of the following : Tonic, Bleaches, Dentifrices and Mouth washes & Tooth Pastes, Cosmetics for Nails.
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
Discover the Simplified Electron and Muon Model: A New Wave-Based Approach to Understanding Particles delves into a groundbreaking theory that presents electrons and muons as rotating soliton waves within oscillating spacetime. Geared towards students, researchers, and science buffs, this book breaks down complex ideas into simple explanations. It covers topics such as electron waves, temporal dynamics, and the implications of this model on particle physics. With clear illustrations and easy-to-follow explanations, readers will gain a new outlook on the universe's fundamental nature.
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS Template 2023-2024 by: Irene S. Rueco
How to Add Chatter in the odoo 17 ERP Module
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
How to Manage Your Lost Opportunities in Odoo 17 CRM
Odoo 17 CRM allows us to track why we lose sales opportunities with "Lost Reasons." This helps analyze our sales process and identify areas for improvement. Here's how to configure lost reasons in Odoo 17 CRM
clinical examination of hip joint (1).pdf
described clinical examination all orthopeadic conditions .
Recently uploaded (20)
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
Digital Artefact 1 - Tiny Home Environmental Design
Digital Artefact 1 - Tiny Home Environmental Design
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
Film vocab for eal 3 students: Australia the movie
Film vocab for eal 3 students: Australia the movie
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
Liberal Approach to the Study of Indian Politics.pdf
Liberal Approach to the Study of Indian Politics.pdf
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
How to Manage Your Lost Opportunities in Odoo 17 CRM
How to Manage Your Lost Opportunities in Odoo 17 CRM
When writing a member function of the HAMT class- the member function.pdf
- 1. When writing a member function of the HAMT class, the member function can access resources directly (eg, self._item) and/or call other member functions to get work done, depending on preference and clarity. Beginning with the hamt_hw.py file, find all the member functions with undefined bodies (I've written pass in each). Finish writing these functions so that they work as described in their comments. Do not change any existing code in the file except the definitions of the previously undefined functions and the testing code at the bottom. When wrting the new functions, you may add helper methods or new parameters with default values if you wish. At the bottom of the supplied file is some indented code which is executed whenever you run the supplied file directly. This is a good place to do your testing. Write your test cases here so that I can see them. Leave all your testing code indented so that it only runs when __name__ == '__main__'. HERE IS hamt_hw.py # This implementation requires objects in the set be hashable. # Resulting trie will have expected log height if hash is random. # In this implementaiton the root node always has _item == None from functools import reduce class hamt: DEG = 4 # Children per node (can be set to any power of 2) BITS = 2 # Should be log2(DEG), bits needed to select child MASK = 0b11 # Should be BITS one-bits def __init__(self, item = None, children = None): self._item = item if children == None: self._children = [None] * hamt.DEG # List of DEG Nones else: self._children = children # returns copy of self node with child i set to node x
- 2. def _updatechild(self, i, x): updatedchildlist = list(self._children) # copy self's child list updatedchildlist[i] = x # update child i return hamt(self._item, updatedchildlist) # build and return new node # Returns reference to new root if change made, else None def _add(self, item, hashbits): if self._item == item: # This node matches item. Return None to indicate no change. return None else: # Continue search using hashbits to pick direction child_num = hashbits & hamt.MASK if self._children[child_num] == None: # item not in trie. Add it as new leaf node. return self._updatechild(child_num, hamt(item)) else: # Ask appropriate child to add item, receive updated reference shiftedhashbits = hashbits >> hamt.BITS newchild = self._children[child_num]._add(item, shiftedhashbits) if newchild == None: return None else: return self._updatechild(child_num, newchild)
- 3. def add(self, item): # Pass item and hashbits to private recursive helper return self._add(item, hash(item)) # Returns True if trie has no items, else False. Rutime O(1). def empty(self): pass # Returns True if item in trie, else False. Expected rutime O(log n). def contains(self, item): pass # Returns number of items in trie. Runtime O(n). def __len__(self): pass # Returns HAMT that is union of self and other. Expected rutime O(n log n). def union(self, other): pass # Adds self's item string to acc list, then ask each child to do the same def _str(self, acc): if self._item != None: # Don't do anything in fake root node acc.append(str(self._item)) for child in self._children: if child != None: child._str(acc) # Build list of all items in trie, then join them with ", " in between
- 4. def __str__(self): acc = [] self._str(acc) return "{" + ", ".join(acc) + "}" # The following is a trick to make this testing code be ignored # when this file is being imported, but run when run directly # https://codefather.tech/blog/if-name-main-python/ if __name__ == '__main__': a = hamt() b = a.add("B") c = b.add("C") d = c.add("D") e = d.add("E") f = e.add("F") g = f.add("F") print(a) print(b) print(c) print(d) print(e) print(f)