#include node1.h #include list.h #include cassert P.pdf
•
0 likes•2 views
#include \"node1.h\" #include \"list.h\" #include // Provides assert #include using namespace std; value_type head(list lst) { list p; p=list_locate(lst,1); return p->data(); } list tail(list lst) { node *head=NULL; node *tail=NULL; list_copy(lst, head, tail); list_head_remove(head); return head; } bool list_is_empty(list lst) { size_t n= list_length(lst); if(n==0) return true; else return false; } list cons(value_type val, const list lst) { node *head=NULL; node *tail=NULL; list_copy(lst, head, tail); list_head_insert(head, val); return head; } Solution #include \"node1.h\" #include \"list.h\" #include // Provides assert #include using namespace std; value_type head(list lst) { list p; p=list_locate(lst,1); return p->data(); } list tail(list lst) { node *head=NULL; node *tail=NULL; list_copy(lst, head, tail); list_head_remove(head); return head; } bool list_is_empty(list lst) { size_t n= list_length(lst); if(n==0) return true; else return false; } list cons(value_type val, const list lst) { node *head=NULL; node *tail=NULL; list_copy(lst, head, tail); list_head_insert(head, val); return head; }.
Report
Share
Report
Share
Download to read offline
Recommended
in C++ , Design a linked list class named IntegerList to hold a seri.pdf
in C++ , Design a linked list class named IntegerList to hold a series of integers. The class must
have public member functions for appending , inserting, deleting and displaying nodes. The
append function must append a node to the end of the list. The insert function must insert node in
ascending order. The delete function must delete the node with the given value. The display
function should display the list from head to tail. The IntegerList class should also have a
destructor that destroys the list and release memory. The list node must be declared as a structure
using keyword struct. This structure is a private member of IntegerList. You should also store the
head of the list as a private member.
Write a test program to test the implementation your IntegerList class works properly.
Solution
Here is the code for the above scenario:
#include
using namespace std;
struct ListNode
{
float value;
ListNode *next;
};
ListNode *head;
class LinkedList
{
public:
int insertNode(float num);
int appendNode(float num);
void deleteNode(float num);
void destroyList();
void displayList();
LinkedList(void) {head = NULL;}
~LinkedList(void) {destroyList();}
};
int LinkedList::appendNode(float num)
{
ListNode *newNode, *nodePtr = head;
newNode = new ListNode;
if(newNode == NULL)
{
cout << \"Error allocating memory for new list member!\ \";
return 1;
}
newNode->value = num;
newNode->next = NULL;
if(head == NULL)
{
cout << \"List was empty - \" << newNode->value;
cout << \" is part of list\'s first node.\ \";
head = newNode;
}
else
{
while(nodePtr->next != NULL)
nodePtr = nodePtr->next;
nodePtr->next = newNode;
}
return 0;
}
int LinkedList::insertNode(float num)
{
struct ListNode *newNode, *nodePtr = head, *prevNodePtr = NULL;
newNode = new ListNode;
if(newNode == NULL)
{
cout << \"Error allocating memory for new list member!\ \";
return 1;
}
newNode->value = num;
newNode->next = NULL;
if(head==NULL) {
cout << \"List was empty - \" << newNode->value;
cout << \" is part of list\'s first node.\ \";
head = newNode;
}
else
{
while((nodePtr != NULL) && (nodePtr->value < num)) {
prevNodePtr = nodePtr;
nodePtr = nodePtr->next;
}
if(prevNodePtr==NULL)
newNode->next = head;
else
newNode->next = nodePtr; prevNodePtr->next = newNode;
}
return 0;
}
void LinkedList::deleteNode(float num)
{
struct ListNode *nodePtr = head, *prevNodePtr = NULL;
if(head==NULL) {
cout << \"The list was empty!\ \";
return;
}
if(head->value == num) {
head = nodePtr->next;
delete [] nodePtr;
}
else
{
while((nodePtr!= NULL)&&(nodePtr->value != num)) {
prevNodePtr = nodePtr;
nodePtr = nodePtr->next;
}
if(nodePtr==NULL)
cout << \"The value \" << num << \" is not in this list!\ \";
else {
prevNodePtr->next = nodePtr->next;
delete [] nodePtr;
}
}
}
void LinkedList::destroyList()
{
struct ListNode *nodePtr = head, *nextNode = nodePtr;
if(head==NULL) {
cout << \"The list is empty!\ \";
return;
}
while (nodePtr != NULL) {
nextNode = nodePtr->next;
delete [] nodePtr;
nodePtr = nextNode;
}
}
void LinkedList.
#include sstream #include linkylist.h #include iostream.pdf
#include
#include \"linkylist.h\"
#include
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
//node* head = new node;
LinkedList list(1);
ifstream infile1 (argv[1]);
//make sure the file opens properly and read the contents of the file in to a list
if(!infile1)
{
cout<<\"Your Testfile could not be opened!\"<>users;
if (users.find(\"I\")!=string::npos)
{
//int spot = atoi((users[3]).c_str());
string pot = string(users.substr(2));
stringstream spot(pot);
string data;
cin>>data;
insertAfter(list.getNode(spot),data);
}
/*else if (users.find(\"D\")!=string::npos)
{
int spoty = atoi((users[3]).c_str());
deleteNode(spoty);
}*/
else if (users==\"L\")
{
list.traverse_and_print();
}
}
return 0;
#include
using namespace std;
class Node
{
friend class LinkedList;
private:
int value; /* data, can be any data type, but use integer for easiness */
Node *Next; /* pointer to the next node */
public:
/* Constructors with No Arguments */
Node(void)
: Next(NULL)
{ }
/* Constructors with a given value */
Node(int val)
: value(val), Next(NULL)
{ }
/* Constructors with a given value and a link of the next node */
Node(int val, Node* next)
: value(val), Next(next)
{}
/* Getters */
int getValue(void)
{ return value; }
Node* getNext(void)
{ return Next; }
};
/* definition of the linked list class */
class LinkedList
{
private:
/* pointer of head node */
Node *Head;
/* pointer of tail node */
Node *Tail;
public:
/* Constructors with a given value of a list node */
LinkedList(int val);
/* Destructor */
~LinkedList(void);
/* Function to append a node to the end of a linked list */
void tailAppend(string val);
/* Remove a node with a specific value if it exists */
void remove(int val);
void insertAfter(Node* afterMe, string val);
Node* getNode(int pos);
/* Traversing the list and printing the value of each node */
void traverse_and_print();
};
#include
#include \"linkylist.h\"
#include
using namespace std;
LinkedList::LinkedList(int val)
{
/* Create a new node, acting as both the head and tail node */
Head = new Node(val);
Tail = Head;
}
Node* LinkedList::getNode(int pos)
{
Node* p = Head;
/* Counter */
while (pos--) {
if (p != NULL)
p = p->Next;
else
return NULL;
}
return p;
}
void LinkedList::insertAfter(Node* afterMe, string val)
{
if(afterme != NULL)
{
afterMe->Next = new Node(val, afterMe->Next);
}
}
LinkedList::~LinkedList()
{
}
void LinkedList::tailAppend(string val)
{
/* The list is empty? */
if (Head == NULL) {
/* the same to create a new list with a given value */
Tail = Head = new Node(val);
}
else
{
/* Append the new node to the tail */
Tail->Next = new Node(val);
/* Update the tail pointer */
Tail = Tail->Next;
}
}
void LinkedList::remove(int val)
{
Node *pPre = NULL, *pDel = NULL;
/* Check whether it is the head node?
if it is, delete and update the head node */
if (Head->value == val) {
/* point to the node to be deleted */
pDel = Head;
/* update */
Head = pDel->Next;
delete pDel;
return;
}
pPre = Head;
pDel = Head->Next;
/*.
Add delete at a position to the code and display it to the code- class.pdf
Add delete at a position to the code and display it to the code:
class listnodes {
int data;
listnodes link;
listnodes() {
data = 0;
link = null;
}
listnodes(int d, listnodes l) {
data = d;
link = l;
}
}
class singlelinkedlist {
public listnodes insertnode(int data, listnodes head) {
listnodes newnode = new listnodes(data, null);
newnode.link = head;
head = newnode;
return head;
}
public listnodes insertAtPosition(listnodes head, int data, int position) {
listnodes newnode = new listnodes(data, null);
listnodes previous = head;
int count = 1;
while (count <= position - 1) {
previous = previous.link;
count++;
}
listnodes current = previous.link;
newnode.link = current;
previous.link = newnode;
return head;
}
public listnodes deletefirst(listnodes head) {
listnodes pre = head;
head = head.link;
pre.link = null;
return pre;
}
public void display(listnodes head) {
listnodes current = head;
while (current.link != null) {
System.out.print(current.data + "-->");
current = current.link;
}
System.out.print(current.data);
}
}
public class LinkedList {
public static void main(String[] args) {
listnodes head=new listnodes(10,null);
singlelinkedlist sl=new singlelinkedlist();
sl.display(head);
System.out.println("\nInsert at front");
listnodes newhead=sl.insertnode(20, head);
sl.display(newhead);
System.out.println("\nInsert at a position");
sl.insertAtPosition(newhead, 40, 1);
sl.display(newhead);
System.out.println("\nDelete first");
listnodes newhead2=sl.deletefirst(newhead);
sl.display(newhead2);
}
}
.
Here is the code.compile g++ Playlist.cpp main.cppPlaylist.h.pdf
Here is the code.
compile : g++ Playlist.cpp main.cpp
Playlist.h
#ifndef PLAYLIST_H
#define PLAYLIST_H
#include
using namespace std;
class PlaylistNode
{
private:
string uniqueID;
string songName;
string artistName;
int songLength;
PlaylistNode* nextNodePtr;
public:
PlaylistNode();
PlaylistNode(string id, string song, string artist, int len);
PlaylistNode* InsertAfter(string id, string song, string artist, int len);
void SetNext(PlaylistNode *next);
string GetID();
string GetSongName();
string GetArtistName();
int GetSongLength();
PlaylistNode* GetNext();
void PrintPlaylistNode();
};
#endif
Playlist.cpp
#include \"Playlist.h\"
#include
using namespace std;
PlaylistNode::PlaylistNode()
{
uniqueID = \"none\";
songName = \"none\";
artistName = \"none\";
songLength = 0;
nextNodePtr = 0;
}
PlaylistNode::PlaylistNode(string id, string song, string artist,int len)
{
uniqueID = id;
songName = song;
artistName = artist;
songLength = len;
nextNodePtr = 0;
}
PlaylistNode* PlaylistNode::InsertAfter(string id, string song, string artist,int len)
{
nextNodePtr=new PlaylistNode(id,song,artist,len);
return nextNodePtr;
}
void PlaylistNode::SetNext(PlaylistNode *next)
{
nextNodePtr = next;
}
string PlaylistNode::GetID()
{
return uniqueID;
}
string PlaylistNode::GetSongName()
{
return songName;
}
string PlaylistNode::GetArtistName()
{
return artistName;
}
int PlaylistNode::GetSongLength()
{
return songLength;
}
PlaylistNode* PlaylistNode::GetNext()
{
return nextNodePtr;
}
void PlaylistNode::PrintPlaylistNode()
{
cout<<\"Unique ID: \"<
using namespace std;
void PrintMenu(string listName);
void SongsByArtist(PlaylistNode* head);
void TotalTime(PlaylistNode* head);
void OutputFullList(string listname, PlaylistNode *head);
//all below function take head and tail by reference and modify their values
void AddSong(PlaylistNode* &head, PlaylistNode* &tail);
void RemoveSong(PlaylistNode* &head, PlaylistNode* &tail);
void ChangePosition(PlaylistNode* &head, PlaylistNode* &tail);
int main()
{
string listname;
cout<<\"Entr playlist\'s title: \";
cin>>listname;
PrintMenu(listname);
}
void PrintMenu(string listname)
{
string option;
PlaylistNode *head=0, *tail=0;
while(true)
{
cout<< listname << \" PLAYLIST MENU\"<>option;
if(option ==\"A\" || option == \"a\")
{
AddSong(head,tail);
cout<<\"Finished adding.\"<PrintPlaylistNode();
cout<GetNext();
i++;
}
}
void AddSong(PlaylistNode* &head, PlaylistNode* &tail)
{
string id, song, artist;
int len;
cout<<\"ADD SONG\"<>id;
getchar();
cout<<\"Enter songs\'s name: \";
getline(cin, song);
cout<<\"Enter artist\'s name: \";
getline(cin, artist);
cout<<\"Enter song\'s length(in seconds): \";
cin>>len;
if(tail == 0)
{
head = tail = new PlaylistNode(id,song,artist,len);
}
else
tail=tail->InsertAfter(id, song, artist, len);
}
void RemoveSong(PlaylistNode* &head, PlaylistNode* &tail)
{
string id;
PlaylistNode *p= head, *prev=NULL;
cout<<\"REMOVE SONG\";
cout<<\"Enter song\'s unique ID: \";
cin>>id;
while(p != NULL)
{
if(p->GetID() == id)
{
.
Recommended
in C++ , Design a linked list class named IntegerList to hold a seri.pdf
in C++ , Design a linked list class named IntegerList to hold a series of integers. The class must
have public member functions for appending , inserting, deleting and displaying nodes. The
append function must append a node to the end of the list. The insert function must insert node in
ascending order. The delete function must delete the node with the given value. The display
function should display the list from head to tail. The IntegerList class should also have a
destructor that destroys the list and release memory. The list node must be declared as a structure
using keyword struct. This structure is a private member of IntegerList. You should also store the
head of the list as a private member.
Write a test program to test the implementation your IntegerList class works properly.
Solution
Here is the code for the above scenario:
#include
using namespace std;
struct ListNode
{
float value;
ListNode *next;
};
ListNode *head;
class LinkedList
{
public:
int insertNode(float num);
int appendNode(float num);
void deleteNode(float num);
void destroyList();
void displayList();
LinkedList(void) {head = NULL;}
~LinkedList(void) {destroyList();}
};
int LinkedList::appendNode(float num)
{
ListNode *newNode, *nodePtr = head;
newNode = new ListNode;
if(newNode == NULL)
{
cout << \"Error allocating memory for new list member!\ \";
return 1;
}
newNode->value = num;
newNode->next = NULL;
if(head == NULL)
{
cout << \"List was empty - \" << newNode->value;
cout << \" is part of list\'s first node.\ \";
head = newNode;
}
else
{
while(nodePtr->next != NULL)
nodePtr = nodePtr->next;
nodePtr->next = newNode;
}
return 0;
}
int LinkedList::insertNode(float num)
{
struct ListNode *newNode, *nodePtr = head, *prevNodePtr = NULL;
newNode = new ListNode;
if(newNode == NULL)
{
cout << \"Error allocating memory for new list member!\ \";
return 1;
}
newNode->value = num;
newNode->next = NULL;
if(head==NULL) {
cout << \"List was empty - \" << newNode->value;
cout << \" is part of list\'s first node.\ \";
head = newNode;
}
else
{
while((nodePtr != NULL) && (nodePtr->value < num)) {
prevNodePtr = nodePtr;
nodePtr = nodePtr->next;
}
if(prevNodePtr==NULL)
newNode->next = head;
else
newNode->next = nodePtr; prevNodePtr->next = newNode;
}
return 0;
}
void LinkedList::deleteNode(float num)
{
struct ListNode *nodePtr = head, *prevNodePtr = NULL;
if(head==NULL) {
cout << \"The list was empty!\ \";
return;
}
if(head->value == num) {
head = nodePtr->next;
delete [] nodePtr;
}
else
{
while((nodePtr!= NULL)&&(nodePtr->value != num)) {
prevNodePtr = nodePtr;
nodePtr = nodePtr->next;
}
if(nodePtr==NULL)
cout << \"The value \" << num << \" is not in this list!\ \";
else {
prevNodePtr->next = nodePtr->next;
delete [] nodePtr;
}
}
}
void LinkedList::destroyList()
{
struct ListNode *nodePtr = head, *nextNode = nodePtr;
if(head==NULL) {
cout << \"The list is empty!\ \";
return;
}
while (nodePtr != NULL) {
nextNode = nodePtr->next;
delete [] nodePtr;
nodePtr = nextNode;
}
}
void LinkedList.
#include sstream #include linkylist.h #include iostream.pdf
#include
#include \"linkylist.h\"
#include
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
//node* head = new node;
LinkedList list(1);
ifstream infile1 (argv[1]);
//make sure the file opens properly and read the contents of the file in to a list
if(!infile1)
{
cout<<\"Your Testfile could not be opened!\"<>users;
if (users.find(\"I\")!=string::npos)
{
//int spot = atoi((users[3]).c_str());
string pot = string(users.substr(2));
stringstream spot(pot);
string data;
cin>>data;
insertAfter(list.getNode(spot),data);
}
/*else if (users.find(\"D\")!=string::npos)
{
int spoty = atoi((users[3]).c_str());
deleteNode(spoty);
}*/
else if (users==\"L\")
{
list.traverse_and_print();
}
}
return 0;
#include
using namespace std;
class Node
{
friend class LinkedList;
private:
int value; /* data, can be any data type, but use integer for easiness */
Node *Next; /* pointer to the next node */
public:
/* Constructors with No Arguments */
Node(void)
: Next(NULL)
{ }
/* Constructors with a given value */
Node(int val)
: value(val), Next(NULL)
{ }
/* Constructors with a given value and a link of the next node */
Node(int val, Node* next)
: value(val), Next(next)
{}
/* Getters */
int getValue(void)
{ return value; }
Node* getNext(void)
{ return Next; }
};
/* definition of the linked list class */
class LinkedList
{
private:
/* pointer of head node */
Node *Head;
/* pointer of tail node */
Node *Tail;
public:
/* Constructors with a given value of a list node */
LinkedList(int val);
/* Destructor */
~LinkedList(void);
/* Function to append a node to the end of a linked list */
void tailAppend(string val);
/* Remove a node with a specific value if it exists */
void remove(int val);
void insertAfter(Node* afterMe, string val);
Node* getNode(int pos);
/* Traversing the list and printing the value of each node */
void traverse_and_print();
};
#include
#include \"linkylist.h\"
#include
using namespace std;
LinkedList::LinkedList(int val)
{
/* Create a new node, acting as both the head and tail node */
Head = new Node(val);
Tail = Head;
}
Node* LinkedList::getNode(int pos)
{
Node* p = Head;
/* Counter */
while (pos--) {
if (p != NULL)
p = p->Next;
else
return NULL;
}
return p;
}
void LinkedList::insertAfter(Node* afterMe, string val)
{
if(afterme != NULL)
{
afterMe->Next = new Node(val, afterMe->Next);
}
}
LinkedList::~LinkedList()
{
}
void LinkedList::tailAppend(string val)
{
/* The list is empty? */
if (Head == NULL) {
/* the same to create a new list with a given value */
Tail = Head = new Node(val);
}
else
{
/* Append the new node to the tail */
Tail->Next = new Node(val);
/* Update the tail pointer */
Tail = Tail->Next;
}
}
void LinkedList::remove(int val)
{
Node *pPre = NULL, *pDel = NULL;
/* Check whether it is the head node?
if it is, delete and update the head node */
if (Head->value == val) {
/* point to the node to be deleted */
pDel = Head;
/* update */
Head = pDel->Next;
delete pDel;
return;
}
pPre = Head;
pDel = Head->Next;
/*.
Add delete at a position to the code and display it to the code- class.pdf
Add delete at a position to the code and display it to the code:
class listnodes {
int data;
listnodes link;
listnodes() {
data = 0;
link = null;
}
listnodes(int d, listnodes l) {
data = d;
link = l;
}
}
class singlelinkedlist {
public listnodes insertnode(int data, listnodes head) {
listnodes newnode = new listnodes(data, null);
newnode.link = head;
head = newnode;
return head;
}
public listnodes insertAtPosition(listnodes head, int data, int position) {
listnodes newnode = new listnodes(data, null);
listnodes previous = head;
int count = 1;
while (count <= position - 1) {
previous = previous.link;
count++;
}
listnodes current = previous.link;
newnode.link = current;
previous.link = newnode;
return head;
}
public listnodes deletefirst(listnodes head) {
listnodes pre = head;
head = head.link;
pre.link = null;
return pre;
}
public void display(listnodes head) {
listnodes current = head;
while (current.link != null) {
System.out.print(current.data + "-->");
current = current.link;
}
System.out.print(current.data);
}
}
public class LinkedList {
public static void main(String[] args) {
listnodes head=new listnodes(10,null);
singlelinkedlist sl=new singlelinkedlist();
sl.display(head);
System.out.println("\nInsert at front");
listnodes newhead=sl.insertnode(20, head);
sl.display(newhead);
System.out.println("\nInsert at a position");
sl.insertAtPosition(newhead, 40, 1);
sl.display(newhead);
System.out.println("\nDelete first");
listnodes newhead2=sl.deletefirst(newhead);
sl.display(newhead2);
}
}
.
Here is the code.compile g++ Playlist.cpp main.cppPlaylist.h.pdf
Here is the code.
compile : g++ Playlist.cpp main.cpp
Playlist.h
#ifndef PLAYLIST_H
#define PLAYLIST_H
#include
using namespace std;
class PlaylistNode
{
private:
string uniqueID;
string songName;
string artistName;
int songLength;
PlaylistNode* nextNodePtr;
public:
PlaylistNode();
PlaylistNode(string id, string song, string artist, int len);
PlaylistNode* InsertAfter(string id, string song, string artist, int len);
void SetNext(PlaylistNode *next);
string GetID();
string GetSongName();
string GetArtistName();
int GetSongLength();
PlaylistNode* GetNext();
void PrintPlaylistNode();
};
#endif
Playlist.cpp
#include \"Playlist.h\"
#include
using namespace std;
PlaylistNode::PlaylistNode()
{
uniqueID = \"none\";
songName = \"none\";
artistName = \"none\";
songLength = 0;
nextNodePtr = 0;
}
PlaylistNode::PlaylistNode(string id, string song, string artist,int len)
{
uniqueID = id;
songName = song;
artistName = artist;
songLength = len;
nextNodePtr = 0;
}
PlaylistNode* PlaylistNode::InsertAfter(string id, string song, string artist,int len)
{
nextNodePtr=new PlaylistNode(id,song,artist,len);
return nextNodePtr;
}
void PlaylistNode::SetNext(PlaylistNode *next)
{
nextNodePtr = next;
}
string PlaylistNode::GetID()
{
return uniqueID;
}
string PlaylistNode::GetSongName()
{
return songName;
}
string PlaylistNode::GetArtistName()
{
return artistName;
}
int PlaylistNode::GetSongLength()
{
return songLength;
}
PlaylistNode* PlaylistNode::GetNext()
{
return nextNodePtr;
}
void PlaylistNode::PrintPlaylistNode()
{
cout<<\"Unique ID: \"<
using namespace std;
void PrintMenu(string listName);
void SongsByArtist(PlaylistNode* head);
void TotalTime(PlaylistNode* head);
void OutputFullList(string listname, PlaylistNode *head);
//all below function take head and tail by reference and modify their values
void AddSong(PlaylistNode* &head, PlaylistNode* &tail);
void RemoveSong(PlaylistNode* &head, PlaylistNode* &tail);
void ChangePosition(PlaylistNode* &head, PlaylistNode* &tail);
int main()
{
string listname;
cout<<\"Entr playlist\'s title: \";
cin>>listname;
PrintMenu(listname);
}
void PrintMenu(string listname)
{
string option;
PlaylistNode *head=0, *tail=0;
while(true)
{
cout<< listname << \" PLAYLIST MENU\"<>option;
if(option ==\"A\" || option == \"a\")
{
AddSong(head,tail);
cout<<\"Finished adding.\"<PrintPlaylistNode();
cout<GetNext();
i++;
}
}
void AddSong(PlaylistNode* &head, PlaylistNode* &tail)
{
string id, song, artist;
int len;
cout<<\"ADD SONG\"<>id;
getchar();
cout<<\"Enter songs\'s name: \";
getline(cin, song);
cout<<\"Enter artist\'s name: \";
getline(cin, artist);
cout<<\"Enter song\'s length(in seconds): \";
cin>>len;
if(tail == 0)
{
head = tail = new PlaylistNode(id,song,artist,len);
}
else
tail=tail->InsertAfter(id, song, artist, len);
}
void RemoveSong(PlaylistNode* &head, PlaylistNode* &tail)
{
string id;
PlaylistNode *p= head, *prev=NULL;
cout<<\"REMOVE SONG\";
cout<<\"Enter song\'s unique ID: \";
cin>>id;
while(p != NULL)
{
if(p->GetID() == id)
{
.
Draw memory map of this link list code and add insert at last ( java)-.pdf
Draw memory map of this link list code and add insert at last ( java):
class listnodes {
int data;
listnodes link;
listnodes() {
data = 0;
link = null;
}
listnodes(int d, listnodes l) {
data = d;
link = l;
}
}
class singlelinkedlist {
public listnodes insertnode(int data, listnodes head) {
listnodes newnode = new listnodes(data, null);
newnode.link = head;
head = newnode;
return head;
}
public listnodes insertAtPosition(listnodes head, int data, int position) {
listnodes newnode = new listnodes(data, null);
listnodes previous = head;
int count = 1;
while (count <= position - 1) {
previous = previous.link;
count++;
}
listnodes current = previous.link;
newnode.link = current;
previous.link = newnode;
return head;
}
public listnodes deletefirst(listnodes head) {
listnodes pre = head;
head = head.link;
pre.link = null;
return pre;
}
public listnodes deletelast(listnodes head) {
listnodes cur = head;
listnodes previouscur = head;
while (cur.link != null) {
previouscur = cur;
cur = cur.link;
}
previouscur.link = null;
return cur;
}
public int length(listnodes head) {
listnodes current = head;
int c = 0;
while (current != null) {
c++;
current = current.link;
}
return c;
}
public boolean find(listnodes head, int searchdata) {
listnodes cur = head;
while (cur != null) {
if (cur.data == searchdata) {
return true;
}
cur = cur.link;
}
return false;
}
public void display(listnodes head) {
listnodes current = head;
while (current.link != null) {
System.out.print(current.data + "-->");
current = current.link;
}
System.out.print(current.data);
}
public listnodes insertAtEnd(listnodes head, int data) {
listnodes newnode = new listnodes(data, null);
if (head == null) {
return newnode;
}
listnodes current = head;
while (current.link != null) {
current = current.link;
}
current.link = newnode;
return head;
}
}
public class LinkedList {
public static void main(String[] args) {
listnodes head=new listnodes(10,null);
singlelinkedlist sl=new singlelinkedlist();
sl.display(head);
System.out.println("\n*****Insert at front*****");
listnodes newhead=sl.insertnode(20, head);
sl.display(newhead);
System.out.println("\n*****Insert at a position*****");
sl.insertAtPosition(newhead, 40, 1);
sl.display(newhead);
System.out.println("\n*****Delete at front*****");
listnodes deletednode=sl.deletefirst(newhead);
System.out.println("Deleted node is: "+deletednode.data);
sl.display(newhead);
System.out.println("\n*****Delete at end*****");
listnodes deletedlast=sl.deletelast(newhead);
System.out.println("Deleted node is: "+deletedlast.data);
sl.display(newhead);
System.out.println("\n*****Length of Linked List*****");
int length=sl.length(newhead);
System.out.println("Length of Linked List is: "+length);
System.out.println("\n*****Search for an element*****");
boolean found=sl.find(newhead, 20);
if(found){
System.out.println("Element found");
}
else{
System.out.println("Element not found");
}
}
}.
A perfect left-sided binary tree is a binary tree where every intern.pdf
A perfect left-sided binary tree is a binary tree where every internal node has two children, and
every left child is a leaf. Write an algorithm, based on DFS or BFS, that takes as input an
undirected graph G, and returns whether or not G is (or can be viewed as) a perfect left-sided
binary tree. Analyze the time complexity of your algorithm.
Solution
bfs(G)
{
list L = empty
tree T = empty
choose a starting vertex x
search(x)
while(L nonempty)
remove edge (v,w) from start of L
if w not yet visited
{
add (v,w) to T
search(w)
}
}
dfs(G)
{
list L = empty
tree T = empty
choose a starting vertex x
search(x)
while(L nonempty)
remove edge (v,w) from end of L
if w not yet visited
{
add (v,w) to T
search(w)
}
}
search(vertex v)
{
visit(v);
for each edge (v,w)
add edge (v,w) to end of L
}
mport java.util.*;
public class BST > implements Iterable
{
public static void main(String[] args)
{
Integer[] a = {1,5,2,7,4};
BST bst = new BST();
for(Integer n : a) bst.insert(n);
bst.preOrderTraversal();
System.out.println();
//testing comparator
//build a mirror BST with a rule: Left > Parent > Right
//code for the comparator at the bottom of the file
bst = new BST(new MyComp1());
for(Integer n : a) bst.insert(n);
bst.preOrderTraversal();
System.out.println();
bst.inOrderTraversal();
System.out.println();
for(Integer n : bst) System.out.print(n);
System.out.println();
System.out.println(bst);
//testing restoring a tree from two given traversals
bst.restore(new Integer[] {11,8,6,4,7,10,19,43,31,29,37,49},
new Integer[] {4,6,7,8,10,11,19,29,31,37,43,49});
bst.preOrderTraversal();
System.out.println();
bst.inOrderTraversal();
System.out.println();
//testing diameter
System.out.println(\"diameter = \" + bst.diameter());
//testing width
System.out.println(\"width = \" + bst.width());
}
private Node root;
private Comparator comparator;
public BST()
{
root = null;
comparator = null;
}
public BST(Comparator comp)
{
root = null;
comparator = comp;
}
private int compare(T x, T y)
{
if(comparator == null) return x.compareTo(y);
else
return comparator.compare(x,y);
}
/*****************************************************
*
* INSERT
*
******************************************************/
public void insert(T data)
{
root = insert(root, data);
}
private Node insert(Node p, T toInsert)
{
if (p == null)
return new Node(toInsert);
if (compare(toInsert, p.data) == 0)
return p;
if (compare(toInsert, p.data) < 0)
p.left = insert(p.left, toInsert);
else
p.right = insert(p.right, toInsert);
return p;
}
/*****************************************************
*
* SEARCH
*
******************************************************/
public boolean search(T toSearch)
{
return search(root, toSearch);
}
private boolean search(Node p, T toSearch)
{
if (p == null)
return false;
else
if (compare(toSearch, p.data) == 0)
return true;
else
if (compare(toSearch, p.data) < 0)
return search(p.left, toSearch);
else
return search(p.right, toSearch);
}
/*****************************************************.
public class SLLT { protected SLLNodeT head, tail; pub.pdf
public class SLL { protected SLLNode head, tail; public SLL() { head = tail = null;
} public void addToTail(T e){ SLLNode newNode = new SLLNode(e); if(head ==
null) head = tail = newNode; else{ tail.next = newNode; tail =
tail.next; } } public void addToHead(T e) { SLLNode newNode = new
SLLNode(e, head); if(head == null) tail = newNode; head = newNode; }
public String toString(){ if (head == null) return "[]"; String out = "[";
SLLNode p = head; while (p.next != null){ out += p.info + " "; p = p.next;
} out += p.info + "]"; return out; } }
public class SLLNode { protected T info; protected SLLNode next; public SLLNode() {
this(null, null); } public SLLNode(T e) { this(e, null); } public SLLNode(T
e, SLLNode ptr) { info = e; next = ptr; } }
public class SortedSLL> extends SLL{ public void insert(T e){ } public void
merge(SortedSLL list){ } }
public class SortedSLL T extends Comparable T extends SLLT{ public void insert (T e) \{ \}
public void merge(SortedSLL T list) \{ \} public class SortedSLL T extends Comparable T
extends SLLT{ public void insert ( T e) \{ \} public void merge(SortedSLL T list) \{ \} \}
ublic class SLLT{ protected SLLNodeT head, tail; public SLL() \{ head = tail = null; \} public
void addToTail( T e) \{ SLLNode newNode = new SLLNodeT(e); if ( head == null) head = tail
= newNode; else\{ tail. next = newNode; tail = tail. next; \} \} public void addToHead( T e) \{
SLLNode T newNode = new SLLNodeT(e, head ); if (head == null) tail = newNode; head =
newNode; \} public string tostring()\{ if (head == null) return "[]"; String out = "["; SLLNode
Tp= head; while (p.next != null) \{ out +=p.info +" "; p=p next; \} out += p.info + "]"; return out;
\}
ublic class SLLNode T{ protected T info; protected SLLNode T next; public SLLNode() \{
this(null, null); \} public SLLNode( T e) \{ this (e, null); \} public SLLNode( T e, SLLNode T
ptr ){ info =e; next =ptr; \}
Write a subclass of SLL named SortedSLL that represents a sorted SinglyLinkedList (sorted in
nondecending order). The class should contain the following methods: 1- [40 Points] void insert
( T e) that inserts an SLLNode in its correct position so that the resulting list remains sorted.
Make sure to consider special cases such as: - The list is empty. - The list has one element. - The
inserted element is smaller than the head, or larger than the tail.. 2- [60 Points] void
merge(SortedSLL T list) that merges the calling list with the argument list. Note that this can be
done by calling the insert method for each element in list, but this is highly ineffiecient, answer
the following question: Q2.1: What is the complexity of this approach? Explain. [10 Points]
Instead, you should come up with a solution that traverse both lists just one time. Furthermore,
the argument list should be empty after the merge is completed. Q2.2: What is the complexity of
this approach? Explain. [10 Points] Hint: Make sure the class SortedSLL accepts types T that is
comparable. You can do this by writing .
Use the singly linked list class introduced in the lab to implement .pdf
Use the singly linked list class introduced in the lab to implement integers of unlimited size.
Each node of the list should store one digit of the integer. You are to implement the addition,
subtraction and multiplication operations. Please note that any additional data structure to be
used in solving this problem has to be taken from the ones introduced in the ICS 202 lab. In
addition, provide a test class that will do the following: It will keep asking the user to enter two
integers, choose one of the operations (addition, subtraction, multiplication) and then display the
result. The program will stop upon entering the # character (without the double quotes).
this singly linked list class:
public class SLL {
private class SLLNode {
private T info;
private SLLNode next;
int value;
public SLLNode() {
this(null, null);
}
public SLLNode(T el) {
this(el, null);
}
public SLLNode(T el, SLLNode ptr) {
info = el;
next = ptr;
}
}
protected SLLNode head, tail;
public SLL() {
head = tail = null;
}
public boolean isEmpty() {
return head == null;
}
public void addToHead(T el) {
head = new SLLNode(el, head);
if (tail == null)
tail = head;
}
public void addToTail(T el) {
if (!isEmpty()) {
tail.next = new SLLNode(el);
tail = tail.next;
} else
head = tail = new SLLNode(el);
}
public T deleteFromHead() { // delete the head and return its info;
if (isEmpty())
return null;
T el = head.info;
if (head == tail) // if only one node on the list;
head = tail = null;
else
head = head.next;
return el;
}
public T deleteFromTail() { // delete the tail and return its info;
if (isEmpty())
return null;
T el = tail.info;
if (head == tail) // if only one node in the list;
head = tail = null;
else { // if more than one node in the list,
SLLNode tmp; // find the predecessor of tail;
for (tmp = head; tmp.next != tail; tmp = tmp.next)
;
tail = tmp; // the predecessor of tail becomes tail;
tail.next = null;
}
return el;
}
public void delete(T el) { // delete the node with an element el;
if (!isEmpty())
if (head == tail && el.equals(head.info)) // if only one
head = tail = null; // node on the list;
else if (el.equals(head.info)) // if more than one node on the list;
head = head.next; // and el is in the head node;
else { // if more than one node in the list
SLLNode pred, tmp;// and el is in a nonhead node;
for (pred = head, tmp = head.next; tmp != null
&& !tmp.info.equals(el); pred = pred.next, tmp = tmp.next)
;
if (tmp != null) { // if el was found;
pred.next = tmp.next;
if (tmp == tail) // if el is in the last node;
tail = pred;
}
}
}
@Override
public String toString() {
if (head == null)
return "[ ]";
String str = "[ ";
SLLNode tmp = head;
while (tmp != null) {
str += tmp.info + " ";
tmp = tmp.next;
}
return str + "]";
}
public boolean contains(T el) {
if (head == null)
return false;
SLLNode tmp = head;
while (tmp != null) {
if (tmp.info.equals(el))
return true;
tmp = tmp.next;
}
return false;
}
public int size() {
if (head == null)
return 0;
int count = 0;
SLLNode p = head;
w.
I need help writing test Codepackage org.example;import j.pdf
I need help writing test
Code:
package org.example;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
class Album implements Comparable {
private int id;
private List artists;
private String title;
private int numSongs;
public Album(int id, List artists, String title, int numSongs) {
this.id = id;
this.artists = artists;
this.title = title;
this.numSongs = numSongs;
}
@Override
public int compareTo(Album other) {
return Integer.compare(this.numSongs, other.numSongs);
}
@Override
public String toString() {
return "ID: " + id + " -- " + numSongs + " songs -- " + artists;
}
// Getter methods for Album properties
// Implement these as needed
}
class DoublyLinkedList {
private Node head;
private Node tail;
private int size;
private class Node {
Album data;
Node prev;
Node next;
Node(Album data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
public DoublyLinkedList() {
head = null;
tail = null;
size = 0;
}
public void append(Album data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
newNode.prev = tail;
tail = newNode;
}
size++;
}
public Node insert(int location, Album data) {
if (location < 0 || location > size) {
throw new IllegalArgumentException("Invalid location");
}
Node newNode = new Node(data);
if (location == 0) {
newNode.next = head;
head.prev = newNode;
head = newNode;
} else if (location == size) {
tail.next = newNode;
newNode.prev = tail;
tail = newNode;
} else {
Node current = head;
for (int i = 0; i < location - 1; i++) {
current = current.next;
}
newNode.prev = current;
newNode.next = current.next;
current.next.prev = newNode;
current.next = newNode;
}
size++;
return newNode;
}
public Node delete(int location) {
if (location < 0 || location >= size) {
throw new IllegalArgumentException("Invalid location");
}
Node deletedNode;
if (location == 0) {
deletedNode = head;
head = head.next;
if (head != null) {
head.prev = null;
} else {
tail = null;
}
} else if (location == size - 1) {
deletedNode = tail;
tail = tail.prev;
tail.next = null;
} else {
Node current = head;
for (int i = 0; i < location; i++) {
current = current.next;
}
deletedNode = current;
current.prev.next = current.next;
current.next.prev = current.prev;
}
size--;
return deletedNode;
}
public int getIndex(Album data) {
Node current = head;
for (int i = 0; i < size; i++) {
if (current.data.equals(data)) {
return i;
}
current = current.next;
}
return -1;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
Node current = head;
while (current != null) {
sb.append(current.data.toString());
if (current.next != null) {
sb.append(" -> ");
} else {
sb.append(" -> NULL");
}
current = current.next;
}
return sb.toString();
}
public void shuffle() {
List albumList = new ArrayList<>();
Node current = head;
while (current != null) {
albumList.add(current.data);
current = current.next;
}
Collections.shuffle(albumList, new Rando.
Template LinkedList;I am using templates to make some linkedLists.pdf
Sargent Corporation bought equipment on January 1, 2013. The equipment cost $180,000 and
had an expected salvage value of $30,000. The life of the equipment was estimated to be 6 years.
The book value of the equipment at the beginning of the third year using straight-line
depreciation would be . C $180,000. $150,000. $130,000. $50,000.
Solution
As per the information provided, Sargent Corporation bought an equipment on Jan 1, 2013 for
$180000 with 6 years life and salvage value of $30000.
Therefore, depreciation expense every year as per Straight line method would be:-
Equipment cost = $180000
LESS:- Salvage value = $30000
Amount on which depriciation is to be charged =$150000
Now, depreciation as per straight line method = $150000 / 6 years
= $25000 every year
Now, book value of Equipment at the beginning of third year is:-
Equipment cost = $180000
LESS :- Depreciation for first and second year = $25000 x 2 years = $50000
Therefore, book value at begginning of third year =$130000
Hence, as per the problem \"Option C\" is correct with book value of $130000..
^^^ Discuss about Header Node And also write a program for unorder.pdf
^^^ Discuss about Header Node? And also write a program for unordered single linked list and
linked implementation of QUEUE?
Solution
Header node:
Sometimes it is desire to keep an extra node at the front of a List. Such a node doesn’t represent
an item in the List and is called a Header Node or a List Header. The Information field of such
Header node might be unused but the Next field maintains the first node address. More often the
information of such a node could be used to keep Global Information about the Entire List.
One of the applications of Header node is the information portion of the Header node contains
the number of nodes (not including Header) in the List. In this Structure the Header must be
adjusted the total number of nodes when we apply addition or deletion operation on the List. We
can directly obtained the total number of nodes without traversing the entire List.
By using this application, we can develop Data Structure Stack easily. Since Header node
information field maintains the number of elements that the Stack contains.
Another application is we can simply develop the Data Structure Queue. Until now, two external
pointers, Front & Rear, were necessary for a List to represent a Queue. However, now only a
single external pointer is sufficient to maintain a Queue that is Head node. Because the Header
node next field behave like a Front and information field of Header node maintains last node
address so that it is behave like a Rear .
Another possibility for the use of the information portion of a List Header is as a pointer
to a Curr node in the List during a traversal process. This would be eliminate the node for an
external pointer during traversal.
#include
#include
#include
#include
struct node
{
char info;
struct node *next;
};
typedef struct node sl;
void display(sl *);
sl * create(sl *root)
{
sl *curr,*new;
char val;
printf(\"\ Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
while(val != \'$\')
{
new=(sl *) malloc(sizeof(sl));
new->info = val;
new->next = NULL;
if(root == NULL)
root = new;
else
{
curr = root;
while( curr->next != NULL )
curr = curr->next;
curr->next = new;
}
printf(\" Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
}
printf(\"\ The Created Linked List Is \ \");
display(root);
return root;
}
sl * delete(sl *root,char val)
{
sl *temp,*curr,*rear;
curr = root;
rear = NULL;
while( curr != NULL && val != curr->info )
{
rear = curr;
curr = curr->next;
}
if(curr == NULL)
{
if( rear == NULL)
{
printf(\"\ Linked List is Empty\");
printf(\"\ Deletion is not Possible \");
}
else
{
printf(\"\ deleted Node does not exist in List\");
printf(\"\ Deletion is not Possible \");
}
}
else
{
if( rear == NULL)
{
temp = root;
root = root->next;
}
else
{
temp = curr;
rear->next = curr->next;
}
printf(\"\ Node is deleted \");
printf(\"\ Deleted Node information is %c\",temp->info);
free(temp);
}
display(root);
return root;
}
sl * insert(sl *root,char val)
{.
Create your own Linked list from scratch (singly linked list).So.pdf
Consider four protons at rest at the corners of a square. The protons are bound together so they
cannot move. Then the bonds holding one of the protons break so that proton is free to move.
Determine that proton\'s acceleration (both direction and magnitude) at the instant after it is no
longer bound as well as its speed when it has moved far away. You know the proton\'s charge, its
mass, and the length of the sides of the square.
Solution
Here we need to note that the like charges repel each other, hence the proton will be pushed
away along the diagonal of the square.
We will assume that the mass of the proton is Mp and charge is q while the length of the side of
the square is a.
The net force due to the proton diagonally opposite would be along the diagonal, and also due to
the other two charges.
Hence the net force would be: 2kq22/a2 + kq2/2a2 = (kq2/a2)[22 + 1/2] along the diagonal.
The acceleration would be given as: Force / mass = (kq2/Mpa2)[22 + 1/2]
So as to determine the speed of the proton once it gets far away, we will use the prinicple of
conservation of energy. Hence the initial potential energy of the proton would be equal to its
final kinetic energy hence giving us the speed.
That is. 2kq2/a + kq2/a2 = (kq2/a)[2 + 1/2] = Mpv2/2
or, V = sqrt[(2kq2/Mpa)[2 + 1/2]] which is the required expression for the speed of the proton..
Discuss about Header Node And also write a program for unordered si.pdf
Consider rectangle ABCD. If mADF=60°, then what is the mFDC?
a) 60°
b) 30°
c) 90°
d) 120°
e) 45°
f) None of the above
Solution
Given figure ABCD is a rectangle.
Looking into the properties of rectangle,
1) All the angles in a rectangle are right angles i.e. equal to 90 degrees.
2) Opposite sides are parallel and equal.
By the first property stated above,
m(D) = 90 degrees
Angle D can be written as given in the following
m(D) = m(ADF) + m(FDC) = 90
Given m(ADF) = 60
Therefore, 60 + m(FDC) = 90
m(FDC) = 30 degress.
Hence option B) 30 is the required answer..
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables: a double data value, a pointer to the next node, and a pointer to the previous
node. Each member variable is protected. So code outside of the class must use the provided
getter and setter member functions to get or set a member variable. Node.h is read only, since no
changes are required. Step 2: Implement the Insert() member function A class for a sorted,
doubly-linked list is declared in SortedNumberList.h. Implement the SortedNumberList class's
Insert() member function. The function must create a new node with the parameter value, then
insert the node into the proper sorted position in the linked list. Ex: Suppose a
SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node with data
value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's sorted order
and yielding: 23 35.5 47.25 86 Step 3: Test in develop mode Code in main() takes a space-
separated list of numbers and inserts each into a SortedNumberList. The list is displayed after
each insertion. Ex: If input is 77 15 -42 63.5 then output is: List after inserting 77: 77 List after
inserting 15: 15 77 List after inserting -42: -42 15 77 List after inserting 63.5: -42 15 63.5 77 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove() member function. The
function takes a parameter for the number to be removed from the list. If the number does not
exist in the list, the list is not changed and false is returned. Otherwise, the first instance of the
number is removed from the list and true is returned. Uncomment the commented-out part in
main() that reads a second input line and removes numbers from the list. Test in develop mode to
ensure that insertion and removal both work properly, then submit code for grading. Ex: If input
is 84 72 19 61 19 84 then output is: List after inserting 84: 84 List after inserting 72: 72 84 List
after inserting 19: 19 72 84 List after inserting 61: 19 61 72 84 List after removing 19: 61 72 84
List after removing 84: 61 72
main.cpp
#include
#include
#include
#include "Node.h"
#include "SortedNumberList.h"
using namespace std; void PrintList(SortedNumberList& list); vector SpaceSplit(string source);
int main(int argc, char *argv[]) { // Read the line of input numbers string inputLine; getline(cin,
inputLine); // Split on space character vector terms = SpaceSplit(inputLine); // Insert each value
and show the sorted list's contents after each insertion SortedNumberList list; for (auto term :
terms) { double number = stod(term); cout << "List after inserting " << number << ": " << endl;
list.Insert(number); PrintList(list); } /* // Read the input line with numbers to remove getline(cin,
inputLi.
Solve using Java programming language- ----------------------------.pdf
Solve using Java programming language.
//************************** SLL.java *********************************
// a generic singly linked list class
public class SLL<T> {
private class SLLNode<T> {
private T info;
private SLLNode<T> next;
public SLLNode() {
this(null,null);
}
public SLLNode(T el) {
this(el,null);
}
public SLLNode(T el, SLLNode<T> ptr) {
info = el; next = ptr;
}
}
protected SLLNode<T> head, tail;
public SLL() {
head = tail = null;
}
public boolean isEmpty() {
return head == null;
}
public void addToHead(T el) {
head = new SLLNode<T>(el,head);
if (tail == null)
tail = head;
}
public void addToTail(T el) {
if (!isEmpty()) {
tail.next = new SLLNode<T>(el);
tail = tail.next;
}
else head = tail = new SLLNode<T>(el);
}
public T deleteFromHead() { // delete the head and return its info;
if (isEmpty())
return null;
T el = head.info;
if (head == tail) // if only one node on the list;
head = tail = null;
else head = head.next;
return el;
}
public T deleteFromTail() { // delete the tail and return its info;
if (isEmpty())
return null;
T el = tail.info;
if (head == tail) // if only one node in the list;
head = tail = null;
else { // if more than one node in the list,
SLLNode<T> tmp; // find the predecessor of tail;
for (tmp = head; tmp.next != tail; tmp = tmp.next);
tail = tmp; // the predecessor of tail becomes tail;
tail.next = null;
}
return el;
}
public void delete(T el) { // delete the node with an element el;
if (!isEmpty())
if (head == tail && el.equals(head.info)) // if only one
head = tail = null; // node on the list;
else if (el.equals(head.info)) // if more than one node on the list;
head = head.next; // and el is in the head node;
else { // if more than one node in the list
SLLNode<T> pred, tmp;// and el is in a nonhead node;
for (pred = head, tmp = head.next;
tmp != null && !tmp.info.equals(el);
pred = pred.next, tmp = tmp.next);
if (tmp != null) { // if el was found;
pred.next = tmp.next;
if (tmp == tail) // if el is in the last node;
tail = pred;
}
}
}
@Override
public String toString() {
if(head == null)
return "[ ]";
String str = "[ ";
SLLNode<T> tmp = head;
while(tmp != null){
str += tmp.info + " ";
tmp = tmp.next;
}
return str+"]";
}
public boolean contains(T el) {
if(head == null)
return false;
SLLNode<T> tmp = head;
while(tmp != null){
if(tmp.info.equals(el))
return true;
tmp = tmp.next;
}
return false;
}
public int size(){
if(head == null)
return 0;
int count = 0;
SLLNode<T> p = head;
while(p != null) {
count++;
p = p.next;
}
return count;
}
}
Given the code above, solve the following tasks (please show the solution for every task
clearly):
For part (c) this is the code for the test program:
public class SLL_Driver {
public static void main(String[] args) {
SLL<String> myList = new SLL<String>();
String[] cityNames = {"Jubail", "Riyadh", "Abha", "Dammam", "Taif"};
for(int i = 0; i < cityNames.length; i++)
myList.addToHead(cityNames[i]);
System.out.println("The list is: " + myList);
System.out.println("It is " + myLis.
Main-cpp #include -iostream- #include -List-h- int main() { retur.pdf
Main.cpp
#include <iostream>
#include "List.h"
int main() {
return 0;
}
List.h
#ifndef HW10_25_LIST_H
#define HW10_25_LIST_H
#include <string>
#include <vector>
using Item = std::string;
class List {
private:
class ListNode {
public:
Item item;
ListNode * next;
ListNode(Item i, ListNode *n=nullptr) {
item = i;
next = n;
}
};
ListNode * head = nullptr;
ListNode * tail = nullptr;
public:
class iterator {
ListNode *node;
iterator(ListNode *n) : node {n} {}
friend class List;
public:
Item& operator*() { return node->item; }
iterator& operator++() { node = node->next; return *this; }
bool operator!=(const iterator& other) const { return node != other.node; }
};
public:
List() = default;
List(const List& other);
List& operator=(const List& rhs);
List(List&& other);
List& operator=(List&& rhs);
~List();
bool empty() const { return head==nullptr; }
void push_back(const Item& a);
void push_front(const Item& a);
iterator begin() const { return iterator(head); }
iterator end() const { return iterator(nullptr); }
friend std::vector<void*> getListPtrs(const List&);
};
#endif //HW10_25_LIST_H
List.cpp
#include "List.h"
// IMPLEMENT MOVE CONSTRUCTOR
// IMPLEMENT MOVE ASSIGNMENT OPERATOR
List::List(const List& other) {
auto p = other.head;
while (p) {
push_back(p->item);
p = p->next;
}
}
List& List::operator=(const List& rhs) {
if (&rhs == this) return *this;
// delete old list
auto p = head;
while (p) {
auto tmp = p->next;
delete p;
p = tmp;
}
head = tail = nullptr;
// copy from rhs
p = rhs.head;
while (p) {
push_back(p->item);
}
// return reference to self
return *this;
}
List::~List() {
auto p = head;
while (p) {
auto tmp = p->next;
delete p;
p = tmp;
}
}
void List::push_back(const Item& a) {
auto node {new ListNode(a)};
if ( head == nullptr ) {
// empty list
head = node;
tail = node;
} else {
tail->next = node;
tail = node;
}
}
void List::push_front(const Item& a) {
auto node {new ListNode(a)};
if (head == nullptr) {
head = node;
tail = node;
}
else {
node->next = head;
head = node;
}
}
10.25 Move constructor and assignment for linked list Write a move constructor and a move
assignment operator for the List class.
.
When we first examined the array based and node based implementations.docx
When we first examined the array based and node based implementations
^^^Q2. Discuss about Header Node And also write a program fo.pdf
^^^
Q2. Discuss about Header Node?
And also write a program for unordered single linked list and linked implementation of
QUEUE?
Solution
Header node:
Sometimes it is desire to keep an extra node at the front of a List. Such a node doesn’t represent
an item in the List and is called a Header Node or a List Header. The Information field of such
Header node might be unused but the Next field maintains the first node address. More often the
information of such a node could be used to keep Global Information about the Entire List.
One of the applications of Header node is the information portion of the Header node contains
the number of nodes (not including Header) in the List. In this Structure the Header must be
adjusted the total number of nodes when we apply addition or deletion operation on the List. We
can directly obtained the total number of nodes without traversing the entire List.
By using this application, we can develop Data Structure Stack easily. Since Header node
information field maintains the number of elements that the Stack contains.
Another application is we can simply develop the Data Structure Queue. Until now, two external
pointers, Front & Rear, were necessary for a List to represent a Queue. However, now only a
single external pointer is sufficient to maintain a Queue that is Head node. Because the Header
node next field behave like a Front and information field of Header node maintains last node
address so that it is behave like a Rear .
Another possibility for the use of the information portion of a List Header is as a pointer
to a Curr node in the List during a traversal process. This would be eliminate the node for an
external pointer during traversal.
#include
#include
#include
#include
struct node
{
char info;
struct node *next;
};
typedef struct node sl;
void display(sl *);
sl * create(sl *root)
{
sl *curr,*new;
char val;
printf(\"\ Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
while(val != \'$\')
{
new=(sl *) malloc(sizeof(sl));
new->info = val;
new->next = NULL;
if(root == NULL)
root = new;
else
{
curr = root;
while( curr->next != NULL )
curr = curr->next;
curr->next = new;
}
printf(\" Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
}
printf(\"\ The Created Linked List Is \ \");
display(root);
return root;
}
sl * delete(sl *root,char val)
{
sl *temp,*curr,*rear;
curr = root;
rear = NULL;
while( curr != NULL && val != curr->info )
{
rear = curr;
curr = curr->next;
}
if(curr == NULL)
{
if( rear == NULL)
{
printf(\"\ Linked List is Empty\");
printf(\"\ Deletion is not Possible \");
}
else
{
printf(\"\ deleted Node does not exist in List\");
printf(\"\ Deletion is not Possible \");
}
}
else
{
if( rear == NULL)
{
temp = root;
root = root->next;
}
else
{
temp = curr;
rear->next = curr->next;
}
printf(\"\ Node is deleted \");
printf(\"\ Deleted Node information is %c\",temp->info);
free(temp);
}
display(root);
return root;
}
sl * insert(sl *root,char va.
#include iostream using namespace std; const int nil = 0; cl.docx
#include iostream using namespace std; const int nil = 0; cl
DnaAORC This protein is responsible for initiation of DNA replicat.pdf
DnaA/ORC: This protein is responsible for initiation of DNA replication. When DNA replication
is temperature sensitive, it affects the function of Dna A/ ORC. It cannot bind to the N-terminus
and thus DNA replication is immediately stopped. So with the increase in temperature, there is
quick stop of the DNA replication.
SSB/RPA: This is the protein complex which acts on the single stranded DNA complex. In the
presences on non-permissible temperatures, this protein complex will quick stop the process of
DNA replication. Thus replication fork is not formed since it requires presence of one of the
proteins from the complex. It can be said that since the process is of so high order, quick stop
mutation takes please due to non- permissible temperature.
DnaB/Mcm: this protein complex is responsible for separating the DNA strand. With the
increase in temperature, the protein cannot separate the DNA strands. Thus DNA replication
stops immediately. Thus it is a quick stop type mutanation.
DNA ligase: there 3 major functions of DNA ligase 1) It seals the repairs in the DNA 2) Joins
the recombinant fragment and 3) it joins Okazaki fragment. When there is temperature sensitive
mutants, DNA ligase will follow the process of slow stop mutants. It is because DNA replication
has taken place only sealing part is left. So DNA replication will be completed but Okazaki
fragments will not be joined.
Solution
DnaA/ORC: This protein is responsible for initiation of DNA replication. When DNA replication
is temperature sensitive, it affects the function of Dna A/ ORC. It cannot bind to the N-terminus
and thus DNA replication is immediately stopped. So with the increase in temperature, there is
quick stop of the DNA replication.
SSB/RPA: This is the protein complex which acts on the single stranded DNA complex. In the
presences on non-permissible temperatures, this protein complex will quick stop the process of
DNA replication. Thus replication fork is not formed since it requires presence of one of the
proteins from the complex. It can be said that since the process is of so high order, quick stop
mutation takes please due to non- permissible temperature.
DnaB/Mcm: this protein complex is responsible for separating the DNA strand. With the
increase in temperature, the protein cannot separate the DNA strands. Thus DNA replication
stops immediately. Thus it is a quick stop type mutanation.
DNA ligase: there 3 major functions of DNA ligase 1) It seals the repairs in the DNA 2) Joins
the recombinant fragment and 3) it joins Okazaki fragment. When there is temperature sensitive
mutants, DNA ligase will follow the process of slow stop mutants. It is because DNA replication
has taken place only sealing part is left. So DNA replication will be completed but Okazaki
fragments will not be joined..
Answer(19)Mary’s parents are normal, therefore her brother must.pdf
Answer:
(19)
Mary’s parents are normal, therefore her brother must have got the disease allele from his mother
who is a carrier of the disease.
Parents
XY (Mary’s father) x XhX (Mary’s mother)
XhY (Mary’s brother)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
(a) Therefore Mary has 50% chance or ½ chance of being a carrier
(b) (c) and (d)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
Among mary’s sons, one will be a carrier and another will be hemophiliac
Among mary’s daughters, one will be a carrier and another will be normal
(e) the carrier daughter can transmit the disease to her son’s
Solution
Answer:
(19)
Mary’s parents are normal, therefore her brother must have got the disease allele from his mother
who is a carrier of the disease.
Parents
XY (Mary’s father) x XhX (Mary’s mother)
XhY (Mary’s brother)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
(a) Therefore Mary has 50% chance or ½ chance of being a carrier
(b) (c) and (d)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
Among mary’s sons, one will be a carrier and another will be hemophiliac
Among mary’s daughters, one will be a carrier and another will be normal
(e) the carrier daughter can transmit the disease to her son’s.
More Related Content
Similar to #include node1.h #include list.h #include cassert P.pdf
Draw memory map of this link list code and add insert at last ( java)-.pdf
Draw memory map of this link list code and add insert at last ( java):
class listnodes {
int data;
listnodes link;
listnodes() {
data = 0;
link = null;
}
listnodes(int d, listnodes l) {
data = d;
link = l;
}
}
class singlelinkedlist {
public listnodes insertnode(int data, listnodes head) {
listnodes newnode = new listnodes(data, null);
newnode.link = head;
head = newnode;
return head;
}
public listnodes insertAtPosition(listnodes head, int data, int position) {
listnodes newnode = new listnodes(data, null);
listnodes previous = head;
int count = 1;
while (count <= position - 1) {
previous = previous.link;
count++;
}
listnodes current = previous.link;
newnode.link = current;
previous.link = newnode;
return head;
}
public listnodes deletefirst(listnodes head) {
listnodes pre = head;
head = head.link;
pre.link = null;
return pre;
}
public listnodes deletelast(listnodes head) {
listnodes cur = head;
listnodes previouscur = head;
while (cur.link != null) {
previouscur = cur;
cur = cur.link;
}
previouscur.link = null;
return cur;
}
public int length(listnodes head) {
listnodes current = head;
int c = 0;
while (current != null) {
c++;
current = current.link;
}
return c;
}
public boolean find(listnodes head, int searchdata) {
listnodes cur = head;
while (cur != null) {
if (cur.data == searchdata) {
return true;
}
cur = cur.link;
}
return false;
}
public void display(listnodes head) {
listnodes current = head;
while (current.link != null) {
System.out.print(current.data + "-->");
current = current.link;
}
System.out.print(current.data);
}
public listnodes insertAtEnd(listnodes head, int data) {
listnodes newnode = new listnodes(data, null);
if (head == null) {
return newnode;
}
listnodes current = head;
while (current.link != null) {
current = current.link;
}
current.link = newnode;
return head;
}
}
public class LinkedList {
public static void main(String[] args) {
listnodes head=new listnodes(10,null);
singlelinkedlist sl=new singlelinkedlist();
sl.display(head);
System.out.println("\n*****Insert at front*****");
listnodes newhead=sl.insertnode(20, head);
sl.display(newhead);
System.out.println("\n*****Insert at a position*****");
sl.insertAtPosition(newhead, 40, 1);
sl.display(newhead);
System.out.println("\n*****Delete at front*****");
listnodes deletednode=sl.deletefirst(newhead);
System.out.println("Deleted node is: "+deletednode.data);
sl.display(newhead);
System.out.println("\n*****Delete at end*****");
listnodes deletedlast=sl.deletelast(newhead);
System.out.println("Deleted node is: "+deletedlast.data);
sl.display(newhead);
System.out.println("\n*****Length of Linked List*****");
int length=sl.length(newhead);
System.out.println("Length of Linked List is: "+length);
System.out.println("\n*****Search for an element*****");
boolean found=sl.find(newhead, 20);
if(found){
System.out.println("Element found");
}
else{
System.out.println("Element not found");
}
}
}.
A perfect left-sided binary tree is a binary tree where every intern.pdf
A perfect left-sided binary tree is a binary tree where every internal node has two children, and
every left child is a leaf. Write an algorithm, based on DFS or BFS, that takes as input an
undirected graph G, and returns whether or not G is (or can be viewed as) a perfect left-sided
binary tree. Analyze the time complexity of your algorithm.
Solution
bfs(G)
{
list L = empty
tree T = empty
choose a starting vertex x
search(x)
while(L nonempty)
remove edge (v,w) from start of L
if w not yet visited
{
add (v,w) to T
search(w)
}
}
dfs(G)
{
list L = empty
tree T = empty
choose a starting vertex x
search(x)
while(L nonempty)
remove edge (v,w) from end of L
if w not yet visited
{
add (v,w) to T
search(w)
}
}
search(vertex v)
{
visit(v);
for each edge (v,w)
add edge (v,w) to end of L
}
mport java.util.*;
public class BST > implements Iterable
{
public static void main(String[] args)
{
Integer[] a = {1,5,2,7,4};
BST bst = new BST();
for(Integer n : a) bst.insert(n);
bst.preOrderTraversal();
System.out.println();
//testing comparator
//build a mirror BST with a rule: Left > Parent > Right
//code for the comparator at the bottom of the file
bst = new BST(new MyComp1());
for(Integer n : a) bst.insert(n);
bst.preOrderTraversal();
System.out.println();
bst.inOrderTraversal();
System.out.println();
for(Integer n : bst) System.out.print(n);
System.out.println();
System.out.println(bst);
//testing restoring a tree from two given traversals
bst.restore(new Integer[] {11,8,6,4,7,10,19,43,31,29,37,49},
new Integer[] {4,6,7,8,10,11,19,29,31,37,43,49});
bst.preOrderTraversal();
System.out.println();
bst.inOrderTraversal();
System.out.println();
//testing diameter
System.out.println(\"diameter = \" + bst.diameter());
//testing width
System.out.println(\"width = \" + bst.width());
}
private Node root;
private Comparator comparator;
public BST()
{
root = null;
comparator = null;
}
public BST(Comparator comp)
{
root = null;
comparator = comp;
}
private int compare(T x, T y)
{
if(comparator == null) return x.compareTo(y);
else
return comparator.compare(x,y);
}
/*****************************************************
*
* INSERT
*
******************************************************/
public void insert(T data)
{
root = insert(root, data);
}
private Node insert(Node p, T toInsert)
{
if (p == null)
return new Node(toInsert);
if (compare(toInsert, p.data) == 0)
return p;
if (compare(toInsert, p.data) < 0)
p.left = insert(p.left, toInsert);
else
p.right = insert(p.right, toInsert);
return p;
}
/*****************************************************
*
* SEARCH
*
******************************************************/
public boolean search(T toSearch)
{
return search(root, toSearch);
}
private boolean search(Node p, T toSearch)
{
if (p == null)
return false;
else
if (compare(toSearch, p.data) == 0)
return true;
else
if (compare(toSearch, p.data) < 0)
return search(p.left, toSearch);
else
return search(p.right, toSearch);
}
/*****************************************************.
public class SLLT { protected SLLNodeT head, tail; pub.pdf
public class SLL { protected SLLNode head, tail; public SLL() { head = tail = null;
} public void addToTail(T e){ SLLNode newNode = new SLLNode(e); if(head ==
null) head = tail = newNode; else{ tail.next = newNode; tail =
tail.next; } } public void addToHead(T e) { SLLNode newNode = new
SLLNode(e, head); if(head == null) tail = newNode; head = newNode; }
public String toString(){ if (head == null) return "[]"; String out = "[";
SLLNode p = head; while (p.next != null){ out += p.info + " "; p = p.next;
} out += p.info + "]"; return out; } }
public class SLLNode { protected T info; protected SLLNode next; public SLLNode() {
this(null, null); } public SLLNode(T e) { this(e, null); } public SLLNode(T
e, SLLNode ptr) { info = e; next = ptr; } }
public class SortedSLL> extends SLL{ public void insert(T e){ } public void
merge(SortedSLL list){ } }
public class SortedSLL T extends Comparable T extends SLLT{ public void insert (T e) \{ \}
public void merge(SortedSLL T list) \{ \} public class SortedSLL T extends Comparable T
extends SLLT{ public void insert ( T e) \{ \} public void merge(SortedSLL T list) \{ \} \}
ublic class SLLT{ protected SLLNodeT head, tail; public SLL() \{ head = tail = null; \} public
void addToTail( T e) \{ SLLNode newNode = new SLLNodeT(e); if ( head == null) head = tail
= newNode; else\{ tail. next = newNode; tail = tail. next; \} \} public void addToHead( T e) \{
SLLNode T newNode = new SLLNodeT(e, head ); if (head == null) tail = newNode; head =
newNode; \} public string tostring()\{ if (head == null) return "[]"; String out = "["; SLLNode
Tp= head; while (p.next != null) \{ out +=p.info +" "; p=p next; \} out += p.info + "]"; return out;
\}
ublic class SLLNode T{ protected T info; protected SLLNode T next; public SLLNode() \{
this(null, null); \} public SLLNode( T e) \{ this (e, null); \} public SLLNode( T e, SLLNode T
ptr ){ info =e; next =ptr; \}
Write a subclass of SLL named SortedSLL that represents a sorted SinglyLinkedList (sorted in
nondecending order). The class should contain the following methods: 1- [40 Points] void insert
( T e) that inserts an SLLNode in its correct position so that the resulting list remains sorted.
Make sure to consider special cases such as: - The list is empty. - The list has one element. - The
inserted element is smaller than the head, or larger than the tail.. 2- [60 Points] void
merge(SortedSLL T list) that merges the calling list with the argument list. Note that this can be
done by calling the insert method for each element in list, but this is highly ineffiecient, answer
the following question: Q2.1: What is the complexity of this approach? Explain. [10 Points]
Instead, you should come up with a solution that traverse both lists just one time. Furthermore,
the argument list should be empty after the merge is completed. Q2.2: What is the complexity of
this approach? Explain. [10 Points] Hint: Make sure the class SortedSLL accepts types T that is
comparable. You can do this by writing .
Use the singly linked list class introduced in the lab to implement .pdf
Use the singly linked list class introduced in the lab to implement integers of unlimited size.
Each node of the list should store one digit of the integer. You are to implement the addition,
subtraction and multiplication operations. Please note that any additional data structure to be
used in solving this problem has to be taken from the ones introduced in the ICS 202 lab. In
addition, provide a test class that will do the following: It will keep asking the user to enter two
integers, choose one of the operations (addition, subtraction, multiplication) and then display the
result. The program will stop upon entering the # character (without the double quotes).
this singly linked list class:
public class SLL {
private class SLLNode {
private T info;
private SLLNode next;
int value;
public SLLNode() {
this(null, null);
}
public SLLNode(T el) {
this(el, null);
}
public SLLNode(T el, SLLNode ptr) {
info = el;
next = ptr;
}
}
protected SLLNode head, tail;
public SLL() {
head = tail = null;
}
public boolean isEmpty() {
return head == null;
}
public void addToHead(T el) {
head = new SLLNode(el, head);
if (tail == null)
tail = head;
}
public void addToTail(T el) {
if (!isEmpty()) {
tail.next = new SLLNode(el);
tail = tail.next;
} else
head = tail = new SLLNode(el);
}
public T deleteFromHead() { // delete the head and return its info;
if (isEmpty())
return null;
T el = head.info;
if (head == tail) // if only one node on the list;
head = tail = null;
else
head = head.next;
return el;
}
public T deleteFromTail() { // delete the tail and return its info;
if (isEmpty())
return null;
T el = tail.info;
if (head == tail) // if only one node in the list;
head = tail = null;
else { // if more than one node in the list,
SLLNode tmp; // find the predecessor of tail;
for (tmp = head; tmp.next != tail; tmp = tmp.next)
;
tail = tmp; // the predecessor of tail becomes tail;
tail.next = null;
}
return el;
}
public void delete(T el) { // delete the node with an element el;
if (!isEmpty())
if (head == tail && el.equals(head.info)) // if only one
head = tail = null; // node on the list;
else if (el.equals(head.info)) // if more than one node on the list;
head = head.next; // and el is in the head node;
else { // if more than one node in the list
SLLNode pred, tmp;// and el is in a nonhead node;
for (pred = head, tmp = head.next; tmp != null
&& !tmp.info.equals(el); pred = pred.next, tmp = tmp.next)
;
if (tmp != null) { // if el was found;
pred.next = tmp.next;
if (tmp == tail) // if el is in the last node;
tail = pred;
}
}
}
@Override
public String toString() {
if (head == null)
return "[ ]";
String str = "[ ";
SLLNode tmp = head;
while (tmp != null) {
str += tmp.info + " ";
tmp = tmp.next;
}
return str + "]";
}
public boolean contains(T el) {
if (head == null)
return false;
SLLNode tmp = head;
while (tmp != null) {
if (tmp.info.equals(el))
return true;
tmp = tmp.next;
}
return false;
}
public int size() {
if (head == null)
return 0;
int count = 0;
SLLNode p = head;
w.
I need help writing test Codepackage org.example;import j.pdf
I need help writing test
Code:
package org.example;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
class Album implements Comparable {
private int id;
private List artists;
private String title;
private int numSongs;
public Album(int id, List artists, String title, int numSongs) {
this.id = id;
this.artists = artists;
this.title = title;
this.numSongs = numSongs;
}
@Override
public int compareTo(Album other) {
return Integer.compare(this.numSongs, other.numSongs);
}
@Override
public String toString() {
return "ID: " + id + " -- " + numSongs + " songs -- " + artists;
}
// Getter methods for Album properties
// Implement these as needed
}
class DoublyLinkedList {
private Node head;
private Node tail;
private int size;
private class Node {
Album data;
Node prev;
Node next;
Node(Album data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
public DoublyLinkedList() {
head = null;
tail = null;
size = 0;
}
public void append(Album data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
newNode.prev = tail;
tail = newNode;
}
size++;
}
public Node insert(int location, Album data) {
if (location < 0 || location > size) {
throw new IllegalArgumentException("Invalid location");
}
Node newNode = new Node(data);
if (location == 0) {
newNode.next = head;
head.prev = newNode;
head = newNode;
} else if (location == size) {
tail.next = newNode;
newNode.prev = tail;
tail = newNode;
} else {
Node current = head;
for (int i = 0; i < location - 1; i++) {
current = current.next;
}
newNode.prev = current;
newNode.next = current.next;
current.next.prev = newNode;
current.next = newNode;
}
size++;
return newNode;
}
public Node delete(int location) {
if (location < 0 || location >= size) {
throw new IllegalArgumentException("Invalid location");
}
Node deletedNode;
if (location == 0) {
deletedNode = head;
head = head.next;
if (head != null) {
head.prev = null;
} else {
tail = null;
}
} else if (location == size - 1) {
deletedNode = tail;
tail = tail.prev;
tail.next = null;
} else {
Node current = head;
for (int i = 0; i < location; i++) {
current = current.next;
}
deletedNode = current;
current.prev.next = current.next;
current.next.prev = current.prev;
}
size--;
return deletedNode;
}
public int getIndex(Album data) {
Node current = head;
for (int i = 0; i < size; i++) {
if (current.data.equals(data)) {
return i;
}
current = current.next;
}
return -1;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
Node current = head;
while (current != null) {
sb.append(current.data.toString());
if (current.next != null) {
sb.append(" -> ");
} else {
sb.append(" -> NULL");
}
current = current.next;
}
return sb.toString();
}
public void shuffle() {
List albumList = new ArrayList<>();
Node current = head;
while (current != null) {
albumList.add(current.data);
current = current.next;
}
Collections.shuffle(albumList, new Rando.
Template LinkedList;I am using templates to make some linkedLists.pdf
Sargent Corporation bought equipment on January 1, 2013. The equipment cost $180,000 and
had an expected salvage value of $30,000. The life of the equipment was estimated to be 6 years.
The book value of the equipment at the beginning of the third year using straight-line
depreciation would be . C $180,000. $150,000. $130,000. $50,000.
Solution
As per the information provided, Sargent Corporation bought an equipment on Jan 1, 2013 for
$180000 with 6 years life and salvage value of $30000.
Therefore, depreciation expense every year as per Straight line method would be:-
Equipment cost = $180000
LESS:- Salvage value = $30000
Amount on which depriciation is to be charged =$150000
Now, depreciation as per straight line method = $150000 / 6 years
= $25000 every year
Now, book value of Equipment at the beginning of third year is:-
Equipment cost = $180000
LESS :- Depreciation for first and second year = $25000 x 2 years = $50000
Therefore, book value at begginning of third year =$130000
Hence, as per the problem \"Option C\" is correct with book value of $130000..
^^^ Discuss about Header Node And also write a program for unorder.pdf
^^^ Discuss about Header Node? And also write a program for unordered single linked list and
linked implementation of QUEUE?
Solution
Header node:
Sometimes it is desire to keep an extra node at the front of a List. Such a node doesn’t represent
an item in the List and is called a Header Node or a List Header. The Information field of such
Header node might be unused but the Next field maintains the first node address. More often the
information of such a node could be used to keep Global Information about the Entire List.
One of the applications of Header node is the information portion of the Header node contains
the number of nodes (not including Header) in the List. In this Structure the Header must be
adjusted the total number of nodes when we apply addition or deletion operation on the List. We
can directly obtained the total number of nodes without traversing the entire List.
By using this application, we can develop Data Structure Stack easily. Since Header node
information field maintains the number of elements that the Stack contains.
Another application is we can simply develop the Data Structure Queue. Until now, two external
pointers, Front & Rear, were necessary for a List to represent a Queue. However, now only a
single external pointer is sufficient to maintain a Queue that is Head node. Because the Header
node next field behave like a Front and information field of Header node maintains last node
address so that it is behave like a Rear .
Another possibility for the use of the information portion of a List Header is as a pointer
to a Curr node in the List during a traversal process. This would be eliminate the node for an
external pointer during traversal.
#include
#include
#include
#include
struct node
{
char info;
struct node *next;
};
typedef struct node sl;
void display(sl *);
sl * create(sl *root)
{
sl *curr,*new;
char val;
printf(\"\ Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
while(val != \'$\')
{
new=(sl *) malloc(sizeof(sl));
new->info = val;
new->next = NULL;
if(root == NULL)
root = new;
else
{
curr = root;
while( curr->next != NULL )
curr = curr->next;
curr->next = new;
}
printf(\" Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
}
printf(\"\ The Created Linked List Is \ \");
display(root);
return root;
}
sl * delete(sl *root,char val)
{
sl *temp,*curr,*rear;
curr = root;
rear = NULL;
while( curr != NULL && val != curr->info )
{
rear = curr;
curr = curr->next;
}
if(curr == NULL)
{
if( rear == NULL)
{
printf(\"\ Linked List is Empty\");
printf(\"\ Deletion is not Possible \");
}
else
{
printf(\"\ deleted Node does not exist in List\");
printf(\"\ Deletion is not Possible \");
}
}
else
{
if( rear == NULL)
{
temp = root;
root = root->next;
}
else
{
temp = curr;
rear->next = curr->next;
}
printf(\"\ Node is deleted \");
printf(\"\ Deleted Node information is %c\",temp->info);
free(temp);
}
display(root);
return root;
}
sl * insert(sl *root,char val)
{.
Create your own Linked list from scratch (singly linked list).So.pdf
Consider four protons at rest at the corners of a square. The protons are bound together so they
cannot move. Then the bonds holding one of the protons break so that proton is free to move.
Determine that proton\'s acceleration (both direction and magnitude) at the instant after it is no
longer bound as well as its speed when it has moved far away. You know the proton\'s charge, its
mass, and the length of the sides of the square.
Solution
Here we need to note that the like charges repel each other, hence the proton will be pushed
away along the diagonal of the square.
We will assume that the mass of the proton is Mp and charge is q while the length of the side of
the square is a.
The net force due to the proton diagonally opposite would be along the diagonal, and also due to
the other two charges.
Hence the net force would be: 2kq22/a2 + kq2/2a2 = (kq2/a2)[22 + 1/2] along the diagonal.
The acceleration would be given as: Force / mass = (kq2/Mpa2)[22 + 1/2]
So as to determine the speed of the proton once it gets far away, we will use the prinicple of
conservation of energy. Hence the initial potential energy of the proton would be equal to its
final kinetic energy hence giving us the speed.
That is. 2kq2/a + kq2/a2 = (kq2/a)[2 + 1/2] = Mpv2/2
or, V = sqrt[(2kq2/Mpa)[2 + 1/2]] which is the required expression for the speed of the proton..
Discuss about Header Node And also write a program for unordered si.pdf
Consider rectangle ABCD. If mADF=60°, then what is the mFDC?
a) 60°
b) 30°
c) 90°
d) 120°
e) 45°
f) None of the above
Solution
Given figure ABCD is a rectangle.
Looking into the properties of rectangle,
1) All the angles in a rectangle are right angles i.e. equal to 90 degrees.
2) Opposite sides are parallel and equal.
By the first property stated above,
m(D) = 90 degrees
Angle D can be written as given in the following
m(D) = m(ADF) + m(FDC) = 90
Given m(ADF) = 60
Therefore, 60 + m(FDC) = 90
m(FDC) = 30 degress.
Hence option B) 30 is the required answer..
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables: a double data value, a pointer to the next node, and a pointer to the previous
node. Each member variable is protected. So code outside of the class must use the provided
getter and setter member functions to get or set a member variable. Node.h is read only, since no
changes are required. Step 2: Implement the Insert() member function A class for a sorted,
doubly-linked list is declared in SortedNumberList.h. Implement the SortedNumberList class's
Insert() member function. The function must create a new node with the parameter value, then
insert the node into the proper sorted position in the linked list. Ex: Suppose a
SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node with data
value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's sorted order
and yielding: 23 35.5 47.25 86 Step 3: Test in develop mode Code in main() takes a space-
separated list of numbers and inserts each into a SortedNumberList. The list is displayed after
each insertion. Ex: If input is 77 15 -42 63.5 then output is: List after inserting 77: 77 List after
inserting 15: 15 77 List after inserting -42: -42 15 77 List after inserting 63.5: -42 15 63.5 77 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove() member function. The
function takes a parameter for the number to be removed from the list. If the number does not
exist in the list, the list is not changed and false is returned. Otherwise, the first instance of the
number is removed from the list and true is returned. Uncomment the commented-out part in
main() that reads a second input line and removes numbers from the list. Test in develop mode to
ensure that insertion and removal both work properly, then submit code for grading. Ex: If input
is 84 72 19 61 19 84 then output is: List after inserting 84: 84 List after inserting 72: 72 84 List
after inserting 19: 19 72 84 List after inserting 61: 19 61 72 84 List after removing 19: 61 72 84
List after removing 84: 61 72
main.cpp
#include
#include
#include
#include "Node.h"
#include "SortedNumberList.h"
using namespace std; void PrintList(SortedNumberList& list); vector SpaceSplit(string source);
int main(int argc, char *argv[]) { // Read the line of input numbers string inputLine; getline(cin,
inputLine); // Split on space character vector terms = SpaceSplit(inputLine); // Insert each value
and show the sorted list's contents after each insertion SortedNumberList list; for (auto term :
terms) { double number = stod(term); cout << "List after inserting " << number << ": " << endl;
list.Insert(number); PrintList(list); } /* // Read the input line with numbers to remove getline(cin,
inputLi.
Solve using Java programming language- ----------------------------.pdf
Solve using Java programming language.
//************************** SLL.java *********************************
// a generic singly linked list class
public class SLL<T> {
private class SLLNode<T> {
private T info;
private SLLNode<T> next;
public SLLNode() {
this(null,null);
}
public SLLNode(T el) {
this(el,null);
}
public SLLNode(T el, SLLNode<T> ptr) {
info = el; next = ptr;
}
}
protected SLLNode<T> head, tail;
public SLL() {
head = tail = null;
}
public boolean isEmpty() {
return head == null;
}
public void addToHead(T el) {
head = new SLLNode<T>(el,head);
if (tail == null)
tail = head;
}
public void addToTail(T el) {
if (!isEmpty()) {
tail.next = new SLLNode<T>(el);
tail = tail.next;
}
else head = tail = new SLLNode<T>(el);
}
public T deleteFromHead() { // delete the head and return its info;
if (isEmpty())
return null;
T el = head.info;
if (head == tail) // if only one node on the list;
head = tail = null;
else head = head.next;
return el;
}
public T deleteFromTail() { // delete the tail and return its info;
if (isEmpty())
return null;
T el = tail.info;
if (head == tail) // if only one node in the list;
head = tail = null;
else { // if more than one node in the list,
SLLNode<T> tmp; // find the predecessor of tail;
for (tmp = head; tmp.next != tail; tmp = tmp.next);
tail = tmp; // the predecessor of tail becomes tail;
tail.next = null;
}
return el;
}
public void delete(T el) { // delete the node with an element el;
if (!isEmpty())
if (head == tail && el.equals(head.info)) // if only one
head = tail = null; // node on the list;
else if (el.equals(head.info)) // if more than one node on the list;
head = head.next; // and el is in the head node;
else { // if more than one node in the list
SLLNode<T> pred, tmp;// and el is in a nonhead node;
for (pred = head, tmp = head.next;
tmp != null && !tmp.info.equals(el);
pred = pred.next, tmp = tmp.next);
if (tmp != null) { // if el was found;
pred.next = tmp.next;
if (tmp == tail) // if el is in the last node;
tail = pred;
}
}
}
@Override
public String toString() {
if(head == null)
return "[ ]";
String str = "[ ";
SLLNode<T> tmp = head;
while(tmp != null){
str += tmp.info + " ";
tmp = tmp.next;
}
return str+"]";
}
public boolean contains(T el) {
if(head == null)
return false;
SLLNode<T> tmp = head;
while(tmp != null){
if(tmp.info.equals(el))
return true;
tmp = tmp.next;
}
return false;
}
public int size(){
if(head == null)
return 0;
int count = 0;
SLLNode<T> p = head;
while(p != null) {
count++;
p = p.next;
}
return count;
}
}
Given the code above, solve the following tasks (please show the solution for every task
clearly):
For part (c) this is the code for the test program:
public class SLL_Driver {
public static void main(String[] args) {
SLL<String> myList = new SLL<String>();
String[] cityNames = {"Jubail", "Riyadh", "Abha", "Dammam", "Taif"};
for(int i = 0; i < cityNames.length; i++)
myList.addToHead(cityNames[i]);
System.out.println("The list is: " + myList);
System.out.println("It is " + myLis.
Main-cpp #include -iostream- #include -List-h- int main() { retur.pdf
Main.cpp
#include <iostream>
#include "List.h"
int main() {
return 0;
}
List.h
#ifndef HW10_25_LIST_H
#define HW10_25_LIST_H
#include <string>
#include <vector>
using Item = std::string;
class List {
private:
class ListNode {
public:
Item item;
ListNode * next;
ListNode(Item i, ListNode *n=nullptr) {
item = i;
next = n;
}
};
ListNode * head = nullptr;
ListNode * tail = nullptr;
public:
class iterator {
ListNode *node;
iterator(ListNode *n) : node {n} {}
friend class List;
public:
Item& operator*() { return node->item; }
iterator& operator++() { node = node->next; return *this; }
bool operator!=(const iterator& other) const { return node != other.node; }
};
public:
List() = default;
List(const List& other);
List& operator=(const List& rhs);
List(List&& other);
List& operator=(List&& rhs);
~List();
bool empty() const { return head==nullptr; }
void push_back(const Item& a);
void push_front(const Item& a);
iterator begin() const { return iterator(head); }
iterator end() const { return iterator(nullptr); }
friend std::vector<void*> getListPtrs(const List&);
};
#endif //HW10_25_LIST_H
List.cpp
#include "List.h"
// IMPLEMENT MOVE CONSTRUCTOR
// IMPLEMENT MOVE ASSIGNMENT OPERATOR
List::List(const List& other) {
auto p = other.head;
while (p) {
push_back(p->item);
p = p->next;
}
}
List& List::operator=(const List& rhs) {
if (&rhs == this) return *this;
// delete old list
auto p = head;
while (p) {
auto tmp = p->next;
delete p;
p = tmp;
}
head = tail = nullptr;
// copy from rhs
p = rhs.head;
while (p) {
push_back(p->item);
}
// return reference to self
return *this;
}
List::~List() {
auto p = head;
while (p) {
auto tmp = p->next;
delete p;
p = tmp;
}
}
void List::push_back(const Item& a) {
auto node {new ListNode(a)};
if ( head == nullptr ) {
// empty list
head = node;
tail = node;
} else {
tail->next = node;
tail = node;
}
}
void List::push_front(const Item& a) {
auto node {new ListNode(a)};
if (head == nullptr) {
head = node;
tail = node;
}
else {
node->next = head;
head = node;
}
}
10.25 Move constructor and assignment for linked list Write a move constructor and a move
assignment operator for the List class.
.
When we first examined the array based and node based implementations.docx
When we first examined the array based and node based implementations
^^^Q2. Discuss about Header Node And also write a program fo.pdf
^^^
Q2. Discuss about Header Node?
And also write a program for unordered single linked list and linked implementation of
QUEUE?
Solution
Header node:
Sometimes it is desire to keep an extra node at the front of a List. Such a node doesn’t represent
an item in the List and is called a Header Node or a List Header. The Information field of such
Header node might be unused but the Next field maintains the first node address. More often the
information of such a node could be used to keep Global Information about the Entire List.
One of the applications of Header node is the information portion of the Header node contains
the number of nodes (not including Header) in the List. In this Structure the Header must be
adjusted the total number of nodes when we apply addition or deletion operation on the List. We
can directly obtained the total number of nodes without traversing the entire List.
By using this application, we can develop Data Structure Stack easily. Since Header node
information field maintains the number of elements that the Stack contains.
Another application is we can simply develop the Data Structure Queue. Until now, two external
pointers, Front & Rear, were necessary for a List to represent a Queue. However, now only a
single external pointer is sufficient to maintain a Queue that is Head node. Because the Header
node next field behave like a Front and information field of Header node maintains last node
address so that it is behave like a Rear .
Another possibility for the use of the information portion of a List Header is as a pointer
to a Curr node in the List during a traversal process. This would be eliminate the node for an
external pointer during traversal.
#include
#include
#include
#include
struct node
{
char info;
struct node *next;
};
typedef struct node sl;
void display(sl *);
sl * create(sl *root)
{
sl *curr,*new;
char val;
printf(\"\ Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
while(val != \'$\')
{
new=(sl *) malloc(sizeof(sl));
new->info = val;
new->next = NULL;
if(root == NULL)
root = new;
else
{
curr = root;
while( curr->next != NULL )
curr = curr->next;
curr->next = new;
}
printf(\" Enter $ to STOP --- Otherwise Continue : \");
fflush(stdin);
scanf(\"%c\",&val);
}
printf(\"\ The Created Linked List Is \ \");
display(root);
return root;
}
sl * delete(sl *root,char val)
{
sl *temp,*curr,*rear;
curr = root;
rear = NULL;
while( curr != NULL && val != curr->info )
{
rear = curr;
curr = curr->next;
}
if(curr == NULL)
{
if( rear == NULL)
{
printf(\"\ Linked List is Empty\");
printf(\"\ Deletion is not Possible \");
}
else
{
printf(\"\ deleted Node does not exist in List\");
printf(\"\ Deletion is not Possible \");
}
}
else
{
if( rear == NULL)
{
temp = root;
root = root->next;
}
else
{
temp = curr;
rear->next = curr->next;
}
printf(\"\ Node is deleted \");
printf(\"\ Deleted Node information is %c\",temp->info);
free(temp);
}
display(root);
return root;
}
sl * insert(sl *root,char va.
#include iostream using namespace std; const int nil = 0; cl.docx
#include iostream using namespace std; const int nil = 0; cl
Similar to #include node1.h #include list.h #include cassert P.pdf (20)
Draw memory map of this link list code and add insert at last ( java)-.pdf
Draw memory map of this link list code and add insert at last ( java)-.pdf
A perfect left-sided binary tree is a binary tree where every intern.pdf
A perfect left-sided binary tree is a binary tree where every intern.pdf
public class SLLT { protected SLLNodeT head, tail; pub.pdf
public class SLLT { protected SLLNodeT head, tail; pub.pdf
Use the singly linked list class introduced in the lab to implement .pdf
Use the singly linked list class introduced in the lab to implement .pdf
I need help writing test Codepackage org.example;import j.pdf
I need help writing test Codepackage org.example;import j.pdf
Template LinkedList;I am using templates to make some linkedLists.pdf
Template LinkedList;I am using templates to make some linkedLists.pdf
^^^ Discuss about Header Node And also write a program for unorder.pdf
^^^ Discuss about Header Node And also write a program for unorder.pdf
Create your own Linked list from scratch (singly linked list).So.pdf
Create your own Linked list from scratch (singly linked list).So.pdf
Discuss about Header Node And also write a program for unordered si.pdf
Discuss about Header Node And also write a program for unordered si.pdf
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Solve using Java programming language- ----------------------------.pdf
Solve using Java programming language- ----------------------------.pdf
Main-cpp #include -iostream- #include -List-h- int main() { retur.pdf
Main-cpp #include -iostream- #include -List-h- int main() { retur.pdf
When we first examined the array based and node based implementations.docx
When we first examined the array based and node based implementations.docx
^^^Q2. Discuss about Header Node And also write a program fo.pdf
^^^Q2. Discuss about Header Node And also write a program fo.pdf
#include iostream using namespace std; const int nil = 0; cl.docx
#include iostream using namespace std; const int nil = 0; cl.docx
More from aquacosmossystems
DnaAORC This protein is responsible for initiation of DNA replicat.pdf
DnaA/ORC: This protein is responsible for initiation of DNA replication. When DNA replication
is temperature sensitive, it affects the function of Dna A/ ORC. It cannot bind to the N-terminus
and thus DNA replication is immediately stopped. So with the increase in temperature, there is
quick stop of the DNA replication.
SSB/RPA: This is the protein complex which acts on the single stranded DNA complex. In the
presences on non-permissible temperatures, this protein complex will quick stop the process of
DNA replication. Thus replication fork is not formed since it requires presence of one of the
proteins from the complex. It can be said that since the process is of so high order, quick stop
mutation takes please due to non- permissible temperature.
DnaB/Mcm: this protein complex is responsible for separating the DNA strand. With the
increase in temperature, the protein cannot separate the DNA strands. Thus DNA replication
stops immediately. Thus it is a quick stop type mutanation.
DNA ligase: there 3 major functions of DNA ligase 1) It seals the repairs in the DNA 2) Joins
the recombinant fragment and 3) it joins Okazaki fragment. When there is temperature sensitive
mutants, DNA ligase will follow the process of slow stop mutants. It is because DNA replication
has taken place only sealing part is left. So DNA replication will be completed but Okazaki
fragments will not be joined.
Solution
DnaA/ORC: This protein is responsible for initiation of DNA replication. When DNA replication
is temperature sensitive, it affects the function of Dna A/ ORC. It cannot bind to the N-terminus
and thus DNA replication is immediately stopped. So with the increase in temperature, there is
quick stop of the DNA replication.
SSB/RPA: This is the protein complex which acts on the single stranded DNA complex. In the
presences on non-permissible temperatures, this protein complex will quick stop the process of
DNA replication. Thus replication fork is not formed since it requires presence of one of the
proteins from the complex. It can be said that since the process is of so high order, quick stop
mutation takes please due to non- permissible temperature.
DnaB/Mcm: this protein complex is responsible for separating the DNA strand. With the
increase in temperature, the protein cannot separate the DNA strands. Thus DNA replication
stops immediately. Thus it is a quick stop type mutanation.
DNA ligase: there 3 major functions of DNA ligase 1) It seals the repairs in the DNA 2) Joins
the recombinant fragment and 3) it joins Okazaki fragment. When there is temperature sensitive
mutants, DNA ligase will follow the process of slow stop mutants. It is because DNA replication
has taken place only sealing part is left. So DNA replication will be completed but Okazaki
fragments will not be joined..
Answer(19)Mary’s parents are normal, therefore her brother must.pdf
Answer:
(19)
Mary’s parents are normal, therefore her brother must have got the disease allele from his mother
who is a carrier of the disease.
Parents
XY (Mary’s father) x XhX (Mary’s mother)
XhY (Mary’s brother)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
(a) Therefore Mary has 50% chance or ½ chance of being a carrier
(b) (c) and (d)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
Among mary’s sons, one will be a carrier and another will be hemophiliac
Among mary’s daughters, one will be a carrier and another will be normal
(e) the carrier daughter can transmit the disease to her son’s
Solution
Answer:
(19)
Mary’s parents are normal, therefore her brother must have got the disease allele from his mother
who is a carrier of the disease.
Parents
XY (Mary’s father) x XhX (Mary’s mother)
XhY (Mary’s brother)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
(a) Therefore Mary has 50% chance or ½ chance of being a carrier
(b) (c) and (d)
For a carrier female, with each pregnancy there is a one in two (50%) chance her sons will
inherit the disease allele and a one in two (50%) chance her daughters will be carriers.
Among mary’s sons, one will be a carrier and another will be hemophiliac
Among mary’s daughters, one will be a carrier and another will be normal
(e) the carrier daughter can transmit the disease to her son’s.
Answer Q1. Red mangroove is the last mangroove to colonise on the.pdf
Answer :
Q1. Red mangroove is the last mangroove to colonise on the shore line
Q2. The melon of Dolphins are used for the focusing of sound pulses.
Q4. Coral reef accounts for the largest pecentage of the oceans primary
Solution
Answer :
Q1. Red mangroove is the last mangroove to colonise on the shore line
Q2. The melon of Dolphins are used for the focusing of sound pulses.
Q4. Coral reef accounts for the largest pecentage of the oceans primary.
An Arrhenius acid produces H+ ions insolutionA Bronsted-Lowry acid.pdf
An Arrhenius acid produces H+ ions insolution
A Bronsted-Lowry acid is a protoon donor.
A Lewis base is an eelectron pair donor.
Water could behave as an Arrhenius acid, Bronsted-Lowryacid, and a Lewis base.
Water acting as an arrhenius acid: Water acts as asArrhenius acid as it is capable of producing
protons insolution.
H2O (l) H+ (aq) + OH-(aq)
Water acting as a Bronsted-Lowry acid: Water acts as aBronsted-Lowry acid as it can donate H+
to a base.
H2O (l) + NH3 (aq) NH4+ (aq) + OH- (aq)
Water acting as a Lewis base: Water acts as a Lewis baseas it can donate the lone pair of
electrons present on the Oxygenatom.
Al+3 (aq) + H2O (l) Al(H2O)6+3 (aq)
Solution
An Arrhenius acid produces H+ ions insolution
A Bronsted-Lowry acid is a protoon donor.
A Lewis base is an eelectron pair donor.
Water could behave as an Arrhenius acid, Bronsted-Lowryacid, and a Lewis base.
Water acting as an arrhenius acid: Water acts as asArrhenius acid as it is capable of producing
protons insolution.
H2O (l) H+ (aq) + OH-(aq)
Water acting as a Bronsted-Lowry acid: Water acts as aBronsted-Lowry acid as it can donate H+
to a base.
H2O (l) + NH3 (aq) NH4+ (aq) + OH- (aq)
Water acting as a Lewis base: Water acts as a Lewis baseas it can donate the lone pair of
electrons present on the Oxygenatom.
Al+3 (aq) + H2O (l) Al(H2O)6+3 (aq).
Ans. One of the main disadvantage is chromatic aberrasion. A more li.pdf
Ans. One of the main disadvantage is chromatic aberrasion. A more likely cost of trichromacy
arises when an image is sampled by receptors with differing spectral sensivities because it is not
possible to separate luminanance information.
Solution
Ans. One of the main disadvantage is chromatic aberrasion. A more likely cost of trichromacy
arises when an image is sampled by receptors with differing spectral sensivities because it is not
possible to separate luminanance information..
A coordination problem occurs in situations where there is no Nash E.pdf
A coordination problem occurs in situations where there is no Nash Equilibrium or there is more
than one Nash Equilibrium. it also occure when there is a unique but undireable Nash
Equilibrium.
Option (B), Option (D) and option (E) is correct answer.
Solution
A coordination problem occurs in situations where there is no Nash Equilibrium or there is more
than one Nash Equilibrium. it also occure when there is a unique but undireable Nash
Equilibrium.
Option (B), Option (D) and option (E) is correct answer..
1. When an integrated F plasmid leaves the chromosome it may take so.pdf
1. When an integrated F plasmid leaves the chromosome it may take some chromosomal genes
from one side of the integration site and it results in F\' cells. Integration of F plasmid into the
host chromosome results in Hfr (High frequency of recombination) cells
2. Genetic transfer in Archaea is by means of horizontal gene transfer where genes can be
transfered from one to other similar to bacteria conjugation or transduction.
3. Methanogenesis is the formation of methane by the methanogens. Methanogenesis actually
complete the decomposition process. The semi-final products of decomposition like carbon
dioxide, small organics and hydrogen are completely removed. If methanogenesis does not
happen, it leads to accumulation of carbon in anaerobic envrionment. Methanogens belong to
group archaea.
4. To resist high temperatures in the environment, bacteria convert all its unsaturated fatty acids
in the membrane to saturated fatty acids. It prevents the denaturation of enzymes and proteins in
the cell.
5. Methanogenesis takes place in Anaerobic condition because oxygen inhibits the growth of
methanogens.
Solution
1. When an integrated F plasmid leaves the chromosome it may take some chromosomal genes
from one side of the integration site and it results in F\' cells. Integration of F plasmid into the
host chromosome results in Hfr (High frequency of recombination) cells
2. Genetic transfer in Archaea is by means of horizontal gene transfer where genes can be
transfered from one to other similar to bacteria conjugation or transduction.
3. Methanogenesis is the formation of methane by the methanogens. Methanogenesis actually
complete the decomposition process. The semi-final products of decomposition like carbon
dioxide, small organics and hydrogen are completely removed. If methanogenesis does not
happen, it leads to accumulation of carbon in anaerobic envrionment. Methanogens belong to
group archaea.
4. To resist high temperatures in the environment, bacteria convert all its unsaturated fatty acids
in the membrane to saturated fatty acids. It prevents the denaturation of enzymes and proteins in
the cell.
5. Methanogenesis takes place in Anaerobic condition because oxygen inhibits the growth of
methanogens..
1. A DNA molecule contains two strands of poly deoxyribonucleotide s.pdf
1. A DNA molecule contains two strands of poly deoxyribonucleotide strands twisted together to
form a double helix. The two strands are antiparallel, i.e., one strand runs in the 5’ to 3’ direction
while the other in 3’ to 5’ direction. The sugar-phosphate backbone is found on the exterior of
this helix and the bases are branching towards the center.
RNA, in the majority cases, consists of one strand (polymer of ribonucleotides) of nucleic acids
linked together by 3\',5\'-phosphodiester bonds.
2. The mRNA molecules which are transcribed from genes of the total genome and have the base
sequence complementary to DNA, carry DNA,s genetic information\'s for the assembly of amino
acids into the polypeptide chains, to the cytoplasmic sites of protein synthesis, the ribosomes. to
which they become associated to participate in codon-anticodon interaction with tRNA, are
called informational or messenger RNAs (mRNA) .
Solution
1. A DNA molecule contains two strands of poly deoxyribonucleotide strands twisted together to
form a double helix. The two strands are antiparallel, i.e., one strand runs in the 5’ to 3’ direction
while the other in 3’ to 5’ direction. The sugar-phosphate backbone is found on the exterior of
this helix and the bases are branching towards the center.
RNA, in the majority cases, consists of one strand (polymer of ribonucleotides) of nucleic acids
linked together by 3\',5\'-phosphodiester bonds.
2. The mRNA molecules which are transcribed from genes of the total genome and have the base
sequence complementary to DNA, carry DNA,s genetic information\'s for the assembly of amino
acids into the polypeptide chains, to the cytoplasmic sites of protein synthesis, the ribosomes. to
which they become associated to participate in codon-anticodon interaction with tRNA, are
called informational or messenger RNAs (mRNA) ..
Ethyl 4-aminobenzoate is a basic organic compound. In basic and neut.pdf
Ethyl 4-aminobenzoate is a basic organic compound. In basic and neutral solutions, it will be
insoluble in water. However, in acidic solutions, the amino group will be protonated, formed a
charged salt species. As with normal salts, this is water-soluble. So; 1.0 M HCl: soluble 1.0 M
NaOH and Water: insoluble.
Solution
Ethyl 4-aminobenzoate is a basic organic compound. In basic and neutral solutions, it will be
insoluble in water. However, in acidic solutions, the amino group will be protonated, formed a
charged salt species. As with normal salts, this is water-soluble. So; 1.0 M HCl: soluble 1.0 M
NaOH and Water: insoluble..
draw a sphere and use raytracing on the sphere in OpenGL glut. .pdf
/* draw a sphere and use raytracing on the sphere in OpenGL glut. */
#include
#include
#include
#include
#include
#define screen_width 750
#define screen_height 750
#define true 1
#define false 0
#define perpendicular 0
int gridXsize = 20;
int gridZsize = 20;
float plane[] = {0.0, 1.0, 0.0, -50.0,};
float sphere[] = {250.0, 270.0, -100.0, 100.0};
float eye[] = {0.0, 400.0, 550.0};
float light[] = {250.0, 550.0, -200.0};
float dot(float *u, float *v)
{
return u[0]*v[0] + u[1]*v[1] + u[2]*v[2];
}
void norm(float *u)
{
float norm = sqrt(abs(dot(u,u)));
for (int i =0; i <3; i++)
{
u[i] = u[i]/norm;
}
}
float plane_intersect(float *u, float *pO)
{
float normt[3] = {plane[0], plane[1], plane[2]};
float s;
if (dot(u,normt) == 0)
{
s = -10;
}
else
{
s = (plane[3]-(dot(pO,normt)))/(dot(u,normt));
}
return s;
}
float sphere_intersect(float *u, float *pO)
{
float deltaP[3] = {sphere[0]-pO[0],sphere[1]-pO[1],sphere[2]-pO[2]};
float deltLen = sqrt(abs(dot(deltaP,deltaP)));
float t=0;
float answer;
float det;
if ((det =(abs(dot(u,deltaP)*dot(u,deltaP))- (deltLen*deltLen)+sphere[3]*sphere[3])) < 0)
{
answer = -10;
}
else
{
t =-1*dot(u,deltaP)- sqrt(det) ;
if (t>0)
{
answer = t;
}
else
{
answer = -10;
}
}
return answer;
}
void find_reflect(float *u, float s, float *pO)
{
float n[3] = {pO[0]+s *u[0]-sphere[0],pO[1]+s *u[1]-sphere[1],pO[2]+s *u[2]- sphere[2]};
float l[3] = {s *u[0],s *u[1],s *u[2]};
u[0] =(2*dot(l,n)*n[0])-l[0];
u[1] = (2*dot(l,n)*n[1])-l[1];
u[2] = (2*dot(l,n)*n[2])-l[2];
}
float find_shade(float *u,float s, float *pO)
{
float answer;
float lightVec[3] = {light[0]-(pO[0]+s *u[0]), light[1]-(pO[1]+s *u[1]), light[2]-(pO[2]+s
*u[2])};
float n[3] = {pO[0]+s *u[0]-sphere[0],pO[1]+s *u[1]-sphere[1],pO[2]+s *u[2]-sphere[2]};
answer = -1*dot(lightVec,n)/(sqrt(abs(dot(lightVec,lightVec)))*sqrt(abs(dot(n,n))));
return answer;
}
void init()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,screen_width,0,screen_height);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
for (int i=0; i < screen_width; i++)
{
for (int j=0; j < screen_height; j++)
{
float ray[3] = {1*(eye[0]-i),-1*(eye[1]-j),1*eye[2]};
float point[3] = {i,j,0};
norm(ray);
int plotted = false;
while (!plotted)
{
float s_plane = plane_intersect(ray, point);
float s_sphere = sphere_intersect(ray, point);
if (s_plane <= 0 && s_sphere <=0)
{
glColor3f(0,0,0);
glBegin(GL_POINTS);
glVertex3f(i,j,0);
glEnd();
plotted = true;
}
else if (s_sphere >= 0 && (s_plane <=0 || s_sphere <= s_plane))
{
find_reflect(ray, s_sphere, point);
}
else if (s_plane >=0 && (s_sphere <=0 ||s_plane <= s_sphere))
{
float shade = find_shade(ray, s_plane, point);
float xx = s_plane*ray[0] + eye[0];
float z = s_plane*ray[2] + eye[2];
if (abs((int)xx/gridXsize)%2 == abs((int)z/gridZsize)%2)
{
glColor3f(shade,0,0);
}
else
{
glColor3f(shade,shade,shade);
}
glBegin(GL_POINTS);
glVertex3f(i,j,0);
glEnd();
plotted = true;
}
}
}
}
glFlush();
}
int main(.
SnO2 (ore) is initially washed and dressed. then .pdf
SnO2 (ore) is initially washed and dressed. then it is treated with red hot
coke/coall(acts as reducing agent) SnO2(s) + C(s)---------> Sn(molten) +CO(g) thus obtained
molten Sn is cooled to Pure solid form
Solution
SnO2 (ore) is initially washed and dressed. then it is treated with red hot
coke/coall(acts as reducing agent) SnO2(s) + C(s)---------> Sn(molten) +CO(g) thus obtained
molten Sn is cooled to Pure solid form.
d) Valine Note its side chain doesnt contain a.pdf
d) Valine Note: its side chain doesn\'t contain acidic H such as those in NH or
COOH group. Thus, pH value doesn\'t affect the charge since no protonation or deprotonation
happens.
Solution
d) Valine Note: its side chain doesn\'t contain acidic H such as those in NH or
COOH group. Thus, pH value doesn\'t affect the charge since no protonation or deprotonation
happens..
Amphiprotic. The preferred term is amphoteric. A .pdf
Amphiprotic. The preferred term is amphoteric. A compound that is amphoteric can
behave as either an acid or a base. These are most commonly explained when using the
Bronsted-Lowry theory of acids and bases. Sorry. NONE of these are amphoteric (or
amphiprotic). In order to behave as a Bronsted-Lowry acid it must donate a proton. That
narrows it down to HCl and HSO4-. In order to behave as a base it must accept a proton. A, D
and E can all accept protons. HCl is a strong acid and dissociates to form H+ and Cl-. There is
no tendency to gain a proton. HSO4- is a weak acid and can donate a proton, but it won\'t accept
a proton to make H2SO4 because H2SO4 is a strong acid and completely dissociates. Even if
one of the choices had been HSO3- we would still have a problem. It would be tempting to say
that HSO3- could gain a proton to make the weak acid H2SO3. The problem is that H2SO3 does
not exist in aqueous solution. It is a fictitious acid, much like H2CO3 which also cannot exist in
aqueous solution. The bottom line is that NONE of these are amphoteric. ========= Follow
up ========== See! HPV got suckered. Sorry, you can\'t possibly form H2SO4 and OH-.
H2SO4 is a strong acid and completely dissociates to form H+ and HSO4-. The H+ will combine
with OH- to make water, and you\'re right back where you started. No. HSO4- is NOT
amphoteric in aqueous solution. ======= More follow up ========== \"Would it matter
about the physical state?\" No. For the substance to gain a proton, it will be in aqueous solution.
As soon as HCl interacts with water it will dissociate to form H+ and Cl-.
=============================== You may see that HSO4- is listed as an amphoteric
substance, but only because whoever wrote that didn\'t think it through.
Solution
Amphiprotic. The preferred term is amphoteric. A compound that is amphoteric can
behave as either an acid or a base. These are most commonly explained when using the
Bronsted-Lowry theory of acids and bases. Sorry. NONE of these are amphoteric (or
amphiprotic). In order to behave as a Bronsted-Lowry acid it must donate a proton. That
narrows it down to HCl and HSO4-. In order to behave as a base it must accept a proton. A, D
and E can all accept protons. HCl is a strong acid and dissociates to form H+ and Cl-. There is
no tendency to gain a proton. HSO4- is a weak acid and can donate a proton, but it won\'t accept
a proton to make H2SO4 because H2SO4 is a strong acid and completely dissociates. Even if
one of the choices had been HSO3- we would still have a problem. It would be tempting to say
that HSO3- could gain a proton to make the weak acid H2SO3. The problem is that H2SO3 does
not exist in aqueous solution. It is a fictitious acid, much like H2CO3 which also cannot exist in
aqueous solution. The bottom line is that NONE of these are amphoteric. ========= Follow
up ========== See! HPV got suckered. Sorry, you can\'t possibly form H2SO4 and OH-.
H2SO4 is a strong acid and completely dissociates to form H+ a.
at equivalence point, Moles OH- added = moles H+.pdf
at equivalence point, Moles OH- added = moles H+ Molarity NaOH x vol. OH- x
1 OH- per NaOH = moles OH- = moles H+ = Molarity H2SO4 x vol H2SO4 x 2 H+ per
H2SO4 More generally, M1V1E1 = M2V2E2, where E is the equivalence factor, number of H+
per formula unit for acids and number of OH- per unit for bases
Solution
at equivalence point, Moles OH- added = moles H+ Molarity NaOH x vol. OH- x
1 OH- per NaOH = moles OH- = moles H+ = Molarity H2SO4 x vol H2SO4 x 2 H+ per
H2SO4 More generally, M1V1E1 = M2V2E2, where E is the equivalence factor, number of H+
per formula unit for acids and number of OH- per unit for bases.
We Know that Water is a Polar component as .pdf
We Know that: Water is a Polar component as the property ofthe solubility Like
dissolves Like methyl tertiary butyl etherwhich is polar compound is relatively more soluble
inwater when compared to other components in gasoline.
Solution
We Know that: Water is a Polar component as the property ofthe solubility Like
dissolves Like methyl tertiary butyl etherwhich is polar compound is relatively more soluble
inwater when compared to other components in gasoline..
molar mass of C2H5OH = 46.1 gmole moles of C2H5O.pdf
molar mass of C2H5OH = 46.1 g/mole moles of C2H5OH = mass / molar mass =
47.0 / 46.1 = 1.02 mole 1 moles of C2H5OH contains 6.02 x 1023 C2H5OH molecules, thus,
number of C2H5OH molecules = 1.02 x 6.02 x 1023 = 6.14 x 1023 C2H5OH molecules
Solution
molar mass of C2H5OH = 46.1 g/mole moles of C2H5OH = mass / molar mass =
47.0 / 46.1 = 1.02 mole 1 moles of C2H5OH contains 6.02 x 1023 C2H5OH molecules, thus,
number of C2H5OH molecules = 1.02 x 6.02 x 1023 = 6.14 x 1023 C2H5OH molecules.
What property of PN code makes them suitable for use in spread spect.pdf
What property of PN code makes them suitable for use in spread spectrum communication?
Solution
Pseudo random noise is used in some electronic musical instruments, either by itself or as an
input to subtractive synthesis, and in many white noise machines.
In spread-spectrum systems, the receiver correlates a locally generated signal with the received
signal. Such spread-spectrum systems require a set of one or more \"codes\" or \"sequences\"
such that
Like random noise, the local sequence has a very low correlation with any other sequence in the
set, or with the same sequence at a significantly different time offset, or with narrow band
interference, or with thermal noise.
Unlike random noise, it must be easy to generate exactly the same sequence at both the
transmitter and the receiver, so the receiver\'s locally generated sequence has a very high
correlation with the transmitted sequence.
In a direct-sequence spread spectrum system, each bit in the pseudorandom binary sequence is
known as a chip and the inverse of its period as chip rate; comparebit rate and symbol rate.
In a frequency-hopping spread spectrum sequence, each value in the pseudo random sequence is
known as a channel number and the inverse of its period as thehop rate. FCC Part 15 mandates at
least 50 different channels and at least a 2.5 Hz hop rate for narrow band frequency-hopping
systems.
GPS satellites broadcast data at a rate of 50 data bits per second – each satellite modulates its
data with one PN bit stream at 1.023 million chips per second and the same data with another PN
bit stream at 10.23 million chips per second. GPS receivers correlate the received PN bit stream
with a local reference to measure distance. GPS is a receive-only system that uses relative timing
measurements from several satellites (and the known positions of the satellites) to determine
receiver position.
Other range-finding applications involve two-way transmissions. A local station generates a
pseudo random bit sequence and transmits it to the remote location (using any modulation
technique). Some object at the remote location echoes this PN signal back to the location station
– either passively, as in some kinds of radar and sonar systems, or using an active transponder at
the remote location, as in the Apollo Unified S-band system.[4] By correlating a (delayed version
of) the transmitted signal with the received signal, a precise round trip time to the remote
location can be determined and thus the distance..
TLC can be used to help determine the number of components in a mixt.pdf
TLC can be used to help determine the number of components in a mixture, the identity of
compounds, and the purity of a compound. By observing the appearance of a product or the
disappearance of a reactant, it can also be used to monitor the progress of a reaction.
The sample is applied to the layer of adsorbent, near one edge, as a small spot of a solution.
After the solvent has evaporated, the adsorbent-coated sheet is propped more or less vertically in
a closed container, with the edge to which the spot was applied down. The spot on the thin layer
plate must be positioned above the level of the solvent in the container .If it is below the level of
the solvent, the spot will be washed off the plate into the developing solvent. The solvent, which
is in the bottom of the container, creeps up the layer of adsorbent, passes over the spot, and, as it
continues up, effects a separation of the materials in the spot (\"develops\" the chromatogram).
When the solvent front has nearly reached nearly the top of the adsorbent, the thin layer plate is
removed from the container.
Solution
TLC can be used to help determine the number of components in a mixture, the identity of
compounds, and the purity of a compound. By observing the appearance of a product or the
disappearance of a reactant, it can also be used to monitor the progress of a reaction.
The sample is applied to the layer of adsorbent, near one edge, as a small spot of a solution.
After the solvent has evaporated, the adsorbent-coated sheet is propped more or less vertically in
a closed container, with the edge to which the spot was applied down. The spot on the thin layer
plate must be positioned above the level of the solvent in the container .If it is below the level of
the solvent, the spot will be washed off the plate into the developing solvent. The solvent, which
is in the bottom of the container, creeps up the layer of adsorbent, passes over the spot, and, as it
continues up, effects a separation of the materials in the spot (\"develops\" the chromatogram).
When the solvent front has nearly reached nearly the top of the adsorbent, the thin layer plate is
removed from the container..
There may have some variables affect the model. So the error term wi.pdf
There may have some variables affect the model. So the error term will reflect a systematic
pattern. Or it is not a correct functional form. So there is a bias.
I would suggest that it can be remedial by using data transformation.
Solution
There may have some variables affect the model. So the error term will reflect a systematic
pattern. Or it is not a correct functional form. So there is a bias.
I would suggest that it can be remedial by using data transformation..
There are four major functional characteristics of skeletal muscle..pdf
There are four major functional characteristics of skeletal muscle.
(i) Contractility- for muscle movement
(ii) Excitability- response to chemical and/or electrical signals.
(iii) Extensibility- the ability to stretch to the normal resting length after contracting
(iv) Elasticity - the ability to return to the original resting length after a muscle has been
stretched.
Solution
There are four major functional characteristics of skeletal muscle.
(i) Contractility- for muscle movement
(ii) Excitability- response to chemical and/or electrical signals.
(iii) Extensibility- the ability to stretch to the normal resting length after contracting
(iv) Elasticity - the ability to return to the original resting length after a muscle has been
stretched..
More from aquacosmossystems (20)
DnaAORC This protein is responsible for initiation of DNA replicat.pdf
DnaAORC This protein is responsible for initiation of DNA replicat.pdf
Answer(19)Mary’s parents are normal, therefore her brother must.pdf
Answer(19)Mary’s parents are normal, therefore her brother must.pdf
Answer Q1. Red mangroove is the last mangroove to colonise on the.pdf
Answer Q1. Red mangroove is the last mangroove to colonise on the.pdf
An Arrhenius acid produces H+ ions insolutionA Bronsted-Lowry acid.pdf
An Arrhenius acid produces H+ ions insolutionA Bronsted-Lowry acid.pdf
Ans. One of the main disadvantage is chromatic aberrasion. A more li.pdf
Ans. One of the main disadvantage is chromatic aberrasion. A more li.pdf
A coordination problem occurs in situations where there is no Nash E.pdf
A coordination problem occurs in situations where there is no Nash E.pdf
1. When an integrated F plasmid leaves the chromosome it may take so.pdf
1. When an integrated F plasmid leaves the chromosome it may take so.pdf
1. A DNA molecule contains two strands of poly deoxyribonucleotide s.pdf
1. A DNA molecule contains two strands of poly deoxyribonucleotide s.pdf
Ethyl 4-aminobenzoate is a basic organic compound. In basic and neut.pdf
Ethyl 4-aminobenzoate is a basic organic compound. In basic and neut.pdf
draw a sphere and use raytracing on the sphere in OpenGL glut. .pdf
draw a sphere and use raytracing on the sphere in OpenGL glut. .pdf
SnO2 (ore) is initially washed and dressed. then .pdf
SnO2 (ore) is initially washed and dressed. then .pdf
d) Valine Note its side chain doesnt contain a.pdf
d) Valine Note its side chain doesnt contain a.pdf
Amphiprotic. The preferred term is amphoteric. A .pdf
Amphiprotic. The preferred term is amphoteric. A .pdf
at equivalence point, Moles OH- added = moles H+.pdf
at equivalence point, Moles OH- added = moles H+.pdf
molar mass of C2H5OH = 46.1 gmole moles of C2H5O.pdf
molar mass of C2H5OH = 46.1 gmole moles of C2H5O.pdf
What property of PN code makes them suitable for use in spread spect.pdf
What property of PN code makes them suitable for use in spread spect.pdf
TLC can be used to help determine the number of components in a mixt.pdf
TLC can be used to help determine the number of components in a mixt.pdf
There may have some variables affect the model. So the error term wi.pdf
There may have some variables affect the model. So the error term wi.pdf
There are four major functional characteristics of skeletal muscle..pdf
There are four major functional characteristics of skeletal muscle..pdf
Recently uploaded
Digital Tools and AI for Teaching Learning and Research
This Presentation in details discusses on Digital Tools and AI for Teaching Learning and Research
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is prepared for master's students (MIFB & MIBS) UUM. May it be useful to all.June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Letter from the Congress of the United States regarding Anti-Semitism sent June 3rd to MIT President Sally Kornbluth, MIT Corp Chair, Mark Gorenberg
Dear Dr. Kornbluth and Mr. Gorenberg,
The US House of Representatives is deeply concerned by ongoing and pervasive acts of antisemitic
harassment and intimidation at the Massachusetts Institute of Technology (MIT). Failing to act decisively to ensure a safe learning environment for all students would be a grave dereliction of your responsibilities as President of MIT and Chair of the MIT Corporation.
This Congress will not stand idly by and allow an environment hostile to Jewish students to persist. The House believes that your institution is in violation of Title VI of the Civil Rights Act, and the inability or
unwillingness to rectify this violation through action requires accountability.
Postsecondary education is a unique opportunity for students to learn and have their ideas and beliefs challenged. However, universities receiving hundreds of millions of federal funds annually have denied
students that opportunity and have been hijacked to become venues for the promotion of terrorism, antisemitic harassment and intimidation, unlawful encampments, and in some cases, assaults and riots.
The House of Representatives will not countenance the use of federal funds to indoctrinate students into hateful, antisemitic, anti-American supporters of terrorism. Investigations into campus antisemitism by the Committee on Education and the Workforce and the Committee on Ways and Means have been expanded into a Congress-wide probe across all relevant jurisdictions to address this national crisis. The undersigned Committees will conduct oversight into the use of federal funds at MIT and its learning environment under authorities granted to each Committee.
• The Committee on Education and the Workforce has been investigating your institution since December 7, 2023. The Committee has broad jurisdiction over postsecondary education, including its compliance with Title VI of the Civil Rights Act, campus safety concerns over disruptions to the learning environment, and the awarding of federal student aid under the Higher Education Act.
• The Committee on Oversight and Accountability is investigating the sources of funding and other support flowing to groups espousing pro-Hamas propaganda and engaged in antisemitic harassment and intimidation of students. The Committee on Oversight and Accountability is the principal oversight committee of the US House of Representatives and has broad authority to investigate “any matter” at “any time” under House Rule X.
• The Committee on Ways and Means has been investigating several universities since November 15, 2023, when the Committee held a hearing entitled From Ivory Towers to Dark Corners: Investigating the Nexus Between Antisemitism, Tax-Exempt Universities, and Terror Financing. The Committee followed the hearing with letters to those institutions on January 10, 202
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.
Digital Artifact 2 - Investigating Pavilion Designs
Digital Artifact 2 - Pavilions
NGV Architecture Commission Competition
MPavilion Commission Competition
Other Pavilion Designs
Unit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Protectable subject matters, Protection in biotechnology, Protection of other biological materials, Ownership and period of protection
Model Attribute Check Company Auto Property
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
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.
Chapter -12, Antibiotics (One Page Notes).pdf
This is a notes for the D.Pharm students and related to the antibiotic drugs.
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Thesis Statement for students diagnonsed withADHD.ppt
Presentation required for the master in Education.
Unit 8 - Information and Communication Technology (Paper I).pdf
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
Biological Screening of Herbal Drugs in detailed.
Biological screening of herbal drugs: Introduction and Need for
Phyto-Pharmacological Screening, New Strategies for evaluating
Natural Products, In vitro evaluation techniques for Antioxidants, Antimicrobial and Anticancer drugs. In vivo evaluation techniques
for Anti-inflammatory, Antiulcer, Anticancer, Wound healing, Antidiabetic, Hepatoprotective, Cardio protective, Diuretics and
Antifertility, Toxicity studies as per OECD guidelines
Recently uploaded (20)
Digital Tools and AI for Teaching Learning and Research
Digital Tools and AI for Teaching Learning and Research
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptx
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
Digital Artifact 2 - Investigating Pavilion Designs
Digital Artifact 2 - Investigating Pavilion Designs
Multithreading_in_C++ - std::thread, race condition
Multithreading_in_C++ - std::thread, race condition
"Protectable subject matters, Protection in biotechnology, Protection of othe...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Group Presentation 2 Economics.Ariana Buscigliopptx
Group Presentation 2 Economics.Ariana Buscigliopptx
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI fund...
Thesis Statement for students diagnonsed withADHD.ppt
Thesis Statement for students diagnonsed withADHD.ppt
Unit 8 - Information and Communication Technology (Paper I).pdf
Unit 8 - Information and Communication Technology (Paper I).pdf
#include node1.h #include list.h #include cassert P.pdf
- 1. #include "node1.h" #include "list.h" #include // Provides assert #include using namespace std; value_type head(list lst) { list p; p=list_locate(lst,1); return p->data(); } list tail(list lst) { node *head=NULL; node *tail=NULL; list_copy(lst, head, tail); list_head_remove(head); return head; } bool list_is_empty(list lst) { size_t n= list_length(lst); if(n==0) return true; else return false; } list cons(value_type val, const list lst) { node *head=NULL; node *tail=NULL; list_copy(lst, head, tail); list_head_insert(head, val); return head;
- 2. } Solution #include "node1.h" #include "list.h" #include // Provides assert #include using namespace std; value_type head(list lst) { list p; p=list_locate(lst,1); return p->data(); } list tail(list lst) { node *head=NULL; node *tail=NULL; list_copy(lst, head, tail); list_head_remove(head); return head; } bool list_is_empty(list lst) { size_t n= list_length(lst); if(n==0) return true; else return false; } list cons(value_type val, const list lst) { node *head=NULL; node *tail=NULL;
- 3. list_copy(lst, head, tail); list_head_insert(head, val); return head; }