ForNext

088. ５人の学生の身長を ソート

VBScript

JScript

Perl

$NINSU = 5;

sub swap
{
    my ($x, $y) = @_;
    $tmp = $$x;
    $$x  = $$y;
    $$y  = $tmp;
}

sub sort
{
    my ($data, $n) = @_;
    
    $k = $$n - 1;
    while ($k >= 0)
    {
        $j = -1;
        foreach $i(1..$k)
        {
            if ($$data[$i - 1] > $$data[$i])
            {
                $j = $i - 1;
                &swap(\$$data[$i], \$$data[$j]);
            }
        }
        $k = $j;
    }
}

@height = (178, 175, 173, 165, 179);

print "ソート前：\n";
for (0..$NINSU-1)
{
    printf("%2d:%4d\n", $_ + 1, $height[$_]);
}
print "\n";

&sort(\@height, \$NINSU);

print "ソート後：\n";
for (0..$NINSU-1)
{
    printf("%2d:%4d\n", $_ + 1, $height[$_]);
}

L:\>perl lesson_12_088.pl
メ[ト前：
 1: 178
 2: 175
 3: 173
 4: 165
 5: 179

メ[ト後：
 1: 165
 2: 173
 3: 175
 4: 178
 5: 179

PHP

<?php
$NINSU = 5;

function swap(&$x, &$y)
{
    $tmp = $x;
    $x   = $y;
    $y   = $tmp;
}

function sort1(&$data, $n)
{
    $k = $n - 1;
    while ($k >= 0)
    {
        $j = -1;
        for ($i = 1; $i <= $k; $i++)
        {
            if ($data[$i - 1] > $data[$i])
            {
                $j = $i - 1;
                swap($data[$i], $data[$j]);
            }
        }
        $k = $j;
    }
}

$height = array(178, 175, 173, 165, 179);

print "ソート前：\n";
for ($i = 0; $i < $NINSU; $i++)
{
    printf("%2d:%4d\n", $i + 1, $height[$i]);
}
print "\n";

sort1($height, $NINSU);

print "ソート後：\n";
for ($i = 0; $i < $NINSU; $i++)
{
    printf("%2d:%4d\n", $i + 1, $height[$i]);
}
?>

L:\>php lesson_12_088.php
ソート前：
 1: 178
 2: 175
 3: 173
 4: 165
 5: 179

ソート後：
 1: 165
 2: 173
 3: 175
 4: 178
 5: 179

Python

# coding: Shift_JIS

NINSU = 5

def sort(data, n):
    k = n - 1
    while (k >= 0):
        j = -1;
        for i in range(1, k + 1, 1):
            if (data[i - 1] > data[i]):
                j = i - 1
                data[i], data[j] = data[j], data[i]
        k = j

height = [178, 175, 173, 165, 179]

print "ソート前："
for i in range(0, NINSU, 1):
    print "%2d:%4d" % (i + 1, height[i])
print

sort(height, NINSU)

print "ソート後："
for i in range(0, NINSU, 1):
    print "%2d:%4d" % (i + 1, height[i])

N:\>python lesson_12_088.py
ソート前：
 1: 178
 2: 175
 3: 173
 4: 165
 5: 179

ソート後：
 1: 165
 2: 173
 3: 175
 4: 178
 5: 179

Ruby

NINSU = 5

def sort(data, n)
    k = n - 1
    while (k >= 0)
        j = -1
        for i in 1..k
            if (data[i - 1] > data[i])
                j = i - 1
                data[i], data[j] = data[j], data[i]
            end
        end
        k = j
    end
end

height = [178, 175, 173, 165, 179]

puts "ソート前："
height.each_with_index do |h, i|
    printf("%2d:%4d\n", i + 1, h)
end
puts ""

sort(height, NINSU)

puts "ソート後："
height.each_with_index do |h, i|
    printf("%2d:%4d\n", i + 1, h)
end

L:\>ruby  l:\lesson_12_088.rb
メ[ト前：
 1: 178
 2: 175
 3: 173
 4: 165
 5: 179

メ[ト後：
 1: 165
 2: 173
 3: 175
 4: 178
 5: 179

PowerShell

Scala

F#

C

#include <stdio.h>

#define NINSU 5

void swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

void sort(int data[], int n)
{
    int k = n - 1;
    while (k >= 0)
    {
        int i, j;
        for (i = 1, j = -1; i <= k; i++)
        {
            if (data[i - 1] > data[i])
            {
                j = i - 1;
                swap(&data[i], &data[j]);
            }
        }
        k = j;
    }
}

int main(int argc, char* argv[])
{
    int i;
    int height[] = {178, 175, 173, 165, 179};

    puts("ソート前：");
    for (i = 0; i < NINSU; i++)
        printf("%2d:%4d\n", i + 1, height[i]);
    puts("");

    sort(height, NINSU);

    puts("ソート後：");
    for (i = 0; i < NINSU; i++)
        printf("%2d:%4d\n", i + 1, height[i]);

    return 0;
}

R:\>lesson088\project1.exe
ソート前：
 1: 178
 2: 175
 3: 173
 4: 165
 5: 179

ソート後：
 1: 165
 2: 173
 3: 175
 4: 178
 5: 179

C++

C++Builder

VC++

C#

Java

class Lesson088 {
    static final int NINSU = 5;

    public static void main(String[] args) {
        int[] height = {178, 175, 173, 165, 179};

        System.out.println("ソート前：");
        for (int i = 0; i < NINSU; i++)
            System.out.printf("%2d:%4d\n", i + 1, height[i]);
        System.out.println("");

        sort(height, NINSU);

        System.out.println("ソート後：");
        for (int i = 0; i < NINSU; i++)
            System.out.printf("%2d:%4d\n", i + 1, height[i]);
    }

    static void sort(int data[], int n) {
        int k = n - 1;
        while (k >= 0) {
            int j = -1;
            for (int i = 1; i <= k; i++) {
                if (data[i - 1] > data[i]) {
                    j = i - 1;
                    int tmp = data[i];
                    data[i] = data[j];
                    data[j] = tmp;
                }
            }
            k = j;
        }
    }
}

L:\>java Lesson088
ソート前：
 1: 178
 2: 175
 3: 173
 4: 165
 5: 179

ソート後：
 1: 165
 2: 173
 3: 175
 4: 178
 5: 179

Objective-C

D

VB

VB.NET

Delphi

program Project1;

{$APPTYPE CONSOLE}

uses
    SysUtils;

const
    NINSU = 5;

procedure swap(var nx:Integer; var ny:Integer);
var
    tmp: Integer;
begin
    tmp := nx;
    nx  := ny;
    ny  := tmp;
end;

procedure sort(var data:array of Integer; n:Integer);
var
    i, j, k: Integer;
begin
    k := High(data);
    while (k >= 0) do
    begin
        j := -1;
        for i := Low(data) + 1 to k do
        begin
            if (data[i - 1] > data[i]) then
            begin
                j := i - 1;
                swap(data[i], data[j]);
            end;
        end;
        k := j;
    end;
end;

procedure main();
var
    i: Integer;
    height: array[1..5] of Integer;
begin
    height[1] := 178;
    height[2] := 175;
    height[3] := 176;
    height[4] := 165;
    height[5] := 179;

    Writeln('ソート前：');
    for i := 1 to NINSU do
        Writeln(Format('%2d:%4d', [i, height[i]]));
    Writeln('');

    sort(height, NINSU);

    Writeln('ソート後：');
    for i := 1 to NINSU do
        Writeln(Format('%2d:%4d', [i, height[i]]));
end;

begin
    main;
end.

S:\>lesson088\project1.exe
ソート前：
 1: 178
 2: 175
 3: 176
 4: 165
 5: 179

ソート後：
 1: 165
 2: 175
 3: 176
 4: 178
 5: 179

Ada

PL/SQL

T-SQL