//給定一個整數陣列 nums和一個整數目標值 target，請你在該陣列中找出 和為目標值 target 的那兩個整數，並返回它們的陣列下標。
//
//你可以假設每種輸入只會對應一個答案。但是，陣列中同一個元素在答案裡不能重複出現。
//
//你可以按任意順序返回答案。
//
//來源：力扣（LeetCode）
//連結：https://leetcode-cn.com/problems/two-sum

給定⼀個數組和⼀個⽬標和，從陣列中找兩個數字相加等於⽬標和，輸出這兩個數字的下標。學習筆記一：

import java.util.HashMap;
import java.util.Map;

public class Num001 {

//   給定⼀個數組和⼀個⽬標和，從陣列中找兩個數字相加等於⽬標和，輸出這兩個數字的下標。
 

   public  static int[] returnIndex(int[] nums1,int target){
       int result[] = new int[2];
       for(int i =0;i<nums1.length;i++){
           for(int j=i+1;j<nums1.length;j++){
               if(nums1[i]+nums1[j]==target){
                   result[0]=i;
                   result[1]=j;
                   
 
return result;
               }
           }
       }
         return result;
   }

    public  static int[] returnIndex2(int[] nums1,int target){
       int[] result= new int[2];
        HashMap<Integer,Integer> maping = new HashMap<>();
       for (int i=0;i<nums1.length;i++){
//          先put會有問題: 重複元素put時，map中記錄的永遠是當前元素的 value，即：last 永遠 ==i
 

           maping.put(nums1[i],i);
//           則  lat 永遠 == i
           int last =maping.get(target-nums1[i]);
           if(maping.containsKey(target-nums1[i]) && last!=i){
               result[0] = i;
               result[1] = last;
               return result;
           }
       }
       return  result;
    }

    public  static int[] returnIndex3(int[] nums1,int target){
        int[] result= new int[2];
        HashMap<Integer,Integer> maping = new HashMap<>();
        for (int i=0;i<nums1.length;i++){
//          先put會有問題: 重複元素put時，map中記錄的永遠是當前元素的 value，即：last 永遠 ==i
//            int last =maping.get(target-nums1[i]); //這樣會報錯空指標，因為首次maping還沒有值，直接get就會空指標
//            maping.put(nums1[i],i);
//           則  lat 永遠 == i
            if(maping.containsKey(target-nums1[i])){
                result[0] = i;
                result[1] = maping.get(target-nums1[i]);
                return result;
            }
            maping.put(nums1[i],i);
        }
        return  result;
    }

    public static int[] twoSum(int[] nums, int target){

        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
//            如果陣列中有多個相同的數，則map記錄的value將是最後一次出現的位置，如{3,3,3,3}，map對應的是<3,3>
            map.put(nums[i],i);
        }
        for(int i=0;i<nums.length;i++) {
            int sub = target - nums[i];
            if (map.containsKey(sub) && map.get(sub) != i) {
                return new int[]{i, map.get(sub)};
            }
        }
        throw new IllegalArgumentException("No two sum solution");
   }


    public static void main(String[] args) {
       int[] a = {3,3,3,3};
//       int[] result = twoSum(a, 6);
 int [] result = returnIndex3(a,6);
       System.out.println(result);

    }

}

學習筆記二：

import java.util.HashMap;

public class Num001_1 {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        for(int i=0;i<nums.length;i++){
//            if(nums[i]>target){
//                i++;
//            } 這裡不對，因為不一定都是正數，直接去掉就可以
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    result[0]=i;
                    result[1]=j;
                }
            }
        }
        return result;
    }

    public int[] twoSum1(int[] nums, int target) {

        HashMap<Integer,Integer> aa = new HashMap<>();

        for(int i = 0 ;i < nums.length; i++){
            aa.put(nums[i],i); }
        for(Integer j: aa.keySet()){
            if(aa.containsKey(target-j))
                return new int[]{aa.get(j),aa.get(target-j)};
        }

        return new int[0];

    }
}