Finding duplicate entries in a list

I want to find all the duplicate entries in a list and write thm out.
So far I've done:

puts $f1 [lsort $mylist]
puts $f2 [lsort -unique $mylist]

and then compared them in Textpad. this was quick & easy, but surely
there's a way to do
what I want very simply and just write out the duplicat entries.

(This was to find any duplicate pin assignments in a large FPGA, which
there shouldn't be, I found 4!).

Regards, Kev P.

maybe:
set l [list a a b c c]
foreach i $l {if {[info exists a($i)]} {puts $i} {set a($i) 1}}
a
c

The thing I don't like about this is that you build up an array. You will 
to unset it afterwards.

Harm

"Niv (KP)" < XXXX@XXXXX.COM > writes:


proc getdups {list} {
     array set tmp {}
     # Count items in tmp
     foreach item $list {
	lappend tmp($item) .
     }
     # Drop all items with count 1, they are unique
     foreach item [array names tmp] {
	if {[llength $tmp($item)] > 1} continue
        unset tmp($item)
     }
     # Return the remainder.
     return [array names tmp]
}

-- 
So long,
	Andreas Kupries < XXXX@XXXXX.COM >
			< http://www.**--****.com/ ;
	Developer @	< http://www.**--****.com/ ;
-------------------------------------------------------------------------------

Best put this functionality in a proc, where the local array is
cleared up on exit.

If you have tcllib you can also use struct::set for this.

Michael

Would be simpler just to incr tmp($item)
then     if ($tmp($item) > 1} continue
At least that's how us histogramming mind-set folks think

-- 
Ron Fox
NSCL
Michigan State University
East Lansing, MI 48824-1321

Another alternative to using an array is to sort the list and then 
traverse once checking for duplicates -- all dups are grouped in the 
sorted list, so detecting them is easy:

proc dups xs {
   set dups [list]
   set xs [lsort $xs]
   set len [expr {[llength $xs]-1}]
   for {set i 0} {$i < $len} {} {
     set x [lindex $xs $i]
     if {$x == [lindex $xs [incr i]]} {
       lappend dups $x
       # discard multiple repeats
       while {[lindex $xs $i] == $x} { incr i }
     }
   }
   return $dups
}

There doesn't seem to be any noticeable time difference between this and 
the array version, however.

-- Neil

Ron Fox < XXXX@XXXXX.COM > writes:


Only in 8.5. In 8.4 you still need an [info exists/incr/set] dance,
the use of lappend and unary counting was easier.


-- 
So long,
	Andreas Kupries < XXXX@XXXXX.COM >
			< http://www.**--****.com/ ;
	Developer @	< http://www.**--****.com/ ;
-------------------------------------------------------------------------------

Another solution - this simply prints the duplicates:

proc prtDups { args } {
    set argc [ llength $args ]
    while { $argc > 1 } {
        foreach item $args {
            set group [ lsearch -all $args $item ]
            set argc [ llength $group ]
            if { $argc > 1 } {
                puts "duplicate = [ lindex $args [ lindex $group 0 ] ]"
                foreach i [ lsort -integer -decreasing $group ] {
                    set args [ lreplace $args $i $i ]
                }
                break;
            }
        }
    }
}

set foo [ list a b b c c d e f ]

eval prtDups $foo

Sonya