Combining Array Elements

G

gregarican

I have an array that I would like to combine elements. Here's a sample
array:

[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
Value B", 1]]

What I would like to do is find the elements where the first two items
are the same and then combine the third. The resulting array would
consist of:

[["Value A", "Value B", 4],["Value A", "Value C", 2]]

This is something that is out in left field in terms of how I've used
arrays in the past. Anyone know of a quick bit of script I can whip up
that will suit the task?
 
J

Jeremy Wells

gregarican said:
I have an array that I would like to combine elements. Here's a sample
array:

[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
Value B", 1]]

What I would like to do is find the elements where the first two items
are the same and then combine the third. The resulting array would
consist of:

[["Value A", "Value B", 4],["Value A", "Value C", 2]]

This is something that is out in left field in terms of how I've used
arrays in the past. Anyone know of a quick bit of script I can whip up
that will suit the task?
Click to expand...
new_array = array.collect{|v| [v[0],v[1], a.select{|b| b[0] == v[0] &&
b[1] == v[1] }.inject(0){|m,b| m + b.last}]}.uniq
 
S

Sebastian Hungerecker

gregarican said:
[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
Value B", 1]]

What I would like to do is find the elements where the first two items
are the same and then combine the third.
Click to expand...

arr=[["Value A", "Value B", 3], ["Value A", "Value C", 2],
["Value A", "Value B", 1]]
arr.inject(Hash.new 0) do |hash, sarr|
hash[sarr[0..-2]] += sarr[-1]
hash
end #=> {["Value A", "Value C"]=>2, ["Value A", "Value B"]=>4}

Not exactly what you asked for, but converting it into an array shouldn't be
too hard from there.
 
D

David A. Black

Hi --

gregarican said:
I have an array that I would like to combine elements. Here's a sample
array:

[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
Value B", 1]]

What I would like to do is find the elements where the first two items
are the same and then combine the third. The resulting array would
consist of:

[["Value A", "Value B", 4],["Value A", "Value C", 2]]

This is something that is out in left field in terms of how I've used
arrays in the past. Anyone know of a quick bit of script I can whip up
that will suit the task?
Click to expand...
new_array = array.collect{|v| [v[0],v[1], a.select{|b| b[0] == v[0] && b[1]
Click to expand...
^^^^^^^^
You mean array.select, I think.
== v[1] }.inject(0){|m,b| m + b.last}]}.uniq
Click to expand...

This is just a cosmetic change, but you could do:

new_array = array.map {|v,w| [v,w, array.select {|b,c|
b == v && c == w }.inject(0){|m,b| m + b.last}]}.uniq

or even:

new_array = array.map {|v,w| [v,w, array.select {|b,c|
[b,c] == [v,w] }.inject(0){|m,b| m + b.last}]}.uniq


David

--
* Books:
RAILS ROUTING (new! http://www.awprofessional.com/title/0321509242)
RUBY FOR RAILS (http://www.manning.com/black)
* Ruby/Rails training
& consulting: Ruby Power and Light, LLC (http://www.rubypal.com)
 
Y

Yossef Mendelssohn

I have an array that I would like to combine elements. Here's a sample
array:

[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
Value B", 1]]

What I would like to do is find the elements where the first two items
are the same and then combine the third. The resulting array would
consist of:

[["Value A", "Value B", 4],["Value A", "Value C", 2]]

This is something that is out in left field in terms of how I've used
arrays in the past. Anyone know of a quick bit of script I can whip up
that will suit the task?
Click to expand...


irb(main):001:0> orig_array = [["Value A", "Value B", 3], ["Value A",
"Value C", 2],["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):002:0> hash = Hash.new(0)
=> {}
irb(main):003:0> orig_array.each { |elem| hash[ elem[0,2] ] +=
elem[2] }
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):004:0> hash.collect { |k, v| k + [v] }
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]


or, more concisely


irb(main):001:0> orig_array = [["Value A", "Value B", 3], ["Value A",
"Value C", 2],["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):002:0> orig_array.inject(Hash.new(0)) { |hash, elem|
hash[ elem[0,2] ] += elem[2]; hash }.collect { |k, v| k + [v] }
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]
 
R

Robert Klemme

2007/8/24 said:
I have an array that I would like to combine elements. Here's a sample
array:

[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
Value B", 1]]

What I would like to do is find the elements where the first two items
are the same and then combine the third. The resulting array would
consist of:

[["Value A", "Value B", 4],["Value A", "Value C", 2]]

This is something that is out in left field in terms of how I've used
arrays in the past. Anyone know of a quick bit of script I can whip up
that will suit the task?
Click to expand...


irb(main):001:0> orig_array = [["Value A", "Value B", 3], ["Value A",
"Value C", 2],["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):002:0> hash = Hash.new(0)
=> {}
irb(main):003:0> orig_array.each { |elem| hash[ elem[0,2] ] +=
elem[2] }
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):004:0> hash.collect { |k, v| k + [v] }
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]


or, more concisely


irb(main):001:0> orig_array = [["Value A", "Value B", 3], ["Value A",
"Value C", 2],["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):002:0> orig_array.inject(Hash.new(0)) { |hash, elem|
hash[ elem[0,2] ] += elem[2]; hash }.collect { |k, v| k + [v] }
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]
Click to expand...

I believe there is an even simpler solution:

irb(main):001:0> arr=[["Value A", "Value B", 3], ["Value A", "Value
C", 2], ["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]

irb(main):003:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)| ha[[a,b]]+=c;ha}
=> {["Value A", "Value C"]=>2, ["Value A", "Value B"]=>4}

irb(main):004:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.inject([]) {|re,v| re<<v.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]

Of course, the most elegant solution uses #inject - in this case two
injects. :)

Although, this one might be even better:

irb(main):007:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.map {|x| x.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]

At least 1 #inject. :)

Kind regards

robert
 
G

gregarican

2007/8/24, Yossef Mendelssohn <[email protected]>:




I have an array that I would like to combine elements. Here's a sample
array:
[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
Value B", 1]]
What I would like to do is find the elements where the first two items
are the same and then combine the third. The resulting array would
consist of:
[["Value A", "Value B", 4],["Value A", "Value C", 2]]
This is something that is out in left field in terms of how I've used
arrays in the past. Anyone know of a quick bit of script I can whip up
that will suit the task?
Click to expand...
Click to expand...
irb(main):001:0> orig_array = [["Value A", "Value B", 3], ["Value A",
"Value C", 2],["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):002:0> hash = Hash.new(0)
=> {}
irb(main):003:0> orig_array.each { |elem| hash[ elem[0,2] ] +=
elem[2] }
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):004:0> hash.collect { |k, v| k + [v] }
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]
Click to expand...
or, more concisely
Click to expand...
irb(main):001:0> orig_array = [["Value A", "Value B", 3], ["Value A",
"Value C", 2],["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]
irb(main):002:0> orig_array.inject(Hash.new(0)) { |hash, elem|
hash[ elem[0,2] ] += elem[2]; hash }.collect { |k, v| k + [v] }
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]
Click to expand...

I believe there is an even simpler solution:

irb(main):001:0> arr=[["Value A", "Value B", 3], ["Value A", "Value
C", 2], ["Value A", "Value B", 1]]
=> [["Value A", "Value B", 3], ["Value A", "Value C", 2], ["Value A",
"Value B", 1]]

irb(main):003:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)| ha[[a,b]]+=c;ha}
=> {["Value A", "Value C"]=>2, ["Value A", "Value B"]=>4}

irb(main):004:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.inject([]) {|re,v| re<<v.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]

Of course, the most elegant solution uses #inject - in this case two
injects. :)

Although, this one might be even better:

irb(main):007:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.map {|x| x.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]

At least 1 #inject. :)

Kind regards

robert- Hide quoted text -

- Show quoted text -
Click to expand...

Thanks guys. All of the insight helps me out tremendously. There are a
lot of abilities that I never tapped into along these lines. Great
stuff and hopefully more tools in my belt. Appreciate the tips!
 
S

Stefan Rusterholz

Greg said:
[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
that will suit the task?
"Value B", 1]]
hash[ elem[0,2] ] += elem[2]; hash }.collect { |k, v| k + [v] }
Click to expand...
=> {["Value A", "Value C"]=>2, ["Value A", "Value B"]=>4}
irb(main):007:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.map {|x| x.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]

At least 1 #inject. :)

Kind regards

robert- Hide quoted text -

- Show quoted text -
Click to expand...

Thanks guys. All of the insight helps me out tremendously. There are a
lot of abilities that I never tapped into along these lines. Great
stuff and hopefully more tools in my belt. Appreciate the tips!
Click to expand...

What makes me slightly sad is that all those examples try to squeeze as
much as possible into a single statement. Frankly, in my opinion the
resulting code is horrible to read again a few months later.
I'll try to go a different way, a bit more to type but hopefully easier
to read. Maybe somebody has an even more readable idea.

array = [["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value
A", "Value B", 1]]
groups = array.group_by { |element| element.first(2) }
result = groups.map { |key, values|
values.map! { |a,b,c| c } # if I knew what each value represents I'd
chose better names
key+[values.sum]
}

# required code (group_by is in 1.9, though probably a different
implementation, sum is in activesupport afaik)
module Enumerable
def group_by(result=nil, add=nil)
result ||= Hash.new { |h,k| h[k]=[] }
add ||= :<<
each { |args| result[yield(args)].__send__(add, args) }
result
end
end

module Enumerable
def sum
inject(0) { |a,b| a+b }
end
end

Regards
Stefan
 
L

Logan Capaldo

Yet another variation on the theme:
def foo(a)
a.inject(Hash.new(0)) { |h, (k1, k2, v)| lambda { |k|
h.update(k=>h[k]+v) }[[k1,k2]] }.map { |k, v| k + [v] }
end
 
R

Robert Klemme

Greg said:
[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
that will suit the task?
"Value B", 1]]
hash[ elem[0,2] ] += elem[2]; hash }.collect { |k, v| k + [v] }
=> {["Value A", "Value C"]=>2, ["Value A", "Value B"]=>4}
irb(main):007:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.map {|x| x.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]

At least 1 #inject. :)

Kind regards

robert- Hide quoted text -

- Show quoted text -
Click to expand...
Thanks guys. All of the insight helps me out tremendously. There are a
lot of abilities that I never tapped into along these lines. Great
stuff and hopefully more tools in my belt. Appreciate the tips!
Click to expand...

What makes me slightly sad is that all those examples try to squeeze as
much as possible into a single statement.
Click to expand...

That was not my primary concern. I tried to avoid pasting lengthy IRB
screen copies as they tend to look horrible. The code could have been
on more lines as well.
Frankly, in my opinion the
resulting code is horrible to read again a few months later.
Click to expand...

I'd say: it depends. People seem to be quite different with regard to
their "readability ranking". I know people who prefer shorter code.
Since this is not production code and especially without explicit
comments (there's always the mail / news thread) it's not intended to be
easily readable after a longer period of time.
I'll try to go a different way, a bit more to type but hopefully easier
to read. Maybe somebody has an even more readable idea.

array = [["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value
A", "Value B", 1]]
groups = array.group_by { |element| element.first(2) }
result = groups.map { |key, values|
values.map! { |a,b,c| c } # if I knew what each value represents I'd
chose better names
key+[values.sum]
}
Click to expand...

What I dislike about this solution is that it traverses the collection
twice although it is more modular. If I want very readable code I'd do
something like this:

array = ...
groups = Hash.new 0
array.each do |(a,b,c)|
p a
groups[[a,b]] += c
end
result = groups.to_a
# required code (group_by is in 1.9, though probably a different
implementation, sum is in activesupport afaik)
module Enumerable
def group_by(result=nil, add=nil)
result ||= Hash.new { |h,k| h[k]=[] }
add ||= :<<
each { |args| result[yield(args)].__send__(add, args) }
result
end
end
Click to expand...

Personally I would not make the Hash and add an argument here because
there are too many requirements. (I.e. result needs to guarantee that
result[] will return something that can receive the method you use).
module Enumerable
def sum
inject(0) { |a,b| a+b }
end
end
Click to expand...

Note that this implementation of sum only works for numeric types. It
does not work for example for string concatenation.

Kind regards

robert
 
G

gregarican

Greg said:
On Aug 24, 9:52 am, "Robert Klemme" <[email protected]>
wrote:
[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
that will suit the task?
"Value B", 1]]
hash[ elem[0,2] ] += elem[2]; hash }.collect { |k, v| k + [v] }
=> {["Value A", "Value C"]=>2, ["Value A", "Value B"]=>4}
irb(main):007:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.map {|x| x.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]
At least 1 #inject. :)
Kind regards
robert- Hide quoted text -
- Show quoted text -
Thanks guys. All of the insight helps me out tremendously. There are a
lot of abilities that I never tapped into along these lines. Great
stuff and hopefully more tools in my belt. Appreciate the tips!
Click to expand...
Click to expand...
What makes me slightly sad is that all those examples try to squeeze as
much as possible into a single statement.
Click to expand...

That was not my primary concern. I tried to avoid pasting lengthy IRB
screen copies as they tend to look horrible. The code could have been
on more lines as well.
Frankly, in my opinion the
resulting code is horrible to read again a few months later.
Click to expand...

I'd say: it depends. People seem to be quite different with regard to
their "readability ranking". I know people who prefer shorter code.
Since this is not production code and especially without explicit
comments (there's always the mail / news thread) it's not intended to be
easily readable after a longer period of time.
I'll try to go a different way, a bit more to type but hopefully easier
to read. Maybe somebody has an even more readable idea.
Click to expand...
array = [["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value
A", "Value B", 1]]
groups = array.group_by { |element| element.first(2) }
result = groups.map { |key, values|
values.map! { |a,b,c| c } # if I knew what each value represents I'd
chose better names
key+[values.sum]
}
Click to expand...

What I dislike about this solution is that it traverses the collection
twice although it is more modular. If I want very readable code I'd do
something like this:

array = ...
groups = Hash.new 0
array.each do |(a,b,c)|
p a
groups[[a,b]] += c
end
result = groups.to_a
# required code (group_by is in 1.9, though probably a different
implementation, sum is in activesupport afaik)
module Enumerable
def group_by(result=nil, add=nil)
result ||= Hash.new { |h,k| h[k]=[] }
add ||= :<<
each { |args| result[yield(args)].__send__(add, args) }
result
end
end
Click to expand...

Personally I would not make the Hash and add an argument here because
there are too many requirements. (I.e. result needs to guarantee that
result[] will return something that can receive the method you use).
module Enumerable
def sum
inject(0) { |a,b| a+b }
end
end
Click to expand...

Note that this implementation of sum only works for numeric types. It
does not work for example for string concatenation.

Kind regards

robert- Hide quoted text -

- Show quoted text -
Click to expand...

I just picked up this thread again. I can concur about the readability
factor, in that if I've picked up my own relatively uncommented code a
few months later it can be hard to read. Especially if it's terser
Perlish stuff. But like regular expressions, if I dig into it for a
bit I can pick up how I did what I needed to do. Usually as a rule I
go back in and heavily comment terser areas of my programming.

Wanted to thank everyone who contributed to different ways to
accomplish this one task. I am using my script to help the jewelry
company I work for price out and keep sufficient on-hand quanities of
loose diamonds. Each stone goes into its own category due to carat,
cut, color, and clarity and I have to parse through all of the
inventory to glead out what goes where. This Ruby script has
eliminated hours of data entry and analysis manually punching things
into an Excel spreadsheet. Now my script goes that work for them
through the array/hash manipulation and through win32ole. Gotta love
Ruby and the Ruby community :)
 
R

Robert Klemme

Greg Kujawa wrote:
On Aug 24, 9:52 am, "Robert Klemme" <[email protected]>
wrote:
[["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value A",
that will suit the task?
"Value B", 1]]
hash[ elem[0,2] ] += elem[2]; hash }.collect { |k, v| k + [v] }
=> {["Value A", "Value C"]=>2, ["Value A", "Value B"]=>4}
irb(main):007:0> arr.inject(Hash.new(0)) {|ha,(a,b,c)|
ha[[a,b]]+=c;ha}.map {|x| x.flatten}
=> [["Value A", "Value C", 2], ["Value A", "Value B", 4]]
At least 1 #inject. :)
Kind regards
robert- Hide quoted text -
- Show quoted text -
Thanks guys. All of the insight helps me out tremendously. There are a
lot of abilities that I never tapped into along these lines. Great
stuff and hopefully more tools in my belt. Appreciate the tips!
What makes me slightly sad is that all those examples try to squeeze as
much as possible into a single statement.
Click to expand...
That was not my primary concern. I tried to avoid pasting lengthy IRB
screen copies as they tend to look horrible. The code could have been
on more lines as well.
Frankly, in my opinion the
resulting code is horrible to read again a few months later.
Click to expand...
I'd say: it depends. People seem to be quite different with regard to
their "readability ranking". I know people who prefer shorter code.
Since this is not production code and especially without explicit
comments (there's always the mail / news thread) it's not intended to be
easily readable after a longer period of time.
I'll try to go a different way, a bit more to type but hopefully easier
to read. Maybe somebody has an even more readable idea.
array = [["Value A", "Value B", 3], ["Value A", "Value C", 2],["Value
A", "Value B", 1]]
groups = array.group_by { |element| element.first(2) }
result = groups.map { |key, values|
values.map! { |a,b,c| c } # if I knew what each value represents I'd
chose better names
key+[values.sum]
}
Click to expand...
What I dislike about this solution is that it traverses the collection
twice although it is more modular. If I want very readable code I'd do
something like this:

array = ...
groups = Hash.new 0
array.each do |(a,b,c)|
p a
groups[[a,b]] += c
end
result = groups.to_a
# required code (group_by is in 1.9, though probably a different
implementation, sum is in activesupport afaik)
module Enumerable
def group_by(result=nil, add=nil)
result ||= Hash.new { |h,k| h[k]=[] }
add ||= :<<
each { |args| result[yield(args)].__send__(add, args) }
result
end
end
Click to expand...
Personally I would not make the Hash and add an argument here because
there are too many requirements. (I.e. result needs to guarantee that
result[] will return something that can receive the method you use).
module Enumerable
def sum
inject(0) { |a,b| a+b }
end
end
Click to expand...
Note that this implementation of sum only works for numeric types. It
does not work for example for string concatenation.

Kind regards

robert- Hide quoted text -

- Show quoted text -
Click to expand...

I just picked up this thread again. I can concur about the readability
factor, in that if I've picked up my own relatively uncommented code a
few months later it can be hard to read. Especially if it's terser
Perlish stuff. But like regular expressions, if I dig into it for a
bit I can pick up how I did what I needed to do. Usually as a rule I
go back in and heavily comment terser areas of my programming.

Wanted to thank everyone who contributed to different ways to
accomplish this one task. I am using my script to help the jewelry
company I work for price out and keep sufficient on-hand quanities of
loose diamonds. Each stone goes into its own category due to carat,
cut, color, and clarity and I have to parse through all of the
inventory to glead out what goes where. This Ruby script has
eliminated hours of data entry and analysis manually punching things
into an Excel spreadsheet. Now my script goes that work for them
through the array/hash manipulation and through win32ole. Gotta love
Ruby and the Ruby community :)
Click to expand...

Hey, that sounds like a great success story! I'm glad, Ruby could make
your life a lot easier, because that's what I believe Ruby is about.

Kind regards

robert
 
P

Phrogz

Wanted to thank everyone who contributed to different ways to
accomplish this one task. I am using my script to help the jewelry
company I work for price out and keep sufficient on-hand quanities of
loose diamonds. Each stone goes into its own category due to carat,
cut, color, and clarity and I have to parse through all of the
inventory to glead out what goes where. This Ruby script has
eliminated hours of data entry and analysis manually punching things
into an Excel spreadsheet. Now my script goes that work for them
through the array/hash manipulation and through win32ole. Gotta love
Ruby and the Ruby community :)
Click to expand...

It's quite disappointing that this is being used for diamonds. How
marvelously meta it would have been if Ruby had been used for
rubies. :)
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

Typical javascript array comparison and manipulation 2
Mandatory Elements To Conduct JavaScript Form Manipulation 7
Accessing array index addresses with custom datatype in a function 0
SENTINEL CONTROL LOOP WHEN DEALING WITH TWO ARRAYS 1
Array of structs function pointer 10
Ordenate and remove duplicate cases of an array passed as a c function argument 0
C exercise 1
Trouble creating multi dimensional array. 0 to 26 in 3 dimensions. 1

Members online

No members online now.
Total: 30 (members: 0, guests: 30)
Robots: 331

Forum statistics

Threads
473,755
Messages
2,569,536
Members
45,009
Latest member
GidgetGamb

Latest Threads

Top