efficiently finding, number is multiple of 3 or not..(in ruby PL)
#author "shivamzaz"
#efficient for nu,ber is multipe of three or not.
#level "medium"
#specially use of bitwise operator
'''Example: 23 (00..10111)
    1) Get count of all set bits at odd positions (For 23 it’s 3).
    2) Get count of all set bits at even positions (For 23 it’s 1).
    3) If difference of above two counts is a multiple of 3 then number is also a multiple of 3.'''
#<---------------------Happy Coding-------------------------< implementation in #ruby>--------------------------Happy Coding---------------------->
g=gets().chomp.to_i
odd=0
even=0
for i in 1.upto(8)
    if(((g & (1<<(i-1)))>0) && (i%2!=0))    #(>0  becoz ruby have'nt if(1) type of stmts while takes if(1>0) means to say conditional stmts..
        odd+=1
        #puts("odd :#{i}")
    elsif(((g & (1<<(i-1)))>0) && (i%2==0))
        even+=1
        #puts("even :#{i}")

    else
        p+=1
    end
end
puts odd
puts even
if((odd-even)%3==0)
    puts("multiple of three ")
else
    puts("not multiples of three")
end

Data structures in Ruby for beginners(Linked List)
'''author => shivamzaz  @imsec
    tag => simply linked list creation
    level => easy but not cakewalk
    '''
Node=Struct.new(:value,:next)
#  optional   <=>
'''class Node
    attr_accessor :value , :next        #value by ll and val by user function call
    def initialize value, next_i
        @value = value
        @next = next_i
        #puts "initialized with value :" + value.to_s
    end
end'''
class LinkedList
    def initialize value    # head ( first node creation ) creation
        @head= Node.new(value,nil)   #=> [5,nil] initially
    end
    def add(value)
        current = @head
        while(current.next!=nil)
            current=current.next
        end
        current.next=Node.new(value,nil)
    end
    def delete(value)
        current=@head
        if(current.value==value)
            @head=@head.next
        else
            current=@head
            while((current.next.value!=value)&& (current.next!=value) && (current!=nil))    # previous index tracking..
                current=current.next
            end
            if(current!=nil && current.next!=nil)
                current.next=current.next.next
            end
        end
    end
    def display()
        current=@head
        full_list=[]
        while(current.next!=nil)
            full_list<<current.value.to_s
            current=current.next
        end
        full_list+=[current.value.to_s]
        puts full_list.join("->")
    end
end
ll=LinkedList.new(5)   # first node  creation.
#ll=LinkedList.add(5)
ll.add(5)
ll.add(10)
#ll.delete(10)
ll.display


-------------------------------------------------------------------------------------------------------------------------------
                                      <<<Happy Coding>>>                      ->Shivam Gupta

Efficient  fibonacci series in ruby..

       '''author -> shivamzaz @imsec
    tag -> effiecient fibonacci series
    level -> cakewalk'''
p=gets().to_i
l=[]
l<<0
l<<1
q=gets().to_i    #qth num of fibonacci.
for i in p..1000   #1000 optional means upto series...
    if(((Math.sqrt(5*i*i+4)).floor)==(Math.sqrt((5*i*i+4)).ceil) || (Math.sqrt((5*i*i-4)).floor)==(Math.sqrt((5*i*i-4)).ceil))
        l<<i
    end
end
puts(l[q-1])    #print qth fibonacci num.
'''output:
       1
       3
       1

efficient prime algorithm in ruby(sieve of eratosthenes)....
  '''author -> shivamzaz @imsec
   tag -> effiecient prime finfinding algorithms
   complexity -> O(n loglog n)
   level -> cake walk'''
p=gets().to_i
prm=[]
for i in 0..p
    prm[i]=1
end
prm[0]=0
prm[1]=0
for i in 2..(Math.sqrt(p)).floor
    if(prm[i]==1)
        j=2
        while((i*j)<=p);    # coz table started from j->2
            prm[i*j]=0
            j+=1
        end
    end
end
for i in 0..p
    if(prm[i]==1)
        puts i
    end
end
'''
output:
    15
    2
    3
    5
    7
    11
    13
'''