All categories

3 years ago

During the name resolution process, which technique is used to avoid congestion when querying a server

Computers and Technology

1 answer:

vekshin13 years ago

8 0

Answer:

"NOT lookup " is the correct approach.

Explanation:

This methodology significantly reduces the quantity of congestion of DNS messages on a certain file. The application establishes that whenever a question reaches if it is processed. Unless the file is loaded, then perhaps the response is returned with the cached cache.
Typically the name resolution occurs in something like a DNS File. The conversion usually occurs throughout this cycle from Username to IP, including IP via Username.

You might be interested in

What is a megavirus in computing

g100num [7]

Answer:

tbh I have no clue.

Explanation:

8 0

3 years ago

Read 2 more answers

Describe a situation involving making a copy of a computer program or an entertainment file of some sort for which you think it

Margaret [11]

Answer:

Copying anything may be the computer program or an entertainment file, it is not a good thing as the original developers or the writers are going to feel bad since their hard work is being used by others without letting them know. However, if you are using it for academic purposes, or give them credit in your work, then the original writer will not feel that bad as he is being credited, and hence you can reuse in that case definitely, but always ensure to give the credit to the original writer.

As an example, if a film is copied like many in the past the Directors always feel bad, and they have the reason for feeling bad. The same thing is to technology.

Explanation:

The answer is self explanatory.

8 0

3 years ago

a cryptarithm is a mathematical puzzle where the goal is to find the correspondence between letters and digits such that the giv

Leokris [45]

Using the knowledge in computational language in C++ it is possible to write a code that cryptarithm is a mathematical puzzle where the goal is to find the correspondence between letters and digits

<h3>Writting the code:</h3>

#include <bits/stdc++.h>

using namespace std;

// chracter to digit mapping, and the inverse

// (if you want better performance: use array instead of unordered_map)

unordered_map<char, int> c2i;

unordered_map<int, char> i2c;

int ans = 0;

// limit: length of result

int limit = 0;

// digit: index of digit in a word, widx: index of a word in word list, sum: summation of all word[digit]

bool helper(vector<string>& words, string& result, int digit, int widx, int sum) {

if (digit == limit) {

ans += (sum == 0);

return sum == 0;

}

// if summation at digit position complete, validate it with result[digit].

if (widx == words.size()) {

if (c2i.count(result[digit]) == 0 && i2c.count(sum%10) == 0) {

if (sum%10 == 0 && digit+1 == limit) // Avoid leading zero in result

return false;

c2i[result[digit]] = sum % 10;

i2c[sum%10] = result[digit];

bool tmp = helper(words, result, digit+1, 0, sum/10);

c2i.erase(result[digit]);

i2c.erase(sum%10);

ans += tmp;

return tmp;

} else if (c2i.count(result[digit]) && c2i[result[digit]] == sum % 10){

if (digit + 1 == limit && 0 == c2i[result[digit]]) {

return false;

}

return helper(words, result, digit+1, 0, sum/10);

} else {

return false;

}

// if word[widx] length less than digit, ignore and go to next word

if (digit >= words[widx].length()) {

return helper(words, result, digit, widx+1, sum);

}

// if word[widx][digit] already mapped to a value

if (c2i.count(words[widx][digit])) {

if (digit+1 == words[widx].length() && words[widx].length() > 1 && c2i[words[widx][digit]] == 0)

return false;

return helper(words, result, digit, widx+1, sum+c2i[words[widx][digit]]);

}

// if word[widx][digit] not mapped to a value yet

for (int i = 0; i < 10; i++) {

if (digit+1 == words[widx].length() && i == 0 && words[widx].length() > 1) continue;

if (i2c.count(i)) continue;

c2i[words[widx][digit]] = i;

i2c[i] = words[widx][digit];

bool tmp = helper(words, result, digit, widx+1, sum+i);

c2i.erase(words[widx][digit]);

i2c.erase(i);

}

return false;

}

void isSolvable(vector<string>& words, string result) {

limit = result.length();

for (auto &w: words)

if (w.length() > limit)

return;

for (auto&w:words)

reverse(w.begin(), w.end());

reverse(result.begin(), result.end());

int aa = helper(words, result, 0, 0, 0);

}

int main()

{

ans = 0;

vector<string> words={"GREEN" , "BLUE"} ;

string result = "BLACK";

isSolvable(words, result);

cout << ans << "\n";

return 0;

}

See more about C++ code at brainly.com/question/19705654

#SPJ1

3 0

2 years ago

On early computers, every byte of data read or written was handled by the CPU (i.e., there was no DMA). What implications does t

grandymaker [24]

Answer:

Multiprogramming will be extremely difficult to be achieved.

Explanation:

If every byte of data read or written is handled by the CPU the implications this will have for multiprogramming are not going to be satisfactory.

This is because, unlike before, after the successful completion of the input and output process, the CPU of a computer is not entirely free to work on other instructions or processes.

5 0

3 years ago

Assume that source elements of length k are mapped in some uniform fashion into a target elements of length p. If each digit can

lukranit [14]

Answer And explanation

$r^k$ has 1/ $r^k$ probability guess the correct source