Skip to content

Commit b6cfc29

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.2469, 2471
- No.2469.Convert the Temperature - No.2471.Minimum Number of Operations to Sort a Binary Tree by Level
1 parent 8b23a46 commit b6cfc29

File tree

9 files changed

+371
-0
lines changed

9 files changed

+371
-0
lines changed

‎solution/2400-2499/2469.Convert the Temperature/README.md

+27
Original file line numberDiff line numberDiff line change
@@ -98,7 +98,34 @@ func convertTemperature(celsius float64) []float64 {
9898
### **TypeScript**
9999

100100
```ts
101+
function convertTemperature(celsius: number): number[] {
102+
return [celsius + 273.15, celsius * 1.8 + 32];
103+
}
104+
```
105+
106+
### **Rust**
107+
108+
```rust
109+
impl Solution {
110+
pub fn convert_temperature(celsius: f64) -> Vec<f64> {
111+
vec![celsius + 273.15, celsius * 1.8 + 32.0]
112+
}
113+
}
114+
```
101115

116+
### **C**
117+
118+
```c
119+
/**
120+
* Note: The returned array must be malloced, assume caller calls free().
121+
*/
122+
double *convertTemperature(double celsius, int *returnSize) {
123+
double *ans = malloc(sizeof(double) * 2);
124+
ans[0] = celsius + 273.15;
125+
ans[1] = celsius * 1.8 + 32;
126+
*returnSize = 2;
127+
return ans;
128+
}
102129
```
103130
104131
### **...**

‎solution/2400-2499/2469.Convert the Temperature/README_EN.md

+27
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,34 @@ func convertTemperature(celsius float64) []float64 {
8585
### **TypeScript**
8686

8787
```ts
88+
function convertTemperature(celsius: number): number[] {
89+
return [celsius + 273.15, celsius * 1.8 + 32];
90+
}
91+
```
92+
93+
### **Rust**
94+
95+
```rust
96+
impl Solution {
97+
pub fn convert_temperature(celsius: f64) -> Vec<f64> {
98+
vec![celsius + 273.15, celsius * 1.8 + 32.0]
99+
}
100+
}
101+
```
88102

103+
### **C**
104+
105+
```c
106+
/**
107+
* Note: The returned array must be malloced, assume caller calls free().
108+
*/
109+
double *convertTemperature(double celsius, int *returnSize) {
110+
double *ans = malloc(sizeof(double) * 2);
111+
ans[0] = celsius + 273.15;
112+
ans[1] = celsius * 1.8 + 32;
113+
*returnSize = 2;
114+
return ans;
115+
}
89116
```
90117
91118
### **...**

‎solution/2400-2499/2469.Convert the Temperature/Solution.c

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
/**
2+
* Note: The returned array must be malloced, assume caller calls free().
3+
*/
4+
double *convertTemperature(double celsius, int *returnSize) {
5+
double *ans = malloc(sizeof(double) * 2);
6+
ans[0] = celsius + 273.15;
7+
ans[1] = celsius * 1.8 + 32;
8+
*returnSize = 2;
9+
return ans;
10+
}

‎solution/2400-2499/2469.Convert the Temperature/Solution.rs

+5
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
impl Solution {
2+
pub fn convert_temperature(celsius: f64) -> Vec<f64> {
3+
vec![celsius + 273.15, celsius * 1.8 + 32.0]
4+
}
5+
}

‎solution/2400-2499/2469.Convert the Temperature/Solution.ts

+3
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
function convertTemperature(celsius: number): number[] {
2+
return [celsius + 273.15, celsius * 1.8 + 32];
3+
}

‎solution/2400-2499/2471.Minimum Number of Operations to Sort a Binary Tree by Level/README.md

+101
Original file line numberDiff line numberDiff line change
@@ -293,7 +293,108 @@ func minimumOperations(root *TreeNode) (ans int) {
293293
### **TypeScript**
294294

295295
```ts
296+
/**
297+
* Definition for a binary tree node.
298+
* class TreeNode {
299+
* val: number
300+
* left: TreeNode | null
301+
* right: TreeNode | null
302+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
303+
* this.val = (val===undefined ? 0 : val)
304+
* this.left = (left===undefined ? null : left)
305+
* this.right = (right===undefined ? null : right)
306+
* }
307+
* }
308+
*/
296309

310+
function minimumOperations(root: TreeNode | null): number {
311+
const queue = [root];
312+
let ans = 0;
313+
while (queue.length !== 0) {
314+
const n = queue.length;
315+
const row: number[] = [];
316+
for (let i = 0; i < n; i++) {
317+
const { val, left, right } = queue.shift();
318+
row.push(val);
319+
left && queue.push(left);
320+
right && queue.push(right);
321+
}
322+
for (let i = 0; i < n - 1; i++) {
323+
let minIdx = i;
324+
for (let j = i + 1; j < n; j++) {
325+
if (row[j] < row[minIdx]) {
326+
minIdx = j;
327+
}
328+
}
329+
if (i !== minIdx) {
330+
[row[i], row[minIdx]] = [row[minIdx], row[i]];
331+
ans++;
332+
}
333+
}
334+
}
335+
return ans;
336+
}
337+
```
338+
339+
### **Rust**
340+
341+
```rust
342+
// Definition for a binary tree node.
343+
// #[derive(Debug, PartialEq, Eq)]
344+
// pub struct TreeNode {
345+
// pub val: i32,
346+
// pub left: Option<Rc<RefCell<TreeNode>>>,
347+
// pub right: Option<Rc<RefCell<TreeNode>>>,
348+
// }
349+
//
350+
// impl TreeNode {
351+
// #[inline]
352+
// pub fn new(val: i32) -> Self {
353+
// TreeNode {
354+
// val,
355+
// left: None,
356+
// right: None
357+
// }
358+
// }
359+
// }
360+
use std::rc::Rc;
361+
use std::cell::RefCell;
362+
use std::collections::VecDeque;
363+
impl Solution {
364+
pub fn minimum_operations(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
365+
let mut queue = VecDeque::new();
366+
queue.push_back(root);
367+
let mut ans = 0;
368+
while !queue.is_empty() {
369+
let n = queue.len();
370+
let mut row = Vec::new();
371+
for _ in 0..n {
372+
let mut node = queue.pop_front().unwrap();
373+
let mut node = node.as_mut().unwrap().borrow_mut();
374+
row.push(node.val);
375+
if node.left.is_some() {
376+
queue.push_back(node.left.take());
377+
}
378+
if node.right.is_some() {
379+
queue.push_back(node.right.take());
380+
}
381+
}
382+
for i in 0..n - 1 {
383+
let mut min_idx = i;
384+
for j in i + 1..n {
385+
if row[j] < row[min_idx] {
386+
min_idx = j;
387+
}
388+
}
389+
if i != min_idx {
390+
row.swap(i, min_idx);
391+
ans += 1;
392+
}
393+
}
394+
}
395+
ans
396+
}
397+
}
297398
```
298399

299400
### **...**

‎solution/2400-2499/2471.Minimum Number of Operations to Sort a Binary Tree by Level/README_EN.md

+101
Original file line numberDiff line numberDiff line change
@@ -280,7 +280,108 @@ func minimumOperations(root *TreeNode) (ans int) {
280280
### **TypeScript**
281281

282282
```ts
283+
/**
284+
* Definition for a binary tree node.
285+
* class TreeNode {
286+
* val: number
287+
* left: TreeNode | null
288+
* right: TreeNode | null
289+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
290+
* this.val = (val===undefined ? 0 : val)
291+
* this.left = (left===undefined ? null : left)
292+
* this.right = (right===undefined ? null : right)
293+
* }
294+
* }
295+
*/
296+
297+
function minimumOperations(root: TreeNode | null): number {
298+
const queue = [root];
299+
let ans = 0;
300+
while (queue.length !== 0) {
301+
const n = queue.length;
302+
const row: number[] = [];
303+
for (let i = 0; i < n; i++) {
304+
const { val, left, right } = queue.shift();
305+
row.push(val);
306+
left && queue.push(left);
307+
right && queue.push(right);
308+
}
309+
for (let i = 0; i < n - 1; i++) {
310+
let minIdx = i;
311+
for (let j = i + 1; j < n; j++) {
312+
if (row[j] < row[minIdx]) {
313+
minIdx = j;
314+
}
315+
}
316+
if (i !== minIdx) {
317+
[row[i], row[minIdx]] = [row[minIdx], row[i]];
318+
ans++;
319+
}
320+
}
321+
}
322+
return ans;
323+
}
324+
```
325+
326+
### **Rust**
283327

328+
```rust
329+
// Definition for a binary tree node.
330+
// #[derive(Debug, PartialEq, Eq)]
331+
// pub struct TreeNode {
332+
// pub val: i32,
333+
// pub left: Option<Rc<RefCell<TreeNode>>>,
334+
// pub right: Option<Rc<RefCell<TreeNode>>>,
335+
// }
336+
//
337+
// impl TreeNode {
338+
// #[inline]
339+
// pub fn new(val: i32) -> Self {
340+
// TreeNode {
341+
// val,
342+
// left: None,
343+
// right: None
344+
// }
345+
// }
346+
// }
347+
use std::rc::Rc;
348+
use std::cell::RefCell;
349+
use std::collections::VecDeque;
350+
impl Solution {
351+
pub fn minimum_operations(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
352+
let mut queue = VecDeque::new();
353+
queue.push_back(root);
354+
let mut ans = 0;
355+
while !queue.is_empty() {
356+
let n = queue.len();
357+
let mut row = Vec::new();
358+
for _ in 0..n {
359+
let mut node = queue.pop_front().unwrap();
360+
let mut node = node.as_mut().unwrap().borrow_mut();
361+
row.push(node.val);
362+
if node.left.is_some() {
363+
queue.push_back(node.left.take());
364+
}
365+
if node.right.is_some() {
366+
queue.push_back(node.right.take());
367+
}
368+
}
369+
for i in 0..n - 1 {
370+
let mut min_idx = i;
371+
for j in i + 1..n {
372+
if row[j] < row[min_idx] {
373+
min_idx = j;
374+
}
375+
}
376+
if i != min_idx {
377+
row.swap(i, min_idx);
378+
ans += 1;
379+
}
380+
}
381+
}
382+
ans
383+
}
384+
}
284385
```
285386

286387
### **...**

‎solution/2400-2499/2471.Minimum Number of Operations to Sort a Binary Tree by Level/Solution.rs

+56
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
// Definition for a binary tree node.
2+
// #[derive(Debug, PartialEq, Eq)]
3+
// pub struct TreeNode {
4+
// pub val: i32,
5+
// pub left: Option<Rc<RefCell<TreeNode>>>,
6+
// pub right: Option<Rc<RefCell<TreeNode>>>,
7+
// }
8+
//
9+
// impl TreeNode {
10+
// #[inline]
11+
// pub fn new(val: i32) -> Self {
12+
// TreeNode {
13+
// val,
14+
// left: None,
15+
// right: None
16+
// }
17+
// }
18+
// }
19+
use std::rc::Rc;
20+
use std::cell::RefCell;
21+
use std::collections::VecDeque;
22+
impl Solution {
23+
pub fn minimum_operations(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
24+
let mut queue = VecDeque::new();
25+
queue.push_back(root);
26+
let mut ans = 0;
27+
while !queue.is_empty() {
28+
let n = queue.len();
29+
let mut row = Vec::new();
30+
for _ in 0..n {
31+
let mut node = queue.pop_front().unwrap();
32+
let mut node = node.as_mut().unwrap().borrow_mut();
33+
row.push(node.val);
34+
if node.left.is_some() {
35+
queue.push_back(node.left.take());
36+
}
37+
if node.right.is_some() {
38+
queue.push_back(node.right.take());
39+
}
40+
}
41+
for i in 0..n - 1 {
42+
let mut min_idx = i;
43+
for j in i + 1..n {
44+
if row[j] < row[min_idx] {
45+
min_idx = j;
46+
}
47+
}
48+
if i != min_idx {
49+
row.swap(i, min_idx);
50+
ans += 1;
51+
}
52+
}
53+
}
54+
ans
55+
}
56+
}

0 commit comments

Comments
 (0)