Язык       Время, микросекунд
Groovy 1.7.4                       260
PHP    5.2.14                      1,200
Python 2.6.5                      210
Python 2.6.5 + Psyco 2.0     70
Ruby 1.8.7                        400
Ruby 1.9.2                        300

Java
view source
print?
 01     public class Chain
 02     {
 03         private Person first = null;
 04      
 05         public Chain(int size)
 06         {
 07             Person last = null;
 08             Person current = null;
 09             for (int i =  0  ; i < size ; i++)
 10             {
 11                 current = new Person(i);
 12                 if (first == null) first = current;
 13                 if (last != null)
 14                 {
 15                     last.setNext(current);
 16                     current.setPrev(last);
 17                 }
 18                 last = current;
 19             }
 20             first.setPrev(last);
 21             last.setNext(first);
 22         }
 23      
 24         public Person kill(int nth)
 25         {
 26             Person current = first;
 27             int shout =  1 ;
 28             while(current.getNext() != current)
 29             {
 30                 shout = current.shout(shout, nth);
 31                 current = current.getNext();
 32             }
 33             first = current;
 34             return current;
 35         }
 36      
 37         public Person getFirst()
 38         {
 39             return first;
 40         }
 41         public static void main(String[] args)
 42         {
 43             int ITER =  100000 ;
 44             long start = System.nanoTime();
 45             for (int i =  0  ; i < ITER ; i++)
 46             {
 47                 Chain chain = new Chain( 40 );
 48                 chain.kill( 3 );
 49             }
 50             long end = System.nanoTime();
 51             System.out.println("Time per iteration = " + ((end - start) / (ITER )) + " nanoseconds.");
 52         }
 53     }
 54      
 55     class Person
 56     {
 57         int count;
 58         private Person prev = null;
 59         private Person next = null;
 60      
 61         public Person(int count)
 62         {
 63             this.count = count;
 64         }
 65      
 66         public int shout(int shout, int deadif)
 67         {
 68             if (shout < deadif) return (shout +  1 );
 69             this.getPrev().setNext(this.getNext());
 70             this.getNext().setPrev(this.getPrev());
 71             return  1 ;
 72         }
 73      
 74         public int getCount()
 75         {
 76             return this.count;
 77         }
 78      
 79         public Person getPrev()
 80         {
 81             return prev;
 82         }
 83      
 84         public void setPrev(Person prev)
 85         {
 86             this.prev = prev;
 87         }
 88      
 89         public Person getNext()
 90         {
 91             return next;
 92         }
 93      
 94         public void setNext(Person next)
 95      
 96         {
 97             this.next = next;
 98         }
 99     }

C++
view source
print?
 01     [/cpp]
 02     #include <stdio .h>
 03     #include <stdlib .h>
 04     #include <time .h>
 05     #include <sys /time.h>
 06      
 07     class Person
 08     {
 09      
 10         public:
 11      
 12             Person(int count) : _next(NULL), _prev(NULL) { _count = count; }
 13             int shout(int shout, int nth)
 14             {
 15                 if (shout < nth) return (shout +  1 );
 16                 _prev->_next = _next;
 17      
 18                 _next->_prev = _prev;
 19                 return  1 ;
 20             }
 21             int count() { return _count; }
 22             Person* next() { return _next; }
 23             void next(Person* person) { this->_next = person ; }
 24             Person* prev() { return _prev; }
 25             void prev(Person* person) { this->_prev = person; }
 26         private:
 27             int _count;
 28             Person* _next;
 29             Person* _prev;
 30     };
 31      
 32     class Chain
 33     {
 34         public:
 35             Chain(int size) : _first(NULL)
 36             {
 37                 Person* current = NULL;
 38                 Person* last = NULL;
 39                 for(int i =  0  ; i < size ; i++)
 40                 {
 41                     current = new Person(i);
 42                     if (_first == NULL) _first = current;
 43                     if (last != NULL)
 44                     {
 45                         last->next(current);
 46                         current->prev(last);
 47                     }
 48                     last = current;
 49                 }
 50                 _first->prev(last);
 51                 last->next(_first);
 52             }
 53             Person* kill(int nth)
 54             {
 55                 Person* current = _first;
 56                 int shout =  1 ;
 57                 while(current->next() != current)
 58      
 59                 {
 60                     Person* tmp = current;
 61                     shout = current->shout(shout,nth);
 62                     current = current->next();
 63                     if (shout ==  1 )
 64                     {
 65                         delete tmp;
 66                     }
 67                 }
 68                 _first = current;
 69                 return current;
 70             }
 71             Person* first() { return _first; }
 72         private:
 73             Person* _first;
 74     };
 75      
 76     int main(int argc, char** argv)
 77     {
 78         int ITER =  1000000 ;
 79         Chain* chain;
 80         struct timeval start, end;
 81         gettimeofday(&start,NULL);
 82         for(int i =  0  ; i < ITER ; i++)
 83         {
 84             chain = new Chain( 40 );
 85             chain->kill( 3 );
 86      
 87             delete chain;
 88         }
 89         gettimeofday(&end,NULL);
 90         fprintf(stdout,"Time per iteration = %d microseconds ", (((end.tv_sec - start.tv_sec) *  1000000 ) + (end.tv_usec - start.tv_usec)) / ITER);
 91         return  0 ;
 92     }
 93     [cpp]

Ruby
view source
print?
 01     class Person
 02         attr_reader :count, :prev, :next
 03         attr_writer :count, :prev, :next
 04      
 05         def initialize(count)
 06             #puts 'Initializing person : ' + count.to_s()
 07             @count = count
 08             @prev = nil
 09             @next = nil
 10         end
 11      
 12         def shout(shout, deadif)
 13             if shout < deadif
 14                 return shout +  1 
 15             end
 16             @prev.next = @next
 17             @next.prev = @prev
 18             return  1 
 19         end
 20     end     
 21      
 22     class Chain
 23         attr_reader :first
 24         attr_writer :first
 25      
 26         def initialize(size)
 27             @first = nil
 28             last = nil
 29             for i in ( 1 ..size)
 30                 current = Person.new(i)
 31                 if @first == nil
 32                     @first = current
 33                 end
 34                 if last != nil
 35                     last.next = current
 36                     current.prev = last
 37                 end
 38                 last = current
 39             end
 40             @first.prev = last
 41             last.next = @first
 42         end
 43      
 44         def kill(nth)
 45             current = @first
 46             shout =  1 
 47             while current.next != current
 48                 shout = current.shout(shout,nth)
 49                 current = current.next
 50             end
 51             @first = current
 52             return current
 53         end
 54     end
 55      
 56     ITER= 100000 
 57     start = Time.now
 58     ITER.times { |i|
 59     chain = Chain.new( 40 )
 60     chain.kill( 3 )
 61     }
 62     ends = Time.now
 63     puts 'Time per iteration = ' + ((ends - start) *  1000000  / ITER).to_s() + " microseconds"

Python
view source
print?
 01     import psyco
 02     psyco.full()
 03      
 04     class Person(object):
 05         def __init__(self,count):
 06             self.count = count;
 07             self.prev = None
 08      
 09             self.next = None
 10         def shout(self,shout,deadif):
 11             if (shout < deadif): return (shout +  1 )
 12             self.prev.next = self.next
 13             self.next.prev = self.prev
 14             return  1 
 15      
 16     class Chain(object):
 17         def __init__(self,size):
 18             self.first = None
 19             last = None
 20             for i in range(size):
 21                 current = Person(i)
 22                 if self.first == None : self.first = current
 23                 if last != None :
 24                     last.next = current
 25                     current.prev = last
 26                 last = current
 27             self.first.prev = last
 28             last.next = self.first
 29         def kill(self,nth):
 30             current = self.first
 31             shout =  1 
 32             while current.next != current:
 33                 shout = current.shout(shout,nth)
 34                 current = current.next
 35             self.first = current
 36             return current
 37      
 38     import time
 39     ITER =  100000 
 40     start = time.time()
 41     for i in range(ITER):
 42         chain = Chain( 40 )
 43         chain.kill( 3 )
 44     end = time.time()
 45     print 'Time per iteration = %s microseconds ' % ((end - start) *  1000000  / ITER)

PHP
view source
print?
 01     class Person
 02     {
 03         function __construct($c)
 04         {
 05             $this->count = $c;
 06         }      
 07      
 08         function getPrev()
 09         {
 10             return $this->prev;
 11         }          
 12      
 13         function setPrev($pr)
 14         {
 15             $this->prev = $pr;
 16         }  
 17      
 18         function getNext()
 19         {
 20             return $this->next;
 21         }
 22      
 23         function setNext($nxt)
 24         {
 25             $this->next = $nxt;
 26         }
 27      
 28         function shout($shout, $nth)
 29         {
 30             if ($shout < $nth)
 31             {
 32                 return $shout +  1 ;
 33             }
 34             $this->getPrev()->setNext($this->getNext());
 35             $this->getNext()->setPrev($this->getPrev());
 36             return  1 ;
 37         }
 38     }
 39      
 40     class Chain
 41     {
 42         var $first;
 43      
 44         function __construct($size)
 45         {
 46             $last = null;
 47      
 48             for($i =  0 ; $i < $size ; $i++)
 49             {
 50                 $current = new Person($i);
 51                 if ($this->first == null) $this->first = $current;
 52                 if ($last != null)
 53                 {
 54                     $last->setNext($current);
 55                     $current->setPrev($last);
 56                 }
 57                 $last = $current;
 58             }
 59             $this->first->setPrev($last);
 60             $last->setNext($this->first);
 61         }
 62      
 63         function kill($nth)
 64         {
 65             $current = $this->first;
 66             $shout =  1 ;
 67             while($current->getNext() !== $current)
 68             {
 69                 $shout =  $current->shout($shout,$nth);
 70                 $current = $current->getNext();
 71             }
 72             $this->first = $current;
 73         }
 74     }
 75      
 76     $start = microtime(true);
 77     $ITER =  100000 ;
 78     for($i =  0  ; $i < $ITER ; $i++)
 79     {
 80         $chain = new Chain( 40 );
 81         $chain->kill( 3 );
 82     }
 83     $end = microtime(true);
 84     printf("Time per iteration = %3.2f microseconds ",(($end -  $start) *  1000000  / $ITER));

Groovy
view source
print?
 01     class Chain
 02     {
 03         def size
 04         def first
 05      
 06         def init(siz)
 07         {
 08             def last
 09             size = siz
 10             for(def i =  0  ; i < siz ; i++)
 11             {
 12                 def current = new Person()
 13                 current.count = i
 14                 if (i ==  0 ) first = current
 15                 if (last != null)
 16                 {
 17                     last.next = current
 18                 }
 19                 current.prev = last
 20                 last = current
 21             }
 22             first.prev = last
 23             last.next = first
 24         }
 25      
 26         def kill(nth)
 27         {
 28             def current = first
 29             def shout =  1 
 30             while(current.next != current)
 31             {
 32                 shout = current.shout(shout,nth)
 33                 current = current.next
 34             }
 35             first = current
 36         }
 37     }
 38      
 39     class Person
 40     {
 41         def count
 42         def prev
 43         def next
 44      
 45         def shout(shout,deadif)
 46         {
 47             if (shout < deadif)
 48             {
 49                 return (shout +  1 )
 50             }
 51             prev.next = next
 52      
 53             next.prev = prev
 54             return  1 
 55         }
 56     }
 57      
 58     def main(args)
 59     {
 60         println "Starting"
 61         def ITER =  100000 
 62         def start = System.nanoTime()
 63         for(def i =  0  ; i < ITER ; i++)
 64         {
 65             def chain = new Chain()
 66             chain.init( 40 )
 67             chain.kill( 3 )
 68         }
 69         def end = System.nanoTime()
 70         println "Total time = " + ((end - start)/(ITER *  1000 )) + " microseconds"
 71     }
 72      
 73     def ITER =  100000 
 74     def start = System.nanoTime()
 75     for(def i =  0  ; i < ITER ; i++)
 76     {
 77         def chain = new Chain()
 78         chain.init( 40 )
 79         chain.kill( 3 )
 80     }
 81     def end = System.nanoTime()
 82     println "Time per iteration = " + ((end - start)/(ITER *  1000 )) + " microseconds"