JavaScript 面接でよくあるアルゴリズムの質問の詳細な説明

[[185725]]

JavaScript での変数の昇格を説明する

いわゆるプロモーションは、その名前が示すように、JavaScript がすべての宣言を現在のスコープの先頭に昇格することを意味します。つまり、変数は宣言される前に使用できますが、JavaScript は宣言を先頭に移動しますが、実際の初期化プロセスは実行しません。

厳密な使用の役割を説明します。

use strict; 名前が示すように、JavaScript はいわゆる strict モードで実行されます。その主な利点の 1 つは、開発者が宣言されていない変数の使用を避けるように強制できることです。古いバージョンのブラウザまたは実行エンジンの場合、この命令は自動的に無視されます。

 //厳密モードの例
「厳密な使用」 ; 
 
すべてをキャッチします();
関数catchThemAll() {
  x = 3.14; // エラーが発生します
x * xを返します。
 }

イベントバブリングとは何か、それを避ける方法を説明する

イベントバブリングとは、イベントが現在の要素をトリガーするだけでなく、ネストされた順序で親要素に渡すことを意味します。直感的に言えば、子要素のクリックイベントは、親要素のクリックイベントハンドラーによってもキャプチャされます。イベントバブリングを回避するには、event.stopPropagation() または IE 9 以下の場合は event.cancelBubble を使用します。

== と === の違いは何ですか?

=== は厳密な比較とも呼ばれます。主な違いは、=== は値だけでなく、型と値の両方を比較することです。

 //比較演算子の例
0 ==偽; //真 
 0 === false ; //偽  
 
 2 == '2' ; //真 
 2 === '2' ; //偽

nullとundefinedの違いを説明する

JavaScript では、null は割り当て可能な値です。null に設定された変数は、値がないことを意味します。未定義とは、変数が宣言されているが、値が割り当てられていないことを意味します。

プロトタイプ継承と古典的継承の違いを説明する

クラス継承では、クラスは不変です。言語によって多重継承のサポートは異なります。一部の言語では、インターフェース、final、abstract の概念もサポートされています。プロトタイプの継承はより柔軟で、プロトタイプ自体は変更可能であり、オブジェクトは複数のプロトタイプから継承できます。

配列

整数配列の中で積が最大となる3つの数値を見つける

順序付けられていない整数の配列が与えられた場合、積が *** となる 3 つの数値を見つける必要があります。

 var 未ソート配列 = [-10, 7, 29, 30, 5, -10, -70]; 
 
 computeProduct(未ソート配列); // 21000 
 
関数sortIntegers(a, b) {
 a - bを返します。
 } 
 
 // 最大の積は(min1 * min2 * max1 || max1 * max2 * max3) のいずれかです
関数computeProduct(未ソート) {
  var sorted_array = unsorted.sort(sortIntegers)、
    製品1 = 1、
    積2 = 1、
    配列n要素 = ソートされた配列の長さ - 1; 
 
  //ソートされた配列内の3つの最大の整数の積を取得します
( var x = array_n_element; x > array_n_element - 3; x --) {  
      product1 = product1 * ソートされた配列[x];
  }
  product2 = ソートされた配列[0] * ソートされた配列[1] * ソートされた配列[配列n要素]; 
 
  (product1 > product2) の場合、product1を返します。 
 
返品商品2
 };

連続した配列内の欠落した数字を見つける

上限と下限がわかっている、n 個の連続する数字 (n - 1 個) を含む順序付けられていない配列が与えられた場合、O(n) の計算量で欠落している数字を見つけます。

 //出力 関数の値は8であるべきである
var 整数の配列 = [2, 5, 1, 4, 9, 6, 3, 7];
 var 上限 = 9;
 var 下限 = 1; 
 
 findMissingNumber(整数の配列、上限、下限); //8 
 
関数findMissingNumber(整数の配列、上限、下限) { 
 
  // 配列を反復処理して合計を求める 数字の
  var 整数の合計 = 0;
 ( var i = 0; i < 整数配列の長さ; i++) {
    整数の合計 += 整数の配列[i];
  } 
 
  // ガウス和の公式を使用して理論的な配列の合計を計算します
  // 式: [(N * (N + 1)) / 2] - [(M * (M - 1)) / 2];
  // Nは上限、 Mは下限です
 
  上限合計 = (上限 * (上限 + 1)) / 2;
  下限値の合計 = (下限値 * (下限値 - 1)) / 2; 
 
  理論上の合計 = 上限の合計 - 下限の合計; 
 
  //
 （理論上の合計 - 整数の合計）を返す
}

アレイ重複排除

順序付けられていない配列が与えられた場合、配列内の重複する数値を削除し、重複のない新しい配列を返す必要があります。

 // ES6 実装
var 配列 = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8]; 
 
 Array.from (新しいSet (配列)); // [1, 2, 3, 5, 9, 8] 
 
 
 // ES5 実装
var 配列 = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8]; 
 
 uniqueArray(配列); // [1, 2, 3, 5, 9, 8] 
 
関数uniqueArray(配列) {
  var ハッシュマップ = {};
  varユニーク= [];
 ( var i = 0; i < 配列の長さ; i++) {
    //キーの場合 返品  null (一意)の場合、次のように評価されます。  間違い。
    if(!hashmap.hasOwnProperty([array[i]])) {
      ハッシュマップ[配列[i]] = 1;
ユニーク.push(配列[i]);
    }
  }
戻る 個性的;
 }

配列内の要素間の差を計算する

順序付けられていない配列が与えられた場合、任意の 2 つの要素間の最大差を求めます。差の計算における小さい方の要素の添え字は、大きい方の要素の添え字よりも小さくなければならないことに注意してください。たとえば、配列 [7, 8, 4, 9, 9, 15, 3, 1, 10] の計算値は、15 の添字が 1 未満であるため、14 (15 - 1) ではなく 11 (15 - 4) になります。

 var 配列 = [7, 8, 4, 9, 9, 15, 3, 1, 10];
 // [7, 8, 4, 9, 9, 15, 3, 1, 10] は、 `4`と`15`の差に基づいて `11`を返します
// 注意: それは  `15`と`1`の差から`14`は得られません。15 が 1 の前に来るからです。 
 
 findLargestDifference(配列); 
 
関数findLargestDifference(配列) { 
 
  // 配列に要素が1つしかない場合は、直接-1を返します
 
  配列の長さが 1 未満の場合は-1 を返します。 
 
  // current_min は現在の最小値を指します
 
  var current_min = 配列[0];
  var 現在の最大差 = 0; 
   
  // 配列全体を走査して、現在の最大差を見つけます。最大差が見つかった場合は、current_max_difference を新しい値で上書きします。
  // また、現在の配列の最小値も追跡し、`将来の最大値` - `それ以前の最小値`を保証します。 
 
 ( var i = 1; i < 配列の長さ; i++) {
    配列[i] > 現在の最小値 && 配列[i] - 現在の最小値 > 現在の最大差) {
      現在の最大差 = 配列[i] - 現在の最小値;
    }そうでない場合 (配列[i] <= current_min) {
      current_min = 配列[i];
    }
  } 
 
  // 負または0の場合は、  大きな違いはない
  (current_max_difference <= 0) の場合は-1 を返します。 
 
現在の最大差を返します。
 }

配列内の要素の積

順序付けられていない配列が与えられた場合、新しい配列出力を返す必要があります。ここで、output[i] は、インデックス i の要素を除く元の配列の要素の積です。複雑さは O(n) である必要があります。

 var firstArray = [2, 2, 4, 1];
 var secondArray = [0, 0, 0, 2];
 var thirdArray = [-2, -2, -3, 2]; 
 
 productExceptSelf(firstArray); // [8, 8, 4, 16]
 productExceptSelf(secondArray); // [0, 0, 0, 0]
 productExceptSelf(thirdArray); // [12, 12, 8, -12] 
 
関数productExceptSelf(numArray) {
  var 製品 = 1;
  var size = numArray.length;
  var出力= []; 
 
  //から 最初の配列: [1, 2, 4, 16]
  //この場合の最後の数字 すでに正しい位置にある（私たちにはそれができる）
  //次のステップで1を掛けるだけです。
  // このステップは基本的に製品を左に移動します インデックスの で インデックス+ 1
 ( var x = 0; x <サイズ; x++) {
出力.push(product);
      製品 = 製品 * numArray[x];
  } 
 
  //後ろから、現在の 出力要素（製品を表す）
  //左に 指数の右側の積を掛け合わせます。  要素の
  var 製品 = 1;
 (var i = size - 1; i > -1; i --) {  
出力[i] =出力[i] * 製品;
      製品 = 製品 * numArray[i];
  } 
 
戻る 出力;
 }

配列の交差

2 つの配列が与えられた場合、2 つの配列の交差部分を見つける必要があります。交差部分の要素は一意である必要があることに注意してください。

 var firstArray = [2, 2, 4, 1];
 var secondArray = [1, 2, 0, 2]; 
 
交差点(最初の配列、2番目の配列); // [2, 1] 
 
関数の交差(最初の配列、2番目の配列) {
  // ここでのロジックは に  firstArrayの要素をキーとしてハッシュマップを作成します。
  //その後、ハッシュマップのO(1)検索時間を使用できます に ハッシュ内に要素が存在するかどうかを確認する
  // 存在する場合は、その要素を新しい配列に追加します。 
 
  var ハッシュマップ = {};
  var 交差点配列 = []; 
 
  firstArray.forEach(関数(要素) {
    ハッシュマップ[要素] = 1;
  }); 
 
  //この場合は一意の要素のみをプッシュしたいので、すでに追加したものを追跡するためのカウンターを実装できます。
  secondArray.forEach(関数(要素) {
    ハッシュマップ[要素] === 1の場合{
      交差点Array.push(要素);
      ハッシュマップ[要素]++;
    }
  }); 
 
交差点の配列を返します。 
 
  //時間計算量 O(n)、空間計算量 O(n)
 }

弦

文字列を反転する

文字列が与えられた場合、その中の単語を逆にして出力する必要があります。たとえば、「Welcome to this Javascript Guide!」は、「emocleW ot siht tpircsavaJ !ediuG」と出力する必要があります。

 var string = "この Javascript ガイドへようこそ！" ; 
 
 //出力は !ediuG tpircsavaJ siht ot emocleW になります
var 逆文法 = 逆文法区切り文字(文字列、 "" ); 
 
 //出力は emocleW ot siht tpircsavaJ !ediuG になります
var 逆各単語 = 逆セパレーター(逆文全体、 " " ); 
 
関数reverseBySeparator(文字列、セパレーター) {
 string.split(separator).reverse(). join (separator)を返します。
 }

ランダムな文字列

2 つの文字列が与えられた場合、それらが文字を逆にして形成された文字列かどうかを判断します。たとえば、Mary と Army は同じ文字ですが、順序が逆になっています。

 var firstWord = "メアリー" ;
 var secondWord = "陸軍" ; 
 
 isAnagram(firstWord, secondWord); //真  
 
関数isAnagram(最初、 2番目) {
  //のために 大文字と小文字を区別しない場合は、両方の単語を小文字に変更します。
  var a = first .toLowerCase();
  var b = second .toLowerCase(); 
 
  // 文字列をソートし、  結果の配列を文字列に結合します。結果を比較します
  a = a.split( "" ).sort(). join ( "" );
  b = b.split( "" ).sort(). join ( "" ); 
 
 a === bを返します。
 }

文字列を尋ねます

文字列が回文かどうかを判定します。たとえば、racecar と race car はどちらも回文です。

 isPalindrome( "レースカー" ); // true  
 isPalindrome( "レースカー" ); // true   
 
関数isPalindrome(単語) {
  //交換する すべての非文字  「」  小文字に変更する
  var lettersOnly = word.toLowerCase(). replace (/\s/g, "" ); 
 
  //文字列を逆順にした文字列と比較する
lettersOnly === lettersOnly.split( "" ).reverse(). join ( "" );を返します。
 }

スタックとキュー

2つのスタックを使用してキューイングとデキューイングを実装する

var inputStack = []; //最初のスタック
var outputStack = []; // 2番目のスタック
 
 // エンキューの場合は、アイテムを最初のスタックにプッシュするだけです
関数enqueue(stackInput, item) {
 stackInput.push(item)を返します。
 } 
 
関数デキュー(stackInput, stackOutput) {
  //出力スタックの最初の要素が
  //入力スタックの最後の要素。その後、一番上の要素をポップします 出力の に 
  //入力スタックにプッシュされた最初の要素を取得します
  スタック出力の長さが0以下の場合
    スタック入力の長さが0より大きい場合
      var elementToOutput = stackInput.pop();
      要素を出力にプッシュします。
    }
  } 
 
 stackOutput.pop()を返します。
 }

中括弧が閉じているかどうかを確認する

指定された式内の中括弧が閉じられているかどうかを判断する関数を作成します。

 var 式 = "{{}}{}{}"  
 var 式False = "{}{{}" ; 
 
 isBalanced(式); // true  
 isBalanced(expressionFalse); // false  
 isBalanced( "" ); //真  
 
関数isBalanced(式) {
  var checkString = 式;
  var スタック = []; 
 
  // 空の場合、括弧は技術的にバランスが取れている
  (checkString.length <= 0) の場合、戻り値 真実; 
 
 ( var i = 0; i < checkString.length; i++) {
    if(checkString[i] === '{' ) {
      スタックをプッシュします(checkString[i]);
    }そうでない場合 (checkString[i] === '}' ) {
      //空の配列のポップは未定義です
      スタックの長さが0より大きい場合
        スタックをポップします。
      }それ以外{
戻る 間違い;
      }
    }
  } 
 
  // 配列が 空ではない、それは バランスが取れていない
  (stack.pop())を返す場合 間違い;
戻る 真実;
 }

再帰

バイナリ変換

再帰関数を使用して入力数値をバイナリ文字列に変換します。

小数点から2進数へ(3); // 11
小数点から2進数(8); // 1000
小数点から2進数(1000); // 1111101000 
 
関数decimalToBinary(数字) {
  if(数字 >= 1) {
    // 数字が  2で割り切れない場合は再帰的に処理を戻す
    //バイナリ  1を引いた数字の残りの1桁に1を加算する
    if (数字 % 2) {
戻り値：decimalToBinary((digit - 1) / 2) + 1;
    }それ以外{
      // 再帰的に次の2進数を返す
戻り値：decimalToBinary(digit / 2) + 0;
    }
  }それ以外{
    // 終了条件
戻る  '' ;
  }
 }

バイナリ検索

関数recursiveBinarySearch(配列, 値, 左位置, 右位置) {
  // 値 DNE
  左位置 > 右位置の場合、 -1 を返します。 
 
  var middlePivot = Math.floor((leftPosition + rightPosition) / 2);
  if (配列[middlePivot] === 値) {
 middlePivotを返します。
  }そうでない場合 (配列[middlePivot] > 値) {
 recursiveBinarySearch(配列、値、左位置、中央ピボット - 1)を返します。
  }それ以外{
 recursiveBinarySearch(配列、値、middlePivot + 1、rightPosition)を返します。
  }
 }

番号

2の指数値であるかどうかを判定する

isPowerOfTwo(4); //真 
 isPowerOfTwo(64); //真 
 isPowerOfTwo(1); //真 
 isPowerOfTwo(0); //偽 
 isPowerOfTwo(-1); //偽  
 
 //ゼロ以外の場合:
関数isPowerOfTwo(数値) {
  // `&` はビット単位の n を使用します。
  //この場合 数 = 4の場合、式は次の式と同一になります。
  // ` return (4 & 3 === 0)`
  // ビット単位では、4は100、3は011です。&を使用すると、2つの値が 同時に
  // スポットが1の場合、結果は1、それ以外の場合は0です。この場合、 000を返します。
  //したがって、4 つの条件を満たす式になります。
  // 逆に、式が` return (5 & 4 === 0)` の場合はfalseになります 
  // 101を返すので、100 = 100 ( NOT === 0) 
 
数値 & (数値 - 1) === 0を返します。
 } 
 
 //ゼロの場合:
関数isPowerOfTwoZeroCase(数値) {
戻り値: (数値 !== 0) && ((数値 & (数値 - 1)) === 0);
 }