文字列に標準のJavaScriptメソッドを使用せずに部分文字列が含まれているかどうかを確認しますか？

Question

私は、trueまたはfalseを返すjavascriptメソッドを実装する必要があります。これは、masterStringにsubStringが含まれているかどうかによって異なります。

は、私は次のような何かをしたが、これは正しいアプローチであるかどうかわからない：

function contains(masterString, subString) { 
if(subString.length > masterString.length){ 
    return false; 
} 
for(var i=subString.length-1; i<masterString.length; i++){ 
    if(concatString(i - subString.length-1, i, masterString) === subString){ 
     return true; 
    } 
} 
    return false; 

} 

function concatString(index1, index2, string){ 
    var conString = ''; 
    console.log(index1, index2-1, string); 
    for(var i=index1; i<index2-1; i++){ 
     conString += string[i]; 
    } 
    console.log(conString); 
    return conString; 
} 


contains('abcd', 'bc'); 

それはしかし正常に動作していません。

私たちはそれを実装できますか？ありがとう:)

Answer 1

あなたは良い解決策を持っています。しかし私は私がもっと簡単だと思います。

ところで：私は.lengthもjavascript funcitonだと思います。

function length(string){ 
 
    var count = 0; 
 
    while(string[count] != undefined) 
 
    count++; 
 
    return count; 
 
} 
 

 
function contains(masterString, subString) { 
 
    var masterStringLength = length(masterString); 
 
    var subStringLength = length(subString); 
 
    for(var i = 0; i <= masterStringLength - subStringLength; i++) 
 
    { 
 
     var count = 0; 
 
     for(var k = 0; k < subStringLength; k++) 
 
     { 
 
      if(masterString[i + k] == subString[k]) 
 
       count++; 
 
      else 
 
       break; 
 
     } 
 
     if(count == subStringLength) 
 
      return true; 
 

 
    } 
 
    return false; 
 
} 
 

 
console.log(contains('abcdefgh', 'bcde')); 
 
console.log(contains('abcdefgh', 'ab')); 
 
console.log(contains('abcdefgh', 'fgh'));

Answer 2

可能なインデックスごとに、subStringがmasterStringのインデックスにあるかどうかをテストします。

var indexOf = function(masterString,subString){ 
    for(var i = 0 ; i < masterString.length - subString.length + 1; i++){ 
     var match = true; 
     for(var j = 0; j < subString.length; j++){ 
      if(masterString[i + j] !== subString[j]){ 
       match = false; 
       break; 
      } 
     } 
     if(match) 
      return i; 
    } 
    return -1; 
}  

var contains = function(master,sub){ 
    return indexOf(master,sub) !== -1; 
} 

注：Knuth-Morris-Prattのような高速アルゴリズムがあります。

Answer 3

あなたは、ネストされたループを使用することができ、この

var substr = "test", 
 
    masterstr = "test1", 
 
checksubstr = (ms,ss) => !!~ms.indexOf(ss); 
 

 
console.log(checksubstr(masterstr,substr));

Answer 4

のように行うことができます。もちろん

function contains(masterString, subString) { 
    outerloop: 
    for(var i=0; i <= masterString.length-subString.length; ++i) { 
    for(var j=0; j<subString.length; ++j) 
     if(masterString[i + j] !== subString[j]) continue outerloop; 
    return true; 
    } 
    return false; 
} 

、あなたがより良い性能を達成できるネイティブメソッドを使用して。

Answer 5

これは最長共通部分列See thisに似ています。 このコードはあなたの問題を解決します。

function contains(masterString, subString) { 
 
     if (findCommonSubsequence(masterString, subString) == subString) 
 
      alert(true); 
 
     else 
 
      alert(false); 
 
    } 
 

 
    function findCommonSubsequence(a, b) { 
 

 
     var table = [], 
 
      aLen = a.length, 
 
      bLen = b.length; 
 
     squareLen = Math.max(aLen, bLen); 
 
     // Initialize a table of zeros 
 
     for (var i = 0; i <= squareLen ; i++) { 
 
      table.push([]); 
 
      for (var j = 0; j <= squareLen; j++) { 
 
       table[i][j] = 0; 
 
      } 
 
     } 
 
     // Create a table of counts 
 
     for (var i = 1; i <= aLen; i++) { 
 
      for (var j = 1; j <= bLen; j++) { 
 
       if (a[i - 1] == b[j - 1]) { 
 
        table[i][j] = table[i - 1][j - 1] + 1; 
 
       } else { 
 
        table[i][j] = Math.max(table[i - 1][j], table[i][j - 1]); 
 
       } 
 
      } 
 
     } 
 

 
     // Move backwards along the table 
 
     i = aLen, j = bLen, LCS = []; 
 
     while (i > 0 && j > 0) { 
 
      if (a[i - 1] == b[j - 1]) { 
 
       LCS.push(a[i - 1]); 
 
       i -= 1; 
 
       j -= 1; 
 
      } else { 
 
       if (table[i][j - 1] >= table[i - 1][j]) { 
 
        j -= 1; 
 
       } else { 
 
        i -= 1; 
 
       } 
 
      } 
 
     } 
 
     return(LCS.reverse().join('')); 
 
    }

Answer 6

あなたの質問は、十分な奇妙な制約があり、それでは、ES6からいくつかの助けを借りて、同様forループせずにそれを を行うことはできません。

// Cf. Array.prototype.some 
 
const any = (f, [x,...xs]) => 
 
    x === undefined ? false : f(x) || any(f,xs); 
 

 
// Return true if the first iterable is a prefix of the second. 
 
const isprefix = ([x,...xs], [y,...ys]) => 
 
    x === undefined ? true : x == y && isprefix(xs,ys); 
 

 
// tails('abc') --> [['a','b','c'], ['b','c'], ['c']] 
 
const tails = ([x,...xs]) => 
 
    x === undefined ? [] : [[x,...xs],...tails(xs)]; 
 

 
// If needle is empty, or is a prefix of any of tails(haystack), return true. 
 
const contains = (haystack, needle) => 
 
    needle.length ? any(bale => isprefix(needle, bale), tails(haystack)) : true; 
 

 
const tests = [ 
 
    ['aaafoobar', 'foo'], 
 
    ['foo', 'foo'], 
 
    ['fo', 'foo'], 
 
    ['', 'f'], 
 
    ['f', ''], 
 
    ['', ''] 
 
]; 
 

 
tests.forEach(test => console.log(JSON.stringify(test), contains(test[0], test[1])));