Third Maximum Number

                                            
class Solution {
public:
    int thirdMax(vector<int>& nums) {
        set<int> uniqueNums(nums.begin(), nums.end());
        
        if (uniqueNums.size() < 3) {
            return *uniqueNums.rbegin();
        }
        
        auto it = uniqueNums.begin();
        advance(it, uniqueNums.size() - 3);
        
        return *it;
    }
};

                                            
class Solution {
    public int thirdMax(int[] nums) {
        Integer max1 = null;
        Integer max2 = null;
        Integer max3 = null;
        
        for (Integer num : nums) {
            if (num.equals(max1) || num.equals(max2) || num.equals(max3)) {
                continue;
            }
            
            if (max1 == null || num > max1) {
                max3 = max2;
                max2 = max1;
                max1 = num;
            } else if (max2 == null || num > max2) {
                max3 = max2;
                max2 = num;
            } else if (max3 == null || num > max3) {
                max3 = num;
            }
        }
        
        return max3 != null ? max3 : max1;
    }
}

                                            
class Solution(object):
    def thirdMax(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums = set(nums)
        if len(nums) < 3:
            return max(nums)
        nums.remove(max(nums))
        nums.remove(max(nums))
        return max(nums)

                                            
int thirdMax(int* nums, int numsSize) {
    long max1 = LONG_MIN;
    long max2 = LONG_MIN;
    long max3 = LONG_MIN;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > max1) {
            max3 = max2;
            max2 = max1;
            max1 = nums[i];
        } else if (nums[i] < max1 && nums[i] > max2) {
            max3 = max2;
            max2 = nums[i];
        } else if (nums[i] < max2 && nums[i] > max3) {
            max3 = nums[i];
        }
    }
    
    if (max3 != LONG_MIN) {
        return (int)max3;
    } else {
        return (int)max1;
    }
}

                                            
public class Solution {
    public int ThirdMax(int[] nums) {
        long first = long.MinValue;
        long second = long.MinValue;
        long third = long.MinValue;

        foreach (int num in nums) {
            if (num > first) {
                third = second;
                second = first;
                first = num;
            } else if (num > second && num < first) {
                third = second;
                second = num;
            } else if (num > third && num < second) {
                third = num;
            }
        }

        return third == long.MinValue ? (int)first : (int)third;
    }
}

                                            
/**
 * @param {number[]} nums
 * @return {number}
 */
var thirdMax = function(nums) {
    let first = -Infinity;
    let second = -Infinity;
    let third = -Infinity;
    
    for (let num of nums) {
        if (num > first) {
            third = second;
            second = first;
            first = num;
        } else if (num > second && num < first) {
            third = second;
            second = num;
        } else if (num > third && num < second) {
            third = num;
        }
    }
    
    return third !== -Infinity ? third : first;
};

                                            
function thirdMax(nums: number[]): number {
    const set = new Set(nums);
    const uniqueNums = Array.from(set);
    uniqueNums.sort((a, b) => b - a);
    if (uniqueNums.length < 3) {
        return uniqueNums[0];
    }
    return uniqueNums[2];
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     */
    function thirdMax($nums) {
        $nums = array_unique($nums);
        rsort($nums);
        
        if(count($nums) < 3) {
            return $nums[0];
        }
        
        return $nums[2];
    }
}

                                            
class Solution {
    func thirdMax(_ nums: [Int]) -> Int {
        var set = Set<Int>()
        for num in nums {
            set.insert(num)
            if set.count > 3 {
                set.remove(set.min()!)
            }
        }
        
        if set.count < 3 {
            return set.max()!
        } else {
            return set.min()!
        }
    }
}

                                            
class Solution {
    fun thirdMax(nums: IntArray): Int {
        val set = nums.toSortedSet()
        return if (set.size < 3) set.last() else set.elementAt(set.size - 3)
    }
}

                                            
class Solution {
  int thirdMax(List<int> nums) {
    Set<int> set = nums.toSet();
    List<int> uniqueNums = set.toList();
    uniqueNums.sort();
    if (uniqueNums.length < 3) {
      return uniqueNums.last;
    }
    return uniqueNums[uniqueNums.length - 3];
  }
}

                                            
func thirdMax(nums []int) int {
    first := math.MinInt64
    second := math.MinInt64
    third := math.MinInt64

    for _, num := range nums {
        if num > first {
            third = second
            second = first
            first = num
        } else if num < first && num > second {
            third = second
            second = num
        } else if num < second && num > third {
            third = num
        }
    }

    if third != math.MinInt64 {
        return third
    }

    return first
}

                                            
# @param {Integer[]} nums
# @return {Integer}
def third_max(nums)
    nums.uniq.sort.reverse[2] || nums.max
end

                                            
object Solution {
    def thirdMax(nums: Array[Int]): Int = {
        var firstMax = Long.MinValue
        var secondMax = Long.MinValue
        var thirdMax = Long.MinValue
        
        for (num <- nums) {
            if (num > firstMax) {
                thirdMax = secondMax
                secondMax = firstMax
                firstMax = num
            } else if (num > secondMax && num < firstMax) {
                thirdMax = secondMax
                secondMax = num
            } else if (num > thirdMax && num < secondMax) {
                thirdMax = num
            }
        }
        
        if (thirdMax != Long.MinValue) thirdMax.toInt
        else firstMax.toInt
    }
}

                                            
impl Solution {
    pub fn third_max(nums: Vec<i32>) -> i32 {
        let mut nums = nums;
        nums.sort_unstable();
        nums.dedup();
        if nums.len() < 3 {
            return *nums.last().unwrap();
        }
        nums[nums.len() - 3]
    }
}

                                            
(define/contract (third-max nums)
  (-> (listof exact-integer?) exact-integer?)
  (define sorted-nums (sort (remove-duplicates nums) >))
  (cond
    ((< (length sorted-nums) 3) (first sorted-nums))
    (else (list-ref sorted-nums 2))
  )
)

To solve this coding challenge, we'll need to identify the third distinct maximum number from the given list of integers. If there aren't three distinct maximum numbers, we'll return the highest number in the list.

Explanation

First, note that we need to account for possible duplicate values in the list, which may affect our counting of distinct maximum values. For instance, in the second example, removing the maximum twice when there's a duplicate would yield a different "second maximum" than if we had distinct numbers. Here's a step-by-step breakdown of the approach to solving this:

Handle Edge Cases :

If the list contains fewer than three distinct numbers, return the maximum number.

Remove Duplicates :

To ensure we're only dealing with distinct numbers, convert the list into a set.

Find the Maximums :

Identify and remove the largest number from the set.
Repeat to find and remove the second largest number.
The third largest in the modified set will be the third distinct maximum.

Return the Result :

If there are fewer than three distinct values after processing, return the highest value.

Step-by-Step Explanation/Detailed Steps in Pseudocode

Initial Set Conversion :

Convert the list of numbers into a set to remove any duplicates.

Check Set Length :

If the length of the set is less than 3, return the maximum value in this set.

Iteratively Remove Maximums :

Remove the maximum value from the set.
Remove the next maximum value from the modified set.

Return the Result :

The next maximum value in the set will be the third maximum.

Pseudocode

                                            
# Convert list to set to eliminate duplicates
unique_numbers = set(nums)

# Check if we have fewer than 3 distinct values
if length of unique_numbers < 3:
# If true, return the maximum value in the set
return the maximum value from unique_numbers

# Remove the first maximum value
remove the maximum value from unique_numbers

# Remove the second maximum value
remove the maximum value from the modified unique_numbers

# The next maximum will be the third distinct maximum
return the maximum value from the modified unique_numbers

Step-by-step representation using the pseudocode provided to ensure every detail is clear:

Convert List to Set

                                            
# Create a set from the list of numbers
unique_numbers = set(nums)  # This removes duplicates

Check Length of Set

                                            
# Check if there are fewer than 3 distinct numbers
if len(unique_numbers) < 3:
# Return the maximum if true
return max(unique_numbers)

Remove Maximums to Find Third Maximum

                                            
# Remove the first maximum value
max_value_1 = max(unique_numbers)
unique_numbers.remove(max_value_1)

# Remove the second maximum value
max_value_2 = max(unique_numbers)
unique_numbers.remove(max_value_2)

# The remaining maximum value is the third distinct maximum
third_max = max(unique_numbers)
return third_max

In the scope of solving this issue, edge cases and specific constraints of the problem (like empty lists or non-integer values) do not need to be handled explicitly due to the problem constraints. Each step ensures that we are dealing with the unique values and appropriately modifying the dataset to get the desiëd result. This approach ensures that the solution is both time efficient and understandable, following the problem requirements strictly.