Brute Force ALGORITHM

What is a brute force algorithm?

"Brute-force algorithms are distinguished by approaching the solution of a problem in

the most natural obvious, simple, or direct method in contrast to a more clever or
sophisticated way. Exhaustive enumeration is an example of a brute-force algorithm."

Describes a primitive programming style, one in which the programmer relies on the
computer's processing power instead of using his or her own intelligence to simplify the
problem, often ignoring problems of scale and applying naive methods suited to small
problems directly to large ones. The term can also be used in reference to programming
style: brute-force programs are written in a heavyhanded, tedious way, full of repetition
and devoid of any elegance or useful abstraction

In computer science, brute-force search or exhaustive search, also known as

generate and test, is a trivial but very general problem-solving technique that consists
of systematically enumerating all possible candidates for the solution and checking
whether each candidate satisfies the problem's statement.

Implementing the brute-force search

Basic algorithm

In order to apply brute-force search to a specific class of problems, one must implement
four procedures, first,next, valid, and output. These procedures should take as a
parameter the data P for the particular instance of the problem that is to be solved, and
should do the following:

first (P): generate a first candidate solution for P.

next (P, c): generate the next candidate for P after the current one c.
valid (P, c): check whether candidate c is a solution for P.
output (P, c): use the solution c of P as appropriate to the application.

The brute force algorithm consists in checking, at all positions in the text between 0
and n-m, whether an occurrence of the pattern starts there or not. Then, after each
attempt, it shifts the pattern by exactly one position to the right.
EXAMPLES:
1.
Selection sort can be one of the examples of brute force algorithm...
Algorithm Selectionsort(a[0...n-1])
for i<-0 to n-2 do
min <- i
for j <- i+1 to n-1 do
if A[j]< A[min] min <-j
swap A[i] and A[min]
2.
Progam to check if a given number is a prime number is a brute force
algorithm.

while(p <= n)
{
c=0;
for(i=2; i<=p/2; i++)
{ if(p % i==0) c++; }
if(c == 1) printf("%d ", p);
p++;
}

 Every Searching algorithm whether it is Linear Search,Binary Search, Linear

Recursive search,etc are brute force algorithms..
 to design a brute force algorithm for password breaking.you need to see what
are the possible characters allowed
 take arrays of different combination like arr1 comprising of special
characters,arr2 of numbers 0-9,arr3 of alphabets(both upper and lower)
 take arr1,keep a pointer pointing to 1st element and check all possible
combination using two loops using all elements of arr1 & arr2

 then fix arr2 and check all possible combination using now arr1 and arr3

 Repeat same for arr3

 For better time complexity you can use binary search instead of linear search

ALL THE BEST.

The canonical example of a brute-force algorithm is associated with the

‘traveling salesman problem’ (TSP), a classical NP-hard problem: Suppose a person is
in, say, Boston, and wishes to drive to N other cities. In what order should the cities be
visited in order to minimize the distance traveled? The brute-force method is to simply
generate all possible routes and compare the distances; while guaranteed to work and
simple to implement, this algorithm is clearly very stupid in that it considers even
obviously absurd routes (like going from Boston to Houston via San Francisco and New
York, in that order). For very small N it works well, but it rapidly becomes absurdly
inefficient when N increases (for N = 15, there are already 1,307,674,368,000 possible
routes to consider, and for N = 1000 — well, see bignum). Sometimes, unfortunately,
there is no better general solution than brute force. See also NP- and rubber-hose
cryptanalysis.

A more simple-minded example of brute-force programming is finding the smallest

number in a large list by first using an existing program to sort the list in ascending
order, and then picking the first number off the front.