1429. First Unique Number

public class FirstUnique {
    private LinkedList<int> queue;
    private Dictionary<int, LinkedListNode<int>> map;
    private HashSet<int> duplicates;
    public FirstUnique(int[] nums) {
        queue = new LinkedList<int>();
        map = new Dictionary<int, LinkedListNode<int>>();
        duplicates = new HashSet<int>();
        foreach (var num in nums) {
            Add(num);
        }
    }
    public int ShowFirstUnique() {
        if (queue.Count > 0) {
            return queue.First.Value;
        }
        return -1;
    }
    public void Add(int value) {
        if (duplicates.Contains(value)) {
            return;
        }
        if (map.ContainsKey(value)) {
            queue.Remove(map[value]);
            map.Remove(value);
            duplicates.Add(value);
        } else {
            var node = new LinkedListNode<int>(value);
            queue.AddLast(node);
            map[value] = node;
        }
    }
}

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
public class FirstUnique {
    private LinkedList<int> queue;
    private unordered_map<int, LinkedListNode<int>> map;
    private HashSet<int> duplicates;
    public FirstUnique(vector<int>& nums) {
        queue = new LinkedList<int>();
        map = new unordered_map<int, LinkedListNode<int>>();
        duplicates = new HashSet<int>();
        foreach (var num in nums) {
            Add(num);
        }
    }
    public int ShowFirstUnique() {
        if (queue.size() > 0) {
            return queue.First.Value;
        }
        return -1;
    }
    public void Add(int value) {
        if (duplicates.Contains(value)) {
            return;
        }
        if (map.count(value)) {
            queue.Remove(map[value]);
            map.Remove(value);
            duplicates.push_back(value);
        } else {
            var node = new LinkedListNode<int>(value);
            queue.AddLast(node);
            map[value] = node;
        }
    }
}

class FirstUnique {
  
  private Set<Integer> setQueue = new LinkedHashSet<>();
  private Map<Integer, Boolean> isUnique = new HashMap<>();
  
  public FirstUnique(int[] nums) {
    for (int num : nums) {
      this.add(num);
    }
  }
    
  public int showFirstUnique() {
    if (!setQueue.isEmpty()) {
       return setQueue.iterator().next();
    }
    return -1;
  }
    
  public void add(int value) {
    if (!isUnique.containsKey(value)) {
      isUnique.put(value, true);
      setQueue.add(value);
    } else if (isUnique.get(value)) {
      isUnique.put(value, false);
      setQueue.remove(value);
    }
  }
}

class FirstUnique {
    constructor(nums) {
        this.isUnique = new Map();
        this.queue = new Map();
        for (let num of nums) {
            this.add(num);
        }
    }

    showFirstUnique() {
        for (let [key, value] of this.queue) {
            if (this.isUnique.get(key)) {
                return key;
            }
        }
        return -1;
    }

    add(value) {
        if (!this.isUnique.has(value)) {
            this.isUnique.set(value, true);
            this.queue.set(value, null);
        } else if (this.isUnique.get(value)) {
            this.isUnique.set(value, false);
            this.queue.delete(value);
        }
    }
}

from collections import OrderedDict

class FirstUnique:
    def __init__(self, nums: List[int]):
        self.is_unique = {}
        self.queue = OrderedDict()
        for num in nums:
            self.add(num)

    def showFirstUnique(self) -> int:
        for key in self.queue:
            if self.is_unique[key]:
                return key
        return -1

    def add(self, value: int) -> None:
        if value not in self.is_unique:
            self.is_unique[value] = True
            self.queue[value] = None
        elif self.is_unique[value]:
            self.is_unique[value] = False
            del self.queue[value]

type FirstUnique struct {
    queue    []int
    isUnique map[int]bool
}

func Constructor(nums []int) FirstUnique {
    fu := FirstUnique{
        queue:    []int{},
        isUnique: make(map[int]bool),
    }
    for _, num := range nums {
        fu.Add(num)
    }
    return fu
}

func (fu *FirstUnique) ShowFirstUnique() int {
    for len(fu.queue) > 0 && !fu.isUnique[fu.queue[0]] {
        fu.queue = fu.queue[1:]
    }
    if len(fu.queue) == 0 {
        return -1
    }
    return fu.queue[0]
}

func (fu *FirstUnique) Add(value int) {
    if _, exists := fu.isUnique[value]; !exists {
        fu.isUnique[value] = true
        fu.queue = append(fu.queue, value)
    } else if fu.isUnique[value] {
        fu.isUnique[value] = false
    }
}

Algorithm

Инициализируйте объект FirstUnique с числами в очереди, добавляя их в структуру данных для отслеживания уникальности и порядка.

Метод showFirstUnique возвращает значение первого уникального элемента в очереди, если таковой существует, или -1, если уникальных элементов нет.

Метод add добавляет новое значение в очередь. Если значение уже было добавлено ранее, обновляет его статус уникальности и удаляет его из множества уникальных значений, если оно больше не уникально.

😎