SOURCE

// 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

// 你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

// 你可以按任意顺序返回答案。

 

// 示例 1：

// 输入：nums = [2,7,11,15], target = 9
// 输出：[0,1]
// 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
// 示例 2：

// 输入：nums = [3,2,4], target = 6
// 输出：[1,2]
// 示例 3：

// 输入：nums = [3,3], target = 6
// 输出：[0,1]

const findSumIndex = (nums,target) => {
    const len = nums.length;

    for(let i = 0;i < len; i ++) {
        let other = target - nums[i];
        for(let j = i + 1;j < len;j++) {
            if(nums[j] === other) {
                return [i,j];
            }
        }
    };

    return []
}


// 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

// 请你将两个数相加，并以相同形式返回一个表示和的链表。

// 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

 

// 示例 1：


// 输入：l1 = [2,4,3], l2 = [5,6,4]
// 输出：[7,0,8]
// 解释：342 + 465 = 807.
// 示例 2：

// 输入：l1 = [0], l2 = [0]
// 输出：[0]
// 示例 3：

// 输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
// 输出：[8,9,9,9,0,0,0,1]

const addTwoNumbers = function(arr1,arr2) {
    const l1 = arr1.join('');
    const l2 = arr2.join('');

    const num1 = Number(l1);
    const num2 = Number(l2);

    const sum = num1 + num2;
    const strArray = `${sum}`.split('');

    const len = strArray.length;

    const result = [];

    console.log('enter====',sum,len);

    for(let j = len -1;j >=0;j-- ) {
        result.push(strArray[j]);
    }

    return result;
};

// 给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。

 

// 示例 1:

// 输入: s = "abcabcbb"
// 输出: 3 
// 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。注意 "bca" 和 "cab" 也是正确答案。
// 示例 2:

// 输入: s = "bbbbb"
// 输出: 1
// 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
// 示例 3:

// 输入: s = "pwwkew"
// 输出: 3
// 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
//      请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

const lengthOfLongestSubstring  = function(s) {
    const sArray = s.split('');
    const len = sArray.length;

    let maxLengh = 1;

    const map = new Map();

    for(let i = 0;i < len;i ++) {
        map.set(sArray[i],i);
       for(let j = i + 1;j < len;j++) {
          if(!map.has(sArray[j])) {
              map.set(sArray[j],j);
          } else{
              let cumpLenth = [...map.values()].length;
              if(cumpLenth > maxLengh){
                  maxLengh = cumpLenth;
              };
              map.clear();
          }
       }
    };

    return maxLengh;
};

// 给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

// 算法的时间复杂度应该为 O(log (m+n)) 。

 

// 示例 1：

// 输入：nums1 = [1,3], nums2 = [2]
// 输出：2.00000
// 解释：合并数组 = [1,2,3] ，中位数 2
// 示例 2：

// 输入：nums1 = [1,2], nums2 = [3,4]
// 输出：2.50000
// 解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

const findMedianSortedArrays = function(arr1,arr2) {
    const len1 = arr1.length;
    const len2 = arr2.length;
    const connectArray = [];

    const maxLenth = len1 + len2;

    let i = 0;
    let j = 0;

    for(let k =0;k < maxLenth;k++) {
        if(arr1[i] < arr2[j]) {
            connectArray[k] = arr1[i];
            i +=1;
        }else{
            connectArray[k] = arr2[j] || arr1[j];
            j +=1;
        }
    };

    console.log('enter==',connectArray);

    if(maxLenth % 2 === 0) {
        const middleIndex = Math.floor(maxLenth / 2);

        return (connectArray[middleIndex] + connectArray[middleIndex - 1]) / 2; 
    }else{
         const middleIndex = Math.floor(maxLenth / 2);
        return connectArray[middleIndex];
    }
};