If (x < y + z) {
x = x â€“ y; z=z+1;
}
else y=y-1;
Instactions given:
The following labels and directives should be included at the end of your program:
X, Dec 4
Y, Dec 2
Z, Dec 5
One, Dec 1
I do not know how to use if statments in marie, all I know is how to add, subtract and multiply ( the basics)
any help would be really appreciated :)
]]>We fill the Sudoku in numbers from 1 to 9. We can only interfere with sudoku cells that initially contained zero. Cell contents that were not initially zero can not be changed. If it is not possible to solve the sudoku display:
NO
If possible, we display a solution in a format like input.
I have a couple questions:
For someone who has never done something like this before what should I expect? What should I know? I know common langauge syntax (for the most part) but OOP is kind of a gray area for me. Obviously I should study up on that, but what else might I want to know?
I should also mention that I don't know what language they will ask me about (and this call is supposed to determine my programming skills). I'm going to call the hiring person about that soon. Will update.
]]>Thanks in advance for the help
]]>I am stuck with a problem, and don't know where to start. I need to calculate the closest pair of points on the Earth using a divide and conquer method. I know I should calculate the orthodromic distance (or in other words the great-circle distance) but I don't know what to do. This calculation has to last at most nlog(n). I found this:
"The problem can be solved in O(n log n) time using the recursive divide and conquer approach, e.g., as follows:[1]
Sort points according to their x-coordinates.
Split the set of points into two equal-sized subsets by a vertical line x=xmid.
Solve the problem recursively in the left and right subsets. This yields the left-side and right-side minimum distances dLmin and dRmin, respectively.
Find the minimal distance dLRmin among the set of pairs of points in which one point lies on the left of the dividing vertical and the other point lies to the right.
The final answer is the minimum among dLmin, dRmin, and dLRmin."
But this algorithm is for (x,y) points. I have to calculate (x,y,z) points on the Earth. I have to cin>> longitude and cin>>latitude. Then do some calculations and return two points with a minimal distance. What can I do? Do you have any suggestions or ideas?
PS. I'm not a native English speaker, so please don't correct my mistakes. I just want to communicate with you. I don't care, if there are mistakes.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
/////////////////////////////////////////////////////////////////////////
/*
// struct Edge
// Represent one edge in the graph. Fields contain
// two vertex numbers and a weight.
*/
struct Edge
{
int vertex_1, vertex_2, weight;
};
////////////////////////////////////////////////////////////////////////
/*
// struct Graph
// Represents a weighted graph. Fields contain the # of vertices,
// edges,an array of edges, along with it's physical size.
*/
struct Graph
{
// V-> Number of vertices, E-> Number of edges
int V, E;
// graph is represented as an array of edges. Since the graph is
// undirected, the edge from vertex_1 to vertex_2 is also edge from vertex_2
// to vertex_1. Both are counted as 1 edge here.
struct Edge* edge;
};
//////////////////////////////////////////////////////////////////////////
/*
// manifestGraph
// Represents a graph with vertices and no edges.
*/
struct Graph* manifestGraph(int V, int E)
{
struct Graph* graph = (struct Graph*) malloc(sizeof(struct Graph));
graph->V = V;
graph->E = E;
graph->edge = (struct Edge*) malloc(graph->E * sizeof( struct Edge));
return graph;
};
/////////////////////////////////////////////////////////////////////////
// A structure to represent a subset for union-find
struct subset
{
int parent;
int rank;
};
////////////////////////////////////////////////////////////////////////
// A utility function to find set of an element i
// (uses path compression technique)
int find(struct subset subsets[], int i)
{
// find root and make root as parent of i (path compression)
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
///////////////////////////////////////////////////////////////////////
// A function that does union of two sets of x and y
// (uses union by rank)
void Union(struct subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);
// Attach smaller rank tree under root of high rank tree
// (Union by Rank)
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
// If ranks are same, then make one as root and increment
// its rank by one
else
{
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
///////////////////////////////////////////////////////////////////////////
// Compare two edges according to their weights.
// Used in qsort() for sorting an array of edges
int myComp(const void* a, const void* b)
{
struct Edge* a1 = (struct Edge*)a;
struct Edge* b1 = (struct Edge*)b;
return a1->weight > b1->weight;
}
//////////////////////////////////////////////////////////////////////////
// The main function to construct MST using Kruskal's algorithm
void KruskalMST(struct Graph* graph)
{
int V = graph->V;
struct Edge result[V]; // Tnis will store the resultant MST
int e = 0; // An index variable, used for result[]
int i = 0; // An index variable, used for sorted edges
// Step 1: Sort all the edges in non-decreasing order of their weight
// If we are not allowed to change the given graph, we can create a copy of
// array of edges
qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
// Allocate memory for creating V ssubsets
struct subset *subsets =
(struct subset*) malloc( V * sizeof(struct subset) );
// Create V subsets with single elements
for (int v = 0; v < V; ++v)
{
subsets[v].parent = v;
subsets[v].rank = 0;
}
// Number of edges to be taken is equal to V-1
while (e < V - 1)
{
// Step 2: Pick the smallest edge. And increment the index
// for next iteration
struct Edge next_edge = graph->edge[i++];
int x = find(subsets, next_edge.vertex_1);
int y = find(subsets, next_edge.vertex_2);
// If including this edge does't cause cycle, include it
// in result and increment the index of result for next edge
if (x != y)
{
result[e++] = next_edge;
Union(subsets, x, y);
}
// Else discard the next_edge
}
// print the contents of result[] to display the built MST
printf("Following are the edges in the constructed MST\n");
for (i = 0; i < e; ++i)
printf("%d -- %d == %d\n", result[i].vertex_1,
result[i].vertex_2, result[i].weight);
return;
}
//////////////////////////////////////////////////////////////////////////
// Driver program to test above functions
int main()
{
return 0;
}
I"m trying to get it to print out like the example in this link:
http://www.cs.ecu.edu/~karl/2530/spr17/Assn/Assn4/assn4.html
where is states functional requirements. Can anyone help me with this?
v/r
]]>if it was digit -> [0 - 9] then it would be ->0->1->2->3->4->5->6->7->8->9 final state
digits -> digit+ then it would be ->digit->digit->digit loop final state
but this question i dont understand the solution:
write a transition diagram for scientific number
number â†’ digits (. digits)?(E[+-]? digits)?
the answer:
my question:
why is there a loop before the period? The dot . between 13 and 14, does the period mean something?
why is there a loop at 15? is it because of the question mark? question mark means zero or one
then after the +- I am so lost. as well as the "other" 's and keene star on the "other" 's
why is it looped at 18 not 17 ?
i'm also lost on the bottom arrows. 13 -> 16, 16 -> 18
Sorry for the questions and if the questions really stupid. my lecturer is like a f1 car in class.
]]>package hw2;
/**
* This class encapsulates the logic and state for a simplified
* game of American football.
*
* @author YOUR NAME HERE
*/
public class FootballGame
{
/**
* Number of points awarded for a touchdown.
*/
public static final int TOUCHDOWN_POINTS = 6;
/**
* Number of points awarded for a successful extra point attempt
* after a touchdown.
*/
public static final int EXTRA_POINTS = 1;
/**
* Number of points awarded for a field goal.
*/
public static final int FIELD_GOAL_POINTS = 3;
/**
* Total length of the field from goal line to goal line, in yards.
*/
public static final int FIELD_LENGTH = 100;
/**
* Initial position of the offensive team after receiving a kickoff.
*/
public static final int STARTING_POSITION = 70;
/**
* Yards required to get a first down.
*/
public static final int YARDS_FOR_FIRST_DOWN = 10;
// TODO - everything else :)
}
]]>ii.Size of page table per segment
iii.How many levels of paging will be implemented in this system?
iv.What would be format of logical address?
v.What would be format of physical address?
]]>