Assign Cookies

                                            
import java.util.Arrays;

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int i = 0;
        for (int j = 0; i < g.length && j < s.length; j++) {
            if (g[i] <= s[j]) {
                i++;
            }
        }
        return i;
    }
}

                                            
class Solution(object):
    def findContentChildren(self, g, s):
        g.sort()
        s.sort()
        i = 0
        j = 0
        while i < len(g) and j < len(s):
            if g[i] <= s[j]:
                i += 1
            j += 1
        return i

                                            
int cmpFunc(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int findContentChildren(int* g, int gSize, int* s, int sSize) {
    int i = 0, j = 0;
    int result = 0;
    
    qsort(g, gSize, sizeof(int), cmpFunc);
    qsort(s, sSize, sizeof(int), cmpFunc);
    
    while (i < gSize && j < sSize) {
        if (g[i] <= s[j]) {
            result++;
            i++;
        }
        j++;
    }
    
    return result;
}

                                            
public class Solution {
    public int FindContentChildren(int[] g, int[] s) 
    {
        Array.Sort(g);
        Array.Sort(s);
        
        int contentChildren = 0;
        int gIndex = 0;
        int sIndex = 0;
        
        while (gIndex < g.Length && sIndex < s.Length) {
            if (s[sIndex] >= g[gIndex]) {
                contentChildren++;
                gIndex++;
                sIndex++;
            } else {
                sIndex++;
            }
        }
        
        return contentChildren;
    }
}

                                            
/**
 * @param {number[]} g
 * @param {number[]} s
 * @return {number}
 */
const findContentChildren = (g, s) => {
    g.sort((a, b) => a - b);
    s.sort((a, b) => a - b);
    
    let i = 0;
    let j = 0;
    let count = 0;
    
    while (i < g.length && j < s.length) {
        if (g[i] <= s[j]) {
            count++;
            i++;
            j++;
        } else {
            j++;
        }
    }
    
    return count;
};

                                            
function findContentChildren(g: number[], s: number[]): number {
    g.sort((a, b) => a - b);
    s.sort((a, b) => a - b);
    
    let i = 0;
    let j = 0;
    let count = 0;
    
    while (i < g.length && j < s.length) {
        if (s[j] >= g[i]) {
            count++;
            i++;
            j++;
        } else {
            j++;
        }
    }
    
    return count;
};

                                            
class Solution {
    /**
     * @param Integer[] $g
     * @param Integer[] $s
     * @return Integer
     */
    function findContentChildren($g, $s) {
         $count = 0;
        sort($g);
        sort($s);
        $i = 0;
        $j = 0;

        while ($i < count($g) && $j < count($s)) {
            if ($g[$i] <= $s[$j]) {
                $count++;
                $i++;
                $j++;
            } else {
                $j++;
            }
        }

        return $count;
    }
}

                                            
class Solution {
    func findContentChildren(_ g: [Int], _ s: [Int]) -> Int {
        var sortedGreedFactors = g.sorted()
        var sortedCookies = s.sorted()
        
        var i = 0
        var j = 0
        var contentChildren = 0
        
        while i < sortedGreedFactors.count && j < sortedCookies.count {
            if sortedCookies[j] >= sortedGreedFactors[i] {
                contentChildren += 1
                i += 1
            }
            j += 1
        }
        
        return contentChildren
    }
}

                                            
class Solution {
    fun findContentChildren(g: IntArray, s: IntArray): Int {
        g.sort()
        s.sort()
        var child = 0
        var cookie = 0
        
        while (child < g.size && cookie < s.size) {
            if (g[child] <= s[cookie]) {
                child++
            }
            cookie++
        }
        
        return child
    }
}

                                            
class Solution {
  int findContentChildren(List<int> g, List<int> s) {
    g.sort();
    s.sort();
    int i = 0;
    int j = 0;
    int count = 0;
    
    while (i < g.length && j < s.length) {
      if (s[j] >= g[i]) {
        count++;
        i++;
      }
      j++;
    }
    
    return count;
  }
}

                                            
func findContentChildren(g []int, s []int) int {
    sort.Ints(g)
    sort.Ints(s)
    
    content := 0
    gIndex := 0
    sIndex := 0
    
    for gIndex < len(g) && sIndex < len(s) {
        if s[sIndex] >= g[gIndex] {
            content++
            gIndex++
        }
        sIndex++
    }
    
    return content
}

                                            
# @param {Integer[]} g
# @param {Integer[]} s
# @return {Integer}
def find_content_children(g, s)
    g.sort!
    s.sort!
    content = 0
    i, j = 0, 0
    while i < g.length && j < s.length
        if s[j] >= g[i]
            content += 1
            i += 1
        end
        j += 1
    end
    return content
end

                                            
object Solution {
    def findContentChildren(g: Array[Int], s: Array[Int]): Int = {
        val sortedG = g.sorted
        val sortedS = s.sorted
        var i = 0
        var j = 0
        var count = 0

        while (i < sortedG.length && j < sortedS.length) {
            if (sortedS(j) >= sortedG(i)) {
                count += 1
                i += 1
            }
            j += 1
        }

        count
    }
}

                                            
impl Solution {
    pub fn find_content_children(g: Vec<i32>, s: Vec<i32>) -> i32 {
        let mut g = g;
        let mut s = s;
        
        g.sort();
        s.sort();
        
        let mut i = 0;
        let mut j = 0;
        let mut count = 0;
        
        while i < g.len() && j < s.len() {
            if s[j] >= g[i] {
                count += 1;
                i += 1;
            }
            j += 1;
        }
        
        count
    }
}

                                            
-spec find_content_children(G :: [integer()], S :: [integer()]) -> integer().
find_content_children(G, S) ->
    greedy_children(lists:sort(G), lists:sort(S), 0).

greedy_children([], _, Count) ->
    Count;
greedy_children(_, [], Count) ->
    Count;
greedy_children([Gh | Gt], [Sh | St], Count) when Sh >= Gh ->
    greedy_children(Gt, St, Count + 1);
greedy_children(G, [_ | St], Count) ->
    greedy_children(G, St, Count).

                                            
class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int content = 0;
        int i = 0;
        int j = 0;
        while (i < g.size() && j < s.size()) {
            if (s[j] >= g[i]) {
                content++;
                i++;
            }
            j++;
        }
        return content;
    }
};

                                            
(define/contract (find-content-children g s)
  (-> (listof exact-integer?) (listof exact-integer?) exact-integer?)
  
  (define sorted-g (sort g <))
  (define sorted-s (sort s <))
  
  (define (helper idx-g idx-s count)
    (cond
      [(or (>= idx-g (length sorted-g)) (>= idx-s (length sorted-s))) count]
      [(>= (list-ref sorted-s idx-s) (list-ref sorted-g idx-g))
       (helper (add1 idx-g) (add1 idx-s) (add1 count))]
      [else
       (helper idx-g (add1 idx-s) count)]
      )
    )
  
  (helper 0 0 0)
  )

To solve this coding challenge, the primary task involves maximizing the number of content children by appropriately distributing the available cookies based on the children's greed factors and the cookie sizes. Let's break this down step-by-step:

# Explanation

Understanding the Inputs and Outputs:

We have two lists:

g[]

which represents the greed factors of the children.
s[]

which represents the sizes of the cookies available.

The goal is to maximize the number of content children, which means each child can only receive one cookie, and the size of the cookie should be at least equal to the child's greed factor.

Sorting Arrays:

To efficiently match the smallest greed factor with the smallest cookie and work upwards, we need to sort both arrays.
Sorting
g[]

will allow us to start with the child who has the smallest greed factor.
Sorting
s[]

will allow us to start with the smallest available cookie.

Two-Pointer Technique:

We'll initialize two pointers, one for each list:

i

for the
g[]

array (greed factors).
j

for the
s[]

array (cookie sizes).

We'll iterate through both arrays to find the optimal assignment of cookies to children:

If the current cookie size (
s[j]

) is greater than or equal to the current greed factor (
g[i]

), we can assign the cookie to the child.
Whether a cookie is assigned or not, we move to the next cookie by incrementing
j

.
If a cookie is assigned (i.e., the child is content), we also move to the next child by incrementing
i

.

Counting Content Children:

The pointer
i

will ultimately represent the count of content children, as it only increments when a child has been successfully assigned a cookie.

Detailed Steps in Pseudocode:

Initialize and Sort:

sort(g)
sort(s)

Initialize two pointers:

i = 0

(for children greed factors)
j = 0

(for cookie sizes)

Iterate through both arrays:

While
i < length of g

and
j < length of s

:

If
g[i]

<=
s[j]

:

Increment
i

(one child is content)

Increment
j

(move to the next cookie)

Return the result:

Return
i

(number of content children)

Full Pseudocode with Comments:

                                            
# Sort both the greed factors and cookie sizes
sort(g)  # Sort the greed factors of children
sort(s)  # Sort the sizes of cookies

# Initialize pointers for both arrays
child_pointer = 0  # Pointer for children greed array
cookie_pointer = 0  # Pointer for cookie sizes array

# Iterate while there are children and cookies to consider
while child_pointer < length(g) and cookie_pointer < length(s):
    # If the current cookie can satisfy the current child's greed
    if g[child_pointer] <= s[cookie_pointer]:
        child_pointer += 1  # Assign cookie to child and move to next child
    
    cookie_pointer += 1  # Move to the next cookie

# The number of content children is equal to the child pointer
return child_pointer  # Return the number of content children

By implementing the steps described above, you can efficiently determine the maximum number of children that can be content with the available cookies. The solution uses sorting and a two-pointer technique to match each child with an appropriate cookie in an optimal manner.