配列操作系モジュール - HSP開発wiki

hinekure.net が http://hspdev-wiki.net/ から自動クローリングした結果を表示しています。画像やリソースなどのリンクが切れています。予めご了承ください。

配列操作系モジュール - HSP開発wiki

OFFICIAL/関連

TUTORIAL

HSP基礎講座

TOPICS

ETC

EDIT

REFERENCE

LOG

お知らせ

お知らせ

HSP Web-Ring

前<-ランダム->次

最新の40件

2013-11-28

外部リンク

2013-11-25

2013-11-24

RecentDeleted

2013-11-23

ソフト開発

2013-11-14

HSPのフォームデザインソフト

2013-11-13

2013-11-10

TUT/calc

2013-11-06

ネタ収集BOX/1

2013-10-23

INIファイル操作モジュール

2013-10-21

String/矩形

2013-10-20

小ワザのその他

2013-10-15

実行結果図鑑

2013-10-12

ソフト開発/HSPLet3拡張ライブラリ/Tips

2013-10-06

Module/hspdb(SQLite版)

2013-09-15

小ワザ/モーダルダイアログ

2013-08-28

2013-08-26

Web Browserを作ろう

2013-08-15

2013-08-06

2013-08-05

ネットワークFPSを作ろう！！

2013-08-02

半透明ウインドウ

2013-07-05

小ワザ/ストップウォッチ

2013-07-02

2013-06-29

2013-06-28

Math/2次Bスプライン関数

2013-06-27

小ワザ/アクション/基本動作

2013-06-25

ＩＭＥの制御

2013-06-14

eller

2013-06-01

Math/平面回転

2013-05-29

衝突判定

2013-05-28

雑談

total: 4964
today: 1
yesterday: 1
now: 1

配列操作系モジュール †

Perl や VB などにある Join/Split/Pop/Push などの関数や命令(予定)。

モジュール †

作りかけ。

+

mod_array.as

Everything is expanded.

Everything is shortened.

; 配列操作系モジュール(文字列型)
#ifndef __MOD_ARRAY_AS__
#const  __MOD_ARRAY_AS__
#module "m_array"
; shift 命令
; 	配列変数の先頭を取り除いて返す
;   (まだ非効率的なのでもっと効率のよい
;   やり方があれば修正をお願いします)
#deffunc shift array v1, array v2
; v1
; 	取り除いた配列を返す変数
; v2
; 	取り除く配列
; refstr
; 	取り除いた文字列
; 注意
;   v1 は初期化されてしまうので v2 と同じ
;   変数は指定しないでください
    sdim v1
    repeat length(v2) - 1, 1
        v1(cnt - 1) = v2(cnt)
    loop
    return v2(0)
 
; join 関数
; 	配列変数を指定の文字列を区切りとして結合して返す
#defcfunc join str s1, array v1, local l1
; s1
; 	連結する文字列
; v1
; 	連結元の配列変数
; ret
; 	結合した結果
    sdim l1
    foreach v1
        l1 += str(v1(cnt)) + s1
        ; 配列数が多い場合、定期的にウェイトをかける
        if (cnt \ 10) = 0 {
            await 1
        }
    loop
 
    ; 文字列最後の連結文字を削除
    poke l1, strlen(l1) - strlen(s1), 0
    return l1
 
; split 命令
; 	文字列を指定の区切り文字単位で区切って配列変数に代入
;   (まだ非効率的なのでもっと効率のよい
;   やり方があれば修正をお願いします)
#deffunc split array v1, str s1, str s2, local l1, local l2, local l3, local l4
; v1
; 	結果を取得する変数
; s1
; 	分割する文字列
; s2
;   区切り文字列
; 注意
; 	まだ、動作は不完全です
#ifdef for
    ; for マクロを使用しているので
    ; HSP 拡張マクロを有効にしてください
    sdim l1
    l2 = s1
    if strmid(l2, -1, strlen(s2)) ! s2 {
        l2 += s2
    }
    for l3, 0, strlen(l2), 1
        l4 = length(l1)
        l1(l4) = strmid(l2, l3, instr(l2, l3, s2))
        l3 += strlen(l1(l4))
    next
    ; 配列の先頭を削除
    shift v1, l1
#endif
    return
#global
#endif  ; end of __MOD_ARRAY_AS__
 
; ↓サンプルを実行するにはコメントを外してください
;#const RUN_SAMPLE
#ifdef RUN_SAMPLE
    ; shift 命令
    buf = "a", "b", "c"
    mes "shift 命令..."
    pos 25
    shift buf2, buf
    mes "取り除かれた文字列: " + refstr
    foreach buf2
        mes "buf2(" + cnt + ") = " + buf2(cnt)
    loop
 
    dialog "画面をクリアします", , "shift 命令"
    cls
 
    mes "join 関数..."
    pos 25
    sdim buf2
    buf2 = join(" ", buf)
    mes "buf2 = " + buf2
 
    dialog "画面をクリアします", , "join 関数"
    cls
 
    mes "split 命令..."
    pos 25
    split buf3, buf2, " "
    foreach buf3
        mes "buf3(" + cnt + ") = " + buf3(cnt)
    loop
    stop
#endif

+

splitをrepeatで実装

Everything is expanded.

Everything is shortened.

 
 
 
 
 
 
 
 
 
-
|
|
!
 
-
|
|
|
-
|
|
|
!

#module
#deffunc split array v1, str s1, str s2
;   v1 ... 結果を取得する変数
;   s1 ... 分割する文字列
;   s2 ... 区切り文字列
    sdim v1
    i = 0   ; 文字検索インデックス 最初は0（文字列の最初）
    s = s1  ; instrで使うためにs1を変数に格納
    repeat
        if i == strlen(s) {
            ; もう分割する文字が残っていない
            break
        }
        tmp = instr(s, i, s2)
        if tmp < 0 {
            ; 区切り文字が見つからないので、文字列の最後まで取得
            v1(cnt) = strmid(s, i, strlen(s)-i)
            break
        } else {
            ; 区切り文字までを取得
            v1(cnt) = strmid(s, i, tmp)
            i += tmp + strlen(s2)
        }
    loop
    return
#global
 
    mes "split 命令..."
    pos 25
    split buf3, "a b c", " "
    foreach buf3
        mes "buf3(" + cnt + ") = " + buf3(cnt)
    loop
    stop

簡易配列操作モジュール †

線形時間かそれ以上の物ばかりです
とりあえずたくさん使えればいいなと思い書きました
sortはこのwikiからのを編集しました
バグはたくさんあると思います
意外と文字列動かすのにも使える
大幅強化
バケットソートが尋常なく早い
map/filter/injectなど更にLLっぽく

+

mod_vector.as

Everything is expanded.

Everything is shortened.

#ifndef MOD_VECTOR
#define MOD_VECTOR
/*
	ほとんどの関数はint型のみ動作
	テンプレート欲しいです
	
	_size(arr) :長さを返す
	_new arr,l :lの長さで初期化
	_clear arr :長さ1で初期化
	_at(arr,l) :配列のl番目を返す
	_put arr,l,t :配列のl番目にtを代入
	_isin(arr,l) :lが0-配列の長さに収まっているかを返す
	_limin(arr,l) :lを配列の長さの範囲に収めた値を返す
	_sequence toarr,l,t :lからtまでの配列を返す
	_slice arr,toarr,l,t :配列のl番目からt個抜き出した配列を代入
	_copy arr,toarr :配列の内容を代入
	_comp arr,toarr,other　:arrにotherをつなげたものを代入
	_times arr,toarr,l　:配列をl回繰り返したものを代入
	_top(arr)　:配列の最初の値を返す
	_bottom(arr)　:配列の最後の値を返す
	_pop arr :配列の最後を削除する
	_push arr,l :配列の最後に値を追加する
	_shift arr :配列の最初を削除する
	_unshift arr :配列の最初に値を追加する
	_insert arr,l,t :配列のl番目にiを挿入して後ろにずらす
	_del arr,l :配列のl番目を削除して前にずらす
	_unshift arr,l :配列の最初に値を追加する
	_reverse arr,toarr :配列を逆順にして代入する
	_join(arr,l) :配列の内容をlを間に挟んだ文字列を返す
	_inspect(arr) :配列の内容を見やすくした文字列を返す
	_replace arr,l,t :配列の中のlをtに置き換える
	_sum(arr)　:配列の内容を合計したものを返す
	_shuffle arr,toarr　：配列の内容をランダムに並び替える
	_find(arr,l) :配列の中からlを探してその場所を返す
	_bifind(arr,l) :ソートされた配列の中からlを探してその場所を返す
	_count(arr,l) :配列の中のlの数を返す
	_equal(array,other) :配列の長さと内容が等しいかを返す
	_mismatch(array,other) :はじめから見て異なるところを返す　等しければ-1
	_iswap arr,r,l :r番目とl番目を交換する
	_any(arr) :1（真）が一つでもあれば1を返す
	_all(arr) :0（偽）が一つでもあれば0を返す
	_set arr,toarr :arrの重複を削除する
	_countarr(arr,other) :含まれているotherの数を返す
	_search(arr,other) :otherが最初に現れるところを返す
	_rawstrrtostr st,toarr :文字列を一文字ずつ区切った配列にする
	_rawstrtoint st,arr :文字列を一文字ずつ区切り文字コードに変えた配列にする
	_strtoint arr,toarr :一文字ずつ区切られた配列から文字コードに変えた配列にする
	_inttostr arr,toarr :文字コードに変えた配列から一文字ずつ区切られた配列にする
	_strtorawstr arr,st :一文字ずつ区切られた配列から文字列にする
	_inttorawstr arr,st :文字コードに変えた配列から文字列にする
	mpeek(st):文字列から一文字を読み取る
	_filter arr,toarr,f :fが真になる要素の配列にする（_self使用） #macro#
	_map arr,toarr,f :fに配列の要素を適用する(_self使用) #macro#
	_bk arr,f :配列にfを破壊的に適用 #macro#
	_bk2 arr,f,l :一引数をもらう関数を破壊的に適用 #macro#
	_inject arr,ret,acc,f :Rubyのinjectを参照　畳込み #macro#
	_zipWith arr,toarr,other,f :arr(_self) other(_other)を使った式fの配列にする #macro#
	_zip arr,toarr,other :arrとotherを交互に入れた配列にする
	_sort arr :クイックソート
	_sort_down arr :逆順にクイックソート
	_baqetsort arr,toarr :バケットソート　0以上の要素を持つ配列に使える
 
*/
#module vector
 
/*
	> 数値を返す関数
	* 第二引数が配列
	! 破壊的作用(末尾にb)
	- 数値型以外でも使える
*/
 
#define true 1
#define false 0
 
//>-長さを返す
#defcfunc _size array arr
    return length(arr)
 
//与えられた型の配列に初期化する
#deffunc _tnew array arr,array toarr,int l
    dimtype toarr,vartype(arr),l
    return
    
//初期化
#deffunc _new array arr ,int l
    dim arr,l
    return
 
//*lからtまでの要素を持った配列を返す
#deffunc _sequence array toarr,int l,int t
    dim toarr,abs(l-t)+1
    if l<=t{
        repeat t-l+1
            toarr.cnt=l+cnt
        loop
    }else{
        repeat l-t+1
            toarr.cnt=l-cnt
        loop
    }
    return
///! 削除
#deffunc _clear array arr
    dim arr
    return
    
//>-場所
#defcfunc _at array arr ,int l
    return arr.l
    
//>代入
#deffunc _put array arr ,int l,int t
    arr.l=t
    return 
    
//>配列要素内か
#defcfunc _isin array arr ,int l
    return (l>=0&&l<_size(arr))
//>配列要素にlimit
#defcfunc _limin array arr ,int l
    return limit(l,0,_size(arr))
  
//*部分配列
#deffunc _slice array arr,array toarr,int l,int t
    dim toarr,abs(t)
    if (l>=0&t>0){//+ +
        repeat t
            toarr.cnt=arr(l+cnt)
        loop
    }else:if(l>=0&t<0){//+ -
        repeat -t
            toarr.cnt=arr(l-(cnt))
        loop
    }else:if(l<0&t>0){//- +
        repeat t
            toarr.cnt=arr(_size(arr)+l+cnt)
        loop
    }else:if(l<0&t<0){//- -
        repeat -t
            toarr.cnt=arr(_size(arr)+l-(cnt))
        loop
    }
    
    return
 
//*複製
#deffunc _copy array arr,array toarr
    _slice arr,toarr,0,_size(arr)
    return
 
//*合成
#deffunc _comp array arr,array toarr,array other
    dim toarr,_size(arr)+_size(other)
    repeat _size(arr)
        toarr(cnt)=arr.cnt
    loop
    repeat _size(other)
        toarr(cnt+_size(arr))=other.cnt
    loop
    return 
 
//*繰り返す
#deffunc _times array arr,array toarr,int l,local _lcnt
    dim toarr,_size(arr)*l
    repeat l
    _lcnt=cnt
        repeat _size(arr)
            toarr(_size(arr)*_lcnt+cnt)=arr.cnt
        loop
    loop
    return
 
//>-始めの値
#defcfunc _top array arr
    return arr.0
//>-終わりの値
#defcfunc _bottom array arr
    return arr(_size(arr)-1)
 
//!末尾を削除する
#deffunc _pop array arr,local _tmparr
    _slice arr,_tmparr,0,_size(arr)-1
    _copy _tmparr,arr
    return
 
//!末尾に追加する
#deffunc _push array arr,int l
    arr(_size(arr))=l
    return
 
//!先頭を削除する
#deffunc _shift array arr,local _tmparr
    _slice arr,_tmparr,1,_size(arr)-1
    _copy _tmparr,arr
    return
 
//!先頭に追加する
#deffunc _unshift array arr,int l
    _insert arr,0,l
    return
 
//*逆順
#deffunc _reverse array arr,array toarr
    _slice arr,toarr,-1,-_size(arr)
    return
 
//>-配列文字連結
#defcfunc _join array arr,str l,local _t
    _t=""+arr.0
    repeat _size(arr)-1
    _t=_t+l+arr(cnt+1)
    loop
    return _t
    
//>-見やすく返す
#defcfunc _inspect array arr
    return "["+_join(arr,",")+"]"
    
//*lの場所に挿入して後ろにずらす
#deffunc _insert array arr,int l,int i,local _tmparr,local _l
    dim _tmparr,_size(arr)+1
    if l<0:_l=_size(arr)+l+1:else:_l=l
    repeat _l
        _tmparr.cnt=arr.cnt
    loop
    _tmparr._l=i
    repeat _size(arr)-_l
        _tmparr(_l+cnt+1)=arr(_l+cnt)
    loop
    _copy _tmparr,arr
    return
    
//*lの場所を削除してつめる
#deffunc _del array arr,int l,local _tmparr,local _l
    dim _tmparr,_size(arr)-1
    if l<0:_l=_size(arr)+l:else:_l=l
    repeat _l
        _tmparr.cnt=arr.cnt
    loop
    repeat _size(arr)-_l-1
        _tmparr(_l+cnt)=arr(_l+cnt+1)
    loop
    _copy _tmparr,arr
    return
 
//!lこのiで埋めた配列を返す
#deffunc _fill array arr,int l,int i
    dim arr,l
    repeat l
        arr.cnt=i
    loop
    return
    
//!置換
#deffunc _replace array arr,int l,int tol
    repeat _size(arr)
        if (arr(cnt)==l):arr(cnt)=tol
    loop
    return
 
//>合計
#defcfunc _sum array arr,local _l
    _l=0
    repeat _size(arr)
        _l+=arr(cnt)
    loop
    return _l
 
//*配列をランダムに並び替える <<< かなり遅い >>>
#deffunc _shuffle array arr,array toarr,local _l
    dim toarr,_size(arr)
    repeat _size(arr)
        _l=rnd(_size(arr))
        toarr(cnt)=arr(_l)
        _del arr,_l
    loop
    return
 
//>線型探索 error -1
#defcfunc _find array arr,int l
    repeat _size(arr)
        if (arr(cnt)==l):return cnt
    loop
    return -1
//>二分探索 同じならその元の場所を返す
#defcfunc _bifind array arr,int l,local _dl,local _dr,local _k,local _c
    _dr=_size(arr)
    _dl=0
    _k=0
    repeat
        _c=(_dr+_dl)/2
        if (arr(_c)==l):_k=_c:break
        if (arr(_c)>l):_dr=_c
        if (arr(_c)<l):_dl=_c
        if (_dr==_dl):return -1
    loop
    while _k>0
        if (arr(_k-1)!=l):_break
        _k--
    wend
    return _k
 
//>iの数を数える
#defcfunc _count array arr,int l,local _i
    _i=0
    repeat _size(arr)
        if (arr(cnt)==l):_i++
    loop
    return _i
 
//>等しいか
#defcfunc _equal array arr,array other
    if (_size(arr)!=_size(other)):return false
    repeat _size(arr)
        if (arr(cnt)!=other(cnt)):return false
    loop
    return true
 
//>最初に異なるところ
#defcfunc _mismatch array arr,array other,local _i
    if (_size(arr)<=_size(other)):_i=_size(arr):else:_i=_size(other)
    repeat _i
        if (arr(cnt)!=other(cnt)):return cnt
    loop
    return -1
 
//!rとlを交換
#deffunc _iswap array arr,int r,int l,local _t
    if (r==l):return
    _t=arr.r
    arr.r=arr.l
    arr.l=_t
    return
 
//>1（真）が一つでもあれば真を返す
#defcfunc _any array arr
    repeat _size(arr)
        if (arr.cnt==true):return true
    loop
    return false
 
//>すべて1（真）あれば真を返す
#defcfunc _all array arr
    repeat _size(arr)
        if (arr.cnt!=true):return false
    loop
    return true
 
//重複を削除 <<< O(n*n) >>>
#deffunc _set array arr,array toarr,local _t,local _f,local _i
    dim toarr
    _i=0
    repeat _size(arr)
        _t=arr.cnt
        _f=0
        repeat _size(toarr)
            if (_t==toarr.cnt):_f=1:break
        loop
        if (_f==0):toarr._i=_t:_i++
    loop
    return
    
//>配列が含まれている数 <<< O(n*n) >>>
#defcfunc _countarr array arr,array other,local _t,local _i,local _f
    if(_size(arr)<_size(other)):return 0
    _i=0
    repeat _size(arr)-_size(other)+1
        _t=cnt
        _f=0
        repeat _size(other)
            if (arr(_t+cnt)!=other(cnt)):_f=1:break
        loop
        if (_f==0):_i++
    loop
    return _i
     
//配列が最初に含まれている場所 <<< O(n*n) >>>
#defcfunc _search array arr,array other,local _t,local _f
    if(_size(arr)<_size(other)):return -1
    repeat _size(arr)-_size(other)+1
        _t=cnt
        _f=0
        repeat _size(other)
            if (arr(_t+cnt)!=other(cnt)):_f=1:break
        loop
        if (_f==0):return _t
    loop
    return -1
 
//*文字から一文字ずつの配列を返す２バイト対応
#deffunc _rawstrtostr str st,array arr,local _i,local _t
    sdim arr,2
    _i=0
    _t=st
    repeat strlen(_t)
        if (IsByte(peek(_t,cnt))){
            wpoke arr._i,0,wpeek(_t,cnt)
            _i++
            continue cnt + 2
        }
        poke arr._i,0,peek(_t,cnt)
        _i++
    loop
    return
 
//*文字から数値配列 ２バイト対応
#deffunc _rawstrtoint str st,array arr,local _i,local _t
    dim arr,2
    _i=0
    _t=st
    repeat strlen(_t)
        if (IsByte(peek(_t,cnt))){
            arr._i=wpeek(_t,cnt)
            _i++
            continue cnt + 2
        }
        arr._i=peek(_t,cnt)
        _i++
    loop
    return
    
//*1文字列配列から数値配列
#deffunc _strtoint array arr,array toarr
    dim toarr,_size(arr)
    repeat _size(arr)
        if (IsByte(peek(arr.cnt,0))){
            toarr.cnt=wpeek(arr.cnt,0)
            continue
        }
        toarr.cnt=peek(arr.cnt,0)
    loop
    return
 
//*数値配列から１文字列配列
#deffunc _inttostr array arr,array toarr
    sdim toarr,2
    repeat _size(arr)
        if (IsByte(peek(arr.cnt,0))){
            wpoke toarr.cnt,0,wpeek(arr.cnt,0)
            continue
        }
        poke toarr.cnt,0,peek(arr.cnt,0)
    loop
    return
    
//*１文字配列から文字
#deffunc _strtorawstr array arr,var _st,local _i
    _st=""
    _i=0
    repeat _size(arr)
        if (IsByte(peek(arr.cnt,0))){
            wpoke _st,_i,wpeek(arr.cnt,0)
            _i+=2
            continue
        }
        poke _st,_i,peek(arr.cnt,0)
        _i++
    loop
    return
 
//*数値配列から文字（文字配列使えるけど整合性のため）
#deffunc _inttorawstr array arr,var st,local _i
    st=""
    _i=0
    repeat _size(arr)
        if (IsByte(peek(arr.cnt))){
            wpoke st,_i,arr.cnt
            _i+=2
            continue
        }
        poke st,_i,peek(arr.cnt)
        _i++
    loop
    return
 
//マルチバイト一文字ピーク
#defcfunc mpeek str st,local _t
        _t=st
        if (IsByte(peek(_t))){
            return wpeek(_t)
        }
        return peek(_t)
#defcfunc local IsByte int p1
    return ((p1>=129)&(p1<=159) )|( (p1>=224)&(p1<=252))
 
//*第3引数が真になる要素のみにする #macro#
#define global _filter(%1,%2,%3)  dim (%2):__f@vecter=0:foreach %1:_self=%1.cnt:if(%3){%2.__f@vecter==_self:__f@vecter++}:loop
//*配列それぞれに式を適用する #macro#
#define global _map(%1,%2,%3) dim(%2):foreach %1:_self=%1.cnt:%2.cnt==%3:loop
//*第1引数(_self)と第3引数(_other)の式の第4引数を適用して第2引数に代入
#define global _zipWith(%1,%2,%3,%4) dim (%2):__f=length(%1):__o=length(%3):repeat (__f>__o)*__o+(__f<=__o)*__f:_self=%1.cnt:_other=%3.cnt:%2.cnt=%4:loop
 
//*第1引数と第3引数を順番に入れた配列を作る（短い方に揃える）
#deffunc _zip array arr,array toarr,array other,local _l
    if (_size(arr)<_size(toarr)):_l=_size(arr):else:_l=_size(toarr)
    dim toarr,_l*2
    repeat _l
        toarr.(cnt*2)=arr.cnt
        toarr.(cnt*2+1)=other.cnt
    loop
    return
 
//*破壊的に式にマクロを適用 #macro#
#define global _bk(%1,%2) %2 %1,__t@vecter:_copy __t@vecter,%1
#define global _bk2(%1,%2,%3) %2 %1,__t@vecter,%3:_copy __t@vecter,%1
 
///Rubyのinject
#define global _inject(%1,%2,%3,%4) _acc=%3:foreach %1:_self=%1.cnt:_acc=%4:loop:%2=_acc
 
//*0以上の要素のソートのみ使用出来るソート
#deffunc _baqetsort array arr,array toarr,local _tmparr,local _tc,local _cc
    dim toarr,length(arr)
    dim _tmparr,length(arr)
    repeat length(arr)
        _tmparr.(arr.cnt)+=1
    loop
    _tc=0
    repeat length(_tmparr)
        _cc=cnt
        repeat _tmparr._cc
            toarr._tc=_cc
            _tc++
        loop
    loop
    return
    
#global
/*
	勝手に編集いたしました
	Quick sort
	http://hspdev-wiki.net/?Sort%2FQuick
*/
#define STACKSIZE@mod_qsort     2048
#module mod_qsort
#define swap_ae@mod_qsort( %1, %2, %3 )\
 tmp@mod_qsort = %1( %2 ) : %1( %2 ) = %1( %3 ) : %1( %3 ) = tmp@mod_qsort
 
#defcfunc compare_ae@mod_qsort array v1, int i1, int i2, int Mode
    if ( vartype( v1 ) != 2 ) {
        if ( Mode < 0 ) {
            return v1( i1 ) > v1( i2 )
        } else {
            return v1( i1 ) < v1( i2 )
        }
    } else {
        if ( Mode < 0 ) {
            return ( v1( i1 ) ! v1( i2 ) ) > 0
        } else {
            return ( v1( i1 ) ! v1( i2 ) ) < 0
        }
    }
    return 0
 
#deffunc qsort_init
    dim FrstIndexStk, STACKSIZE
    dim LastIndexStk, STACKSIZE
    return
 
#deffunc qsort_core array v1, int FrstIndexArg, int LastIndexArg, int Mode,\
 local StackLevel, local FrstIndex, local LastIndex, local PivtCount, local TrueCount
    StackLevel = 0
    FrstIndexStk( 0 ) = FrstIndexArg
    LastIndexStk( 0 ) = LastIndexArg
    repeat:if ( StackLevel < 0 ) {break }
        FrstIndex = FrstIndexStk( StackLevel )
        LastIndex = LastIndexStk( StackLevel )
        if ( FrstIndex >= LastIndex ) {
        } else : if ( LastIndex - FrstIndex == 1 ) {
            if ( compare_ae@mod_qsort( v1, LastIndex, FrstIndex, Mode ) ) {
                swap_ae@mod_qsort v1, FrstIndex, LastIndex } } else {
            swap_ae@mod_qsort v1, FrstIndex, ( FrstIndex + LastIndex ) / 2    //  基準値にする要素を先頭要素と入れ替え。
            PivtCount = 1   //  比較関数による比較で基準値と等価な要素の数。
            TrueCount = 0   //  比較関数による基準値との比較が真になる要素の数。
            repeat LastIndex - FrstIndex, FrstIndex + 1
                if ( compare_ae@mod_qsort( v1, cnt, FrstIndex, Mode ) ) {
                    if ( cnt != PivtCount + TrueCount ) {
                        swap_ae@mod_qsort v1, FrstIndex + PivtCount + TrueCount, cnt}
                    TrueCount++
                } else : if ( compare_ae@mod_qsort( v1, FrstIndex, cnt, Mode ) == 0 ) {
                    if ( cnt != PivtCount + TrueCount ) {
                        swap_ae@mod_qsort v1, FrstIndex + PivtCount + TrueCount, cnt}
                    if ( TrueCount > 0 ) {
                        swap_ae@mod_qsort v1, FrstIndex + PivtCount, FrstIndex + PivtCount + TrueCount }
                    PivtCount++ }:loop
            if ( TrueCount > 0 ) {
                repeat PivtCount
                    swap_ae@mod_qsort v1, FrstIndex + cnt, FrstIndex + PivtCount + TrueCount - 1 - cnt 
                loop}
            FrstIndexStk( StackLevel + 1 ) = FrstIndex
            LastIndexStk( StackLevel + 1 ) = FrstIndex + TrueCount - 1
            FrstIndexStk( StackLevel     ) = FrstIndex + PivtCount + TrueCount
            LastIndexStk( StackLevel     ) = LastIndex
            StackLevel += 2}
        StackLevel--:loop
    return
 
#deffunc _sort array v1
    qsort_core v1, 0, length( v1 ) - 1, 0
    return
 
#deffunc _sort_down array v1
    qsort_core v1, 0, length( v1 ) - 1, -1
    return
 
#global
 
qsort_init
 
#if 1
out=""
 
arr=3,5,7,1,8
out+="_size:"+  _size(arr)  +"\n"//大きさを返す=length
out+="_inspect:"+  _inspect(arr)  +"\n"//見やすく返す
out+="_join:"+  _join(arr,"~")  +"\n"//つなげて返す
 
_clear arr//要素1で0の配列にする
out+="_clear:"+  _inspect(arr)  +"\n"//->[0]
_new arr,5//数値型初期化 dimのほうが良いと思う
out+="_arr:"+  _inspect(arr)  +"\n"//->[0,0,0,0,0]
out+="_at:"+  _at(arr,3)  +"\n"//arr.3 使う意味はあまりない
_put arr,2,9//arr.2=9
out+="_ate:"+  _inspect(arr)  +"\n"
out+="_isin:"+  _isin(arr,7)  +"\n"//配列要素内のインデックスであるか
out+="_limin:"+  _limin(arr,7)  +"\n"//配列要素内のインデックスにlimit
 
_sequence arr,1,5//1から5までの配列
out+="_sequence:"+  _inspect(arr)  +"\n"//->[1,2,3,4,5]
 
dim arr
arr=3,5,7,1,8
_slice arr,t,1,3//python的なあれ
out+="_slice:"+  _inspect(t)  +"\n"//->[5,7,1] 
_slice arr,t,-1,-3//マイナスも可
out+="_slice(nega):"+  _inspect(t)  +"\n"//->[8,1,7] 
 
_copy arr,t//複製する
out+="_copy:"+  _inspect(t)  +"\n"//->[3,5,7,1,8] 
 
dim arr
arr=3,5,7,1,8
dim oth
oth=10,45,23
_comp arr,t,oth//t=arr+oth arrの末尾にothをつなげる
out+="_comp:"+  _inspect(t)  +"\n"//->[3,5,7,1,8,10,45,23]
 
dim arr
arr=3,5,7,1,8
_times arr,t,3//t=arr*2 arrをn回くっつける
out+="_times:"+  _inspect(t)  +"\n"//->[3,5,7,1,8,3,5,7,1,8,3,5,7,1,8]
 
dim arr
arr=3,5,7,1,8
out+="_top:"+  _top(arr)  +"\n"//最初の要素 ->3
out+="_buttom:"+  _bottom(arr)  +"\n"//最後の要素 ->8
 
_push arr,9//最後に追加
out+="_push:"+  _inspect(arr)  +"\n"//->[3,5,7,1,8,9]
_pop arr//最後を削除
out+="_pop:"+  _inspect(arr)  +"\n"//->[3,5,7,1,8]
_unshift arr,2//最初に追加
out+="_unshift:"+  _inspect(arr)  +"\n"//->[2,3,5,7,1,8]
_shift arr//最後に追加
out+="_shift:"+  _inspect(arr)  +"\n"//->[3,5,7,1,8]
_insert arr,2,9//2番目に9を入れて後ろにずらす
out+="_insert:"+  _inspect(arr)  +"\n"//->[3,5,9,7,1,8]
_del arr,2//2番目を削除して前に詰める
out+="_del:"+  _inspect(arr)  +"\n"//->[3,5,7,1,8]
 
_fill arr,6,2//2を6こ詰めた配列にする
out+="_fill:"+  _inspect(arr)  +"\n"//->[2,2,2,2,2,2]
 
dim arr
arr=3,1,7,1,8
_replace arr,1,2//すべての1を2に変える
out+="_replace"+  _inspect(arr)  +"\n"//->[3,2,7,2,8]
 
dim arr
arr=3,1,7,1,8
_set arr,t//重複を削除
out+="_set:"+  _inspect(t)  +"\n"//-?[3,1,7,8]
 
dim arr
arr=3,5,7,1,8
_sort_down arr//大きい順に
out+="_sort_down:"+  _inspect(arr)  +"\n"//->[8,7,5,3,1]
_sort arr//小さい順に
out+="_sort:"+  _inspect(arr)  +"\n"//->[1,3,5,7,8]
out+="_bifind:"+  _bifind(arr,7)  +"\n"//2分探索（小さい順にソートしている配列のみに使用可)
 
arr=3,5,7,1,8
_baqetsort arr,t//0以上の要素を持つ配列のソート　かなり早い
out+="_baqetsort:"+  _inspect(t)  +"\n"//->[1,3,5,7,8]
 
dim arr
arr=3,5,7,1,8
_shuffle arr,t//順番をランダムに並び替える
out+="_shuffle:"+  _inspect(t)  +"\n"// ->[5,8,7,3,1]
 
dim arr
arr=3,5,7,1,8
out+="_find:"+  _find(arr,7)  +"\n"//線型探索 ->2
 
dim arr
arr=3,5,3,1,3
out+="_count:"+  _count(arr,3)  +"\n"//3を数える ->3
out+="_sum"+  _sum(arr)  +"\n"//合計 ->15
 
dim arr
dim oth
arr=3,4,5,6,7
oth=3,4,5,6,7
out+="_equal:"+  _equal(arr,oth)  +"\n"//等しいか ->1
oth.3=2
out+="_mismatch:"+  _mismatch(arr,oth)  +"\n"//最初に異なるところ ->3
 
dim arr
dim oth
arr=3,3,4,5,6,7,5,6,7,3
oth=5,6
out+="_countarr:"+  _countarr(arr,oth)  +"\n"//配列がいくつ含まれているか ->2 
out+="_search:"+  _search(arr,oth)  +"\n"//配列が最初に含まれている場所 ->4
 
dim arr
arr=3,5,7,1,8
_iswap arr,1,3//1番目と3番目を入れ替える
out+="_iswap:"+  _inspect(arr)  +"\n"//->@3,1,5,7,8]
 
dim arr
arr=0,0,0,0,0,0,1
out+="_any:"+  _any(arr)  +"\n"//一つでも真なら真->1
out+="_all:"+  _all(arr)  +"\n"//全て真なら真->0
 
hoge="moziほげ"
_rawstrtostr hoge,arr//一文字ずつ配列に マルチバイト対応
out+="_rawstrtostr:"+  _inspect(arr)  +"\n"//->[m,o,z,i,ほ,げ]
_rawstrtoint hoge,arr//一文字ずつ配列にintで扱えるように
out+="_rawstrtoint:"+  _inspect(arr)  +"\n"//->[109,111,122,105,55682,45186]
_inttostr arr,t//intで扱えるようにしたものを一文字ずつ配列にする
out+="_inttostr:"+  _inspect(t)  +"\n"//->[m,o,z,i,ほ,げ]
_strtoint t,arr//一文字ずつ配列にしたものをintで扱えるようにをする
out+="_strtoint:"+  _inspect(arr)  +"\n"//->[m,o,z,i,ほ,げ]
_strtorawstr t,hoge//一文字ずつ配列にしたものを文字列に join(t,"")
out+="_strtorawstr:"+  hoge
_inttorawstr arr,hoge//intで扱えるようにしたものを文字列に
out+="_inttorawstr:"+  hoge  +"\n"
 
out+="mpeek:"+  mpeek("あ")  +"\n"//マルチバイト対応一文字コード
 
hoge="moziほげ"
_rawstrtoint hoge,arr
_bk arr,_reverse
_inttorawstr arr,hoge
out+="strrevarse:"+  hoge  +"\n"//->げほizom
 
hoge="moziほむmomiほんとほむほむ"
_rawstrtoint hoge,arr
out+="strcount:"+  _count(arr,mpeek("ほ"))  +"\n"//->4
piyo="ほむ"
_rawstrtoint piyo,t
out+="strcountarr:"+  _countarr(arr,t)  +"\n"//->3
 
dim arr
arr=3,5,7,1,8
_filter arr,hoge,_self>4//_selfが真になるものの配列
out+="_filter:"+  _inspect(hoge)  +"\n"//->[5,7,8]
_map arr,hoge,_self*cnt
out+="_map:"+  _inspect(hoge)  +"\n"//->[0,5,14,3,32]
_bk arr,_shuffle//->_shuffle arr,arrのように破壊的に適用
out+="_bk:"+  _inspect(arr)  +"\n"//->[8,7,3,5,1]
_bk2 arr,_times,5//->_times arr,arr,5のように破壊的に適用
out+="_bk2:"+  _inspect(arr)  +"\n"//->[8,7,3,5,1,8,7,3,5,1,8,7,3,5,1,8,7,3,5,1,8,7,3,5,1]
 
arr=2,3,4,5,5
t=4,4,4,4
_zipWith arr,hoge,t,_self+_other//arrとtそれぞれに式を適用して代入
out+="_zipWith:"+  _inspect(hoge)  +"\n"//->[6,7,8,9]
_zip arr,hoge,t//arr,tを交互に入れた配列を返す
out+="_zip:"+  _inspect(hoge)  +"\n"//->[2,4,3,4,4,4,5,4]
 
mesbox out,640,480
#endif
#endif

簡易な実装のスタック/キュー †

push/pop/shift/unshiftが目的

マクロによりintでもdoubleでもstrでも使える

+

mod_list.hsp

Everything is expanded.

Everything is shortened.

#ifndef MOD_LIST
#define MOD_LIST
#module list
#define global T_LABEL 1
#define global T_STR 2
#define global T_DOUBLE 3
#define global T_INT 4
#define global T_MODULE 5
#define global T_COMOBJ 6
/*
	l_new tolis,t :型がtであるListを初期化
	l_tolist arr,tolis :配列からListを作る
	l_toarr lis,arr :Listを配列に戻す
	l_size(lis) :大きさを返す
	l_at(lis,l) :l番目を返す
	l_put lis,l,t :l番目にtを代入する #macro#
	l_isin(lis,l) :lの添字が範囲内か
	l_top(lis) :最初の値を返す
	l_buttom(lis) :最後の値を返す
	l_pop lis :最後の値を削除
	l_push lis,l :最後にlを追加 #macro#
	l_shift lis :最初の値を削除
	l_unshift lis,l:最初にlを追加 #macro#
	l_sethead lis,l:最初にlこ配列をを確保
	l_settail lis,l:最後に配列を確保
*/
 
#define autohead 100//足りなくなった時に確保する大きさ
#define head 0
#define tail 1
//head,tail,[sets]
 
#define global l_put(%1,%2,%3):assert l_isin(%1,%2):%1(int(%1.head@list)+%2)=%3
#define global l_push(%1,%2) %1(int(%1.tail@list))=%2:%1.tail@list=cm(%1,int(%1.tail@list)+1)
#define global l_unshift(%1,%2) if (int(%1.head@list)<3){l_sethead %1,autohead@list}if 1:%1.head@list=cm(%1,int(%1.head@list)-1):%1(int(%1.head@list))==%2
 
#deffunc l_new array tolis,int t
    dimtype tolis,t,autohead*2+2
    tolis.head=cm(tolis,autohead+2)//listの開始位置
    tolis.tail=cm(tolis,autohead+2)//listの終了位置
    return
#deffunc l_tolist array arr,array tolis
    l_new tolis,vartype(arr)
    foreach arr
        l_push tolis,arr.cnt
    loop
    return
#deffunc l_toarr array lis,array toarr
    dimtype toarr,vartype(lis)
    repeat l_size(lis)
        toarr.cnt=l_at(lis,cnt)
    loop
    return
#defcfunc l_size array lis
    return int(lis.tail)-int(lis.head)
    
#defcfunc l_at array lis,int l
    assert l_isin(lis,l)
    return lis(int(lis.head)+l)
 
#defcfunc l_isin array lis,int l
    return (l>=0&&l<l_size(lis))
    
#defcfunc l_top array lis
    assert l_size(lis)!=0
    return lis(int(lis.head))
#defcfunc l_buttom array lis
    assert l_size(lis)!=0
    return lis(int(lis.tail)-1)
    
#deffunc l_pop array lis
    assert l_size(lis)!=0
    lis.tail=cm(lis,int(lis.tail)-1)
    return
 
#deffunc l_shift array lis
    assert l_size(lis)!=0
    lis.head=cm(lis,int(lis.head)+1)
    return
 
#deffunc l_sethead array lis,int sethead,local _tmplis
    dimtype _tmplis,vartype(lis)
    _tmplis.head=cm(lis,int(lis.head)+sethead)
    _tmplis.tail=cm(lis,int(lis.tail)+sethead)
    repeat l_size(lis)
        _tmplis(int(_tmplis.head)+cnt)=lis(int(lis.head)+cnt)
    loop
    dimtype lis,vartype(_tmplis)
    foreach _tmplis
        lis.cnt=_tmplis.cnt
    loop
    return
#deffunc l_settail array lis,int settail
    lis(int(lis.tail)+settail)=zero(lis)
    return
 
//多様なゼロ
#defcfunc local zero var t
    switch vartype(t)
        case T_STR:return "":swbreak
        case T_DOUBLE:return 0.0:swbreak
        case T_INT:return 0:swbreak
    swend
    return 0
//多様なint
#defcfunc cm var t,int l
    switch vartype(t)
        case T_STR:return ""+l:swbreak
        case T_DOUBLE:return 1.0*l:swbreak
        case T_INT:return l:swbreak
    swend
    return l
#global
 
#if 0
l_new a,T_STR
 
l_unshift a,"f"
l_unshift a,"ff"
l_unshift a,"fff"
l_unshift a,"ffff"
l_unshift a,"fffff"
l_unshift a,"ffffff"
l_push a,"b"
l_push a,"bb"
l_push a,"bbb"
l_push a,"bbbb"
l_push a,"bbbbb"
l_push a,"bbbbbb"
mes l_size(a)//配列の大きさを返す->12
 
l_put a,2,"ppppp"//配列のn番目を変える
mes l_at(a,2)//配列のn番目を返す->"ppppp"
 
l_push a,"buttom"
mes l_buttom(a)//配列の最後を返す->"buttom"
l_pop a//配列の最後を消す
mes l_buttom(a)//->"bbbbbb"
l_unshift a,"top"//配列の最初に追加
mes l_top(a)//配列の最初を返す->"top"
l_shift a//配列の最初を削除
mes l_top(a)//->"ffffff"
 
h=2.3,4.5,6.7
l_tolist h,a//配列をListに変換
l_push a,8.9
mes l_size(a)//->4
l_toarr a,h//Listを配列に変換
foreach h
    mes h.cnt
loop
#endif
#endif

コメント †

split 命令は少し無理矢理やっています。もう少し効率いいやり方があるようなら修正してください。 -- Irisawa 2007-01-18 (木) 20:58:42
Irisawaさんこんにちは。splitをforを使わずに行なう方法を提案してみました。コードは長くなりますが、より直感的になったと思います。shiftはこれで良いと思います。 -- eller 2007-01-18 (木) 21:32:55
それと自分も詳しくはないのですが、再帰を行なわない場合はローカル変数を宣言する必要はないのではないでしょうか？ -- eller 2007-01-18 (木) 21:35:48
- ローカル変数を使用しているのは単純に念のためです。 local 宣言した場合、モジュール内の変数としては表示されなくなります(変数名のミスなどを事前に防げたり...)。また、 return で戻るとその時点でメモリから破棄されます。 -- Irisawa 2007-01-18 (木) 21:49:40
- なるほど、メモリから廃棄されるのは便利かもしれませんね。ローカル変数の勉強になりました！ありがとうございましたm(_ _)m -- eller 2007-01-19 (金) 06:18:52
上手く整形できない　どうしてだろ　くそソースすいません -- wass? 2012-01-05 (木) 11:34:51
}} がソース中にあったからみたいです -- 2012-01-05 (木) 13:00:41
そうですか　なるほど，気づきませんでした -- wass? 2012-01-05 (木) 13:24:05
要素数０の配列がほしいし　組み直そうかね　C++で実装しようか -- wass? 2012-01-08 (日) 21:58:50
大幅強化　バケットソートの速さに恐れいった -- wass? 2012-09-02 (日) 15:55:52
大幅強化　バケットソートの速さに恐れいった -- wass? 2012-09-02 (日) 15:56:59