thảo luận Nhờ tư vấn intern hay fresher

Hỏi mấy câu mình k trả lời dc. Timeout màn A 30 phút mà sang màn b thì hủy timeout thì làm cách nào, mấy câu trắc nghiệm về quece và stack mình k học nên cũng k trả lời dc. Giải thuật thì phải dùng 2 vòng for 0n2 gà quá
Bắt sự kiện nhảy sang màn b, khi sự kiện đó xảy ra thì tắt timeout màn a :byebye:
 
Mình có nghĩ đến cái đó nhưng k biết có sự kiện sang màn. Nó tên là gì fence. Search gg cũng k dc
Nghĩ ra thì bác cứ nói ý tưởng của mình cho bên phỏng vấn là ok, chứ hỏi chi tiết thì chả ai nhớ nổi đâu :byebye: Người ta hỏi chủ yếu để xem cách mình tư duy giải quyết vấn đề, còn về mặt kỹ thuật thì search google là xong.
 
Các fence cho hỏi thêm cũng như để các fence khác tham khảo, giải thuật tối ưu bài này là gì. Param la array vd Function([1 2,3]) =[6,3,2]
 
Nghĩ ra thì bác cứ nói ý tưởng của mình cho bên phỏng vấn là ok, chứ hỏi chi tiết thì chả ai nhớ nổi đâu :byebye: Người ta hỏi chủ yếu để xem cách mình tư duy giải quyết vấn đề, còn về mặt kỹ thuật thì search google là xong.
Thật sự lúc đó mình cũng định nói thế mà. Phải bắt được cái cơ chế lúc sang màn để clear nó đi chứ mình k biết có sự kiện, nhưng nghĩ là câu trả lời như thế lại giống câu hỏi nên thôi:D
 
Tích của các phần tử còn lại trong mảng ban đầu được đưa vào trong một mảng mới. Ví dụ phần tử 1 thì 2x3=6 fence
vòng lặp đầu tiên anh tính tích các phần tử là M. vòng thứ 2 duyệt đến phần tử nào thì anh chia cho phần tử đó, độ phức tạp tuyến tính.
 
Vẫn 0n2 à fence, với cả nếu chứa số 0 thì sao
à phải rồi chưa tính đến trường hợp 0, vòng lặp đầu tiên nếu gặp 0 thì bỏ qua, tích vẫn là phần còn lại. À còn trường hợp có nhiều hơn 1 số 0 thì M luôn = 0, đặt thêm 1 biến đếm nếu có 2 số 0 thì M=0 thoát vòng lặp luôn.
p/s: 2 vòng lặp độc lập chứ ko phải lồng nhau.
 
Last edited:
à phải rồi chưa tính đến trường hợp 0, vòng lặp đầu tiên nếu gặp 0 thì bỏ qua, tích vẫn là phần còn lại. À còn trường hợp có nhiều hơn 1 số 0 thì M luôn = 0, đặt thêm 1 biến đếm nếu có 2 số 0 thì M=0 thoát vòng lặp luôn.
p/s: 2 vòng lặp độc lập chứ ko phải lồng nhau.
Nếu mảng chỉ có một phần tử thì sao fence
 
Chỉ có khoảng 5 phút thôi

Số 0 thoát vòng lặp luôn là sao fence, check tn nhỉ, mình hơi gà, rồi nếu mảng chỉ có 1 phần tử thì sao
vòng lặp đầu tiên anh đi tính tích các phần tử khác 0 trong mảng, gặp 0 thì bỏ qua.
TH1: Nếu gặp số 0 thứ 2 thì break luôn vì output là mảng toàn số 0.
TH2: hết vòng lặp 1 mà input chỉ có 1 số 0. vòng lặp 2 gặp số 0 thì tích phần còn lại bằng M, khác 0 thì bằng 0.
TH3: nếu input không có số 0 nào thì chia thoải mái.

Mảng có 1 phần tử thì anh có thể viết riêng 1 dòng nữa ở đầu trả về exception.
 
Nếu mảng chỉ có một phần tử thì sao fence
Bác xem còn cách nào tối ưu hơn k
JavaScript:
const multiArray = (array) => {
      let temp = [];
      let nZero = 0;

      let multi = array.reduce((a, b) => {
        return a * b;
      });

      if (multi === 0) {
        for (let i = 0; i < array.length; i++) {
          if (array[i] === 0) {
            nZero++;
          }
        }

        if (nZero > 1) {
          temp = array.map((item => item * 0));
          return temp;
        }

        if (nZero === 1) {
          let arrayNoZero = array.filter(item => item !== 0);
          let multiNoZero = arrayNoZero.reduce((a, b) => {
            return a * b;
          });
          temp = array.map(item => {
            if (item === 0) {
              return item = multiNoZero;
            } else {
              return item = 0;
            }
          })
          return temp;
        }
      }

      temp = array.map(item => multi / item);
      return temp;
    }
 
Bác xem còn cách nào tối ưu hơn k
JavaScript:
const multiArray = (array) => {
      let temp = [];
      let nZero = 0;

      let multi = array.reduce((a, b) => {
        return a * b;
      });

      if (multi === 0) {
        for (let i = 0; i < array.length; i++) {
          if (array[i] === 0) {
            nZero++;
          }
        }

        if (nZero > 1) {
          temp = array.map((item => item * 0));
          return temp;
        }

        if (nZero === 1) {
          let arrayNoZero = array.filter(item => item !== 0);
          let multiNoZero = arrayNoZero.reduce((a, b) => {
            return a * b;
          });
          temp = array.map(item => {
            if (item === 0) {
              return item = multiNoZero;
            } else {
              return item = 0;
            }
          })
          return temp;
        }
      }

      temp = array.map(item => multi / item);
      return temp;
    }
Ban đầu tính tích nên check 0 luôn, chỉ tính tích các số khác 0 thôi. Vì đã có biến nZero rồi thì không cần check multi===0 nữa.
C#:
static int[] ConvertArray(int[] numbers)
{
    if (numbers.Length <= 1)
        throw new Exception("Array size must be bigger than 1");
    int count = 0, M = 1;
    for (int i = 0; i < numbers.Length; i++)
    {
        if (numbers[i] == 0)
        {
            count++;
            if (count == 2)
                break;
        }
        else
            M *= numbers[i];
    }
    int[] newNumbers = new int[numbers.Length];
    if (count == 0)
        for (int i = 0; i < numbers.Length; i++)
            newNumbers[i] = M / numbers[i];
    if (count == 1)
        for (int i = 0; i < numbers.Length; i++)
            newNumbers[i] = numbers[i] == 0 ? M : 0;
    return newNumbers;
}
 
Back
Top