std.algorithm.searching

template all(alias pred = "a")

すべての要素がpred を満たしているかどうかを確認する。

Examples:

assert( all!"a & 1"([1, 3, 5, 7, 9]));
assert(!all!"a & 1"([1, 2, 3, 5, 7, 9]));

Examples: また、条件文でその項目がtrueまたはfalseと評価できる場合は、述語なしでも使用できる。これは、範囲内のすべての要素がtrueであることを素早く評価する便利な方法である。

allまた、条件文でその項目が trueまたはfalseと評価できる場合は、述語なしでも使用できる。これは、 範囲内のすべての要素がtrueであることを素早く評価する便利な方法である。

int[3] vals = [5, 3, 18];
assert( all(vals[]));

truetrue

入力された範囲が真である場合にのみ、xml-ph-0000@deepl.internal を返す。

bool all(Range)(Range range)
if (isInputRange!Range && (__traits(isTemplate, pred) || is(typeof(unaryFun!pred(range.front)))));

true 入力範囲が空の場合、または range空である か、または、見つかったすべての値が range述語pred を満たす場合にのみ、 を返す。pred の評価を、(最大で)Ο(range.length)回実行する。

template any(alias pred = "a")

いずれかの要素がpred を満たしているかどうかを確認する。!anyいずれの要素もpredを満たさないことを確認するために使用できる。 これは、他の言語ではexists と呼ばれることもある。

to can be usedだ

Examples:

import std.ascii : isWhite;
assert( all!(any!isWhite)(["a a", "b b"]));
assert(!any!(all!isWhite)(["a a", "b b"]));

Examples: また、条件文でその項目がtrueまたはfalseと評価できる場合は、述語なしでも使用できる。

anyまた、条件文でその項目が trueまたはfalseと評価できる場合は、述語なしでも使用できる。 !anyこれは、 範囲内の要素がすべて true

int[3] vals1 = [0, 0, 0];
assert(!any(vals1[])); //vals1のどれもがtrue

int[3] vals2 = [2, 0, 2];
assert( any(vals2[]));
assert(!all(vals2[]));

int[3] vals3 = [3, 3, 3];
assert( any(vals3[]));
assert( all(vals3[]));

alsoも

入力された範囲が真と評価される場合にのみ、xml-ph-0000@deepl.internal を返す。

bool any(Range)(Range range)
if (isInputRange!Range && (__traits(isTemplate, pred) || is(typeof(unaryFun!pred(range.front)))));

true 入力された範囲が range空ではなく、 かつ、その範囲に含まれるいずれかの値が range述語を満たす 場合のみ、pred を返す。pred の評価を(多くても)Ο(range.length)回だけ行う。

bool balancedParens(Range, E)(Range r, E lPar, E rPar, size_t maxNestingLevel = size_t.max)
if (isInputRange!Range && is(typeof(r.front == lPar)));

r「バランスが取れた括弧」になっているか、すなわち lPar対応するインスタンスで閉じられているかどうかを rPar。 パラメータは maxNestingLevelネストのレベルを制御する。 最も一般的な用途は、デフォルトまたは0 である。後者の場合、 ネストは許可されない。

Parameters:

Range r	確認する範囲。
E lPar	左(開き)括弧に対応する要素。
E rPar	右(閉じ)括弧に対応する要素。
size_t maxNestingLevel	許容される最大ネストレベル。

Returns:

指定された最大ネストレベル内で、指定された範囲内に釣り合った括弧がある場合は「true」、 そうでない場合は「false」を返す。

truetrue

Examples:

auto s = "1 + (2 * (3 + 1 / 2)";
assert(!balancedParens(s, '(', ')'));
s = "1 + (2 * (3 + 1) / 2)";
assert(balancedParens(s, '(', ')'));
s = "1 + (2 * (3 + 1) / 2)";
assert(!balancedParens(s, '(', ')', 0));
s = "1 + (2 * 3 + 1) / (2 - 5)";
assert(balancedParens(s, '(', ')', 0));
s = "f(x) = ⌈x⌉";
assert(balancedParens(s, '⌈', '⌉'));

struct BoyerMooreFinder(alias pred, Range);

BoyerMooreFinder!(binaryFun!pred, Range) boyerMooreFinder(alias pred = "a == b", Range)(Range needle)
if (isRandomAccessRange!Range && hasSlicing!Range || isSomeString!Range);

find で使用するBoyer-Mooreマッチングを設定する。 デフォルトでは、要素は同一性について比較される。

BoyerMooreFinderGCメモリを割り当てる。

Parameters:

pred	要素を比較するために使用される述語。
Range needle	長さとスライスによるランダムアクセス可能な範囲。

Returns:

そのインスタンスは、 BoyerMooreFinderfind() と共に使用することで、 与えられた干し草の中から特定のものを検索するためのBoyer-Mooreマッチングアルゴリズムを呼び出すことができる needle与えられた干し草の山の中から

haystackhaystack

Examples:

auto bmFinder = boyerMooreFinder("TG");

string r = "TAGTGCCTGA";
// 干し草の山から最初の一致するものを探す r
r = bmFinder.beFound(r);
writeln(r); // "TGCCTGA"

// 干し草の山で捜し物を続ける
r = bmFinder.beFound(r[2 .. $]);
writeln(r); // "TGA"

this(Range needle);

scope Range beFound(Range haystack);

@property size_t length();

alias opDollar = length;

2つの範囲の共通部分を返す。

auto commonPrefix(alias pred = "a == b", R1, R2)(R1 r1, R2 r2)
if (isForwardRange!R1 && isInputRange!R2 && !isNarrowString!R1 && is(typeof(binaryFun!pred(r1.front, r2.front))));

auto commonPrefix(alias pred, R1, R2)(R1 r1, R2 r2)
if (isNarrowString!R1 && isInputRange!R2 && is(typeof(binaryFun!pred(r1.front, r2.front))));

auto commonPrefix(R1, R2)(R1 r1, R2 r2)
if (isNarrowString!R1 && isInputRange!R2 && !isNarrowString!R2 && is(typeof(r1.front == r2.front)));

auto commonPrefix(R1, R2)(R1 r1, R2 r2)
if (isNarrowString!R1 && isNarrowString!R2);

2つの範囲の共通部分を返す。

Parameters: 共通部分を持つ要素を比較する際に使用する述語。デフォルトでは

pred	共通性のために要素を比較する際に使用する述語。デフォルトは 等価である"a == b" 。
R1 r1	要素の前方範囲。
R2 r2	要素の入力範囲。

Returns:

スライスで、 r1両方の範囲が一致する文字を含む。 最初の引数が文字列の場合、そうでなければ、takeExactly(r1, n)、n は両方の範囲に共通する接頭辞の要素数である。

number数

See Also:

std.range.takeExactly

result結果

Examples:

writeln(commonPrefix("hello, world", "hello, there")); // "hello, "

size_t count(alias pred = "a == b", Range, E)(Range haystack, E needle)
if (isInputRange!Range && !isInfinite!Range && is(typeof(binaryFun!pred(haystack.front, needle))));

size_t count(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
if (isForwardRange!R1 && !isInfinite!R1 && isForwardRange!R2 && is(typeof(binaryFun!pred(haystack.front, needle.front))));

の一致数を数える。 needlehaystack。

最初のオーバーロードでは、e の各要素を haystackpred(e, needle)true である。pred はデフォルトで 等しい。Ο(haystack.length)で pred を評価する。

2番目のオーバーロードでは、 needle一致した回数を数えますhaystack。pred は各範囲の要素を比較する。 の場合、例外がスローされる。 needle.emptytrue の場合、 任意のレンジにおける空のレンジのカウントは無限大となるため、例外が発生する。重複したカウントは 考慮されない。例えば、 count("aaa", "aa")1 であり、2 ではない。

注 オーバーロードに関係なく、

注釈 過負荷に関わらず、 count無限の範囲は受け付けません。 haystack。

notない

Parameters:

pred	要素を比較するための述語。
Range haystack	カウントする範囲。
E needle	要素またはサブレンジをカウントする haystack。

Returns:

一致するものの数 haystack。

Examples:

// 範囲内の要素を数える
int[] a = [ 1, 2, 4, 3, 2, 5, 3, 2, 4 ];
writeln(count(a, 2)); // 3
writeln(count!("a > b")(a, 2)); // 5

match試合

Examples:

import std.uni : toLower;
// 範囲内のrangeを数える
writeln(count("abcadfabf", "ab")); // 2
writeln(count("ababab", "abab")); // 1
writeln(count("ababab", "abx")); // 0
// あいまいな範囲内のrangeを数える
writeln(count!((a, b) => toLower(a) == toLower(b))("AbcAdFaBf", "ab")); // 2

すべての要素または述語を満たす要素をカウントする

size_t count(alias pred, R)(R haystack)
if (isInputRange!R && !isInfinite!R && is(typeof(unaryFun!pred(haystack.front))));

size_t count(R)(R haystack)
if (isInputRange!R && !isInfinite!R);

すべての要素または述語を満たす要素を数える。 haystack。

最初のオーバーロードでは、e が である haystackpred(e) true。pred のΟ (haystack.length)評価を行う。

2番目のオーバーロードでは、範囲内の要素数を数える。 指定された範囲がlength プロパティを持つ場合、 そのプロパティがすぐに返される。そうでない場合は、haystack.length )を実行して範囲を順にたどる。

Parameters:

pred	要素を見つけるためのオプションの述語。
R haystack	カウントする範囲。

Returns:

xml-ph-0000@deepl.internal が true を返した haystack(pred がtrueを返した)要素の数。

truetrue

Examples:

// 範囲内の述語を数える
int[] a = [ 1, 2, 4, 3, 2, 5, 3, 2, 4 ];
writeln(count(a)); // 9
// 範囲内の述語を数える
writeln(count!("a > 2")(a)); // 5

与えられた前方範囲内の要素を カウントする。 与えられた述語が与えられた要素のいずれかに対して真になるまで

ptrdiff_t countUntil(alias pred = "a == b", R, Rs...)(R haystack, Rs needles)
if (isForwardRange!R && (Rs.length > 0) && (isForwardRange!(Rs[0]) == isInputRange!(Rs[0])) && allSatisfy!(canTestStartsWith!(pred, R), Rs));

ptrdiff_t countUntil(alias pred = "a == b", R, N)(R haystack, N needle)
if (isInputRange!R && is(typeof(binaryFun!pred(haystack.front, needle)) : bool));

ptrdiff_t countUntil(alias pred, R)(R haystack)
if (isInputRange!R && is(typeof(unaryFun!pred(haystack.front)) : bool));

与えられた前方範囲内の要素を 数え、 与えられた述語が与えられた要素のいずれかに対して真になるまで needles。

Parameters:

pred	カウントを停止する条件を指定する述語。
R haystack	入力範囲 をカウントする。
Rs needles	単一の要素、または 順方向の 要素の範囲で、 haystack与えられた述語の下で、

Returns:

先頭からポップされる要素の数 haystackその要素に到達するまでに startsWith!pred(haystack, needles)true である。 startsWith!pred(haystack, needles)のどの要素に対してもtrue でない場合、 haystack場合、-1 が返されます。pred のみが提供された場合、 pred(haystack)各要素に対してテストされます。

See Also:

std.string.indexOf

inin

Examples:

writeln(countUntil("hello world", "world")); // 6
writeln(countUntil("hello world", 'r')); // 8
writeln(countUntil("hello world", "programming")); // -1
writeln(countUntil("日本語", "本語")); // 1
writeln(countUntil("日本語", '語')); // 2
writeln(countUntil("日本語", "五")); // -1
writeln(countUntil("日本語", '五')); // -1
writeln(countUntil([0, 7, 12, 22, 9], [12, 22])); // 2
writeln(countUntil([0, 7, 12, 22, 9], 9)); // 4
writeln(countUntil!"a > b"([0, 7, 12, 22, 9], 20)); // 3

thenだ

Examples:

import std.ascii : isDigit;
import std.uni : isWhite;

writeln(countUntil!(isWhite)("hello world")); // 5
writeln(countUntil!(isDigit)("hello world")); // -1
writeln(countUntil!"a > 20"([0, 7, 12, 22, 9])); // 3

与えられた範囲が、与えられた針(複数可)で終わっているかどうかを確認する。 xml-ph-0000@deepl.internal の逆数。

uint endsWith(alias pred = "a == b", Range, Needles...)(Range doesThisEnd, Needles withOneOfThese)
if (isBidirectionalRange!Range && (Needles.length > 1) && allSatisfy!(canTestStartsWith!(pred, Range), Needles));

bool endsWith(alias pred = "a == b", R1, R2)(R1 doesThisEnd, R2 withThis)
if (isBidirectionalRange!R1 && isBidirectionalRange!R2 && is(typeof(binaryFun!pred(doesThisEnd.back, withThis.back)) : bool));

bool endsWith(alias pred = "a == b", R, E)(R doesThisEnd, E withThis)
if (isBidirectionalRange!R && is(typeof(binaryFun!pred(doesThisEnd.back, withThis)) : bool));

bool endsWith(alias pred, R)(R doesThisEnd)
if (isInputRange!R && ifTestable!(typeof(doesThisEnd.front), unaryFun!pred));

与えられた範囲が、与えられた針(複数可)で終わっているかどうかを確認する。startsWith の逆数。

Parameters:

pred	範囲と針(複数可)の要素を比較する際に使用する述語 。
Range doesThisEnd	双方向の範囲 を調べる。
Needles withOneOfThese	比較対象となる針。単一の要素、または双方向の要素範囲である可能性がある 。
R2 withThis	チェックする単一要素。

Returns: 針が指定された範囲の終わりにない場合は0、それ以外は一致する針の位置、つまり範囲が終わる場合は1

針が指定された範囲の終わりに存在しない場合は0、 それ以外は一致する針の位置、つまり、範囲が で終わる場合は1、 withOneOfThese[0]、2であれば withOneOfThese[1]、など。

ニードルパラメータが指定されていない場合、true を返す。ただし、doesThisStart が述語pred を満たす場合に限る。

xml-ph-0003@deepl.internalxml-ph-0003@deepl.internal

Examples:

import std.ascii : isAlpha;
assert("abc".endsWith!(a => a.isAlpha));
assert("abc".endsWith!isAlpha);

assert(!"ab1".endsWith!(a => a.isAlpha));

assert(!"ab1".endsWith!isAlpha);
assert(!"".endsWith!(a => a.isAlpha));

import std.algorithm.comparison : among;
assert("abc".endsWith!(a => a.among('c', 'd') != 0));
assert(!"abc".endsWith!(a => a.among('a', 'b') != 0));

assert(endsWith("abc", ""));
assert(!endsWith("abc", "b"));
writeln(endsWith("abc", "a", 'c')); // 2
writeln(endsWith("abc", "c", "a")); // 1
writeln(endsWith("abc", "c", "c")); // 1
writeln(endsWith("abc", "bc", "c")); // 2
writeln(endsWith("abc", "x", "c", "b")); // 2
writeln(endsWith("abc", "x", "aa", "bc")); // 3
writeln(endsWith("abc", "x", "aaa", "sab")); // 0
writeln(endsWith("abc", "x", "aaa", 'c', "sab")); // 3

InputRange find(alias pred, InputRange)(InputRange haystack)
if (isInputRange!InputRange);

入力範囲の要素e を見つけ、pred(e) はtrue である。

• find他の言語におけるdropWhile と同様の動作をする。
• 双方向の テキストで 最後の一致する要素を見つけるには、 haystack、 呼び出す find!pred(retro(haystack))。 std.range.retro。

複雑さfind実行Ο(walkLength(haystack)) 評価pred.

Parameters:

pred	要素に一致する述語。
InputRange haystack	検索対象となる入力範囲 。

Returns: 先頭の要素がxml-ph-0000@deepl.internalを満たすように高度な検索を行う。そのような要素が存在しない場合は、空の要素を返す。

haystack先頭の要素がpred を満たすように高度な検索を行う。 そのような要素が存在しない場合は、空の値を返す haystack。

advancedadvanced

Examples:

auto arr = [ 1, 2, 3, 4, 1 ];
writeln(find!("a > 2")(arr)); // [3, 4, 1]

// 述語エイリアス付き
bool pred(int e) => e + 1 > 1.5;
writeln(find!(pred)(arr)); // arr

advanced見つける

InputRange find(alias pred = "a == b", InputRange, Element)(InputRange haystack, scope Element needle)
if (isInputRange!InputRange && is(typeof(binaryFun!pred(haystack.front, needle)) : bool) && !is(typeof(binaryFun!pred(haystack.front, needle.front)) : bool));

R1 find(alias pred = "a == b", R1, R2)(R1 haystack, scope R2 needle)
if (isForwardRange!R1 && isForwardRange!R2 && is(typeof(binaryFun!pred(haystack.front, needle.front)) : bool));

入力範囲内の個々の要素を見つける。 要素の haystack比較されます。 needle述語を使用して比較されます。pred pred(haystack.front, needle)。 この述語は std.functional.binaryFun、文字列を受け入れるか、pred(element, element) によって実行可能な任意のコールバックを受け入れる。

haystack順方向の範囲である場合、needle範囲も可能です。 この場合、 startsWith!pred(haystack, needle)は各評価で評価されます。

注釈: 針に一致しない最初の要素を見つけるには、述語"a != b" を使用する。

複雑性findpred のΟ(walkLength(haystack))評価を行う。 パフォーマンスを向上させる特殊化があり、 双方向 またはランダムアクセス 範囲(可能な場合)を

Parameters:

pred	各要素を針と比較するための述語。デフォルトでは等価である。"a == b" 。
InputRange haystack	検索対象となる入力範囲 。
Element needle	検索対象の要素。

Returns:

haystack前方の要素が検索対象となるように高度化されている。 つまり、xml-ph-0000@deepl.internal となるまで binaryFun!pred(haystack.front, needle)true となるまで。そのような位置が存在しない場合は、 空の文字列を返す haystack。

See Also:

findAdjacent、 findAmong、 findSkip, findSplit, startsWith

to beだ

Examples:

import std.range.primitives;

auto arr = [1, 2, 4, 4, 4, 4, 5, 6, 9];
writeln(arr.find(4)); // [4, 4, 4, 4, 5, 6, 9]
writeln(arr.find(1)); // arr
writeln(arr.find(9)); // [9]
writeln(arr.find!((e, n) => e > n)(4)); // [5, 6, 9]
writeln(arr.find!((e, n) => e < n)(4)); // arr
assert(arr.find(0).empty);
assert(arr.find(10).empty);
assert(arr.find(8).empty);

writeln(find("hello, world", ',')); // ", world"

Examples: 大文字小文字を区別しない文字列検索

大文字小文字を区別しない文字列検索

import std.range.primitives;
import std.uni : toLower;

string[] s = ["Hello", "world", "!"];
writeln(s.find!((e, n) => toLower(e) == n)("hello")); // s

findfind

case-insensitive大文字小文字を区別しない

Examples:

import std.container : SList;
import std.range.primitives : empty;
import std.typecons : Tuple;

assert(find("hello, world", "World").empty);
writeln(find("hello, world", "wo")); // "world"
writeln([1, 2, 3, 4].find(SList!int(2, 3)[])); // [2, 3, 4]
alias C = Tuple!(int, "x", int, "y");
auto a = [C(1,0), C(2,0), C(3,1), C(4,0)];
writeln(a.find!"a.x == b"([2, 3])); // [C(2, 0), C(3, 1), C(4, 0)]
writeln(a[1 .. $].find!"a.x == b"([2, 3])); // [C(2, 0), C(3, 1), C(4, 0)]

case-insensitive大文字小文字を区別しない

Tuple!(Range, size_t) find(alias pred = "a == b", Range, Needles...)(Range haystack, Needles needles)
if (Needles.length > 1 && is(typeof(startsWith!pred(haystack, needles))));

2つ以上の needles。 haystack。述語pred は、要素を比較するために全体で使用される。デフォルトでは、要素は 等価であるかどうかが比較される。

Parameters:

pred	要素を比較する際に使用する述語。
Range haystack	検索の対象。入力範囲でなければならない。 いずれかが needles比較可能な要素を含む範囲である場合、 haystack、 haystack前方範囲でなければなりません。 検索がバックトラックできるようにするためです。
Needles needles	検索対象となる1つ以上の項目。それぞれは needles、 の1つの要素と比較できるか、 haystack、またはそれ自体が 前方範囲であり、その前方範囲内の要素と比較可能な要素を持つhaystack。

Returns:

タプルは、 haystackいずれかの針に一致するように配置され、 またneedles 内の一致する要素の1を基底とするインデックス(一致するものがなければ0 needles一致しない場合は0、一致する場合は1、 needles[0] 一致する場合は2、 needles[1]。最初に発見された ものが一致するものとなる。複数の針が 範囲内の同じ場所で発見された場合、最も短いものが一致するものとなる (同じ長さの複数の針が同じ場所で発見された場合(例えば"a" と'a' )、引数リスト内のそれらのうち最も左にあるものが一致する )。

と の関係は haystack、 needles単に、 例えば、intの個々または配列、intの配列をintの配列で検索できることを意味する。さらに、要素が 個別に比較可能である場合、異種型の検索も許可される。double[] はint またはshort[] で検索でき、逆にlong はfloat またはdouble[] で検索できる。これにより、 比較する一方を他方の型に強制的に変換する必要がなくなり、効率的な検索が可能になる。

検索の複雑性はΟ(haystack.length * max(needles.length)) である。 (個々のアイテムである針の場合、長さは 1とみなされる。) 複数のサブレンジを一度に検索する戦略は、 できるだけ少ない回数で移動することでキャッシュの使用を最大限に活用する haystack回数を できるだけ少なくする。

to maximize最大化

Examples:

import std.typecons : tuple;
int[] a = [ 1, 4, 2, 3 ];
writeln(find(a, 4)); // [4, 2, 3]
writeln(find(a, [1, 4])); // [1, 4, 2, 3]
writeln(find(a, [1, 3], 4)); // tuple([4, 2, 3], 2)
// 比較可能な場合は、混合型も許可する
writeln(find(a, 5, [1.2, 3.5], 2.0)); // tuple([2, 3], 3)

RandomAccessRange find(RandomAccessRange, alias pred, InputRange)(RandomAccessRange haystack, scope BoyerMooreFinder!(pred, InputRange) needle);

needlehaystack ボイヤー・ムーア法を 効率的に使用する。

Parameters: 長さとスライスによるランダムアクセス範囲。

RandomAccessRange haystack	長さとスライスによるランダムアクセス範囲。
BoyerMooreFinder!(pred, InputRange) needle	BoyerMooreFinder。

Returns: 高度なもので、

haystack高度なもので、 needleその接頭辞である(そのような位置が存在しない場合は、 haystack終了するまで進む)。

advancedadvanced

Examples:

import std.range.primitives : empty;
int[] a = [ -1, 0, 1, 2, 3, 4, 5 ];
int[] b = [ 1, 2, 3 ];

writeln(find(a, boyerMooreFinder(b))); // [1, 2, 3, 4, 5]
assert(find(b, boyerMooreFinder(a)).empty);

便利な関数。findと同様だが、検索が成功したかどうかのみを返す。

template canFind(alias pred = "a == b")

便利な関数。findと同様だが、検索が成功したかどうかのみを返す。

pred の詳細については、 find。

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

See Also:

std.algorithm.comparison.among複数の引数に対して値をチェックする場合は、

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

Examples:

const arr = [0, 1, 2, 3];
assert(canFind(arr, 2));
assert(!canFind(arr, 4));

// いくつかの針のうちの1本を見つける
assert(arr.canFind(3, 2));
assert(arr.canFind(3, 2) == 2); // 2本目の針が見つかった
writeln(arr.canFind([1, 3], 2)); // 2

assert(canFind(arr, [1, 2], [2, 3]));
writeln(canFind(arr, [1, 2], [2, 3])); // 1
assert(canFind(arr, [1, 7], [2, 3]));
writeln(canFind(arr, [1, 7], [2, 3])); // 2
assert(!canFind(arr, [1, 3], [2, 4]));
writeln(canFind(arr, [1, 3], [2, 4])); // 0

forだ

Examples: カスタム述語を使用した例。針は述語の2番目の引数として表示されることに注意。

カスタム述語を使用した例。 針は述語の2番目の引数として表示されることに注意。

auto words = [
    "apple",
    "beeswax",
    "cardboard"
];
assert(!canFind(words, "bees"));
assert( canFind!((string elem, string needle) => elem.startsWith(needle))(words, "bees"));

Examples:

アイテムの配列から複数のアイテムを検索する(干し草の山の中の針を探す)

string s1 = "aaa111aaa";
string s2 = "aaa222aaa";
string s3 = "aaa333aaa";
string s4 = "aaa444aaa";
const hay = [s1, s2, s3, s4];
assert(hay.canFind!(e => e.canFind("111", "222")));

needle針

xml-ph-0001@deepl.internal が任意の値 xml-ph-0002@deepl.internal に対して真である場合にのみ、xml-ph-0000@deepl.internal を返す。

bool canFind(Range)(Range haystack)
if (is(typeof(find!pred(haystack))));

入力範囲range 内の値pred(e) が真である場合にのみ、true を返す。 e pred の評価を(多くとも)Ο(haystack.length)だけ行う。

bool canFind(Range, Element)(Range haystack, scope Element needle)
if (is(typeof(find!pred(haystack, needle))));

true が存在する場合にのみ、 を返す。 needle range で見つかった場合のみ、 を返す。Ο(haystack.length) pred の評価を行う。

size_t canFind(Range, Needles...)(Range haystack, scope Needles needles)
if (Needles.length > 1 && is(typeof(find!pred(haystack, needles))));

見つかった最初の針の1を基底とするインデックスを返す haystack。 もし 針が見つからなかった場合は、0 が返される。

したがって、if 文やループの条件で直接使用した場合、 針の1つが見つかればtrue 、見つからなければfalse となる。 一方、結果を他の場所で使用する場合は、bool にキャストすることで同じ効果を得られるか、 find。 同じ操作を返す

Range findAdjacent(alias pred = "a == b", Range)(Range r)
if (isForwardRange!Range);

r最初の2つの隣接要素a 、b を見つけるまで進む。pred(a, b) を満たす。Ο(r.length) の評価をpred に対して行う。

pred の詳細については、 find。

Parameters:

pred	満たすべき述語。
Range r	検索する前方の範囲。

Returns: 与えられた述語を満たす隣接する2つの要素の最初の出現位置まで進む。そのような2つの要素がない場合は、戻り値は

r与えられた述語を満たす隣接する2つの要素の最初の出現位置まで進む。 そのような2つの要素がない場合は、 r空になるまで 前進する。

See Also:

STLのadjacent_find

STLSTL

Examples:

int[] a = [ 11, 10, 10, 9, 8, 8, 7, 8, 9 ];
auto r = findAdjacent(a);
writeln(r); // [10, 10, 9, 8, 8, 7, 8, 9]
auto p = findAdjacent!("a < b")(a);
writeln(p); // [7, 8, 9]

与えられた選択肢のいずれかと一致する要素を、与えられた範囲で検索する。

InputRange findAmong(alias pred = "a == b", InputRange, ForwardRange)(InputRange seq, ForwardRange choices)
if (isInputRange!InputRange && isForwardRange!ForwardRange);

与えられた選択肢のいずれかと一致する要素を、与えられた範囲内で検索する。

seq呼び出しによって seq.popFrontfind!(pred)(choices, seq.front)true になるか、 seq空になるまでpred をΟ(seq.length * choices.length) で評価する。

pred についての詳細は、 find。

Parameters:

pred	一致を判断するために使用する述語。
InputRange seq	検索する入力範囲。
ForwardRange choices	選択肢の順方向の範囲 。

Returns:

seq最初の一致する要素まで、または一致する要素がない場合は空になるまで 進む。

See Also:

find、 std.algorithm.comparison.among

advanced

Examples:

int[] a = [ -1, 0, 1, 2, 3, 4, 5 ];
int[] b = [ 3, 1, 2 ];
writeln(findAmong(a, b)); // a[2 .. $]

bool findSkip(alias pred = "a == b", R1, R2)(ref R1 haystack, R2 needle)
if (isForwardRange!R1 && isForwardRange!R2 && is(typeof(binaryFun!pred(haystack.front, needle.front))));

size_t findSkip(alias pred, R1)(ref R1 haystack)
if (isForwardRange!R1 && ifTestable!(typeof(haystack.front), unaryFun!pred));

needlehaystack、位置を haystack 最初の出現の直後に位置を特定する needle。

針が提供されていない場合、 haystackpredがtrue と評価される限り、前進する。 同様に、pred がfalse と評価されるように、干し草の山の位置が決定される。 haystack.front。

pred についての詳細は、 find。

Parameters:

R1 haystack	検索対象の 前方範囲。
R2 needle	検索対象の前方範囲 検索対象の前方範囲
pred	干し草の山と針を比較するためのカスタム述語

Returns: 針が見つかった場合、その場合は、

true 針が見つかった場合、その場合、 haystack最初の出現の後に配置される needle。それ以外の場合、false はそのまま残し、 haystack。 針が提供されていない場合、 true を返した pred(haystack.front)trueを返した

See Also:

find

ofof

Examples:

import std.range.primitives : empty;
// needleが見つかった; sはneedleの最初の出現位置に
// 続く部分文字列に置き換えられる。
string s = "abcdef";
assert(findSkip(s, "cd") && s == "ef");

// needleは見つからない; sはそのまま残る。
s = "abcdef";
assert(!findSkip(s, "cxd") && s == "abcdef");

// 範囲の最後にneedleが現れた場合、その範囲は空欄のままとなる。
s = "abcdef";
assert(findSkip(s, "def") && s.empty);

otherwise

Examples:

import std.ascii : isWhite;
string s = "    abc";
assert(findSkip!isWhite(s) && s == "abc");
assert(!findSkip!isWhite(s) && s == "abc");

s = "  ";
writeln(findSkip!isWhite(s)); // 2

auto findSplit(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
if (isForwardRange!R1 && isForwardRange!R2);

auto findSplitBefore(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
if (isForwardRange!R1 && isForwardRange!R2);

auto findSplitAfter(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
if (isForwardRange!R1 && isForwardRange!R2);

これらの関数は、 needlehaystack、 以下のように分割する haystack。

findSplit3つの範囲を含むタプルresult を返す。

• result[0] は haystackneedle
• result[1] の部分に一致するhaystack一致する部分 needle
• result[2] 一致した部分の後の部分である。 haystack 一致した後の部分。

needle見つからなかった場合、result[0] は完全に理解し haystack 完全に理解し、result[1] とresult[2] は空になる。

はfindSplitBeforeは、2つの範囲を含むタプルresult を返す。

• result[0] は、その haystackneedle
• result[1] 残りは haystack一致する部分から始まる。

もし needle見つからなかった場合、result[0]は 完全に理解し、 は空になります。 haystack完全に理解し、result[1] は空になります。

はfindSplitAfter2つの範囲を含むタプルresult を返す。

• result[0] の部分は、 haystackマッチするものまでを含む 部分
• result[1] 残りは haystack一致 後の残額である。

もし needle見つからなかった場合、result[0] は空欄、result[1] は haystack。

いずれの場合も、返された範囲の結合は全体にまたがる。 haystack。

もし haystackランダムアクセス可能な範囲である場合、タプルの3つのコンポーネントはすべて と同じ型である haystack。 そうでなければ、 haystack前方範囲でなければならず、 result[0] (およびresult[1] )の型は findSplit結果と同じでなければならない。 std.range.takeExactly。

pred についての詳細は、 find。

xml-ph-0000@deepl.internalxml-ph-0001@deepl.internal

Parameters:

pred	2つの要素を比較する述語。
R1 haystack	前方の範囲を検索する。
R2 needle	前方の範囲を検索する。

Returns:

std.typecons.Tuple分割部分のサブタイプ haystack(詳細は上記を参照)。このサブタイプのTuple はopCast!bool を定義し、 区切りが見つかった場合はtrue を返し、 needle見つかった場合は を返し、それ以外はfalse を返す。

See Also:

find

Examples: サブタイプを返す

サブタイプを返すことで、 std.typecons.Tupleすると、 次のような便利なイディオムが利用可能になる。

// findSplitは3つの要素からなる組を返す
if (auto split = "dlang-rocks".findSplit("-"))
{
    writeln(split[0]); // "dlang"
    writeln(split[1]); // "-"
    writeln(split[2]); // "rocks"
}
else assert(0);

// findSplitBeforeは2つの範囲を返す
if (const split = [2, 3, 2, 3, 4, 1].findSplitBefore!"a > b"([2, 2]))
{
    writeln(split[0]); // [2, 3, 2]
    // [3, 4]はそれぞれ[2, 2]より大きい
    writeln(split[1]); // [3, 4, 1]
}
else assert(0);

subtypeサブタイプ

to return戻る

Examples:

import std.range.primitives : empty;

auto a = "Carl Sagan Memorial Station";
auto r = findSplit(a, "Velikovsky");
import std.typecons : isTuple;
static assert(isTuple!(typeof(r.asTuple)));
static assert(isTuple!(typeof(r)));
assert(!r);
writeln(r[0]); // a
assert(r[1].empty);
assert(r[2].empty);
r = findSplit(a, " ");
writeln(r[0]); // "Carl"
writeln(r[1]); // " "
writeln(r[2]); // "Sagan Memorial Station"("セーガン記念ステーション")
if (const r1 = findSplitBefore(a, "Sagan"))
{
    assert(r1);
    writeln(r1[0]); // "Carl "
    writeln(r1[1]); // "Sagan Memorial Station"("セーガン記念ステーション")
}
if (const r2 = findSplitAfter(a, "Sagan"))
{
    assert(r2);
    writeln(r2[0]); // "Carl Sagan"(カール・セーガン)
    writeln(r2[1]); // " Memorial Station"( 記念ステーション)
}

Examples: 使用する

std.range.only単一の要素を見つけるために使用する:

import std.range : only;
writeln([1, 2, 3, 4].findSplitBefore(only(3))[0]); // [1, 2]

to useだ

Tuple!(ElementType!Range, size_t) minCount(alias pred = "a < b", Range)(Range range)
if (isInputRange!Range && !isInfinite!Range && is(typeof(binaryFun!pred(range.front, range.front))));

Tuple!(ElementType!Range, size_t) maxCount(alias pred = "a < b", Range)(Range range)
if (isInputRange!Range && !isInfinite!Range && is(typeof(binaryFun!pred(range.front, range.front))));

最小値(最大値)を計算し、 rangeその出現回数とともに。 厳密に言えば、最小値はx という値であり、 rangepred(a, x) すべての値a においてfalse となるような値である range。逆に、最大値はx という値であり、 rangepred(x, a) は、aのすべての値に対してfalse である。 range(pred への引数の交換に注意)。

これらの関数は、predを適切に選択することで、任意の極値を計算するために使用できる。 正しく機能させるには、pred が厳密な半順序、すなわち 推移的(pred(a, b) && pred(b, c) ならばpred(a, c) )で、 非反射的(pred(a, a) はfalse )でなければならない。不等号の三区分性は 必要ない。これらのアルゴリズムでは、a とb が (カウントの目的で)等しいとみなされるのは、pred がそれらを同じ同値類に分類した場合、 すなわち!pred(a, b) && !pred(b, a) の場合である。 "function""関数"

Parameters:

pred	極大値(最小値または最大値)を決定するために使用する順序述語。
Range range	カウントする入力範囲。

Returns:

範囲の最小値、最大値の要素と、 その範囲における出現回数。

制限事項 引数の少なくとも1つがNaNの場合、結果は 未定義の値となる。 std.algorithm.searching.maxElement NaN への対処方法の例については、

limitation例

Throws:

Exception 。 range.empty。 if

ifif

See Also:,

std.algorithm.comparison.min、 minIndexminElementminPos

to beだ

Examples:

import std.conv : text;
import std.typecons : tuple;

int[] a = [ 2, 3, 4, 1, 2, 4, 1, 1, 2 ];
// 最小値は1で、3回発生する
writeln(a.minCount); // tuple(1, 3)
// 最大は4で、2回発生する
writeln(a.maxCount); // tuple(4, 2)

渡された範囲を繰り返し、最小の要素を返す。 カスタムのマッピング関数は、xml-ph-0000@deepl.internal に渡すことができる。 他の言語では、これはxml-ph-000と呼ばれることもある。

auto minElement(alias map = (a) => a, Range)(Range r)
if (isInputRange!Range && !isInfinite!Range);

auto minElement(alias map = (a) => a, Range, RangeElementType = ElementType!Range)(Range r, RangeElementType seed)
if (isInputRange!Range && !isInfinite!Range && !is(CommonType!(ElementType!Range, RangeElementType) == void));

渡された範囲を反復し、最小の要素を返す。 カスタムのマッピング関数は、map に渡すことができる。 他の言語では、これはargmin と呼ばれることもある。

複雑さ O(n) n - 1 比較が正確に必要である。

Parameters:

map	比較キー用のカスタムアクセッサ
Range r	最小の要素が選択される範囲
RangeElementType seed	初期要素として使用するカスタムシード

前提条件 シードが指定されない場合は、 r空であってはならない。

Returns:

渡された範囲の最小要素。

注意 引数のうち少なくともひとつが NaN の場合、結果は未定義の値となる。 xml-ph-0000@deepl.internal NaN を無視したい場合は、

注釈 引数のうち少なくともひとつが NaN の場合、結果は未定義の値となる。

NaN を無視したい場合は、 std.algorithm.iteration.filter std.math.isNaNminElementを適用する前に、それらを削除する。 すべての要素がNaNの場合にエラーメッセージを回避するには、適切なシードを追加する。

<range>.filter!(a=>!a.isNaN).minElement(<seed>);

範囲内に NaN が存在する場合に NaN を結果として取得したい場合は、 次の方法を使用できる。 std.algorithm.iteration.foldおよび std.math.isNaN。

<range>.fold!((a,b)=>a.isNaN || b.isNaN ? real.nan : a < b ? a : b);

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

See Also:

maxElement、 std.algorithm.comparison.min, minCount, minIndex, minPos

to beだ

Examples:

import std.range : enumerate;
import std.typecons : tuple;

writeln([2, 7, 1, 3].minElement); // 1

// 要素のインデックスも取得できる
writeln([5, 3, 7, 9].enumerate.minElement!"a.value"); // tuple(1, 3)

// 任意のカスタムアクセサリを渡すことができる
writeln([[0, 4], [1, 2]].minElement!"a[1]"); // [1, 2]

// シードできる
int[] arr;
writeln(arr.minElement(1)); // 1

to beだ

auto maxElement(alias map = (a) => a, Range)(Range r)
if (isInputRange!Range && !isInfinite!Range);

auto maxElement(alias map = (a) => a, Range, RangeElementType = ElementType!Range)(Range r, RangeElementType seed)
if (isInputRange!Range && !isInfinite!Range && !is(CommonType!(ElementType!Range, RangeElementType) == void));

渡された範囲を繰り返し、最大の要素を返す。 カスタムのマッピング関数は、map に渡すことができる。 他の言語では、これはargmax と呼ばれることもある。

複雑さ O(n) n - 1 比較が正確に必要である。

Parameters:

map	比較キー用のカスタムアクセッサ
Range r	最大要素が選択される範囲
RangeElementType seed	初期要素として使用するカスタムシード

前提条件 シードが指定されない場合は、 r空であってはならない。

Returns:

渡された範囲の最大要素。

注意 引数のうち少なくともひとつが NaN の場合、結果は未定義の値となる。 参照

注釈 引数のうち少なくともひとつが NaN の場合、結果は未定義の値となる。 std.algorithm.searching.minElementNaN への対処方法の例については、 こちらを参照のこと。

See Also:

minElement、 std.algorithm.comparison.max, maxCount, maxIndex, maxPos

to beだ

Examples:

import std.range : enumerate;
import std.typecons : tuple;
writeln([2, 1, 4, 3].maxElement); // 4

// 要素のインデックスも取得できる
writeln([2, 1, 4, 3].enumerate.maxElement!"a.value"); // tuple(2, 4)

// 任意のカスタムアクセサリを渡すことができる
writeln([[0, 4], [1, 2]].maxElement!"a[1]"); // [0, 4]

// シードできる
int[] arr;
writeln(arr.minElement(1)); // 1

Range minPos(alias pred = "a < b", Range)(Range range)
if (isForwardRange!Range && !isInfinite!Range && is(typeof(binaryFun!pred(range.front, range.front))));

Range maxPos(alias pred = "a < b", Range)(Range range)
if (isForwardRange!Range && !isInfinite!Range && is(typeof(binaryFun!pred(range.front, range.front))));

サブレンジを計算する rangeの最初の出現から始まり、 range最小値(最大値)から始まり、 同じ終了値を持つ range、または 自体が空の場合は空の範囲 range自身が空の場合。

厳密には、最小値はx という値であり、 range、pred(a, x) はfalse であり、a のすべての値に対して range。逆に、最大値は、x という値であり、range、pred(x, a) は、a のすべての値に対してfalse となるような値である range(pred への引数の交換に注意)。

これらの関数は、predを適切に選択することで、任意の極値を計算するために使用できる。 正しく機能させるには、pred は厳密な半順序でなければならない。 すなわち、推移的(pred(a, b) && pred(b, c) ならpred(a, c) )で 反射的ではない(pred(a, a) はfalse )。 "function""関数"

Parameters:

pred	極大(最小または最大)要素を決定するために使用する順序述語。
Range range	検索する範囲。

Returns: 前方範囲の最小(最大)要素の位置

前方範囲の最小(最大)要素の位置 range、すなわち、 range最小(それぞれ最大)要素の位置から始まり、 同じ終了位置を持つ range。

制限事項 引数のうち少なくとも1つがNaNの場合、結果は 未定義の値となる。 参照

制限事項 引数のうち少なくとも1つがNaNの場合、結果は 未定義の値となる。 std.algorithm.searching.maxElement NaN への対処方法の例については、

See Also:

std.algorithm.comparison.max、 minCountminIndexminElement

to beだ

Examples:

int[] a = [ 2, 3, 4, 1, 2, 4, 1, 1, 2 ];
// 最小値は1で、位置3に最初に現れる
writeln(a.minPos); // [1, 2, 4, 1, 1, 2]
// 最大は4で、最初に位置2で発生する
writeln(a.maxPos); // [4, 1, 2, 4, 1, 1, 2]

最初の出現のインデックスを計算する。

ptrdiff_t minIndex(alias pred = "a < b", Range)(Range range)
if (isInputRange!Range && !isInfinite!Range && is(typeof(binaryFun!pred(range.front, range.front))));

の最小要素の最初の出現のインデックスを計算する range最小要素の最初の出現のインデックスを計算する。

Parameters:

pred	最小要素を決定するために使用する順序付け述語。
Range range	検索対象となる入力範囲。

複雑性 Ο(range.length) 正確な range.length - 1比較が必要である。

Returns:

最小要素の最初の遭遇のインデックス range。 range空の場合は、-1 が返されます。

制限事項 引数の少なくとも1つがNaNの場合、結果は 未定義の値となる。 std.algorithm.searching.maxElement NaN への対処方法の例については、

See Also:

maxIndex、 std.algorithm.comparison.minminCount, minElement, minPos

to beだ

Examples:

int[] a = [2, 3, 4, 1, 2, 4, 1, 1, 2];

// 最小値は1で、位置3に最初に現れる
writeln(a.minIndex); // 3
// minIndexで最大インデックスを得る
writeln(a.minIndex!"a > b"); // 2

// 範囲が空なので、戻り値は-1
int[] b;
writeln(b.minIndex); // -1

// より多くのカスタムタイプで動作する
struct Dog { int age; }
Dog[] dogs = [Dog(10), Dog(5), Dog(15)];
writeln(dogs.minIndex!"a.age < b.age"); // 1

最初の出現のインデックスを計算する。

ptrdiff_t maxIndex(alias pred = "a < b", Range)(Range range)
if (isInputRange!Range && !isInfinite!Range && is(typeof(binaryFun!pred(range.front, range.front))));

の最大要素の最初の出現のインデックスを計算する range最大要素の最初の出現のインデックスを計算する。

計算量 Ο(range) 正確な range.length - 1比較が必要である。

Parameters:

pred	最大要素を決定するために使用する順序述語。
Range range	検索する入力範囲。

Returns: 最大値が最初に現れたインデックス

最大値が最初に現れたインデックス。 range。 range空の場合は、-1が返されます。

制限事項 引数のうち少なくとも1つがNaNの場合、結果は 未定義の値となる。 std.algorithm.searching.maxElement NaN への対処方法の例については、

See Also:

minIndex、 std.algorithm.comparison.maxmaxCount, maxElement, maxPos

to beだ

Examples:

// 最大は4で、最初に位置2で発生する
int[] a = [2, 3, 4, 1, 2, 4, 1, 1, 2];
writeln(a.maxIndex); // 2

// 空の範囲
int[] b;
writeln(b.maxIndex); // -1

// より多くのカスタムタイプで動作する
struct Dog { int age; }
Dog[] dogs = [Dog(10), Dog(15), Dog(5)];
writeln(dogs.maxIndex!"a.age < b.age"); // 1

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

template skipOver(alias pred = (a, b) => a == b)

最初に与えられた範囲 (haystack) のうち、 追加で与えられた範囲 (needles) のいずれかと完全に一致する部分をスキップする。または、 2番目の範囲が与えられていない場合は、predを満たす要素をスキップする。 一致しない場合は何もしない。

Parameters:

pred	それぞれの範囲の要素が一致するかどうかを判定する述語。 デフォルトは等価"a == b" 。

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

Examples:

import std.algorithm.comparison : equal;

auto s1 = "Hello world";
assert(!skipOver(s1, "Ha"));
writeln(s1); // "Hello world"
assert(skipOver(s1, "Hell") && s1 == "o world", s1);

string[]  r1 = ["abc", "def", "hij"];
dstring[] r2 = ["abc"d];
assert(!skipOver!((a, b) => a.equal(b))(r1, ["def"d]), r1[0]);
writeln(r1); // ["abc", "def", "hij"]
assert(skipOver!((a, b) => a.equal(b))(r1, r2));
writeln(r1); // ["def", "hij"]

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

Examples:

import std.ascii : isWhite;
import std.range.primitives : empty;

auto s2 = "\t\tvalue";
auto s3 = "";
auto s4 = "\t\t\t";
assert(s2.skipOver!isWhite && s2 == "value");
assert(!s3.skipOver!isWhite);
assert(s4.skipOver!isWhite && s3.empty);

Examples:

可変長スキップ

auto s = "Hello world";
assert(!skipOver(s, "hello", "HellO"));
writeln(s); // "Hello world"

// 範囲はスキップされ、最も長い一致するneedleはスキップされる
assert(skipOver(s, "foo", "hell", "Hello "));
writeln(s); // "world"

skipoverskipOver

skipoverskipOver

Examples:

import std.algorithm.comparison : equal;

auto s1 = "Hello world";
assert(!skipOver(s1, 'a'));
writeln(s1); // "Hello world"
assert(skipOver(s1, 'H') && s1 == "ello world");

string[] r = ["abc", "def", "hij"];
dstring e = "abc"d;
assert(!skipOver!((a, b) => a.equal(b))(r, "def"d));
writeln(r); // ["abc", "def", "hij"]
assert(skipOver!((a, b) => a.equal(b))(r, e));
writeln(r); // ["def", "hij"]

auto s2 = "";
assert(!s2.skipOver('a'));

skipoverskipOver

Examples: 部分的なインスタンス化

部分的なインスタンス化

import std.ascii : isWhite;
import std.range.primitives : empty;

alias whitespaceSkiper = skipOver!isWhite;

auto s2 = "\t\tvalue";
auto s3 = "";
auto s4 = "\t\t\t";
assert(whitespaceSkiper(s2) && s2 == "value");
assert(!whitespaceSkiper(s2));
assert(whitespaceSkiper(s4) && s3.empty);

partial instantiation部分的なインスタンス化

partial instantiation部分的なインスタンス化

bool skipOver(Haystack, Needles...)(ref Haystack haystack, Needles needles)
if (is(typeof(binaryFun!pred(haystack.front, needles[0].front))) && isForwardRange!Haystack && allSatisfy!(isInputRange, Needles) && !is(CommonType!(staticMap!(ElementType, staticMap!(Unqual, Needles))) == void));

bool skipOver(R)(ref R r1)
if (isForwardRange!R && ifTestable!(typeof(r1.front), unaryFun!pred));

bool skipOver(R, Es...)(ref R r, Es es)
if (isInputRange!R && is(typeof(binaryFun!pred(r.front, es[0]))));

Parameters: 前方に移動できる範囲 。

Haystack haystack	前方に移動する範囲 。
Needles needles	入力範囲は、 スキップする r1スキップする。
Es es	一致させる要素。

Returns:

true 接頭辞が haystackいずれかの範囲に一致する needles完全に 一致するか、pred が true と評価され、 haystackこのセグメントを過ぎた位置まで進められ、 そうでなければ false となり、 haystack元の位置に残る。

注釈 定義上、空の範囲は完全に一致し、 needles空の範囲が含まれている場合、 skipOvertrue が返されます。

uint startsWith(alias pred = (a, b) => a == b, Range, Needles...)(Range doesThisStart, Needles withOneOfThese)
if (isInputRange!Range && (Needles.length > 1) && allSatisfy!(canTestStartsWith!(pred, Range), Needles));

bool startsWith(alias pred = "a == b", R1, R2)(R1 doesThisStart, R2 withThis)
if (isInputRange!R1 && isInputRange!R2 && is(typeof(binaryFun!pred(doesThisStart.front, withThis.front)) : bool));

bool startsWith(alias pred = "a == b", R, E)(R doesThisStart, E withThis)
if (isInputRange!R && is(typeof(binaryFun!pred(doesThisStart.front, withThis)) : bool));

bool startsWith(alias pred, R)(R doesThisStart)
if (isInputRange!R && ifTestable!(typeof(doesThisStart.front), unaryFun!pred));

与えられた入力範囲が、 与えられた針(複数可)で始まるかどうか、 または、針が与えられていない場合は、 その先頭の要素が述語を満たすかどうかを調べる。pred 。

pred に関する詳細情報については、 find。

Parameters: haystack(干し草の山)と針(複数形)の要素を比較する際に使用する述語。針が指定されていない場合は必須。

pred	干し草の山と針(複数可)の要素を比較する際に使用する述語。 針が指定されていない場合は必須。
Range doesThisStart	確認する入力範囲。
Needles withOneOfThese	範囲を照合する針、 すなわち個々の要素または要素の入力範囲である。
R2 withThis	チェックする単一の針。これは、単一の要素または 要素の入力範囲のいずれかである。

Returns:

指定された範囲の最初で針(複数可)が発生していない場合は0、 それ以外は一致する針の位置、つまり、範囲が で始まっている場合は1、 withOneOfThese[0]、2 は withOneOfThese[1]、 というように 続きます。

doesThisStart複数の範囲または要素で始まる場合、 withOneOfThese、最も短いものが一致します( 一致するものが2つあり、同じ長さである場合(例:"a" と'a' )、 引数リストの最も左にあるものが一致します )。

針パラメータが与えられていない場合、true を返します。doesThisStart述語pred を満たす場合、 を返す。

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

Examples:

import std.ascii : isAlpha;

assert("abc".startsWith!(a => a.isAlpha));
assert("abc".startsWith!isAlpha);
assert(!"1ab".startsWith!(a => a.isAlpha));
assert(!"".startsWith!(a => a.isAlpha));

import std.algorithm.comparison : among;
assert("abc".startsWith!(a => a.among('a', 'b') != 0));
assert(!"abc".startsWith!(a => a.among('b', 'c') != 0));

assert(startsWith("abc", ""));
assert(startsWith("abc", "a"));
assert(!startsWith("abc", "b"));
writeln(startsWith("abc", 'a', "b")); // 1
writeln(startsWith("abc", "b", "a")); // 2
writeln(startsWith("abc", "a", "a")); // 1
writeln(startsWith("abc", "ab", "a")); // 2
writeln(startsWith("abc", "x", "a", "b")); // 2
writeln(startsWith("abc", "x", "aa", "ab")); // 3
writeln(startsWith("abc", "x", "aaa", "sab")); // 0
writeln(startsWith("abc", "x", "aaa", "a", "sab")); // 3

import std.typecons : Tuple;
alias C = Tuple!(int, "x", int, "y");
assert(startsWith!"a.x == b"([ C(1,1), C(1,2), C(2,2) ], [1, 1]));
writeln(startsWith!"a.x == b"([C(1, 1), C(2, 1), C(2, 2)], [1, 1], [1, 2], [1, 3])); // 2

alias OpenRight = std.typecons.Flag!"openRight".Flag;

until (下記)およびその他のオプション指定のための間隔。

に設定すると、 OpenRight.yes、区間は右側が開いている (最後の要素は含まれない)。

そうでなければ、 OpenRight.no、右側が閉じられ センチネル全体が含まれる。

Until!(pred, Range, Sentinel) until(alias pred = "a == b", Range, Sentinel)(Range range, Sentinel sentinel, OpenRight openRight = Yes.openRight)
if (!is(Sentinel == OpenRight));

Until!(pred, Range, void) until(alias pred, Range)(Range range, OpenRight openRight = Yes.openRight);

struct Until(alias pred, Range, Sentinel) if (isInputRange!Range);

遅延して反復し、 range要素がe になるまでpred(e, sentinel)true

これは、他の言語におけるtakeWhile と同様である。

Parameters:

pred	停止するタイミングを決定する述語。
Range range	反復処理の対象となる入力範囲。
Sentinel sentinel	停止する要素。
OpenRight openRight	指定された述語が真である要素が 結果のレンジに含まれるべきか(No.openRight、または そうでない(Yes.openRight。

Returns:

入力範囲は、 元の範囲の要素を繰り返し処理するが、指定された 述語が真になった時点で終了する。元の範囲が 前方範囲または それ以上の場合、この範囲は前方範囲となる。

higher高い

Examples:

import std.algorithm.comparison : equal;
import std.typecons : No;
int[] a = [ 1, 2, 4, 7, 7, 2, 4, 7, 3, 5];
assert(equal(a.until(7), [1, 2, 4]));
assert(equal(a.until(7, No.openRight), [1, 2, 4, 7]));

rangerange