Brute force

Brute \Brute\, a. [F. brut, nasc., brute, fem., raw, rough,
   rude, brutish, L. brutus stupid, irrational: cf. It. & Sp.
   bruto.]
   1. Not having sensation; senseless; inanimate; unconscious;
      without intelligence or volition; as, the brute earth; the
      brute powers of nature.
      [1913 Webster]

   2. Not possessing reason, irrational; unthinking; as, a brute
      beast; the brute creation.
      [1913 Webster]

            A creature . . . not prone
            And brute as other creatures, but endued
            With sanctity of reason.              --Milton.
      [1913 Webster]

   3. Of, pertaining to, or characteristic of, a brute beast.
      Hence: Brutal; cruel; fierce; ferocious; savage; pitiless;
      as, brute violence. --Macaulay.
      [1913 Webster]

            The influence of capital and mere brute labor.
                                                  --Playfair.
      [1913 Webster]

   4. Having the physical powers predominating over the mental;
      coarse; unpolished; unintelligent.
      [1913 Webster]

            A great brute farmer from Liddesdale. --Sir W.
                                                  Scott.
      [1913 Webster]

   5. Rough; uncivilized; unfeeling. [R.]
      [1913 Webster]

   {brute force}, The application of predominantly physical
      effort to achieve a goal that could be accomplished with
      less effort if more carefully considered. Figuratively,
      repetitive or strenuous application of an obvious or
      simple tactic, as contrasted with a more clever stratagem
      achieving the same goal with less effort; -- as, the first
      prime numbers were discovered by the brute force
      repetition of the {Sieve of Eratosthenes}.
      [PJC]
    

brute force
 adj.

   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
   (see also {brute force and ignorance}).

   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 travelled? 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.

   Whether brute-force programming should actually be considered stupid
   or not depends on the context; if the problem is not terribly big, the
   extra CPU time spent on a brute-force solution may cost less than the
   programmer time it would take to develop a more `intelligent'
   algorithm. Additionally, a more intelligent algorithm may imply more
   long-term complexity cost and bug-chasing than are justified by the
   speed improvement.

   Ken Thompson, co-inventor of Unix, is reported to have uttered the
   epigram "When in doubt, use brute force". He probably intended this as
   a {ha ha only serious}, but the original Unix kernel's preference for
   simple, robust, and portable algorithms over {brittle} `smart' ones
   does seem to have been a significant factor in the success of that OS.
   Like so many other tradeoffs in software design, the choice between
   brute force and complex, finely-tuned cleverness is often a difficult
   one that requires both engineering savvy and delicate esthetic
   judgment.
    

brute force

   <programming> A primitive programming style in which the
   programmer relies on the computer's processing power instead
   of using his 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 heavy-handed, tedious way, full of
   repetition and devoid of any elegance or useful abstraction
   (see also {brute force and ignorance}).

   The {canonical} example of a brute-force algorithm is
   associated with the "{travelling 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 minimise the distance travelled?

   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-complete}.

   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.

   Whether brute-force programming should actually be considered
   stupid or not depends on the context; if the problem is not
   terribly big, the extra CPU time spent on a brute-force
   solution may cost less than the programmer time it would take
   to develop a more "intelligent" algorithm.  Additionally, a
   more intelligent algorithm may imply more long-term complexity
   cost and bug-chasing than are justified by the speed
   improvement.

   When applied to {cryptography}, it is usually known as {brute
   force attack}.

   {Ken Thompson}, co-inventor of {Unix}, is reported to have
   uttered the epigram "When in doubt, use brute force".  He
   probably intended this as a {ha ha only serious}, but the
   original {Unix} {kernel}'s preference for simple, robust and
   portable {algorithms} over {brittle} "smart" ones does seem to
   have been a significant factor in the success of that
   {operating system}.  Like so many other tradeoffs in software
   design, the choice between brute force and complex,
   finely-tuned cleverness is often a difficult one that requires
   both engineering savvy and delicate aesthetic judgment.

   [{Jargon File}]

   (1995-02-14)
    

73 Moby Thesaurus words for "brute force":
      amperage, armipotence, authority, beef, big battalions,
      black power, charge, charisma, clout, cogence, cogency, compulsion,
      dint, drive, duress, effect, effectiveness, effectuality, energy,
      flower power, force, force majeure, forcefulness, full blast,
      full force, influence, main force, main strength, mana, might,
      might and main, mightiness, moxie, muscle power, naked force,
      physical force, pizzazz, poop, potence, potency, potentiality,
      power, power pack, power structure, power struggle, powerfulness,
      prepotency, productiveness, productivity, puissance, pull, punch,
      push, rule of might, sinew, steam, steamroller, strength,
      strong arm, superiority, superpower, tyranny, ultima ratio,
      validity, vehemence, vigor, vim, virility, virtue, virulence,
      vitality, wattage, weight