A coupling is a mechanical element part that connects two shafts together to accurately transmit the power from the drive side to the driven side while absorbing the mounting error (misalignment), etc. of the two shafts.
Coupling in the machine industry is interpreted as “a part that connects two shafts together”, and is generally called “coupling”, “shaft coupling” or “joint”
A decision support system (DSS) is a computerized program used to support determinations, judgments, and courses of action in an organization or a business. A DSS sifts through and analyzes massive amounts of data, compiling comprehensive information that can be used to solve problems and in decision-making.
Typical information used by a DSS includes target or projected revenue, sales figures or past ones from different time periods, and other inventory- or operations-related data.
A data dictionary is a file or a set of files that contains a database's metadata. The data dictionary contains records about other objects in the database, such as data ownership, data relationships to other objects, and other data.
The data dictionary is a crucial component of any relational database. It provides additional information about relationships between different database tables, helps to organize data in a neat and easily searchable way, and prevents data redundancy issues.
Ironically, because of its importance, it is invisible to most database users. Typically, only database administrators interact with the data dictionary
User interface (UI) design is the process designers use to build interfaces in software or computerized devices, focusing on looks or style. Designers aim to create interfaces which users find easy to use and pleasurable. UI design refers to graphical user interfaces and other forms—e.g., voice-controlled interfaces
User interfaces are the access points where users interact with designs. They come in three formats:
To design UIs best, you should consider:
Often confused with UX design, UI design is more concerned with the surface and overall feel of a design. UI design is a craft where you the designer build an essential part of the user experience. UX design covers the entire spectrum of the user experience. One analogy is to picture UX design as a car with UI design as the driving console.
To deliver impressive GUIs, remember—users are humans, with needs such as comfort and a limit on their mental capacities. You should follow these guidelines:
Joint Application Development (JAD) is a process used to collect business requirements while developing new information systems for a company. The JAD process may also include approaches for enhancing user participation, expediting development and improving the quality of specifications. The intention of a JAD session is to pool in subject matter expert’s/Business analyst or IT specialist to bring out solutions.
A Business analyst is the one who interacts with the entire group and gathers the information, analyses it and brings out a document. He plays a very important role in JAD session.
JAD sessions are highly structured, facilitated workshops that bring together customer decision makers and IT staff to produce high quality deliverables in a short period.
In other words, a JAD Session enables customers and developers to quickly come to an agreement on the basic scope, objectives and specifications of a project or in case, not come to an agreement which means the project needs to be re-evaluated.
Simply put, JAD sessions can
The participants involved in a JAD session are as follows −
An executive sponsor is the person who drivers the project ─ the system owner. They normally are from higher positions and are able to make decisions and provide necessary strategy, planning and direction.
These are the business users and outside experts who are required for a successful workshop. The subject matter experts are the backbone of the JAD session. They will drive the changes.
He chairs the meeting; he identifies issues that can be solved as part of the meeting. The facilitator does not contribute information to the meeting.
Key users or also called as super users in some instances have been used interchangeable and differs from company to company still. Key users are generally the business users who are more tightly aligned to the IT project and are responsible for the configuration of profiles of their team members during the projects.
For Example: Suppose John is a key user and Nancy, Evan are users of a SAP system. In this instance, Nancy and Evan does not have access to change the functionality and profile whereas John being a Key user has access to edit profile with more authorizations.
The JAD approach, in comparison with the more traditional practice, is thought to lead to faster development times and greater client satisfaction, because the client is involved throughout the development process. In comparison, in the traditional approach to systems development, the developer investigates the system requirements and develops an application, with client input consisting of a series of interviews
| #include<stdio.h> /* Structure declaration */ struct LinkedList { struct LinkedList *previous; int number; struct LinkedList *next; }; typedef struct LinkedList NODE; /* Global variable declaration */ NODE *head, *temp, *p; /* Global functions declaration */ void insertNode(int n); void deleteNode(int n); void displayList(); /* main( ) function */ void main() { int choice, num; while(1) { printf("\n Press 1 for insert number"); printf("\n Press 2 for delete number"); printf("\n Press 3 for display list"); printf("\n Press 4 for exit"); printf("\n Enter your choice : "); scanf("%d",&choice); switch(choice) { case 1: printf("\n Enter the number : "); scanf("%d",&num); insertNode(num); break; case 2: if(head == NULL) printf("\n List is blank !"); else { printf("\n Enter the number : "); scanf("%d",&num); deleteNode(num); } break; case 3: displayList(); break; case 4: exit(0); default: printf("\n\n\n Wrong Input"); } } } /* Insert number into the list */ void insertNode(int n) { /* Check whether the list is blank or not */ /* If blank then create a memory into head variable and place the number into it */ if(head == NULL) { head = (NODE *) malloc(sizeof(NODE)); head->number = n; head->previous = head; head->next = head; } else { /* If the list is not blank then create a memory into temp variable, place the number into it and add this memory to the end of the list */ temp = (NODE *) malloc(sizeof(NODE)); temp->number = n; p = head; while(p->next != head) p = p->next; p->next = temp; temp->previous = p; temp->next = head; head->previous = temp; } } /* Delete a particular number from the list */ void deleteNode(int n) { int found = 0; /* Check whether the list contain only one element or not */ if(head->next == head && head->previous == head) { if(head->number == n) { found = 1; head = NULL; } } else /* Check whether the number found into the first-memory (head) of the list or not ? */ if(head->number == n) { temp = head; head = head->next; head->previous = temp->previous; temp->previous->next = head; found = 1; } else { p = head->next; while(p != head) { if(p->number == n) { p->next->previous = p->previous; p->previous->next = p->next; found = 1; break; } p = p->next; } } if(found == 0) printf("\n Element not found !"); } /* Display list elements */ void displayList() { /* Check whether the list is blank or not */ if(head == NULL) printf("\n List is blank !"); else { p = head; while(p->next != head) { printf("\t%d",p->number); p = p->next; } printf("\t%d",p->number); } } |
B-Tree is a specialized m-way tree that can be widely used for disk access. A B-Tree of order m can have at most m-1 keys and m children. One of the main reason of using B-Tree is its capability to store large number of keys in a single node and large key values by keeping the height of the tree relatively small.
Properties of B-Tree -
B-Tree Insertion
Let us understand the algorithm with an example tree of minimum degree ‘t’ as 3 and a sequence of integers 10, 20, 30, 40, 50, 60, 70, 80 and 90 in an initially empty B-Tree.
Initially root is NULL. Let us first insert 10.
Let us now insert 60. Since root node is full, it will first split into two, then 60 will be inserted into the appropriate child.
Let us now insert 70 and 80. These new keys will be inserted into the appropriate leaf without any split.
Let us now insert 90. This insertion will cause a split. The middle key will go up to the parent.
Initial Tree
After delete 60 the Tree will be
After delete 20 the Tree will be
After delete 30 the Tree will be
/* Header-File declaration */
#include<stdio.h>
#include<stdlib.h>
/* Structure declaration */
struct BinaryTree
{
int number;
struct BinaryTree *leftchild;
struct BinaryTree *rightchild;
};
typedef struct BinaryTree NODE;
/* Global variable declaration */
NODE *root, *child, *p;
int num, height=0, count=0;
/* Global function declaration */
void insertNode(int n);
void main()
{
char choice;
root = NULL;
while(1)
{
printf("\n Insert Node ? (Y/N)...");
scanf("%c",&choice);
if(choice == 'N')
break;
else
if(choice == 'Y')
{
printf("\n Enter the Number...");
scanf("%d",&num);
insertNode(num);
if(count > height)
{
height = count;
}
count = 0;
}
else
printf("\n\n Press Only (Y/N)");
}
printf("\n\n Height = %d",height);
}
/* Insert operation and height count */
void insertNode(int n)
{
if(root == NULL)
{
root = (NODE *) malloc(sizeof(NODE));
root->number = n;
root->leftchild = NULL;
root->rightchild = NULL;
}
else
{
child = (NODE *) malloc(sizeof(NODE));
child->number = n;
child->leftchild = NULL;
child->rightchild = NULL;
p = root;
while(p != NULL)
{
/* If number <= root value then goto the left side */
if(n <= p->number)
{
if(p->leftchild == NULL)
{
p->leftchild = child;
count++;
break;
}
else
p = p->leftchild;
}
/* If number > root value then goto the right side */
if(n > p->number)
{
if(p->rightchild == NULL)
{
p->rightchild = child;
count++;
break;
}
else
p = p->rightchild;
}
count++;
}
}
}
The problem is opposite of this post. We are given a stack data structure with push and pop operations, the task is to implement a queue using instances of stack data structure and operations on them.
A queue can be implemented using two stacks. Let queue to be implemented be q and stacks used to implement q be stack1 and stack2. q can be implemented in two ways:
Method 1 (By making enQueue operation costly) This method makes sure that oldest entered element is always at the top of stack 1, so that deQueue operation just pops from stack1. To put the element at top of stack1, stack2 is used
enQueue(q, x):
Here time complexity will be O(n)
deQueue(q):
Here time complexity will be O(1)
// CPP program to implement Queue using // two stacks with costly enQueue() #include <bits/stdc++.h> using namespace std; struct Queue { stack<int> s1, s2; void enQueue(int x) { // Move all elements from s1 to s2 while (!s1.empty()) { s2.push(s1.top()); s1.pop(); } // Push item into s1 s1.push(x); // Push everything back to s1 while (!s2.empty()) { s1.push(s2.top()); s2.pop(); } } // Dequeue an item from the queue int deQueue() { // if first stack is empty if (s1.empty()) { cout << "Q is Empty"; exit(0); } // Return top of s1 int x = s1.top(); s1.pop(); return x; } }; // Driver code int main() { Queue q; q.enQueue(1); q.enQueue(2); q.enQueue(3); cout << q.deQueue() << '\n'; cout << q.deQueue() << '\n'; cout << q.deQueue() << '\n'; return 0; } |
Output:
1 2 3
Complexity Analysis:
