排排坐,分糖果。
我们买了一些糖果 candies,打算把它们分给排好队的 n = num_people 个小朋友。
给第一个小朋友 1 颗糖果,第二个小朋友 2 颗,依此类推,直到给最后一个小朋友 n 颗糖果。
然后,我们再回到队伍的起点,给第一个小朋友 n + 1 颗糖果,第二个小朋友 n + 2 颗,依此类推,直到给最后一个小朋友 2 * n 颗糖果。
重复上述过程(每次都比上一次多给出一颗糖果,当到达队伍终点后再次从队伍起点开始),直到我们分完所有的糖果。注意,就算我们手中的剩下糖果数不够(不比前一次发出的糖果多),这些糖果也会全部发给当前的小朋友。
返回一个长度为 num_people、元素之和为 candies 的数组,以表示糖果的最终分发情况(即 ans[i] 表示第 i 个小朋友分到的糖果数)。
示例 1:
输入:candies = 7, num_people = 4
输出:[1,2,3,1]
解释:
第一次,ans[0] += 1,数组变为 [1,0,0,0]。
第二次,ans[1] += 2,数组变为 [1,2,0,0]。
第三次,ans[2] += 3,数组变为 [1,2,3,0]。
第四次,ans[3] += 1(因为此时只剩下 1 颗糖果),最终数组变为 [1,2,3,1]。
示例 2:
输入:candies = 10, num_people = 3
输出:[5,2,3]
解释:
第一次,ans[0] += 1,数组变为 [1,0,0]。
第二次,ans[1] += 2,数组变为 [1,2,0]。
第三次,ans[2] += 3,数组变为 [1,2,3]。
第四次,ans[0] += 4,最终数组变为 [5,2,3]。
提示:
1 <= candies <= 10^9
1 <= num_people <= 1000
object Solution {
def distributeCandies(k: Int, N: Int): Array[Int] = {
val ans = Array.fill(N)(0)
def f(i:Int, amount:Int, acc:Int):Unit = amount match {
case x if x <= acc => ans(i) += x
case _ => ans(i) += acc; f((i+1) % N, amount - acc, acc + 1)
}
f(0,k,1)
ans
}
}
在一棵无限的二叉树上,每个节点都有两个子节点,树中的节点 逐行 依次按 “之” 字形进行标记。
如下图所示,在奇数行(即,第一行、第三行、第五行……)中,按从左到右的顺序进行标记;
而偶数行(即,第二行、第四行、第六行……)中,按从右到左的顺序进行标记。
给你树上某一个节点的标号 label,请你返回从根节点到该标号为 label 节点的路径,该路径是由途经的节点标号所组成的。
示例 1:
输入:label = 14
输出:[1,3,4,14]
示例 2:
输入:label = 26
输出:[1,2,6,10,26]
提示:
1 <= label <= 10^6
object Solution {
def pathInZigZagTree(label: Int): List[Int] = {
def pow2(x:Int):Int = Math.pow(2,x).toInt
def g(x:Int, i:Int):Int = i % 2 match {
// use Math to solve
// i-th layer: 2^(i-1), 2^i -1
// first a0 = 2^i -1 , d = -1, a0+n*d = x => n = a0 - x
case 0 => (pow2(i)-1 - x) / 2 + pow2(i-2)
// first a0 = 2^(i-1), d = 1, a0 + n = x => n = x - a0
case 1 => pow2(i-1) - 1 - (x - pow2(i-1))/2
}
def log2(x:Int, acc:Int = 0):Int = x match {
case 0 => acc
case _ => log2(x / 2, acc + 1)
}
def f(x:Int, acc:List[Int]):List[Int] = x match {
case 1 => 1::acc
case _ => f(g(x, log2(x)),x::acc)
}
f(label,Nil)
}
}
附近的家居城促销,你买回了一直心仪的可调节书架,打算把自己的书都整理到新的书架上。
你把要摆放的书 books 都整理好,叠成一摞:从上往下,第 i 本书的厚度为 books[i][0],高度为 books[i][1]。
按顺序 将这些书摆放到总宽度为 shelf_width 的书架上。
先选几本书放在书架上(它们的厚度之和小于等于书架的宽度 shelf_width),然后再建一层书架。重复这个过程,直到把所有的书都放在书架上。
需要注意的是,在上述过程的每个步骤中,摆放书的顺序与你整理好的顺序相同。 例如,如果这里有 5 本书,那么可能的一种摆放情况是:第一和第二本书放在第一层书架上,第三本书放在第二层书架上,第四和第五本书放在最后一层书架上。
每一层所摆放的书的最大高度就是这一层书架的层高,书架整体的高度为各层高之和。
以这种方式布置书架,返回书架整体可能的最小高度。
示例:
输入:books = [[1,1],[2,3],[2,3],[1,1],[1,1],[1,1],[1,2]], shelf_width = 4
输出:6
解释:
3 层书架的高度和为 1 + 3 + 2 = 6 。
第 2 本书不必放在第一层书架上。
提示:
1 <= books.length <= 1000
1 <= books[i][0] <= shelf_width <= 1000
1 <= books[i][1] <= 1000
object Solution {
def minHeightShelves(A: Array[Array[Int]], w: Int): Int = {
val dp = Array.fill(A.length+1)(Int.MaxValue)
dp(0) = 0
for{i <- 0 until A.length}{
var width = 0
var height = 0
for{j <- i until A.length}{
width+= A(j)(0)
height = height max A(j)(1)
if(width <= w)
dp(j+1) = dp(j+1) min (dp(i)+ height)
}
}
dp.last
}
}
给你一个以字符串形式表述的 布尔表达式(boolean) expression,返回该式的运算结果。
有效的表达式需遵循以下约定:
“t”,运算结果为 True
“f”,运算结果为 False
“!(expr)”,运算过程为对内部表达式 expr 进行逻辑 非的运算(NOT)
“&(expr1,expr2,…)”,运算过程为对 2 个或以上内部表达式 expr1, expr2, … 进行逻辑 与的运算(AND)
“|(expr1,expr2,…)”,运算过程为对 2 个或以上内部表达式 expr1, expr2, … 进行逻辑 或的运算(OR)
示例 1:
输入:expression = “!(f)”
输出:true
示例 2:
输入:expression = “|(f,t)”
输出:true
示例 3:
输入:expression = “&(t,f)”
输出:false
示例 4:
输入:expression = “|(&(t,f,t),!(t))”
输出:false
提示:
1 <= expression.length <= 20000
expression[i] 由 {’(’, ‘)’, ‘&’, ‘|’, ‘!’, ‘t’, ‘f’, ‘,’} 中的字符组成。
expression 是以上述形式给出的有效表达式,表示一个布尔值。
object Solution {
case class Expr(x:Boolean, op:String, flag:Boolean)
def parseBoolExpr(expression: String): Boolean = {
def solve(l:List[Expr]):List[Expr] = {
var nl = l
var acc = List.empty[Expr]
while(!nl.head.flag){
acc ::= nl.head
nl = nl.tail
}
nl.head.op match {
case "Or" => Expr(acc.map(_.x).reduce(_|_),"",false)::nl.tail
case "And" => Expr(acc.map(_.x).reduce(_&&_),"",false)::nl.tail
case "Not" => Expr(!acc.head.x, "",false)::nl.tail
}
}
def f(l:List[Char], stack:List[Expr]):Boolean = l match {
case ','::t => f(t, stack)
case '|'::t => f(t, Expr(true, "Or", true)::stack)
case '!'::t => f(t, Expr(true, "Not", true)::stack)
case '&'::t => f(t, Expr(true, "And", true)::stack)
case '('::t => f(t, stack)
case ')'::t => f(t, solve(stack))
case 'f'::t => f(t, Expr(false, "", false)::stack)
case 't'::t => f(t, Expr(true, "", false)::stack)
case h::t => f(t,stack)
case Nil => stack.head.x
}
f(expression.toList,Nil)
}
}```