Leetcode, Two Sum Problemi Çözümü (Python & Kotlin)

Bir Array<Int> ve bir de hedef değer(Int) veriliyor. Toplamı hedef değere eşit olan, arraydeki iki sayının indekslerinin döndürülmesi isteniyor.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:

İlk çözümüm

Önce enumerate fonksiyonuyla verilen listeden yeni bir liste oluşturdum. Böylece for döngüsündeyken verilen listedeki elemanı yönetebilirken indeksini de bilecektim.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        newList = list(enumerate(nums))

for döngüsünde, enumerate ile oluşturulan listedeki her elamanın indeksine ve elemanın kendisine index, val şeklinde ulaşıyorum.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        newList = list(enumerate(nums))
        
        for index, val in newList:

if satırında toplamdaki diğer sayı olması gereken target - val, nums listesinde bulunuyorsa ve val'ın index'i toplamı sağlayan diğer öğe target-val'ın indeksi ile aynı değilse return aşamasına geçiyoruz. Bu ikinci kontrolü, bir sayının kendisiyle toplamının hedefi vermesi olasılığını yok saymak için yapıyoruz.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        newList = list(enumerate(nums))
        
        for index, val in newList:
            if(target-val in nums and index!=nums.index(target-val)):

Bu noktada akla neden enumerate() ile yeni liste oluşturup indeks kontrol ettik, onu da nums.index(val) şeklinde kontrol etseydik gibi bir soru gelebilir. Böyle yapmamın sebebi listede aynı değerde birden fazla eleman olduğunda (örn. [0,1,5,2,4,2]) nums.index(val) fonksiyonu, ilk val'ın indeksini döndürüyor(örn. val=2, [0,1,5,2,4,2] -> index = 3 ). for döngüsünde geçerli sıradakini değil.

Son olarak if koşulu sağlandığında indeksleri return ediyoruz. Soru, indeksleri sıralı istediği için return satırında bir kontrol yaptım. Burada ikinci sayının indexinin birincisininkinden küçük gelebilmesinin sebebi de şöyle. Örneğin listede aynı sayıdan birden fazla olduğunu ve hedefin bu sayının kendisiyle toplamı olduğunu düşünelim: [0,1,5,2,4,2], hedef=4. for döngüsü 2'ye geldiğinde enumerate()'ten gelen index 3'ü gösterecektir. if kontrolünde 3!=nums.index(4-2) bölümünde nums.index(4-2) de 3 indeksini vereceğinden for döngüsü bir sonraki döngüsüne geçiş yapacaktır. Nihayetinde listedeki bir sonraki 2'ye gelindiğinde enumerate()'ten gelen index 5 olacaktır ve nums.index(4-2) ise bize 3 indeksini verecektir. return'de ise indeksleri [5,3] şeklinde değil de [3,5] şeklinde döndürmek için küçük bi kontrol yapıyorum.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        newList = list(enumerate(nums))
        
        for index, val in newList:
            if(target-val in nums and index!=nums.index(target-val)):
                a=nums.index(target-val)
                return [index,a] if index<a else [a,index]

İkinci çözüm

Tabi düşününce çok büyük listeler verildiğinde de enumerate() ile yeni liste oluşturmak yerine kodu şu şekilde değiştirmek aklıma geldi. Sonuçta mantık olarak bir şey değişmiyor.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        i=0
        for val in nums:
            if(target-val in nums and i!=nums.index(target-val)):
                a=nums.index(target-val)
                return [i,a] if i<a else [a,i]
            i+=1

Aynı kodun Kotlin versiyonu

class Solution {
    fun twoSum(nums: IntArray, target: Int): IntArray {
        var i : Int = 0
        nums.forEach {
            if((target-it) in nums && i!=nums.indexOf(target-it)){
                val a : Int = nums.indexOf(target-it)
                return if(i<a) arrayOf(i,a).toIntArray() else arrayOf(a,i).toIntArray()
            }
            i++
        }
        return intArrayOf()
    }
}