Ask question

Ask question

All categories

3 years ago

14

what's the best mouse for fast clicking ? I play a lot of fps and a lot of pvp games I need a mouse that I can click fast with a

nd also best mouse pads? let me know

Computers and Technology

1 answer:

kondaur [170]3 years ago

7 0

Alenware hp dell logtech, and i know others

You might be interested in

Design a data structure to support the following two operations for a set S of inte- gers, which allows duplicate values: • INSE

umka2103 [35]

Answer and Explanation:

Note that we are free to use any data structure that allows for arbitrary insertion and deletion of data

As an underlying data structure, we’ll use an (unsorted) array. INSERT(S, x) will simply append x to the array, increasing its length. This has a constant runtime, so we’ll say its cost is 1.

DELETE-LARGER-HALF(S) will work as follows: first, use SELECT to find the median. Next, use PARTITION around the median to make sure that the upper half is stored within the last $[|S|/2]$ elements. Finally, we delete these elements, reducing the size of the array.This has a linear running time, so we’ll say its cost is n.

To show that any m operations can run in O(m) time, we define a potential function $\phi(S) = 2|S|$ . The amortized cost of INSERT is thus $1 + \delta \phi = 1 + 1 = 1$ ; the amortized cost of DELETE-LARGER-HALF is $n +\delta\phi\leq n-2(n/2) = 0$ . So the amortized cost of any m operations is O(m).

This answer essentially captures the idea behind the problem. However, there are some technical points to clear up. (Calling the real-time costs 1 and n are not among them; this underestimates the running time by at most a constant. Ignoring constants like that is necessary to make concise arguments about amortized costs.)

First, an array does not support arbitrary insertions. Possible remedies include:

(1) using a dynamic array along the lines of §17.4, or (2) using a different structure like a linked list, and having DELETE-LARGER-HALF convert it to an array and back in linear time so that the SELECT and PARTITION algorithms may be used.

Second, it’s important to know which median to partition around and how to delete the upper half of the elements: a mistake could lead to incorrect behavior when the array has an odd size or repeated elements. We should select the lower median, $[|S|/2]$ , since that’s the number of elements we want in the lower set: as written, the CLRS Partition function will put elements less than or equal to the

pivot in the left set, and strictly larger elements in the right set. (If the partition function is defined differently, the answer should be different as well. You generally should give a brief description of how your partition function works.) After a call to Partition, it is safe simply to keep the first $[|S|/2]$ elements and drop the rest. On the other hand, it is not safe to go around deleting every element with

a sufficiently large value—take an array of zeros as a drastic example. If you wish to take that approach, you’ll have to count the number of elements equal to the median and delete the correct number of them.

Finally, the argument only shows that the <em>amortized</em> cost with respect to $\phi$ is O(m). The conclusion we’re asked for requires a technical condition: the potential $\phi$ never drops below its initial value. This is true for the usual reason: initially, $\phi$ = 0 because S is empty; during execution, $\phi \geq 0$ by definition.

7 0

3 years ago

Leslie’s parents put a big dry-erase board on the refrigerator and let the kids write suggestions for how to organize and assign

blondinia [14]

Answer

determine possible solutions

Explanation:

im assuming

ty for the thanks

5 0

2 years ago

Quired to the weight

expeople1 [14]

Answer:

The mechanical advantage is 0.25

This mechanical advantage shows that the force at which the deodorant sprays is the quarter of the applied effort, and hence the efficiency of your finger as a machine is 25%.

Explanation:

Given;

output force, F₂ = 15 N

input force, F₁ = 60 N

Mechanical advantage also known as force ratio is defined as the ratio of the output force (load) to the ratio of input force (effort).

$M.A = \frac{0utput \ Force}{1nput \ Force} \\\\M.A = \frac{15 \ N}{60 \ N} \\\\M.A = 0.25$

This shows that the force at which the deodorant sprays is the quarter of the applied effort, and hence the efficiency of your finger as a machine is 25%.

3 0

3 years ago

why is it important for you to understand and describe the internal and external components of a computer in the workplace

zhannawk [14.2K]

Hi! I have been troubleshooting and building PCs all my life and I find it very important to know the the internal core components of a PC and how they function that way when errors occur you can attempt to fix the problem.

Ex1: Lets say your BIOS identifies a problem with a RAM slot you would be able to know that your RAM slot is either shorted or there is a problem with the RAM stick you inserted.

Ex2: Now your monitor is flashing and turning colors randomly. You could make an inference that either your monitor is prongs are broken, your cable prongs could be bent, your cable might not be plugged in all the way, or your external or integrated GPU is toast.

Hope this might've showed you something

Aaron

7 0

3 years ago

A palindrome is any word, phrase, or sentence that reads the same forward and backward. Here are some well-known palindromes: Ab

Pavlova-9 [17]

Answer:

Following are the program in the C++ Programming Language.

//header file

#include <iostream>

//header file for string

#include <string>

#include<cstring>

//using namespace

using namespace std;

//define Function to checks the string is passed is a Palindrome or not

bool is_Palin(string strng, int start_Position, int end_Position)

{

//set the if Conditional statement

if(start_Position >= end_Position)

{

return true;

}

//Check if the character is not the alphabet

if(!isalpha(strng[start_Position]))

{

//Update the starting position

start_Position += 1;

//call Recursive function

return is_Palin(strng, start_Position++, end_Position);

}

//Check if the character is not the alphabet

if(!isalpha(strng[end_Position]))

{

//Update the end position

end_Position -= 1;

//call Recursive function

return is_Palin(strng, start_Position, end_Position--);

}

//Check if the characters are same or not same

if(tolower(strng[start_Position]) != tolower(strng[end_Position]))

{

return false;

}

//Update the positions

start_Position = start_Position + 1;

end_Position = end_Position - 1;

//call Recursive function

return is_Palin(strng, start_Position, end_Position);

}

//define Main function

int main()

{

string strng;

//get string from the user

cout << "\n\n Enter a string: ";

getline(cin, strng);

//Check for the palindrome

if(is_Palin(strng, 0, strlen(strng.c_str())-1))

{

//then print message

cout << "\n Is a Palindrome!!!! \n";

}

//otherwise

else

{

//then print message

cout << "\n Is not a Palindrome!!!! \n";

}

return 0;

}

<u>Output:</u>

Enter a string: Able was I, ere I saw Elba

Is a Palindrome!!!!

Explanation:

Here, we define a boolean data type function "is_Palin" to check the string which passed through is palindrome or not and pass and pass two integer type arguments for starting position and ending position and pass one string data type argument to pass string, inside the function.

Set the if conditional statement to check the condition if the start_position of the string is greater than end _position of the string then return true.
Set the if conditional statement to check the condition the start_position of the staring is alphabet then, update the start_position and call the recursion function.

Again set the if conditional statement to check the condition the end_position of the staring is alphabet then, update the end_position and call the recursion function.

Set the if conditional statement to check the condition if the start_position of the string is not equal to the end _position of the string then, return false.
Then, update the start_position and end _position of the string increment by 1 then, call the recursive function and then, close the function.

Finally, we define the main function and pass string through calling and passing and argument list in its parameter.

5 0

3 years ago