DZone Snippets: string code

java String

zsearch (yonglongzhou) — Sun, 20 Jul 2008 11:58:17 GMT

// description of your code here



public static void main(String args[]) {



}

Javascript count line breaks

featurelover (Jochen Preusche) — Tue, 15 Jul 2008 08:57:23 GMT

Returns the number of line breaks in a string.



function lineBreakCount(str){

	/* counts \n */

	try {

		return((str.match(/[^\n]*\n[^\n]*/gi).length));

	} catch(e) {

		return 0;

	}

}

Acronym Builder

JamesHarrison (James Harrison) — Tue, 08 Jul 2008 10:36:12 GMT

// Generates an acronym from a string. For example "Hello World Ruby SCrIpT" goes to "HWRS".



    acronym = ''

    bytes = [] # Byte array

    long_string = ' ' + long_string # so the first letter, if capital, is included

    long_string.each_byte {|byte| bytes.push(byte)} # Build array of bytes

    bytes.each_with_index do |byte, index|

      if byte > 64 and byte < 96 # This is the range for ASCII capital letters, your encoding may vary

        # Capital letter

        if bytes[index-1] == 32 # We check behind to see if the letter is preceded by a space. Again, encoding may vary. 32 is ASCII space.

          acronym = acronym + long_string[index,1]

        end

      end

    end

String.random

mcmire () — Mon, 23 Jun 2008 15:58:23 GMT



class String

  def self.random(length=20)

    chars = ('a'..'z').to_a + ('A'..'Z').to_a + ("0".."9").to_a

    hash = ""; length.times { hash << chars[rand(chars.size)] }; hash

  end

end

Split array or string into smaller arrays

santiago.aguiar (Santiago Aguiar) — Fri, 13 Jun 2008 19:37:23 GMT

Splits an array or string into smaller arrays of the given size. Inspired on the ruby one ;).



import math

# v = value to split, l = size of each chunk

f = lambda v, l: [v[i*l:(i+1)*l] for i in range(int(math.ceil(len(v)/float(l))))]

Example



>>> f('000000111111222222333333444444567', 6)

['000000', '111111', '222222', '333333', '444444', '567']



>>> f(tuple('000000111111222222333333444444567'), 6)

[('0', '0', '0', '0', '0', '0'), ('1', '1', '1', '1', '1', '1'), ('2', '2', '2', '2', '2', '2'), ('3', '3', '3', '3', '3', '3'), ('4', '4', '4', '4', '4', '4'), ('5', '6', '7')]

Long live python :). Of course, a lisp/haskell implementation probably blows this snippet out.

Very simple ruby code to chunk a string

fjfish (Francis Fish) — Mon, 09 Jun 2008 15:34:02 GMT

I wanted to chunk a string and saw lots of 100 line examples. This is the trivial thing I came up with. Does have a small bug when the string length is an exact multiple of the len variable (as in this example!) that adds an extra empty string on the end.

But it worked for what I needed.



  string = "some long test string or other"

  r = []

  len = 15

  start = 0

  while(start <= string.length) do                                              

    r << string[start...start+len] 

    start += len 

  end

  r # ["some long test ", "string or other", ""]

Basic Trie data structure in Ruby

ntk () — Sat, 07 Jun 2008 20:54:39 GMT



# Inspired by http://www.rubyquiz.com/quiz103.html

# cf. also http://en.wikipedia.org/wiki/Trie



#!/usr/local/bin/ruby -w



require 'pp'



class Hash



   def deep_merge!(second)

      # cf. http://snippets.dzone.com/posts/show/4146

      merger = proc { |key,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }

      self.merge!(second, &merger)

   end



   def nested_hash(array)

      node = self

      array.each do |i|

         node[i]=Hash.new if node[i].nil?

         node = node[i]

      end 

      self

   end



   def merge_nested_hash!(nested_hash)

      deep_merge!(nested_hash)

   end



   # code basis taken from: "Find every path and it's value in a Hash" by Florian Aßmann,

   # http://snippets.dzone.com/posts/show/3565



   def each_trie_path

      raise ArgumentError unless block_given?

      self.class.each_trie_path(self) { |path, object| yield(path, object) }

   end



   protected

   def self.each_trie_path(object, path = [], &block)  



      if object.is_a?(Hash)

         object.each do |key, value|



            if key == true && value == {}

               if path == [:root]  # special case for empty string: [[:root], {true=>{}}]

                  yield(path, {true=>{}})

                  next

               end

               yield(path, object)

            end



            self.each_trie_path(value, [path , key].flatten, &block)

         end

      else 

         yield(path, object)

      end

   end 



end





class Trie



   @hash = Hash.new.merge_nested_hash!(Hash.new)

   #@hash = Hash.new.merge_nested_hash!({:root=>{}})

   #@hash = Hash.new.merge_nested_hash!(Hash.new.nested_hash([:root]))

   class << self; attr_accessor :hash; end    # Trie.hash



   def initialize

      Trie.hash.merge_nested_hash!({:root=>{}})

   end





   def add_int(int)   # for int >= 0

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  # integer array; ex: [4,6,2]

      ia.unshift(:root).push(true)

      Trie.hash.merge_nested_hash!(Hash.new.nested_hash(ia))

   end



   def matchi(int)  # match integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node[digit]

         #node = node.fetch(digit,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpi(int)   # match first part of integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node[digit]

         return false unless node

      end

      return true

   end





   def add_word(word)

      ca = word.split(//u)    # UTF-8 aware character array

      ca.unshift(:root).push(true)

      Trie.hash.merge_nested_hash!(Hash.new.nested_hash(ca))

   end



   def match(word)   # match entire word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node[char]

         #node = node.fetch(char,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpw(word)   # match first part of word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node[char]

         return false unless node

      end

      return true

   end



end





trie = Trie.new

p Trie.hash



trie.add_word("word")

pp Trie.hash            

p trie.match("word")      

p trie.match("word2")   

trie.add_word("word2")

p trie.match("word2")   

pp Trie.hash            # {:root=>{"w"=>{"o"=>{"r"=>{"d"=>{true=>{}, "2"=>{true=>{}}}}}}}}



trie.add_word("")

p trie.match("")

pp Trie.hash



puts



p trie.match("word")      

p trie.mfpw("wor")     # match first part of word



puts



trie.add_int(12345)

p Trie.hash



trie.add_int(12980345)

pp Trie.hash



trie.add_int(8512)

pp Trie.hash

p trie.matchi(8512)

p trie.matchi(85)

p trie.mfpi(85)     # match first part of integer

p trie.matchi(51)



puts



puts

pp Trie.hash

paths = []

Trie.hash.each_trie_path { |path, value| paths.push([ path ]) }

#Trie.hash.each_trie_path { |path, value| paths.push([ path, value ]) }

#pp paths

puts

paths.each { |x| p x }

puts





#------------------------------------------------------





require 'pp'



class Hash

   def Hash.new_nested_hash

     Hash.new{|h,k| h[k]=Hash.new(&h.default_proc) }

   end

end





class Trie



   @hash = Hash.new_nested_hash

   #@hash = Hash.new_nested_hash.update(true=>{})  # add empty string by default

   class << self; attr_accessor :hash; end    # Trie.hash



   def <<(word)

      ca = word.split(//u)    # UTF-8 aware character array

      wl = ca.size            # word length

      str = ""

      wl.times { |x| str << "[ca.at(#{x})]" }

      str = "Trie.hash" << str << "[true]"

      #p str     # example: "Trie.hash[ca.at(0)][ca.at(1)][ca.at(2)][ca.at(3)][true]"

      eval(str)

   end





   def match(word)

      ca = word.split(//u)    # UTF-8 aware character array

      wl = ca.size            # word length

      str = ""



      wl.times { |x| str << ".fetch(ca.at(#{x}),nil)" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),nil).fetch(ca.at(1),nil).fetch(ca.at(2),nil).fetch(true,nil)"

      ret = eval(str) rescue nil



=begin

      # alternative

      wl.times { |x| str << ".fetch(ca.at(#{x}),{})" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),{}).fetch(ca.at(1),{}).fetch(ca.at(2),{}).fetch(true,nil)"

      ret = eval(str)

=end



      ret == {} ? true : false   # {} is the default value created by Trie.hash or Hash.new_nested_hash respectively

   end



end





trie = Trie.new

trie << "word"

pp Trie.hash            

p trie.match("word")      

p trie.match("word2")   

trie << "word2"

p trie.match("word2")   

pp Trie.hash            # {"w"=>{"o"=>{"r"=>{"d"=>{true=>{}, "2"=>{true=>{}}}}}}}



trie << ""

p trie.match("")

pp Trie.hash





#------------------------------------------





# alternative with default :root element



require 'pp'



class Hash

   def Hash.new_nested_hash

     Hash.new{|h,k| h[k]=Hash.new(&h.default_proc) }

   end

end





class Hash



   # code basis taken from: "Find every path and it's value in a Hash" by Florian Aßmann,

   # http://snippets.dzone.com/posts/show/3565



   def each_trie_path

      raise ArgumentError unless block_given?

      self.class.each_trie_path(self) { |path, object| yield(path, object) }

   end



   protected

   def self.each_trie_path(object, path = [], &block)  



      if object.is_a?(Hash)

         object.each do |key, value|



            if key == true && value == {}

               if path == [:root]  # special case for empty string: [[:root], {true=>{}}]

                  yield(path, {true=>{}})

                  next

               end

               yield(path, object)

            end



            self.each_trie_path(value, [path , key].flatten, &block)

         end

      else 

         yield(path, object)

      end

   end 



end





class Trie



   @hash = Hash.new_nested_hash

   class << self; attr_accessor :hash; end    # Trie.hash



   def initialize

      Trie.hash[:root]

   end





   def add_int(int)   # for int >= 0

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  # integer array; ex: [4,6,2]

      ia.unshift(:root)

      str = ""

      ia.size.times { |x| str << "[ia.at(#{x})]" }

      str = "Trie.hash" << str << "[true]"

      eval(str)

   end



   def matchi(int)  # match integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node.fetch(digit,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpi(int)   # match first part of integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node.fetch(digit,nil)

         return false unless node

      end

      return true

   end





   def <<(word)

      ca = word.split(//u)    # UTF-8 aware character array

      ca.unshift(:root)

      #ca = [:root, *word.split(//u)]

      #ca = [:root].concat(word.split(//u))

      str = ""

      ca.size.times { |x| str << "[ca.at(#{x})]" }

      str = "Trie.hash" << str << "[true]"

      #p str     # example: "Trie.hash[ca.at(0)][ca.at(1)][ca.at(2)][ca.at(3)][true]"

      eval(str)

   end



   def match(word)

      ca = word.split(//u)    

      ca.unshift(:root)

      #ca = [:root, *word.split(//u)]

      #ca = [:root].concat(word.split(//u))

      str = ""

      ca.size.times { |x| str << ".fetch(ca.at(#{x}),nil)" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),nil).fetch(ca.at(1),nil).fetch(ca.at(2),nil).fetch(true,nil)"

      ret = eval(str) rescue nil



=begin

      # alternative

      ca.size.times { |x| str << ".fetch(ca.at(#{x}),{})" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),{}).fetch(ca.at(1),{}).fetch(ca.at(2),{}).fetch(true,nil)"

      ret = eval(str)

=end



      ret == {} ? true : false   # {} is the default value created by Trie.hash or Hash.new_nested_hash respectively

   end



   def match2(word)   # match entire word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node.fetch(char,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpw(word)   # match first part of word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node.fetch(char,nil)

         return false unless node

      end

      return true

   end



end





trie = Trie.new

trie << "word"

pp Trie.hash            

p trie.match("word")      

p trie.match("word2")   

trie << "word2"

p trie.match("word2")   

pp Trie.hash            # {:root=>{"w"=>{"o"=>{"r"=>{"d"=>{true=>{}, "2"=>{true=>{}}}}}}}}



trie << ""

p trie.match("")

pp Trie.hash



puts



p trie.match2("word")      

p trie.mfpw("wor")     # match first part of word



puts



trie.add_int(8512)

pp Trie.hash

p trie.matchi(8512)

p trie.matchi(85)

p trie.mfpi(85)     # match first part of integer

p trie.matchi(51)



puts



puts

pp Trie.hash

paths = []

Trie.hash.each_trie_path { |path, value| paths.push([ path ]) }

#Trie.hash.each_trie_path { |path, value| paths.push([ path, value ]) }

#pp paths

puts

paths.each { |x| p x }

puts

String Translit for Rails

mattetti (Matt Aimonetti) — Fri, 06 Jun 2008 22:03:29 GMT

// Translit for Rails using ActiveSupport. (convert é in e and other utf8 codes in latin chars)



class String

  def translit

    ActiveSupport::Multibyte::Handlers::UTF8Handler.normalize(self,:d).split(//u).reject { |e| e.length > 1 }.join

  end

end

file extension methods

elliottcable (elliott cable) — Sat, 17 May 2008 02:08:39 GMT

Allows you to use file extensions as methods



class File

  # Feel free to add more here, as you need them.

  Extensions = %r=^(txt|rb|markdown|textile|haml|sass|css|html|xhtml)$=i

  

  module Extension

    def method_missing(meth, *args)

      if Extensions =~ meth.to_s

        [self, '.', meth.to_s].join

      else

        super

      end # if

    end # method_missing

  end # Extension

end # File



class Symbol

  include File::Extension

end

class String

  include File::Extension

end



'myfile'.html

# => "myfile.html"



:a_file.rb

# => "a_file.rb"

Strip accents

pyninja (Adeel Khan) — Fri, 16 May 2008 00:19:40 GMT

// Strip accents from a string. For example, "Sigur Rós" => "Sigur Ros".



def strip_accents(string):

  import unicodedata

  return unicodedata.normalize('NFKD', unicode(string)).encode('ASCII', 'ignore')