[Swift]LeetCode767. 重构字符串 | Reorganize String

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10534876.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a string S, check if the letters can be rearranged so that two characters that are adjacent to each other are not the same.

If possible, output any possible result.  If not possible, return the empty string.

Example 1:

Input: S = "aab"
Output: "aba"

Example 2:

Input: S = "aaab"
Output: ""

Note:

• S will consist of lowercase letters and have length in range [1, 500].

---

给定一个字符串S，检查是否能重新排布其中的字母，使得两相邻的字符不同。

若可行，输出任意可行的结果。若不可行，返回空字符串。

示例 1:

输入: S = "aab"
输出: "aba"

示例 2:

输入: S = "aaab"
输出: ""

注意:

• S 只包含小写字母并且长度在[1, 500]区间内。

---

Runtime: 12 ms

Memory Usage: 20.2 MB

class Solution {
    func reorganizeString(_ S: String) -> String {
        var n:Int = S.count
        var idx:Int = 1
        var cnt:[Int] = [Int](repeating:0,count:26)
        var arrChar:[Character] = Array(S)
        for char in S.characters
        {
            cnt[char.ascii - 97] += 100
        }
        for i in 0..<26
        {
            cnt[i] += i
        }
        cnt.sort()
        for num in cnt
        {
            var t:Int = num / 100
            var ch:Character = (97 + (num % 100)).ASCII
            if t > (n + 1) / 2 {return String()}
            for i in 0..<t
            {
                if idx >= n {idx = 0}
                arrChar[idx] = ch
                idx += 2
            }            
        }
        return String(arrChar)
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }    
}

//Int扩展
extension Int
{
    //Int转Character,ASCII值(定义大写为字符值)
    var ASCII:Character 
    {
        get {return Character(UnicodeScalar(self)!)}
    }
}

---

12ms

class Solution {
    func reorganizeString(_ s: String) -> String {
      let n = s.count
      var counts = [Int](repeating: 0, count: 26)
      for character in s {
        let index: Int = Int(character.unicodeScalars.first!.value - "a".unicodeScalars.first!.value)
        counts[index] += 100
      }
      for i in 0..<counts.count {
        counts[i] += i
      }
      counts = counts.sorted(by: >)

      var output = [Character](repeating: " ", count:n)
      var j = 0
      for code in counts {
        let count = code / 100
        let charValue = Int("a".unicodeScalars.first!.value) + (code % 100)
        let unicode = UnicodeScalar(charValue)!
        let char = Character(unicode)
        guard count <= (n + 1) / 2 else {
          return ""
        }

        for i in 0..<count {
          if (j >= n) {
            j = 1
          }
          output[j] = char
          j += 2
        }
      }

      return String(output)
    }
}

---

16ms

class Solution {
    func reorganizeString(_ S: String) -> String {
        var s = Array(S.utf8)
        var counts = [Int](repeating: 0, count: 26)
        for u in s {
            counts[Int(u) - 97] += 1
        }
        var res = [Character]()
        var lastIndex = -1
        while res.count != s.count {
            guard let index = maxIndex(counts, lastIndex) else { 
                return "" 
            }
            counts[index] -= 1
            lastIndex = index
            res.append(Character(UnicodeScalar(index + 97)!))
        }
        return String(res)
    }
    
    private func maxIndex(_ counts: [Int], _ notIndex: Int) -> Int? {
        var maxC = 0
        var retVal = -1
        for i in 0..<26 {
            if i != notIndex && counts[i] > maxC {
                retVal = i
                maxC = counts[i]
            }   
        }
        return retVal == -1 ? nil : retVal
    }
}

---

24ms

class Solution {
    func reorganizeString(_ string: String) -> String {
        
        // we only care about the character counts, and not how the string is constructed
        let characterToCount = string.reduce(into: [:], { $0[$1, default: 0] += 1 })
        
        var maxHeap = Heap<(character: Character, count: Int)>(
            array: characterToCount.map { $0 },
            sort: { $0.count > $1.count })
        
        var newString = ""
        
        while let maxPair = maxHeap.remove() {
            
            // we can use the maxPair `character`
            if newString.last != maxPair.character {
                
                newString.append(maxPair.character)
                
                if maxPair.count > 1 {
                    maxHeap.insert((maxPair.character, maxPair.count-1))
                }
            } else if let nextMaxPair = maxHeap.remove() {
                
                newString.append(nextMaxPair.character)
                
                if nextMaxPair.count > 1 {
                    maxHeap.insert((nextMaxPair.character, nextMaxPair.count-1))
                }
                maxHeap.insert(maxPair)
            } else {
                return "" // we can't find any character to place in next
            }
        }
        
        return newString
    }
}

public struct Heap<T> {
    var elements = [T]()
    fileprivate var isOrderedBefore: (T, T) -> Bool
    public init(sort: @escaping (T, T) -> Bool) {
        self.isOrderedBefore = sort
    }
    public init(array: [T], sort: @escaping (T, T) -> Bool) {
        self.isOrderedBefore = sort
        buildHeap(fromArray: array)
    }
    fileprivate mutating func buildHeap(fromArray array: [T]) {
        elements = array
        for i in stride(from: (elements.count/2 - 1), through: 0, by: -1) {
            shiftDown(i, heapSize: elements.count)
        }
    }
    public var isEmpty: Bool {
        return elements.isEmpty
    }

    public var count: Int {
        return elements.count
    }
    @inline(__always) func parentIndex(ofIndex i: Int) -> Int {
        return (i - 1) / 2
    }
    @inline(__always) func leftChildIndex(ofIndex i: Int) -> Int {
        return 2*i + 1
    }
    @inline(__always) func rightChildIndex(ofIndex i: Int) -> Int {
        return 2*i + 2
    }
    public func peek() -> T? {
        return elements.first
    }
    public mutating func insert(_ value: T) {
        elements.append(value)
        shiftUp(elements.count - 1)
    }
    public mutating func insert<S: Sequence>(_ sequence: S) where S.Iterator.Element == T {
        for value in sequence {
            insert(value)
        }
    }
    public mutating func replace(index i: Int, value: T) {
        guard i < elements.count else { return }

        assert(isOrderedBefore(value, elements[i]))
        elements[i] = value
        shiftUp(i)
    }
    @discardableResult public mutating func remove() -> T? {
        if elements.isEmpty {
            return nil
        } else if elements.count == 1 {
            return elements.removeLast()
        } else {
            // Use the last node to replace the first one, then fix the heap by
            // shifting this new first node into its proper position.
            let value = elements[0]
            elements[0] = elements.removeLast()
            shiftDown()
            return value
        }
    }
    public mutating func removeAt(_ index: Int) -> T? {
        guard index < elements.count else { return nil }

        let size = elements.count - 1
        if index != size {
            elements.swapAt(index, size)
            // swap(&elements[index], &elements[size])
            shiftDown(index, heapSize: size)
            shiftUp(index)
        }
        return elements.removeLast()
    }
    mutating func shiftUp(_ index: Int) {
        var childIndex = index
        let child = elements[childIndex]
        var parentIndex = self.parentIndex(ofIndex: childIndex)

        while childIndex > 0 && isOrderedBefore(child, elements[parentIndex]) {
            elements[childIndex] = elements[parentIndex]
            childIndex = parentIndex
            parentIndex = self.parentIndex(ofIndex: childIndex)
        }

        elements[childIndex] = child
    }
    mutating func shiftDown() {
        shiftDown(0, heapSize: elements.count)
    }
    mutating func shiftDown(_ index: Int, heapSize: Int) {
        var parentIndex = index

        while true {
            let leftChildIndex = self.leftChildIndex(ofIndex: parentIndex)
            let rightChildIndex = leftChildIndex + 1
            var first = parentIndex
            if leftChildIndex < heapSize && isOrderedBefore(elements[leftChildIndex], elements[first]) {
                first = leftChildIndex
            }
            if rightChildIndex < heapSize && isOrderedBefore(elements[rightChildIndex], elements[first]) {
                first = rightChildIndex
            }
            if first == parentIndex { return }

            elements.swapAt(parentIndex, first)
            // swap(&elements[parentIndex], &elements[first])
            parentIndex = first
        }
    }
}
extension Heap where T: Equatable {
    public func index(of element: T) -> Int? {
        return index(of: element, 0)
    }
    fileprivate func index(of element: T, _ i: Int) -> Int? {
        if i >= count { return nil }
        if isOrderedBefore(element, elements[i]) { return nil }
        if element == elements[i] { return i }
        if let j = index(of: element, self.leftChildIndex(ofIndex: i)) { return j }
        if let j = index(of: element, self.rightChildIndex(ofIndex: i)) { return j }
        return nil
    }
}

---

36ms

class Solution {
    func reorganizeString(_ S: String) -> String {
        var mapy = [Character: Int]()
        for c in S {
            mapy[c, default: 0] += 1
        }
        let heap = Heap<(Character, Int)>(elements: mapy.map { ($0.0,$0.1) }, priority: {
            return $0.1 > $1.1  
        })
        var arr = [Character]()
        while heap.isEmpty == false {
            var top = heap.dequeue()!
            if arr.last == top.0 {
                if var second = heap.dequeue() {
                    arr.append(second.0)
                    second.1 -= 1
                    if top.1 > 0 {
                        heap.enqueue(top)
                    }
                    if second.1 > 0 {
                        heap.enqueue(second)
                    }
                } else {
                    return ""
                }
            } else {
                arr.append(top.0)
                top.1 -= 1
                if top.1 > 0 {
                    heap.enqueue(top)
                }
            }
        }
        return String(arr)
    }
}

final class Heap<T> {

    typealias Comparator = (T,T) -> Bool

    var elements: [T]
    let priority: Comparator

    init(elements: [T], priority: @escaping Comparator) {
        self.priority = priority
        self.elements = elements
        if elements.isEmpty == false {
            for i in stride(from: (count / 2) - 1, to: -1, by: -1) {
                siftDown(i)
            }
        }
    }

    var isEmpty: Bool {
        return elements.isEmpty
    }

    var count: Int {
        return elements.count
    }

    var first: T? {
        return elements.first
    }

    func leftChildIndex(of index: Int) -> Int {
        return (2 * index) + 1
    }

    func rightChild(of index: Int) -> Int {
        return (2 * index) + 2
    }

    func parentIndex(of index: Int) -> Int {
        return (index - 1) / 2
    }

    func isHigherPriority(_ a: Int, _ b: Int) -> Bool {
        return priority(elements[a], elements[b])
    }

    func highestPriorityIndex(of index: Int) -> Int {
        let left = highestPriorityIndex(of: index, and: leftChildIndex(of: index))
        let right = highestPriorityIndex(of: index, and: rightChild(of: index))
        return highestPriorityIndex(of: left, and: right)
    }

    func highestPriorityIndex(of parent: Int, and child: Int) -> Int {
        guard child < count else {
            return parent
        }
        guard isHigherPriority(child, parent) else {
            return parent
        }
        return child
    }

    func enqueue(_ element: T) {
        elements.append(element)
        siftUp(count - 1)
    }

    func siftUp(_ i: Int) {
        let parent = parentIndex(of: i)
        guard parent >= 0 else {
            return
        }
        guard isHigherPriority(i, parent) else {
            return
        }
        swap(i, parent)
        siftUp(parent)
    }

    func dequeue() -> T? {
        guard count > 0 else {
            return nil
        }
        return remove(at: 0)
    }

    func remove(at i: Int) -> T? {
        swap(i, count - 1)
        let element = elements.popLast()
        siftDown(i)
        return element
    }

    fileprivate func swap(_ i: Int, _ j: Int) {
        (elements[i], elements[j]) = (elements[j], elements[i])
    }

    func siftDown(_ i: Int) {
        let indexToSwap = highestPriorityIndex(of: i)
        guard indexToSwap != i else {
            return
        }
        swap(indexToSwap, i)
        siftDown(indexToSwap)
    }
}

---

40ms

class Solution {
    func reorganizeString(_ S: String) -> String {
        var countByChar = [Character:Int]()
        for c in Array(S) {
            countByChar[c, default:0] += 1
        }
        var chars = countByChar.keys.sorted { 
            return countByChar[$0]! > countByChar[$1]!
        }
        var t = 0
        var result = Array(repeating: Character("~"), count: S.count)
        for c in chars {
            for _ in 0..<countByChar[c]! {
                if countByChar[c]! > (S.count + 1) / 2 {
                    return ""
                }
                if t >= S.count {
                    t = 1
                }
                result[t] = c
                t += 2
            }
        }
        
        return String(result)
    }
}

---

48ms

class Solution {
    func reorganizeString(_ S: String) -> String {
        typealias Pair = (key: Character, value: Int)
        let s = S
        if s.count < 1 { return "" }
        var dict = [Character: Int]()
        // var heap = Heap<Pair> { $0.value > $1.value }
        var sorted = [Pair]()
        var queue = [Pair]()
        var result = ""

        for c in s {
            dict[c] = (dict[c] ?? 0) + 1
        }

        // dict.forEach {
        //     heap.add($0)
        // }
        sorted = dict.sorted { $0.value > $1.value }.map { $0 }

        while sorted.count > 0 {
            let top = sorted.removeFirst()
            result += String(top.key)

            let count = top.value - 1
            queue.append((top.key, count))

            if queue.count > 1 {
                let first = queue.removeFirst()
                if first.value > 0 {
                    sorted.append(first)
                    sorted = sorted.sorted { $0.value > $1.value }
                }
            }
        }

        if result.count != s.count {
            return ""
        }

        return result
    }
}

---

56ms

class Solution {    
    func reorganizeString(_ S: String) -> String {
        var countByChar = Dictionary<Character, Int>(minimumCapacity:26)
        for c in Array(S) {
            countByChar[c, default:0] += 1
        }
        var chars = countByChar.keys.sorted { 
            return countByChar[$0]! > countByChar[$1]!
        }
        var t = 0
        var result = Array(repeating: Character("~"), count: S.count)
        for c in chars {
            for _ in 0..<countByChar[c]! {
                if countByChar[c]! > (S.count + 1) / 2 {
                    return ""
                }
                if t >= S.count {
                    t = 1
                }
                result[t] = c
                t += 2
            }
        }
        
        return String(result)
    }
}

---

68ms

import Foundation

public struct Heap<T> {
    
    /** The array that stores the heap's nodes. */
    var nodes = [T]()
    
    /**
     * Determines how to compare two nodes in the heap.
     * Use '>' for a max-heap or '<' for a min-heap,
     * or provide a comparing method if the heap is made
     * of custom elements, for example tuples.
     */
    private var orderCriteria: (T, T) -> Bool
    
    /**
     * Creates an empty heap.
     * The sort function determines whether this is a min-heap or max-heap.
     * For comparable data types, > makes a max-heap, < makes a min-heap.
     */
    public init(sort: @escaping (T, T) -> Bool) {
        self.orderCriteria = sort
    }
    
    /**
     * Creates a heap from an array. The order of the array does not matter;
     * the elements are inserted into the heap in the order determined by the
     * sort function. For comparable data types, '>' makes a max-heap,
     * '<' makes a min-heap.
     */
    public init(array: [T], sort: @escaping (T, T) -> Bool) {
        self.orderCriteria = sort
        configureHeap(from: array)
    }
    
    /**
     * Configures the max-heap or min-heap from an array, in a bottom-up manner.
     * Performance: This runs pretty much in O(n).
     */
    private mutating func configureHeap(from array: [T]) {
        nodes = array
        for i in stride(from: (nodes.count/2-1), through: 0, by: -1) {
            shiftDown(i)
        }
    }
    
    public var isEmpty: Bool {
        return nodes.isEmpty
    }
    
    public var count: Int {
        return nodes.count
    }
    
    /**
     * Returns the index of the parent of the element at index i.
     * The element at index 0 is the root of the tree and has no parent.
     */
    @inline(__always) internal func parentIndex(ofIndex i: Int) -> Int {
        return (i - 1) / 2
    }
    
    /**
     * Returns the index of the left child of the element at index i.
     * Note that this index can be greater than the heap size, in which case
     * there is no left child.
     */
    @inline(__always) internal func leftChildIndex(ofIndex i: Int) -> Int {
        return 2*i + 1
    }
    
    /**
     * Returns the index of the right child of the element at index i.
     * Note that this index can be greater than the heap size, in which case
     * there is no right child.
     */
    @inline(__always) internal func rightChildIndex(ofIndex i: Int) -> Int {
        return 2*i + 2
    }
    
    /**
     * Returns the maximum value in the heap (for a max-heap) or the minimum
     * value (for a min-heap).
     */
    public func peek() -> T? {
        return nodes.first
    }
    
    /**
     * Adds a new value to the heap. This reorders the heap so that the max-heap
     * or min-heap property still holds. Performance: O(log n).
     */
    public mutating func insert(_ value: T) {
        nodes.append(value)
        shiftUp(nodes.count - 1)
    }
    
    /**
     * Adds a sequence of values to the heap. This reorders the heap so that
     * the max-heap or min-heap property still holds. Performance: O(log n).
     */
    public mutating func insert<S: Sequence>(_ sequence: S) where S.Iterator.Element == T {
        for value in sequence {
            insert(value)
        }
    }
    
    /**
     * Allows you to change an element. This reorders the heap so that
     * the max-heap or min-heap property still holds.
     */
    public mutating func replace(index i: Int, value: T) {
        guard i < nodes.count else { return }
        
        remove(at: i)
        insert(value)
    }
    
    /**
     * Removes the root node from the heap. For a max-heap, this is the maximum
     * value; for a min-heap it is the minimum value. Performance: O(log n).
     */
    @discardableResult public mutating func remove() -> T? {
        guard !nodes.isEmpty else { return nil }
        
        if nodes.count == 1 {
            return nodes.removeLast()
        } else {
            // Use the last node to replace the first one, then fix the heap by
            // shifting this new first node into its proper position.
            let value = nodes[0]
            nodes[0] = nodes.removeLast()
            shiftDown(0)
            return value
        }
    }
    
    /**
     * Removes an arbitrary node from the heap. Performance: O(log n).
     * Note that you need to know the node's index.
     */
    @discardableResult public mutating func remove(at index: Int) -> T? {
        guard index < nodes.count else { return nil }
        
        let size = nodes.count - 1
        if index != size {
            nodes.swapAt(index, size)
            shiftDown(from: index, until: size)
            shiftUp(index)
        }
        return nodes.removeLast()
    }
    
    /**
     * Takes a child node and looks at its parents; if a parent is not larger
     * (max-heap) or not smaller (min-heap) than the child, we exchange them.
     */
    internal mutating func shiftUp(_ index: Int) {
        var childIndex = index
        let child = nodes[childIndex]
        var parentIndex = self.parentIndex(ofIndex: childIndex)
        
        while childIndex > 0 && orderCriteria(child, nodes[parentIndex]) {
            nodes[childIndex] = nodes[parentIndex]
            childIndex = parentIndex
            parentIndex = self.parentIndex(ofIndex: childIndex)
        }
        
        nodes[childIndex] = child
    }
    
    /**
     * Looks at a parent node and makes sure it is still larger (max-heap) or
     * smaller (min-heap) than its childeren.
     */
    internal mutating func shiftDown(from index: Int, until endIndex: Int) {
        let leftChildIndex = self.leftChildIndex(ofIndex: index)
        let rightChildIndex = leftChildIndex + 1
        
        // Figure out which comes first if we order them by the sort function:
        // the parent, the left child, or the right child. If the parent comes
        // first, we're done. If not, that element is out-of-place and we make
        // it "float down" the tree until the heap property is restored.
        var first = index
        if leftChildIndex < endIndex && orderCriteria(nodes[leftChildIndex], nodes[first]) {
            first = leftChildIndex
        }
        if rightChildIndex < endIndex && orderCriteria(nodes[rightChildIndex], nodes[first]) {
            first = rightChildIndex
        }
        if first == index { return }
        
        nodes.swapAt(index, first)
        shiftDown(from: first, until: endIndex)
    }
    
    internal mutating func shiftDown(_ index: Int) {
        shiftDown(from: index, until: nodes.count)
    }
    
}

extension Heap where T: Equatable {
    
    /** Get the index of a node in the heap. Performance: O(n). */
    public func index(of node: T) -> Int? {
        return nodes.index(where: { $0 == node })
    }
    
    /** Removes the first occurrence of a node from the heap. Performance: O(n log n). */
    @discardableResult public mutating func remove(node: T) -> T? {
        if let index = index(of: node) {
            return remove(at: index)
        }
        return nil
    }
    
}

/*
 Priority Queue, a queue where the most "important" items are at the front of
 the queue.
 The heap is a natural data structure for a priority queue, so this object
 simply wraps the Heap struct.
 All operations are O(lg n).
 Just like a heap can be a max-heap or min-heap, the queue can be a max-priority
 queue (largest element first) or a min-priority queue (smallest element first).
 */
public struct PriorityQueue<T> {
    fileprivate var heap: Heap<T>
    
    /*
     To create a max-priority queue, supply a > sort function. For a min-priority
     queue, use <.
     */
    public init(sort: @escaping (T, T) -> Bool) {
        heap = Heap(sort: sort)
    }
    
    public var isEmpty: Bool {
        return heap.isEmpty
    }
    
    public var count: Int {
        return heap.count
    }
    
    public func peek() -> T? {
        return heap.peek()
    }
    
    public mutating func enqueue(_ element: T) {
        heap.insert(element)
    }
    
    public mutating func dequeue() -> T? {
        return heap.remove()
    }
    
    /*
     Allows you to change the priority of an element. In a max-priority queue,
     the new priority should be larger than the old one; in a min-priority queue
     it should be smaller.
     */
    public mutating func changePriority(index i: Int, value: T) {
        return heap.replace(index: i, value: value)
    }
}

extension PriorityQueue where T: Equatable {
    public func index(of element: T) -> Int? {
        return heap.index(of: element)
    }
    
    public mutating func dequeue(element: T) -> T? {
        guard peek() != nil else { return nil }
        let indexToDequeue = index(of: element)!
        changePriority(index: indexToDequeue, value: peek()!)
        return dequeue()
    }
}

class Solution {
    func reorganizeString(_ S: String) -> String {
        guard S.count != 0 else { return "" }

        // Store char frequency pair into map
        var map = [Character: Int]()

        for character in S {
            map[character] = (map[character] ?? 0) + 1
        }

        // push all map entry into priority element, by sorting from high frequency to low frequency. Max Priority queue where highest frequeny elements are first
        var pq = PriorityQueue<(Character, Int)> { (a, b) -> Bool in
            return a.1 > b.1
        }
        for (key, value) in map {
            pq.enqueue((key, value))
        }

        var result = ""

        while !pq.isEmpty {
            // store character with the highest frequency in cache
            var cache = pq.dequeue()!
            let resultsArray = Array(result)
            
            // if character in cache is different from tail character in current string
            if result.count == 0 || cache.0 != resultsArray.last {
                result.append(cache.0)
                cache.1 -= 1

                // if the current character still have more frequencies left, push to q
                if cache.1 > 0 {
                    pq.enqueue(cache)
                }
            }
            // if character in cache is same as tail character in current string
            // we need to try the character with second highest frequency
            else {
                var cache2 = pq.dequeue()
                // corner case: if no more elements in queue, the input string should be invalid
                // because we do not have any other characters that different with current string tail
                if cache2 == nil {
                    return ""
                }

                result.append(cache2!.0)
                cache2!.1 -= 1

                // if current character still have mor efrequencies left, push to q
                // if the current character still have more frequencies left, push to q
                if cache2!.1 > 0 {
                    pq.enqueue(cache2!)
                }

                //Push top freqeuncy entry into queue as well
                pq.enqueue(cache)
            }
        }
        return result
    }
}

---

96ms

class Solution {
    func reorganizeString(_ S: String) -> String {
        guard S.count > 2 && S.count <= 500 else {
            return S.count > 0 && S.count <= 2 ? S : ""
        }
        var dict = [Character: Int]()
        for char in Array(S) {
            if let count = dict[char] {
                dict[char] = count + 1
            } else {
                dict[char] = 1
            }
        }
        var sortedCharInfos = dict.sorted {
            $0.1 >= $1.1
        }
        if let firstCharInfo = sortedCharInfos.first, firstCharInfo.1 > (S.count + 1) / 2 {
            return ""
        }
        var result = ""
        func addChar(_ index: Int) {
            guard index < sortedCharInfos.count else {
                return
            }
            let firstCharInfo = sortedCharInfos[index]
            result.append(firstCharInfo.key)
            if sortedCharInfos[index].value == 1 {
                sortedCharInfos.remove(at: index)
            } else {
                sortedCharInfos[index] = (firstCharInfo.key, firstCharInfo.value - 1)
            }
        }
        while !sortedCharInfos.isEmpty {
            if let lastChar = result.last {
                sortedCharInfos.sort {
                    $0.1 >= $1.1
                }
                if lastChar == sortedCharInfos.first!.key {
                    addChar(1)
                } else {
                    addChar(0)
                }
            } else {
                addChar(0)
            }
        }
        return result
    }
}