Maximum Gap

You are given an array of integers @N.

Write a script to display the maximum difference between two successive elements once the array is sorted.

If the array contains only 1 element then display 0.

#!/usr/bin/env tclsh
#
# You are given an array of integers @N.
# Write a script to display the maximum difference between 
# two successive elements once the array is sorted.
# If the array contains only 1 element then display 0.
#

if {$argc == 0} {
    exit
} elseif {$argc == 1} {
    puts "0"
    exit
}

set len [llength $argv]
set mylist [lsort -integer $argv]
set max 0
for {set count 1} {$count < $len} {incr count} {
    set prev [lindex $mylist [expr $count - 1]]
    set curr [lindex $mylist $count]

    set result [expr $curr - $prev]
    if {$result > $max} {
        set max $result
    }
}

puts $max

The Name Game

You are given a $name.

Write a script to display the lyrics to the Shirley Ellis song The Name Game. Please checkout the wiki page for more information.

#!/usr/bin/env tclsh
#
# You are given a $name.
# Write a script to display the lyrics to
# the Shirley Ellis song The Name Game.
#
if {$argc >= 1} {
    set xname [lindex $argv 0]
} elseif {$argc == 0} {
    puts "Please input a string"
    exit    
}

if {[string length $xname] <= 1} {
    puts "Please give a longer string"
    exit
}

set yname [string range $xname 1 end]
puts "$xname, $xname, bo-b$yname"
puts "Bonana-fanna fo-f$yname"
puts "Fee fi mo-m$yname"
puts "$xname!"

FUSC Sequence

Write a script to generate first 50 members of FUSC Sequence.

The sequence defined as below:
fusc(0) = 0
fusc(1) = 1
for n > 1:
when n is even: fusc(n) = fusc(n / 2),
when n is odd: fusc(n) = fusc((n-1)/2) + fusc((n+1)/2)

#!/usr/bin/env tclsh
#
# Write a script to generate first 50 members of FUSC Sequence.
# fusc(0) = 0
# fusc(1) = 1
# for n > 1:
# when n is even: fusc(n) = fusc(n / 2),
# when n is odd: fusc(n) = fusc((n-1)/2) + fusc((n+1)/2)
#
proc fusc {n} {
    if {$n == 0}  {
        return 0
    } elseif {$n == 1} {
        return 1
    } elseif {$n > 1} {
        set checkn [tcl::mathop::% $n 2]
        if {$checkn==0} {
            return [fusc [tcl::mathop::/ $n 2]]
        } else {
            set subn [tcl::mathop::- $n 1]
            set addn [tcl::mathop::+ $n 1]
            return [tcl::mathop::+ [fusc [tcl::mathop::/ $subn 2]] [fusc [tcl::mathop::/ $addn 2]]]
        }
    } else {
        return -code error "Invalid input"
    }
}

set results [list]
for {set i 0} {$i < 50} {incr i} {
    lappend results [fusc $i]
}
set r [join $results ", "]
puts $r

Chinese Zodiac

You are given a year $year.

Write a script to determine the Chinese Zodiac for the given year $year. Please check out wikipage for more information about it.

#!/usr/bin/env tclsh
# You are given a year $year.
# Write a script to determine the Chinese Zodiac
# for the given year $year.

if {$argc >= 1} {
    set year [lindex $argv 0]
} elseif {$argc == 0} {
    puts "Please input a year."
    exit    
}

if {$year <= 0} {
    puts "Year requires > 0."
    exit    
}

# The animal cycle: Rat, Ox, Tiger, Rabbit, Dragon, Snake, Horse, Goat,
# Monkey, Rooster, Dog, Pig.
# The element cycle: Wood, Fire, Earth, Metal, Water.
set animal [list Monkey Rooster Dog Pig Rat Ox Tiger Rabbit Dragon Snake Horse Goat]
set element [list Metal Metal Water Water Wood Wood Fire Fire Earth Earth]

set a [lindex $animal [expr $year % 12]]
set e [lindex $element [expr $year % 10]]
puts "$e $a"

Rare Number

Given an integer N, the task is to check if N is a Rare Number.

Rare Number is a number N which is non-palindromic and N+rev(N) and N-rev(N) are both perfect squares where rev(N) is the reverse of the number N.

#!/usr/bin/env tclsh
#
# Given an integer N, the task is to check if N is a Rare Number.
#

if {$argc >= 1} {
    set nvalue [lindex $argv 0]
} elseif {$argc == 0} {
    puts "Please input a number."
    exit    
}

if {$nvalue <= 0} {
    puts "Number requires > 0."
    exit
}

proc reverseNumber {num} {
    set rev_num 0
    while {$num > 0} {  
        set rev_num [expr $rev_num * 10 + $num % 10]  
        set num [expr $num / 10]
    }  
    return $rev_num
}

proc isPerfectSquare {x} {
    if {$x <= 0 } {
        return 0
    }

    set sr [expr round(sqrt(double($x)))]
    set result [expr $sr * $sr]    
    if {$result==$x} {
        return 1
    }

    return 0
}

proc isRare {nvalue} {
    set rvalue [reverseNumber $nvalue]
    if {$nvalue==$rvalue} {
        return 0
    }

    set addvalue [expr $nvalue + $rvalue]
    set subvalue [expr $nvalue - $rvalue]
    if {[isPerfectSquare $addvalue] && [isPerfectSquare $subvalue]} {
        return 1;
    }

    return 0;
}

if {[isRare $nvalue]==1} {
    puts "Yes"
} else {
    puts "No"
}