All categories

2 years ago

What when can you expect technology to be effective?

Computers and Technology

1 answer:

loris [4]2 years ago

3 0

Answer:

we dont have to expect , the technology are effective , as each day the technology are being advance and developed day by day. each day the technology are being more and more effective. they are effective now and they will be effective in future too

You might be interested in

SMART PEOPLE NEEDED

mario62 [17]

D doesn't make much sense, it's valid, but not what we're looking for. B also has a correlation with D, same reasoning applies. As for A, it seems pretty legit, but I don't believe that's what we're looking for.

Choice C is the most obvious one though. We're talking about a network and as may or may not know it's a wireless one in a manner of speaking. A couple of computers in the network that have trouble maintaining a signal will indefinitely lead to failure of a network since both the links and nodes of certain computer systems are incapable of maintaining a signal.

6 0

2 years ago

Using language c, find the nth Fibonacci, knowing that nth Fibonacci is calculated by the following formula: - If n = 1 Or n = 2

Nina [5.8K]

Answer:

#include <stdio.h>

int fib(int n) {

if (n <= 0) {

return 0;

}

if (n <= 2) {

return 1;

}

return fib(n-1) + fib(n-2);

}

int main(void) {

for(int nr=0; nr<=20; nr++)

printf("Fibonacci %d is %d\n", nr, fib(nr) );

return 0;

}

Explanation:

The code is a literal translation of the definition using a recursive function.

The recursive function is not per se a very efficient one.

4 0

2 years ago

Consider a set of mobile computing clients in a certain town who each

poizon [28]

Answer: answer given in the explanation

Explanation:

We have n clients and k-base stations, say each client has to be connected to a base station that is located at a distance say 'r'. now the base stations doesn't have allocation for more than L clients.

To begin, let us produce a network which consists of edges and vertex

Network (N) = (V,E)

where V = [S, cl-l, - - - - cl-n, bs-l - - - - - - bs-k, t]

given that cl-l, - - - - - cl-n represents nodes for the clients

also we have that bs-l, - - - - - bs-k represents the nodes for base station

Also

E = [ (s, cl-i), (cl-i,bs-j), (bs-j,t)]

(s, cl-i) = have capacity for all cl-i (clients)

(cl-i,bs-j) = have capacity for all cl-i clients & bs-j (stations)

⇒ using Fond Fulkorson algorithm we find the max flow in N

⇒ connecting cl-i clients to bs-j stations

like (cl-i, bs-j) = 1

if f(cl-i, bs-j) = 0

⇒ say any connection were to produce a valid flow, then

if cl-i (clients) connected f(s,cl-i) = 1 (o otherwise)

if cl-i (clients) connected to bs-j(stations) f(cl-i,bs-j) = 1 (o otherwise)

f(bs-j,t) = no of clients (cl-i) connected to bs-j

⇒ on each node, the max flow value (f) is longer than the no of clients that can be connected.

⇒ create the connection between the client and base station i.e. cl-l to base bs-j iff f(cl-i, bs-j) = 1

⇒ when considering the capacity, we see that any client cannot directly connect to the base stations, and also the base stations cannot handle more than L clients, that is because the load allocated to the base statsion is L.

from this, we say f is the max no of clients (cl-i) that can be connected if we find the max flow, we can thus connect the client to the base stations easily.

cheers i hope this helps

5 0

3 years ago

What are the primary functions of motor oil? a. Reduce friction and prevent wear b. Keep engine surfaces clean c. Remove heat to

ryzh [129]

The answer is E: all of the above.

7 0

2 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

1 year ago