home > 写経編 > 柴田望洋『明解C言語 入門編』 > 7. 基本型 >

ForNext

Only Do What Only You Can Do

057. ビットシフト

VBScript

JScript

Perl

更新日 : 2010.10.18
sub count_bits
{
    my ($x) = @_;
    $count = 0;
    while ($x)
    {
        $count++ if ($x & 1) ;
        $x >>= 1;
    }
    return $count;
}

sub int_bits
{
    return &count_bits(~0);
}

sub print_bits
{
    my ($x) = @_;
    for ($i = &int_bits - 1; $i >= 0; $i--)
    {
        print ((($x >> $i) & 1) ? '1' : '0');
    }

    print "\n";
}

$na = 12345;

print "A       = ";  &print_bits($na);
print "A >> 1  = ";  &print_bits($na >> 1);
print "A >> 2  = ";  &print_bits($na >> 2);
print "A >> 3  = ";  &print_bits($na >> 3);
print "A >> 4  = ";  &print_bits($na >> 4);
print "\n";

print "A       = ";  &print_bits($na);
print "A << 1  = ";  &print_bits($na << 1);
print "A << 2  = ";  &print_bits($na << 2);
print "A << 3  = ";  &print_bits($na << 3);
print "A << 4  = ";  &print_bits($na << 4);
L:\>perl lesson_07_057.pl
A       = 00000000000000000011000000111001
A >> 1  = 00000000000000000001100000011100
A >> 2  = 00000000000000000000110000001110
A >> 3  = 00000000000000000000011000000111
A >> 4  = 00000000000000000000001100000011

A       = 00000000000000000011000000111001
A << 1  = 00000000000000000110000001110010
A << 2  = 00000000000000001100000011100100
A << 3  = 00000000000000011000000111001000
A << 4  = 00000000000000110000001110010000

PHP

更新日 : 2010.11.03
<?php
function count_bits($x)
{
    $count = 0;
    while ($x)
    {
        if ($x & 1) $count++;
        $x = ($x >> 1) & ~(~0 << (PHP_INT_SIZE * 8) - 1);
    }
    return $count;
}

function int_bits()
{
return count_bits(~0);

    return count_bits(~0);
}

function print_bits($x)
{
    for ($i = int_bits() - 1; $i >= 0; $i--)
    {
        print ((($x >> $i) & 1) ? '1' : '0');
    }

    print "\n";
}

$na = 12345;

print "A       = ";  print_bits($na);
print "A >> 1  = ";  print_bits($na >> 1);
print "A >> 2  = ";  print_bits($na >> 2);
print "A >> 3  = ";  print_bits($na >> 3);
print "A >> 4  = ";  print_bits($na >> 4);
print "\n";

print "A       = ";  print_bits($na);
print "A << 1  = ";  print_bits($na << 1);
print "A << 2  = ";  print_bits($na << 2);
print "A << 3  = ";  print_bits($na << 3);
print "A << 4  = ";  print_bits($na << 4);
?>
L:\>php lesson_07_057.php
A       = 00000000000000000011000000111001
A >> 1  = 00000000000000000001100000011100
A >> 2  = 00000000000000000000110000001110
A >> 3  = 00000000000000000000011000000111
A >> 4  = 00000000000000000000001100000011

A       = 00000000000000000011000000111001
A << 1  = 00000000000000000110000001110010
A << 2  = 00000000000000001100000011100100
A << 3  = 00000000000000011000000111001000
A << 4  = 00000000000000110000001110010000

Python

更新日 : 2010.11.17
import sys

def count_bits(x):
    count = 0
    while (x != 0):
        if (x & 1 != 0):
            count +=1
        x = (x >> 1) & ~(~0 << (sys.getsizeof(x) * 8));
    return count

def int_bits():
    return count_bits(~0)

def print_bits(x):
    for i in range(int_bits() - 1, -1,  -1):
        if ((x >> i) & 1) != 0:
            sys.stdout.write("1")
        else:
            sys.stdout.write("0")
    print

na = 12345

sys.stdout.write("A       = ");  print_bits(na)
sys.stdout.write("A >> 1  = ");  print_bits(na >> 1)
sys.stdout.write("A >> 2  = ");  print_bits(na >> 2)
sys.stdout.write("A >> 3  = ");  print_bits(na >> 3)
sys.stdout.write("A >> 4  = ");  print_bits(na >> 4)
print

sys.stdout.write("A       = ");  print_bits(na)
sys.stdout.write("A << 1  = ");  print_bits(na << 1)
sys.stdout.write("A << 2  = ");  print_bits(na << 2)
sys.stdout.write("A << 3  = ");  print_bits(na << 3)
sys.stdout.write("A << 4  = ");  print_bits(na << 4)
N:\>python lesson_07_057.py
A       = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000111001
A >> 1  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000001100000011100
A >> 2  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000110000001110
A >> 3  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000111
A >> 4  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000001100000011

A       = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000111001
A << 1  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000110000001110010
A << 2  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000001100000011100100
A << 3  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000011000000111001000
A << 4  = 0000000000000000000000000000000000000000000000000000000000000000000000000000000110000001110010000

Ruby

更新日 : 2010.11.01
def count_bits(x)
    count = 0
    while (x != 0)
        count += 1 if (x & 1 != 0) 
        x = (x >> 1) & ~(~0 << (x.size * 8))
    end
    return count
end

def int_bits
    return count_bits(~0)
end

def print_bits(x)
    (int_bits - 1).downto(0) do |i|
        print(((x >> i) & 1) != 0 ? '1' : '0')
    end

    puts ""
end

na = 12345

print "A       = ";  print_bits(na)
print "A >> 1  = ";  print_bits(na >> 1)
print "A >> 2  = ";  print_bits(na >> 2)
print "A >> 3  = ";  print_bits(na >> 3)
print "A >> 4  = ";  print_bits(na >> 4)
puts  ""

print "A       = ";  print_bits(na)
print "A << 1  = ";  print_bits(na << 1)
print "A << 2  = ";  print_bits(na << 2)
print "A << 3  = ";  print_bits(na << 3)
print "A << 4  = ";  print_bits(na << 4)
L:\>ruby  l:\lesson_07_057.rb
A       = 000000000000000000011000000111001
A >> 1  = 000000000000000000001100000011100
A >> 2  = 000000000000000000000110000001110
A >> 3  = 000000000000000000000011000000111
A >> 4  = 000000000000000000000001100000011

A       = 000000000000000000011000000111001
A << 1  = 000000000000000000110000001110010
A << 2  = 000000000000000001100000011100100
A << 3  = 000000000000000011000000111001000
A << 4  = 000000000000000110000001110010000

PowerShell

Scala

F#

C

更新日 : 2010.10.08
#include <stdio.h>

int count_bits(unsigned x)
{
    int count = 0;
    while (x)
    {
        if (x & 1u) count++;
        x >>= 1;
    }
    return count;
}

int int_bits(void)
{
    return count_bits(~0u);
}

void print_bits(unsigned x)
{
    int i;
    for (i = int_bits() - 1; i >= 0; i--)
        putchar(((x >> i) & 1u) ? '1' : '0');

    putchar('\n');
}

int main(int argc, char* argv[])
{
    unsigned na = 12345;

    printf("A       = ");  print_bits(na);
    printf("A >> 1  = ");  print_bits(na >> 1);
    printf("A >> 2  = ");  print_bits(na >> 2);
    printf("A >> 3  = ");  print_bits(na >> 3);
    printf("A >> 4  = ");  print_bits(na >> 4);
    putchar('\n');

    printf("A       = ");  print_bits(na);
    printf("A << 1  = ");  print_bits(na << 1);
    printf("A << 2  = ");  print_bits(na << 2);
    printf("A << 3  = ");  print_bits(na << 3);
    printf("A << 4  = ");  print_bits(na << 4);

    return 0;
}
R:\>lesson057\project1.exe
A       = 00000000000000000011000000111001
A >> 1  = 00000000000000000001100000011100
A >> 2  = 00000000000000000000110000001110
A >> 3  = 00000000000000000000011000000111
A >> 4  = 00000000000000000000001100000011

A       = 00000000000000000011000000111001
A << 1  = 00000000000000000110000001110010
A << 2  = 00000000000000001100000011100100
A << 3  = 00000000000000011000000111001000
A << 4  = 00000000000000110000001110010000

C++

C++Builder

VC++

C#

Java

更新日 : 2010.11.05
class Lesson057 {
    public static void main(String[] args) {
        int na = 12345;

        System.out.printf("A       = ");  print_bits(na);
        System.out.printf("A >> 1  = ");  print_bits(na >> 1);
        System.out.printf("A >> 2  = ");  print_bits(na >> 2);
        System.out.printf("A >> 3  = ");  print_bits(na >> 3);
        System.out.printf("A >> 4  = ");  print_bits(na >> 4);
        System.out.print('\n');

        System.out.printf("A       = ");  print_bits(na);
        System.out.printf("A << 1  = ");  print_bits(na << 1);
        System.out.printf("A << 2  = ");  print_bits(na << 2);
        System.out.printf("A << 3  = ");  print_bits(na << 3);
        System.out.printf("A << 4  = ");  print_bits(na << 4);

    }

    static void print_bits(int x)
    {
        int i;
        for (i = int_bits() - 1; i >= 0; i--)
            System.out.print(((x >>> i) & 1) != 0 ? '1' : '0');

        System.out.print('\n');
    }

    static int int_bits()
    {
        return count_bits(~0);
    }

    static int count_bits(int x)
    {
        int count = 0;
        while (x != 0)
        {
            if ((x & 1) != 0) count++;
            x >>>= 1;
        }
        return count;
    }
}
L:\>java Lesson057
A       = 00000000000000000011000000111001
A >> 1  = 00000000000000000001100000011100
A >> 2  = 00000000000000000000110000001110
A >> 3  = 00000000000000000000011000000111
A >> 4  = 00000000000000000000001100000011

A       = 00000000000000000011000000111001
A << 1  = 00000000000000000110000001110010
A << 2  = 00000000000000001100000011100100
A << 3  = 00000000000000011000000111001000
A << 4  = 00000000000000110000001110010000

Objective-C

D

VB

VB.NET

Delphi

更新日 : 2010.09.24
program Project1;

{$APPTYPE CONSOLE}

uses
    SysUtils;

function count_bits(x:Longword):Integer;
var
    count:Integer;
begin
    count := 0;
    while (x <> 0) do
    begin
        if x and 1 <> 0 then inc(count);
        x := x shr 1;
    end;
    result := count;
end;

function int_bits():Integer;
begin
    result := count_bits(Longword(not 0));
end;

procedure print_bits(x:Longword);
var
    i: Integer;
begin
    for i := int_bits() - 1 downto 0 do
    begin
        if x shr i and 1 <> 0 then
            write('1')
        else
            write('0');
    end;

    writeln('');
end;

procedure main();
var
    na: Longword;
begin
    na := 12345;
    write('A       = '); print_bits(na);
    write('A >> 1  = '); print_bits(na shr 1);
    write('A >> 2  = '); print_bits(na shr 2);
    write('A >> 3  = '); print_bits(na shr 3);
    write('A >> 4  = '); print_bits(na shr 4);
    writeln('');

    write('A       = '); print_bits(na);
    write('A << 1  = '); print_bits(na shl 1);
    write('A << 2  = '); print_bits(na shl 2);
    write('A << 3  = '); print_bits(na shl 3);
    write('A << 4  = '); print_bits(na shl 4);
end;

begin
    main;
end.
S:\>lesson057\project1.exe
A       = 00000000000000000011000000111001
A >> 1  = 00000000000000000001100000011100
A >> 2  = 00000000000000000000110000001110
A >> 3  = 00000000000000000000011000000111
A >> 4  = 00000000000000000000001100000011

A       = 00000000000000000011000000111001
A << 1  = 00000000000000000110000001110010
A << 2  = 00000000000000001100000011100100
A << 3  = 00000000000000011000000111001000
A << 4  = 00000000000000110000001110010000

Ada

PL/SQL

T-SQL

関数型

inserted by FC2 system