i found this lovely treat in my facebook news feed and wanted to share it. i think this would be the only kind of sushi i would eat lol. but not much of, all that damn sugar.

I saw a very interesting programming challenge which was to write a script that finds the longest repeated substring in a given text.

Repeated
substrings may not overlap. If more than one substring is repeated with
the same length, you may print any of them. If there is no repeated
substring, the result is an empty string (print nothing).

This is by no means a trivial task but I was amazed at the elegance of the solution once it was hammered through.  The final test was to run it against "war and peace" to find the longest repeated substring.  FYI, that substring turned out to be ", which under his leadership will be directed against the redoubt and come into line with the rest of the forces.  A".  (I got the book in text format from http://www.gutenberg.org)

Ruby code follows:

# Finds the longest, non-overlapping repeated substring in its input.
#
# The basic technique used by this solution is to create an array of
# all suffixes of the data.  So if the input were "banana", the array
# would contain ["banana", "anana", "nana", "ana", "na", "a"].  Then
# we sort this array, so it would now contain ["a", "ana", "anana",
# "banana", "na", "nana"].  Finally we can compare neighboring entries
# in the array to see if they share a long enough prefix to beat the
# current best.

# Extra care must be taken if the substrings are not allowed to
# overlap.  Consider the input "ananana"; the longest non-overlapping
# substring is "ana".  The array of sorted suffixes of is ["a", "ana",
# "anana", "ananana", "na", "nana", "nanana"].  The 2nd and 3rd items
# can only have a match of "an" because the "ana" would overlap, and
# the same is true with the 3rd and 4th items.  However by comparing
# the 2nd and 4th items we can get the desired result of "ana".  So
# under certain circumstances we have to compare an item with more
# than just its immediate predecessor.

# This program seems to run reasonably fast.  It should run in O(n *
# log n) time in most cases, assuming that Array's sort method
# provides that performance.  Due to the rare cases when the program
# cannot just compare an item and its immediate predecessor, there may
# be some strange cases where it requires O(n ** 2).  Because Ruby
# allows a computed substring to share the data with the original
# string (until one of the strings is altered, i.e., "copy on write"),
# the memory used is linear to the input size.


# returns the maximum of the two parameters
def max(a, b)
  a >= b ? a : b
end


# Return the longest common prefix between two strings.  If max is
# specified then the longest common prefix cannot exceed it
def longest_common_prefix(s1, s2, max = nil)
  l1, l2 = s1.size, s2.size
  min = l1 < l2 ? l1 : l2
  min = min < max ? min : max if max
  min.times do |i|
    return s1.slice(0, i) if s1[i] != s2[i]
  end
  return s1.slice(0, min)
end


# Returns the longest repeated substring in a given string.
def longest_repeated_substring(string)
  size = string.length

  # put every possible suffix into an array
  suffixes = Array.new(size)
  size.times do |i|
    suffixes[i] = string.slice(i, size)
  end

  # sort the array of suffixes, so common substrings (i.e., prefixes
  # of suffixes) will be found in neighboring elements of the array
  suffixes.sort!

  best = ""
  at_least_size = 1    # the size to meet or exceed to be the new best
  distance = nil
  neighbors_to_check = 1

  # compare pairs of consecutive suffixes and see how much initial
  # commonality there is
  # (size - 1).times do |i|
  (1...size).each do |i|
    # p [i, neighbors_to_check]
    s1 = suffixes[i]

    # generally we will only need to compare the ith item and the one
    # preceding it; however if we were in a position to reject a long
    # enough common substring due to overlap issues, then we may have
    # to compare an ith item with additional preceding items;
    # neighbors_to_check tracks how many neighbors we need to check
    neighbors_to_check.downto(1) do |neighbor|
      s2 = suffixes[i - neighbor]

      # make sure that these to suffixes further apart than the size
      # of the current best; we don't explicitly track the index of
      # these suffixes, but since all suffixes go to the end of the
      # initial string, the size can be used as a proxy
      distance = (s1.size - s2.size).abs
      if distance < at_least_size
        if s1.size >= at_least_size &&
            s2.size >= at_least_size &&
            s1.slice(0, at_least_size) == s2.slice(0, at_least_size)
          neighbors_to_check = max(neighbors_to_check, neighbor + 1)
        else
          neighbors_to_check = neighbor
        end
        next
      end

      # if neighboring suffixes don't at least match as far as the best,
      # no need to check more carefully
      unless s1.slice(0, at_least_size) == s2.slice(0, at_least_size)
        neighbors_to_check = neighbor
        next
      end

      # get the longest common prefix that's no larger than distance,
      # since at that point the substrings overlap
      best = longest_common_prefix(s1, s2, distance)
      at_least_size = best.size + 1
      if best.size == distance
        neighbors_to_check = max(neighbors_to_check, neighbor + 1)
      else
        neighbors_to_check = neighbor
      end
    end
  end

  best
end

open("c:\\Belfry\\WarAndPeace.txt") do |f| @string = f.read end   
result = longest_repeated_substring(@string)
puts result && "\"#{result}\" (#{result.length} characters)" || "none"

I have a favorite website for programs and utilities that I that I would share. 

http://www.techsupportalert.com/

Everything on this site is freeware.  No shareware.  No demos.  No trials.

The content is arranged in categories but I have yet to need something that I could not find in here.  They have programs for just about everything and there is an editorial which compares and explains each. 

It greatly simplifies finding what I need as well as supplying it for FREE.  It has been immensely userful to me and now it can be for you too.  :)

dust specs are from my scanner. photograms are made without using an actual camera.  just placing objects on resin coated paper and exposing to F/16 light for 5 seconds and running through several developer baths.

I have noticed that the latest patch has had the big time pvp warlocks change their talent spec.  It was about half and half destro/affliction.  Now, it is heavily in favor of affliction. I have changed to an affliction pvp spec to try it out.  It has been quite effective so far.  I have only spent a few hours in BGs with this so the testing continues for me.  What I wanted to ask was how it was going for the other warlocks.  Have you tried affliction pvp since the patch? 

fwiw, I have also heard that the new gear is weighted toward affliction for raiding but initial experiments with this in heroics have not gone as well as it has for pvp affliction.

I have heard that Al Gore has a new book.  I have not seen it and cannot, therefore, comment upon it.  However, others have and take issue.  (go figure)

They say that there are doctored photos.  http://tinyurl.com/y86hfch  They call him bad things because of that.

I was wondering if anyone has seen this book.  If so, are the photos as the web says they are?  If so, does it say that they are artist depictions of things he is describing or are they just presented at face value?

I have no problem with someone drawing a picture to illustrate a point.  But wattsupwiththat.com seems to think that he is presenting fiction without saying that it is fiction.  So, I just wondered if someone that had access to that book could clarify this point.  Does it really look like that and do they say that it is not real but a depiction?

Thanks!  :)