クイックソート（quickSort）を9種類の言語で書いてみた

プログラミング アルゴリズム

何故書くか？はこのエントリー書いたので、以下、即本題。 今回は、C言語によるアルゴリズム事典を参考にしたので、C言語は省くことにした。

実行環境はcoding groundというWEB上でコンパイルから実行までしてくれるサービスを使用。

本当は定義したメソッドだけ書いておきたいのだけど、後々動作確認したいと思った時にコピペで済むので前処理等も書いておいた。

JavaScript

function quickSort(arr) {
    let q = (head, tail) => {
        let i = head;
        let j = tail;
        let pivot = arr[Math.floor((head + tail) / 2)];
        let tmp;
        for ( ; ; ) {
            while (arr[i] < pivot) {
                i++;
            }
            while (pivot < arr[j]) {
                j--;
            }
            if (i >= j) {
                break;
            }
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = arr[i];
            i++;
            i--;
        }
        if (head < i - 1) {
            q(head, i-1);
        }
        if (j + 1 < tail) {
            q(j + 1, tail);
        }
        return arr;
    }
}
console.log(quickSort([148, 651, 124, 638, 567, 435, 185, 413, 35]));

PHP

function quickSort($arr) {
    function q($arr, $head, $tail) {
        $i = $head;
        $j = $tail;
        $pivot = $arr[floor(($head + $tail) / 2)];

        for ( ; ; ) {
            while ($arr[$i] < $pivot) {
                $i++;
            }
            while ($pivot < $arr[$j]) {
                $j--;
            }
            if ($i >= $j) {
                break;
            }
            $tmp = $arr[$i];
            $arr[$i] = $arr[$j];
            $arr[$j] = $tmp;  
            $i++;
            $j--;
        }
        if ($head < $i - 1) {
            q($arr, $head, $i-1);
        }
        if ($j + 1 < $tail) {
            q($arr, $j+1, $tail);
        }
        return $arr;
    }
    return q($arr, 0, count($arr)-1);
}
$arr = array(651, 148 , 124, 638, 567, 435, 185, 413, 841, 35);
print_r(quickSort($arr));

Perl

use POSIX qw(floor);

my @arr = (148, 651, 124, 638, 567, 435, 185, 413, 841, 353);
print join(",", &quickSort(@arr));

sub quickSort {
    my ($arr) = @_;
    my $q;
    $q = sub {
        my ($arr, $head, $tail) = @_;
        my $i = $head;
        my $j = $tail;
        my $pivot = @arr[floor(($head + $tail) / 2)];
        my $tmp;
        while (1) {
            while (@arr[$i] < $pivot) {
                $i++;
            }
            while ($pivot < @arr[$j]) {
                $j--;
            }
            if ($i >= $j) {
                last;
            }
            $tmp = @arr[$i];
            @arr[$i] = @arr[$j];
            @arr[$j] = $tmp;
            $i++;
            $j--;
        }

        if ($head < $i - 1) {
            $q->(\@arr, $head, $i-1);
        }
        if ($j + 1 < $tail) {
            $q->(\@arr, $j+1, $tail);
        }
        return @arr;
    };   
    return $q->(\@arr, 0, $#arr);
}

Python

import math
def quickSort(arr):
    def q(head, tail):
        i = head
        j = tail
        pivot = arr[math.floor((head + tail) / 2)]
        while True:
            while arr[i] < pivot:
                i += 1
            while pivot < arr[j]:
                j -= 1
            if i >= j:
                break
            tmp = arr[i]
            arr[i] = arr[j]
            arr[j] = tmp
            i += 1
            j -= 1
        if head < i - 1:
            q(head, i-1)
        if j + 1 < tail:
            q(j+1, tail)
        return arr
    return q(0, len(arr)-1)
print(quickSort([104, 865, 413, 541, 304, 354, 165, 150]))

Ruby

def quickSort(arr)
    # 内部メソッドだが、スコープはトップレベル
    def q(arr, head, tail)
        i = head
        j = tail
        pivot = arr[((head + tail) / 2).floor]

        while true
            while arr[i] < pivot
                i += 1
            end
            while pivot < arr[j]
                j -= 1
            end
            if i >= j
                break
            end
            tmp = arr[i]0
            arr[i] = arr[j]
            arr[j] = tmp
            i += 1
            j -= 1
        end
        if head < i - 1
            q(arr, head, i-1)
        end
        if j + 1 < tail
            q(arr, j+1, tail)
        end
        return arr
    end
    return q(arr, 0, arr.size-1)
end
arr = [148, 651, 124, 638, 567, 435, 185, 413, 841, 35]
print quickSort(arr)

Go

package main

import (
    "fmt"
    "math"
)

func main() {
    arr := []int{148, 651, 124, 638, 567, 435, 185, 413, 841, 35};
    fmt.Println(quickSort(arr));
}
func quickSort(arr []int) []int {
    var q func(int, int) []int;
    q = func(head int, tail int) []int {
        i := head;
        j := tail;
        pivot := arr[int(math.Floor(float64(head + tail) / 2))];
        tmp := 0;
        for{
            for arr[i] < pivot {
                i++;
            }
            for pivot < arr[j] {
                j--;
            }
            if i >= j {
                break;
            }
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++
            j--;
        }
        if head < i-1 {
            q(head, i-1);
        }
        if j+1 < tail {
            q(j+1, tail);
        }
        return arr;
    }
    return q(0, len(arr)-1);
}

Kotlin

fun main(args: Array<String>) {
    var arr = arrayOf(148, 651, 124, 638, 567, 435, 185, 413, 841, 35);
    var result = quickSort(arr);
    for(i in result) println(i)
}

fun quickSort(arr: Array<Int>): Array<Int> {
    return q(arr, 0, arr.size-1);
}

fun q(arr: Array<Int>, head: Int, tail: Int): Array<Int> {
    var i = head;
    var j = tail;
    var pivot = arr[Math.floor((head + tail).toDouble() / 2).toInt()];
    while (true) {
        while (arr[i] < pivot) {
            i++;
        }
        while (pivot < arr[j]) {
            j--;
        }
        if (i >= j) {
            break;
        }
        var tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
        i++;
        j--;
    }
    if (head < i - 1){
        q(arr, head, i - 1);
    }
    if (j + 1 < tail) {
        q(arr, j + 1, tail);
    }
    return arr;
}

Swift

func quickSort(a: [Int]) -> [Int] {
    var arr = a
    func q(head: Int, tail: Int) -> [Int] {
        var i = head
        var j = tail
        var pivot = arr[Int(floor(Double(head + tail) / 2))]
        while true {
            while arr[i] < pivot {
                i += 1
            }
            while pivot < arr[j] {
                j -= 1
            }
            if i >= j {
                break;
            }
            var tmp = arr[i]
            arr[i] = arr[j]
            arr[j] = tmp
            i += 1
            j -= 1
        }
        if head < i - 1 {
            q(head: head, tail: i-1)
        }
        if j + 1 < tail {
            q(head: j+1, tail: tail)
        }
        return arr
    }
    return q(head: 0, tail: arr.count-1)
}
print(quickSort(a: [867, 104, 413, 541, 304, 354, 165, 150]))

C#

using System.IO;
using System;

class Program
{
    static void Main()
    {
        int[] arr = {148, 651, 124, 638, 567, 435, 185, 413, 841, 35};
        Console.WriteLine(string.Join(", ", quickSort(arr)));
    }

    static int[] quickSort(int[] arr) {
        Func<int, int, int[]> q = null;
        q = (head, tail) => {
            int i = head;
            int j = tail;
            int pivot = arr[(int)Math.Floor((double)(head + tail) / 2)];

            for ( ; ; ) {
                while (arr[i] < pivot) {
                    i++;
                }
                while (pivot < arr[j]) {
                    j--;
                }
                if (i >= j) {
                    break;
                }
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
                i++;
                j--;
            }
            if(head < i - 1) {
                q(head, i - 1);
            }
            if (j + 1 < tail) {
                q(j + 1, tail);
            }
            return arr;
        };
        q(0, arr.Length-1);
        return arr;
    }
}

マージソート（mergeSort）9種類の言語で書いてみた

何故書くか？は前前前前回書いたので、以下、即本題。 今回は、C言語によるアルゴリズム事典を参考にしたので、C言語は省くことにした。

実行環境はcoding groundというWEB上でコンパイルから実行までしてくれるサービスを使用。

本当は定義したメソッドだけ書いておきたいのだけど、後々動作確認したいと思った時にコピペで済むので前処理等も書いておいた。

JavaScript

function margeSort(arr, head, tail) {
    let m = (head, tail) => {
        if (head < tail) {
            let mid = Math.floor((head + tail) / 2);
            m(head, mid);
            m(mid+1, tail);

            let l = arr.slice(head, mid+1);
            let r = arr.slice(mid+1, tail+1);
            let i = head;
            while (l.length > 0 && r.length > 0) {
                if (l[0] <= r[0]) {
                    arr[i++] = l.shift();
                } else {
                    arr[i++] = r.shift();
                }
            }
            while (l.length > 0) {
                arr[i++] = l.shift();
            }
        }
        return arr;
    }
    m(0, arr.length-1);
    return arr;
}
console.log(margeSort([148, 651, 124, 638, 567, 435, 185, 413, 35]));

PHP

function margeSort(&$arr) {
    function m (&$arr, $head, $tail) {
        if ($head < $tail) {
            $mid = floor(($head + $tail) / 2);
            m($arr, $head, $mid);
            m($arr, $mid+1, $tail);

            $l = array_slice($arr, $head, $mid+1 - $head);
            $r = array_slice($arr, $mid+1, ($tail - $mid));
            $i = $head;
            while (count($l) > 0 && count($r) > 0) {
                if ($l[0] <= $r[0]) {
                    $arr[$i++] = array_shift($l);
                } else {
                    $arr[$i++] = array_shift($r);
                }
            }
            while (count($l) > 0) {
                $arr[$i++] = array_shift($l);
            }
        }
        return $arr;
    }
    return m($arr, 0, count($arr)-1);
}

$arr = array(651, 148 , 124, 638, 567, 435, 185, 413, 841, 35);
print_r(margeSort($arr));

Perl

use POSIX qw(floor);

my @arr = (148, 651, 124, 638, 567, 435, 185, 413, 841, 35);
print join(",", &margeSort(@arr));

sub margeSort {
    my ($arr) = @_;
    my $m;
    $m = sub {
        my ($arr, $head, $tail) = @_;
        if ($head < $tail) {
            my $mid = floor(($head + $tail) / 2);
            $m->(\@arr, $head, $mid);
            $m->(\@arr, $mid + 1, $tail);

            my @l = @arr[$head .. ($mid+1)];
            my @r = @arr[($mid+1) .. ($tail+1)];
            my $i = $head;
            while ($#l > 0 && $#r > 0) {
                if ($l[0] <= $r[0]) {
                    @arr[$i++] = shift(@l);
                } else {
                    @arr[$i++] = shift(@r);
                }
            }
            while ($#l > 0) {
                @arr[$i++] = shift(@l);
            }
        }
        return @arr;
    };
    return $m->(\@arr, 0, $#arr, $m);
}

Python

import math
def margeSort(arr):
    def m(head, tail):
        if head < tail:
            mid = math.floor((head + tail) / 2)
            m(head, mid)
            m(mid + 1, tail)

            l = arr[head: mid + 1]
            r = arr[mid+1: tail+1]
            k = head
            while len(l) > 0 and len(r) > 0:
                if l[0] <= r[0]:
                    arr[k] = l.pop(0)
                else:
                    arr[k] = r.pop(0)
                k += 1

            while len(l) > 0:
                arr[k] = l.pop(0)
                k += 1
        return arr
    return m(0, len(arr)-1)

arr = [104, 865, 413, 541, 304, 354, 165, 150]
print(margeSort(arr))

Ruby

def margeSort(arr)
    # 内部メソッドだが、スコープはトップレベル
    def m(arr, head, tail) 
        if head < tail
            mid = ((head + tail) / 2).floor
            m(arr, head, mid)
            m(arr, mid + 1, tail)

            l = arr.slice(Range.new(head, mid + 1, true))
            r = arr.slice(Range.new(mid + 1, tail + 1, true))
            i = head
            while l.size > 0 && r.size > 0 do
                if l[0] <= r[0]
                    arr[i] = l.shift
                else
                    arr[i] = r.shift
                end
                i += 1
            end

            while l.size > 0 do
                arr[i] = l.shift
                i += 1
            end
        end
        return arr
    end
    return m(arr, 0, arr.size-1)
end

arr = [148, 651, 124, 638, 567, 435, 185, 413, 841, 35]
print margeSort(arr)

Go

package main

import (
    "fmt"
    "math"
)

func main() {
    arr := []int{148, 651, 124, 638, 567, 435, 185, 413, 841, 35};
    fmt.Println(margeSort(arr));
}
func margeSort(arr []int) []int {
    var m func(int, int) []int;
    m = func(head int, tail int) []int {
        if head < tail {
            mid := int(math.Floor(float64(head + tail) / 2));
            m(head, mid);
            m(mid + 1, tail);

            l := make([]int, len(arr[head:mid+1]), (cap(arr[head:mid+1])+1))
            r := make([]int, len(arr[mid+1:tail+1]), (cap(arr[mid+1:tail+1])+1))
            copy(l, arr[head:mid+1]);
            copy(r, arr[mid+1:tail+1]);

            i := head;
            for len(l) > 0 && len(r) > 0 {
                if l[0] <= r[0] {
                    arr[i] = l[0];
                    l = l[1:];
                } else {
                    arr[i] = r[0];
                    r = r[1:];
                }
                i++;
            }

            for len(l) > 0 {
                arr[i] = l[0];
                l = l[1:];
                i++;
            }
        }
        return arr;
    }
    return m(0, len(arr)-1);
}

Kotlin

fun main(args: Array<String>) {
    var arr = arrayOf(148, 651, 124, 638, 567, 435, 185, 413, 841, 35);
    var result = margeSort(arr);
    for(i in result) println(i)
}

fun margeSort(arr: Array<Int>): Array<Int> {
    return m(arr, 0, arr.size-1);
}

fun m(arr: Array<Int>, head: Int, tail: Int): Array<Int> {
    if (head < tail) {
        var mid = Math.floor((head + tail).toDouble() / 2).toInt();
        m(arr, head, mid);
        m(arr, mid + 1, tail);

        var l = arr.sliceArray(head..(mid));
        var i = 0;
        var j = mid + 1;
        var k = head;
        while (i < l.size && j <= tail) {
            if (l[i] <= arr[j]) {
                arr[k++] = l[i++];
            } else {
                arr[k++] = arr[j++];
            }
        }

        while (i < l.size){
            arr[k++] = l[i++];
        }
    }
    return arr;
}

Swift

import Foundation
import Glibc

func margeSort(a: [Int]) -> [Int] {
    var arr = a
    func m(head: Int, tail: Int) {
        if head < tail {
            let mid = Int(floor(Double(head + tail) / 2))
            m(head: head, tail: mid)
            m(head: mid + 1, tail: tail)

            var l = arr[head...mid] // インデックスは0番からではなく、headの値からとなる
            var i = head
            var j = mid + 1
            var k = head
            while i <= mid && j <= tail {
                if l[i] <= arr[j] {
                    arr[k] = l[i]
                    i += 1
                } else {
                    arr[k] = arr[j]
                    j += 1
                }
                k += 1
            }

            while i <= mid {
                arr[k] = l[i]
                i += 1
                k += 1
            }
        }
    }
    m(head: 0, tail: arr.count-1)
    return arr
}
print(margeSort(a: [867, 104, 413, 541, 304, 354, 165, 150]))

C#

using System.IO;
using System;

class Program
{
    static void Main()
    {
        int[] arr = {148, 651, 124, 638, 567, 435, 185, 413, 841, 35};
        Console.WriteLine(string.Join(", ", margeSort(arr)));
    }

    static int[] margeSort(int[] arr) {
        Func<int, int, int[]> m = null;
        m = (head, tail) => {
            if (head < tail) {
                int mid = (int)Math.Floor((double)(head + tail) / 2);
                m(head, mid);
                m(mid + 1, tail);

                int[] l = new int[mid+1-head];
                Array.Copy(arr, head, l, 0, mid+1-head);
                int i = 0;
                int j = mid + 1;
                int k = head;
                while (i < l.Length && j <= tail) {
                    if (l[i] <= arr[j]) {
                        arr[k++] = l[i++];
                    } else {
                        arr[k++] = arr[j++];
                    }
                }

                while (i < l.Length) {
                    arr[k++] = l[i++];
                }
            }
            return arr;
        };
        m(0, arr.Length-1);
        return arr;
    }
}

二分探索（binarySearch）を10種類の言語で書いてみた

何故書くか？は前前前回書いたので、以下、即本題。

実行環境は今までと同じく、coding groundを使用。

本当は定義したメソッドだけ書いておきたいのだけど、後々動作確認したいと思った時にコピペで済むので前処理等も書いておいた。

JavaScript

function binarySearch(arr, target) {
    let head = 0,
        mid,
        tail = arr.length;

    while(head <= tail){
        mid = Math.floor((head + tail) / 2);
        if (arr[mid] === target) {
            return mid;
        } else if(arr[mid] < target) {
            head = mid + 1;
        } else {
            tail = mid -1;
        }
    }
    return -1;
}
console.log(binarySearch([104, 150, 165, 304, 354, 413, 541, 865], 304));

PHP

function binarySearch($arr, $target) {
    $head = 0;
    $tail = count($arr) - 1 ;
    while ($head <= $tail) {
        $mid = floor(($head + $tail) / 2);
        if ($arr[$mid] === $target) {
            return $mid;
        } else if ($arr[$mid] < $target) {
            $head = $mid + 1;
        } else {
            $tail = $mid -1;
        }
    }
    return -1;
}

echo (binarySearch([104, 150, 165, 304, 354, 413, 541, 865], 304));

Perl

use POSIX qw(floor);

my @arr = (104, 150, 165, 304, 354, 413, 541, 865);
my $result = &binarySearch(\@arr, 304);
print $result;
sub binarySearch {
    my ($arr, $target) = @_;
    my $head = 0;
    my $mid;
    my $tail = $#arr;

    while ($head <= $tail) {
        $mid = floor(($head + $tail) / 2);
        if ($arr[$mid] == $target) {
            return $mid;
        } elsif ($arr[$mid] < $target) {
            $head = $mid + 1;
        } else {
            $tail = $mid - 1;
        }
    }
    return -1;
}

Python

import math
def binarySearch(arr, target):
    head = 0
    tail = len(arr) - 1
    while head <= tail:
        mid = math.floor((head + tail) / 2)
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            head = mid + 1
        else:
            tail = mid - 1
    return False

print(binarySearch([104, 150, 165, 304, 354, 413, 541, 865], 304))

Ruby

def binarySearch(arr, target)
    head = 0
    tail = arr.size - 1
    while head <= tail do
        mid = ((head + tail) / 2).floor
        if arr[mid] == target
            return mid
        elsif arr[mid] < target
            head = mid + 1;
        else
            tail = mid -1;
        end
    end
    return -1
end

print binarySearch([104, 150, 165, 304, 354, 413, 541, 865], 304)

Go

package main

import (
    "fmt"
    "math"
)

func main() {
fmt.Println(binarySearch([]int{104, 150, 165, 304, 354, 413, 541, 865}, 304));
}

func binarySearch(arr []int, target int) int {
    head := 0;
    tail := len(arr) - 1;
    for head <= tail {
        mid := int(math.Floor(float64(head + tail) / 2));
        if arr[mid] == target {
            return mid;
        } else if arr[mid] < target {
            head = mid + 1;
        } else {
            tail = mid - 1;
        }
    }
    return -1;
}

Kotlin

func binarySearch(arr: [Int], target: Int) -> Int {
    var head = 0
    var mid = 0
    var tail = arr.count - 1;
    while head <= tail {
        mid = Int(floor(Double(head + tail) / 2))
        if arr[mid] == target {
            return mid;
        } else if arr[mid] < target {
            head = mid + 1;
        } else {
            tail = mid - 1;
        }
    }
    return -1;
}

print(binarySearch(arr: [104, 150, 165, 304, 354, 413, 541, 865], target: 304))

Swift

fun main(args: Array<String>) {
    println(binarySearch(arrayOf(104, 150, 165, 304, 354, 413, 541, 865), 304));
}

fun binarySearch(arr: Array<Int>, target: Int): Int {
    var head = 0
    var tail = arr.size-1
    while (head <= tail) {
        var mid = Math.floor((head + tail).toDouble() / 2).toInt()
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            head = mid + 1;
        } else {
            tail = mid - 1;
        }
    }
    return -1;
}

C

using System.IO;
using System;

class Program
{
    static void Main()
    {
        int[] arr = { 104, 150, 165, 304, 354, 413, 541, 865 };
        Console.WriteLine(binarySearch(arr, 304));
    }

    static int binarySearch(int[] arr, int target) {
        int head = 0;
        int tail = arr.Length - 1;
        while (head <= tail) {
            int mid = (int)Math.Floor((double)(head + tail) / 2);
            if (arr[mid] == target) {
                return mid;
            } else if(arr[mid] < target) {
                head = mid + 1;
            } else {
                tail = mid - 1;
            }
        }
        return -1;
    }
}

C

#include <stdio.h>
#include <math.h>

int binarySearch(int arr[], int len, int target) {
    int head = 0;
    int tail = len - 1;
    while (head <= tail) {
        double tmp = (head + tail) / 2;
        int mid = (int) floor(tmp);
        if(arr[mid] == target) {
            return mid;    
        } else if(arr[mid] < target) {
            head = mid + 1;
        } else {
            tail = mid - 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = {104, 150, 165, 304, 354, 413, 541, 865};
    printf("%d", binarySearch(arr, 8, 304));

    return 0;
}

バブルソート（bubbleSort）を10種類の言語で書いてみた

前回、linearSearch（線形探索）を10の言語で書いが、今回はバブルソートを書いてみた。

何故書くか？は前前回書いたので、以下、即本題。

以下は簡単な仕様。

  • bubbleSortメソッドor関数を定義
  • 数値の入った配列を引数にする
  • 昇順にソートする

各言語間のListオブジェクトや、ビルトインの配列操作ヘルパーの違いも気になるけれども、今は基本的な構文の違い等の方が興味があるので、そっちを優先した。

実行環境は今までと同じく、coding groundを使用。

JavaScript

function bubbleSort(arr) {
    for (let i = 0, len = arr.length-1; i < len; i++) {
        for (let j = len; j > i; j--) {
            if (arr[j] < arr[j-1]) {
                let tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
            }
        }
    }
    return arr;
}
console.log(bubbleSort([104, 865, 413, 541, 304, 354, 165, 150]));

PHP

function bubbleSort($arr) {
    for ($i = 0, $len = (count($arr)-1); $i < $len; $i++) {
        for ($j = $len; $j > $i; $j--) {
            if ($arr[$j] < $arr[$j-1]) {
                $tmp = $arr[$j];
                $arr[$j] = $arr[$j-1];
                $arr[$j-1] = $tmp;
            }
        }
    }
    return $arr;
}

print_r(bubbleSort([104, 865, 413, 541, 304, 354, 165, 150]));

Perl

use strict;
use warnings;

my @arr = (104, 865, 413, 541, 304, 354, 165, 150);
my @result = &bubbleSort(\@arr);
print join(",", @result);
sub bubbleSort {
    my ($arr) = @_;
    for (my $i = 0; $i < $#arr; $i++) {
        for(my $j = $#arr; $j > $i; $j--) {
            if ($arr[$j] < $arr[$j-1]) {
                my $tmp = $arr[$j];
                $arr[$j] = $arr[$j-1];
                $arr[$j-1] = $tmp;
            }
        }
    }
    return @arr;
}

Python

def bubbleSort(arr):
    for i in range(len(arr)):
        j = len(arr)-1
        while j > i:
            if arr[j] < arr[j-1]:
                tmp = arr[j]
                arr[j] = arr[j-1]
                arr[j-1] = tmp
            j -= 1
    return arr

print(bubbleSort([104, 865, 413, 541, 304, 354, 165, 150]))

Ruby

def bubbleSort(arr)
    i = 0
    while i < arr.size do
        j = arr.size
        while j > i do
            if arr[j] < arr[j-1]
                tmp = arr[j]
                arr[j] = arr[j-1]
                arr[j-1] = tmp
            end
            j -= 1
        end
        i += 1
    end
    return arr
end

print bubbleSort([104, 865, 413, 541, 304, 354, 165, 150])

Go

package main

import "fmt"

func main() {
    fmt.Println(bubbleSort([]int{104, 865, 413, 541, 304, 354, 165, 150}));
}
func bubbleSort(arr []int) []int {
    len := len(arr)-1;
    for i := 0; i < len; i++ {
        for j := len; j > i; j-- {
            if arr[j] < arr[j-1] {
                tmp := arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
            }
        }        
    }
    return arr;
}

Kotlin

fun main(args: Array<String>) {
    var result = bubbleSort(arrayOf(104, 865, 413, 541, 304, 354, 165, 150))
    for(i in result) println(i)
}
fun bubbleSort(arr: Array<Int>): Array<Int> {
    for (i in arr.indices) {
    println(i)
        var j = arr.size-1
        while (j > i) {
            if (arr[j] < arr[j-1]) {
                var tmp = arr[j]
                arr[j] = arr[j-1]
                arr[j-1] = tmp
            }            
            j--
        }
    }
    return arr
}

Swift

func bubbleSort(a: [Int]) -> [Int] {
    var arr = a // 引数の配列は定数となってしまう
    for i in 0 ..< arr.count {
        var j = arr.count-1
        while j > i {
            if arr[j] < arr[j-1] {
                let tmp = arr[j]
                arr[j] = arr[j-1]
                arr[j-1] = tmp
            }
            j -= 1
        }
    }
    return arr
}

print(bubbleSort(a: [104, 865, 413, 541, 304, 354, 165, 150]))

C#

using System.IO;
using System;

class Program
{
    static void Main()
    {
        int[] arr = { 104,865,413,541,304,354,165,150 };
        Console.WriteLine(string.Join(", ", bubbleSort(arr)));
    }

    static int[] bubbleSort(int[] arr) {
        int len  = arr.Length - 1;
        for (int i = 0; i < len; i++) {
            for (int j = len; j > i; j--) {
                if(arr[j] < arr[j-1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = tmp;
                }
            }
        }
        return arr;
    }
}

C

#include <stdio.h>

void bubbleSort(int arr[], int len)
{
    len -= 1;
    for (int i = 0; i < len; i++) {
        for(int j = len; j > i; j--){
            if(arr[j] < arr[j-1]){
                int tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
            }
        }
    }
}

int main()
{
    int arr[] = {104, 865, 413, 541, 304, 354, 165, 150};
    bubbleSort(arr, 8);
    for (int i = 0; i < 8; i++) {
        printf("%d\n", arr[i]);    
    }
    return 0;
}

あとで動作を確認しようと思った時にコピペで済ませるため、実行箇所や、前処理も含めて記載しておいた。

線形探索（linearSearch）を10種類の言語で書いてみた

前回、hello worldを12の言語で書いた。その続編として、少し難易度を上げてlinearSearch（線形探索）を書いてみた。

何故書くか？は前回書いたので、以下、即本題。

以下は簡単な仕様。

各言語間のListオブジェクトや、ビルトインの配列操作ヘルパーの違いも気になるけれども、今は基本的な構文の違い等の方が興味があるので、そっちを優先した。

実行環境は前回と同じく、coding groundを使用。

JavaScript

function linearSerch(arr, target) {
    for(var i = 0, len = arr.length; i < len; i++) {
        if(arr[i] === target){
            return i;
        }
    }
    return -1;
}

console.log(linearSerch([104, 865, 413, 541, 304, 354, 165, 150], 304));

PHP

function linearSearch($arr, $target) {
    for ($i = 0, $len = count($arr); $i <= $len; $i++) {
        if ($arr[$i] == $target) {
            return $i;
        }
    }
    return -1;
}

echo linearSearch([104, 865, 413, 541, 304, 354, 165, 150], 304);

Perl

use strict;
use warnings;

my @arr = (104, 865, 413, 541, 304, 354, 165, 150);
my $result = &linearSearch(\@arr, 304);
if ($result) {
    print($result);
} else {
    print('見つかりませんでした');
}
sub linearSearch {
    my ($arr, $target) = @_;
    for (my $i = 0; $i < @arr; $i++) {
        if ($arr[$i] == $target) {
            return $i;
        }
    }
    return -1;
}

Python

def linearSearch(arr, target):
    for (i, j) in enumerate(arr):
        if j == target:
            return i
    return -1

print(linearSearch([104, 865, 413, 541, 304, 354, 165, 150], 304))

Ruby

def linearSearch(arr, target)
    for i,j in arr
        if j == target
            return j
        end
    end
    return -1
end

print linearSearch([104, 865, 413, 541, 304, 354, 165, 150], 304)

Go

package main

import "fmt"

func main() {
    fmt.Println(linearSearch([]int{104, 865, 413, 541, 304, 354, 165, 150}, 304));
}

func linearSearch(arr []int, target int) int {
    for i, _ := range arr {
        if arr[i]  == target {
            return i;
        }
    }
    return -1;
}

Kotlin

fun main(args: Array<String>) {
    println(linearSearch(arrayOf(104, 865, 413, 541, 304, 354, 165, 150), 304));
}

fun linearSearch(arr: Array<Int>, target: Int): Int {
    for(i in arr.indices){
        if(arr[i] == target) {
            return i;
        }
    }
    return -1;
}

Swift

func linearSearch(arr: [Int], target: Int) -> Int {
    for i in 0 ..< arr.count {
        if arr[i] == target {
            return i;
        }
    }
    return -1;
}

print(linearSearch(arr: [104, 865, 413, 541, 304, 354, 165, 150], target: 304));

C#

using System.IO;
using System;

class Program
{
    static void Main()
    {
        int[] arr = { 104, 865, 413, 541, 304, 354, 165, 150 };
        Console.WriteLine(linearSearch(arr, 304));
    }

    static int linearSearch (int[] arr, int target) {
        for (int i = 0; i < arr.Length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }
}

C

#include <stdio.h>

int linearSearch(int *arr, int target)
{
    for(int i = 0; i < 8; ++i){
        if(arr[i] == target)
        {
            return i;
        }
    }
    return -1;
}

int main()
{
    int arr[] = {104, 865, 413, 541, 304, 354, 165, 150};
    printf("%d", linearSearch(arr, 304));

    return 0;
}

あとで動作を確認しようと思った時にコピペで済ませるため、実行箇所や、前処理も含めて記載しておいた。

C++はCと互換性があるので省き、Lispはトライしてみたけれど、網羅的に学習しないと書けそうにないことが判明したので書いていない（笑）

hello worldと比べて、少し世界観の差異が見えてきなあと感じる。もうちょっといろいろやってみたい気がするなあ。 bubbleSort、margeSort、quickSort、binarySearchくらいやってみよう！今無職だしね！（笑）

しかし、Lispは書けなかったけど一番興味が出た。

Hello, Worldを12種類の言語で書いてみた

Hello, worldを10種類ほどの言語で書いてみた。

これからしばらくは基本的なアルゴリズムを複数のプログラミング言語で書いていく。 出てくる言語はドットインストールやProgateなどで学習したことがある言語ばかり。

基本構文を学習したとは言え、言語の世界観を知るためには物足りないと思っていたので、とりあえずアルゴリズムでも書いて自分の好奇心に餌を与えちゃろう！と思っているのだ。

それから、アルゴリズムのイメージをプログラムに落とし込む能力をアップさせることもねらい。

僕は、アルゴリズムそのものをイメージする力も、それをプログラムに落とし込む力もそれ程高くない。 初めてクイックソートを書いた時なんて、納得するまでに相当な時間を要した。

だから、トレーニングとして基本的なアルゴリズムをよく書いているけれど、そのうち手が書くことを覚えてしまって、トレーニングにならなくて困っていた。

複数言語をまたげば、異なる書き方が強制されるので、いい刺激になりそうだと思っている。

あと、正規表現クックブックというオライリー出版の神本があって、これはいろんなパターンの正規表現処理を7言語に渡ってどう書くかを解説してくれるヤバイ本である。

僕は仕事でこの本に馬鹿みたいに助けられて、この本が大好きになってしまい、要は真似したくなったのだ笑

この本が無かったら、今でもゴミみたいな正規表現を書いていただろうと断言できるぜ・・・。

話が若干逸れたけど、以下本題。

実行環境はcoding groundというWEB上でコンパイルから実行までしてくれるサービスを使用。

JavaScript

console.log('Hello, world!!')

PHP

echo "Hello, world!!";

Perl

print "Hello, world!";

Python

print('Hello, world!!')

Ruby

print "Hello, world!!"

Go

fmt.Println("Hello, world!!")

Kotlin

println("Hello, world!!")

Swift

print("Hello, world!!");

C#

Console.WriteLine("Hello, world!!");

C

printf("Hello, world!!");

C++

cout << "Hello, world!!" << endl;

Lisp

(write-line "Hello, world!!")

本当はmain()必須など前処理が必要な言語もあるのだけれど、趣旨じゃない気がしたのでスルー（笑）

どれもそれほど変わりは無いだろうと思っていたけど、C++とLispが異彩を放っていて、さすがという気持ちになった（笑）

それから、自分の関心のある言語ってオブジェクト指向系なんやなあと気づく。プログラミング言語銀河と勝手に読んでいるサービスを参照。ALGOL系はあんまり触ったことが無いけどそのうち使ってみたい。

しかし、hello worldは簡単すぎた。ソートやサーチ等のアルゴリズムを複数言語に渡って紹介しているサイトとか欲しいなあと思った。

ブログを書く。久しい。

高校の時は銀杏BOYZが好きだったのでlivedoorブログを使っていたけれど、今はプログラマとして書きたくなったのでHatenaブログにお邪魔することにした。よろしくHatena！

昔はMarkdownの意味などわかるはずもないし、Javaゲームというサイトに入り浸っておきながら、プログラマの世話になっているなんて全く思ったことが無かったなあ（笑）

「プログラマ=パソコンしかしない人」

という漠然すぎるイメージしかなくて、自分でホームページを作りながらも、まさか自分がプログラマ的なことをやっているなんて夢にも思っていなかったなあ。