with t as(
    select t1.name,t1.category,t1.product_id,sum(t2.quantity) as total_sales
    from products t1
    left join orders t2
    on t1.product_id=t2.product_id
    
    group by t1.name,t1.category,t1.product_id
    
),
tt as( select name,total_sales,category,product_id,
rank()over(partition by category order by total_sales desc,product_id) as category_rank
from t
where total_sales is not null
order by category
)
select name as product_name,total_sales,category_rank
from tt

select t1.post,round(avg(timestampdiff(minute,t2.first_clockin,t2.last_clockin)/60),3) as work_hours
from staff_tb as t1
left join attendent_tb t2
on t1.staff_id=t2.staff_id
where t2.first_clockin is not null
group by t1.post
order by work_hours desc

public class Solution {
    public int solve (String nums) {
        return back(nums.toCharArray(), 0);
    }
    // 递归函数
    public int back(char[] nums, int start){
        //当start走到终点时，证明已经解码完毕，直接返回1
        if(start == nums.length){
            return 1;
        }    
        //当字符为0的时候，0没对应的解码，所以直接返回0 (此路解码废掉)
        if(nums[start] == '0')
            return 0;
        //每次解码一个字符
        int res1 = back(nums,start+1);
        int res2 = 0;

        //如果当前字符等于1 或者 当前字符加上下一个字符合起来小于等于26 则可以一次解码两个字符
        if((start < nums.length-1) && (nums[start] == '1' || (nums[start] == '2' &&nums[start+1] <= '6'))){
            res2 = back(nums,start+2);
        }
        //返回结果
        return res1 + res2;
    }
}

import java.util.Arrays;

public class Solution {
    public int minMoney(int[] arr, int aim) {
        if (aim == 0) return 0;
        if (arr == null || arr.length == 0) return -1;

        int[] dp = new int[aim + 1];
        Arrays.fill(dp, aim + 1);  // 初始化为一个不可能的大值
        dp[0] = 0;  // 金额为0时需要0张货币

        for (int coin : arr) {
            if (coin <= aim) {
                dp[coin] = 1;  // 金额为coin时只需1张
            }
        }

        for (int i = 1; i <= aim; i++) {
            for (int coin : arr) {
                if (i - coin >= 0 && dp[i - coin] != aim + 1) {
                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
                }
            }
        }

        return dp[aim] == aim + 1 ? -1 : dp[aim];
    }
}