2006年7月アーカイブ

トップページから移動

#include <iostream>
#include <algorithm> //max_element
#include <map>
#include <cstdlib> // atoi

typedef std::map<int,int> xs_t;

int g(int n) {
  return ( n == 1 ) ? 1 : 1 + g((n%2) ? n*3+1 : n/2);
}

int s(const xs_t::value_type& lhs, const xs_t::value_type& rhs) {
  return lhs.second < rhs.second;
}

int h(int n) {
  xs_t xs;
  for (int i = 0; i < n; ++i) {
    xs[i+1]=g(i+1);
  }
  return std::max_element(xs.begin(), xs.end(), s)->first;
}

int main(int argc, char** argv) {
  int n = ( argc > 1) ? std::atoi(argv[1]) : 100;
  std::cout << "h(" << n << ")=" << h(n) << std::endl;
  return 0;
}

#!perl
#

use strict;

sub f;
sub g;
sub h;

use Time::HiRes;

my $t = Time::HiRes::time;
print h(100), "\n";
printf "%-10.2f ms elapsed\n", (Time::HiRes::time - $t)*1000;

sub f {
  my $n = shift;
  if ( $n == 1 ) {
    1;
  }
  elsif ( $n % 2 ) {
    3 * $n + 1;
  }
  else {
    $n / 2;
  }
}

sub g {
  my $n = shift;
  my $cnt;
  do {
    ++$cnt;
  } until ( ($n = f($n)) == 1 );
  ++$cnt;
}

sub h {
  my $n = shift;

  my $k;
  my $max_g;
  for ( 1 .. $n ) {
    my $g = g($_);
    if ( $g > $max_g ) {
      $k = $_;
      $max_g = $g;
    }
  }
  $k;
}

#!perl
#

use strict;

use Language::Functional qw(:all);
use Time::HiRes;

my $t = Time::HiRes::time;
print h(100), "\n";
printf "%-10.2f ms elapsed\n", (Time::HiRes::time - $t)*1000;

sub f {
  my $n = shift;
  if ( $n == 1 ) {
    1;
  }
  elsif ( $n % 2 ) {
    $n*3+1;
  }
  else {
    $n/2;
  }
}

sub g {
  my $n = shift;
  my $c;
  Until { ++$c && shift() == 1; } \&f, $n;
  $c;
}

sub h {
  my $n = shift;
  my $max = maximum([map {g($_)} (1..$n)]);
  
  head(filter sub {g(shift) ==  $max}, [1..$n]);
}

sub f{
  my $n = shift;
  ($n % 2) ? $n*3+1 : $n/2;
}

#!perl
#

use strict;

sub g;
sub h;

use Time::HiRes;

my $t = Time::HiRes::time;
print h(100000), "\n";
printf "%-10.2f ms elapsed\n", (Time::HiRes::time - $t)*1000;

sub g {
  my $n = shift;
  $n == 1 ? 1 : 1 + g(($n%2) ? $n*3+1 : $n/2)
}

sub h {
  scalar((
    sort { $b->[1] <=> $a->[1] } 
    map { [$_, g($_)] } 1 .. shift
  )[0])->[0];
}

#include <windows.h>
#include <winioctl.h>

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <string>

class CdromDriveEnumerator : public std::iterator<std::input_iterator_tag, const std::string>
{
  DWORD dwDrives_;
  int index_;
  std::string drive_;

  public:
  CdromDriveEnumerator()
    : dwDrives_(GetLogicalDrives() << 1), index_(-1), drive_()
    {++(*this);}

  CdromDriveEnumerator(const CdromDriveEnumerator& x)
    : dwDrives_(x.dwDrives_), index_(x.index_), drive_(x.drive_)
    {}

  CdromDriveEnumerator& operator =(const CdromDriveEnumerator& x)
  {
    dwDrives_ = x.dwDrives_;
    index_ = x.index_;
    drive_ = x.drive_;
    return *this;
  }

  reference operator *() const
  {
    return drive_;
  }

  pointer operator ->() const
  {
    return &drive_;
  }

  CdromDriveEnumerator& operator ++()
  {
    ++index_;
    dwDrives_ >>= 1;
    if ( dwDrives_ & 1 ) {
      drive_ = std::string(1, static_cast<char>('A'+index_)).append(":");
      if ( GetDriveType(drive_.c_str()) != DRIVE_CDROM ) {
        ++(*this);
      }
    }
    else {
      ++(*this);
    }
    return *this;
  }

  CdromDriveEnumerator operator ++(int)
  {
    CdromDriveEnumerator ret = *this;
    ++(*this);
    return ret;
  }

  private:
  CdromDriveEnumerator(char drive)
    : dwDrives_(0), index_(0), drive_(std::string(1, drive).append(":"))
    {}

  public:
  static const CdromDriveEnumerator& end() {
    static CdromDriveEnumerator end('Z'+1);
    return end;
  }
};
bool operator ==(const CdromDriveEnumerator& x, const CdromDriveEnumerator& y)
{
  return *x == *y;
}
bool operator !=(const CdromDriveEnumerator& x, const CdromDriveEnumerator& y)
{
  return !(x == y);
} 

struct DriveEjector : public std::unary_function<const std::string&, int>
{
  result_type operator()(argument_type drive) {
    std::cout << "try to eject " << drive << std::endl;

    HANDLE h = CreateFile(
        std::string("\\\\.\\").append(drive).c_str(),
        GENERIC_READ,
        FILE_SHARE_READ,
        0,
        OPEN_EXISTING,
        0,
        0);

    if ( h == INVALID_HANDLE_VALUE ) {
      std::cerr << "failed to open volume \\\\.\\" << drive << std::endl;
      return 1;
    }

    DWORD dwReturned;
    for ( int i = 0; i < 20; ++i ) {
      if ( DeviceIoControl(h, FSCTL_LOCK_VOLUME, 0, 0, 0, 0, &dwReturned, 0) ) {
        if ( DeviceIoControl(h, FSCTL_DISMOUNT_VOLUME, 0, 0, 0, 0, &dwReturned, 0) ) {
          PREVENT_MEDIA_REMOVAL pmr;
          pmr.PreventMediaRemoval = FALSE;
          if ( DeviceIoControl(h, IOCTL_STORAGE_MEDIA_REMOVAL, 
                &pmr, sizeof(PREVENT_MEDIA_REMOVAL), 0, 0, &dwReturned, 0) ) {
            if ( DeviceIoControl(h, IOCTL_STORAGE_EJECT_MEDIA, 0, 0, 0, 0, &dwReturned, 0) ) {
              std::cout << "EJECT!" << std::endl;
            }
            break;
          }
        }
      }
    }

    CloseHandle(h);
    return 0;
  }
};

int main()
{
  std::for_each(CdromDriveEnumerator(), CdromDriveEnumerator::end(), DriveEjector());
  return 0;
}