Дмитрий Беляев

use std::rc::{Rc, Weak};

pub struct Node {
    parent: Weak<Node>,
    data: u32,
    pub left: Option<Rc<Node>>,
    pub right: Option<Rc<Node>>,
}

#[derive(Debug)]
pub struct SetChildError;

impl Node {
    pub fn new(data: u32) -> Self {
        Self {
            parent: Weak::new(),
            data,
            left: None,
            right: None,
        }
    }

    pub fn set_left(self: &mut Rc<Self>, mut child: Rc<Self>) -> Result<(), SetChildError> {
        let child_mut = Rc::get_mut(&mut child).ok_or(SetChildError)?;
        child_mut.parent = Rc::downgrade(self);

        let self_mut = Rc::get_mut(self).ok_or(SetChildError)?;
        self_mut.left = Some(child);

        Ok(())
    }
}

// Сохраняем исходные индексы и сортируем по высоте по убыванию
const preparedData = data
    .map((e, i) => ({i, e}))
    .sort((a, b) => b.e.height - a.e.height);

for (const el of preparedData) {
    const { height } = el.e;
    // тут никогда не вернет -1, так как мы ищем элемент который точно есть в массиве - минимальный
    const index = columnHeight.indexOf(Math.min(...columnHeight));
    // обновляем данные массивов по выбранному индексу
    columnHeight[index] += height;
    columns[index].push(el);
}

// нормализуем columns
for (let i = 0; i < columns.length; ++i) {
    // восстановим исходный порядок, отсортировав по сохраненному индексу по возрастанию
    columns[i].sort((a, b) => a.i - b.i);
    // избавимся от сохраненных индексов, оставив только исходные объекты
    columns[i] = columns[i].map(({ e }) => e);
}

1)curr = dummy = ListNode()
что это за конструкция. ну вернее я знаю, что это объект класса, но зачем сразу 2 переменные? сделал вот так
dummy = ListNode() и не работает

if l1.val >l2.val:
                curr.next = l2 
                l2 = l2.next

объясните пожалуйста вот эти 2 строчки

curr.next = l2 
l2 = l2.next

3) Почему возвращаем именно dummy и next?
return dummy.next

#[no_mangle]
pub fn test() {
    // Вот тут на стеке выделено 4 байта
    let mut idx: i32 = 10;
    // Указатель на эти 4 байта
    let ptr = &mut idx as *mut i32;

    // По сути указатель на те же 4 байта, но на деле указатель на 40 байт
    let buffer = unsafe { core::slice::from_raw_parts_mut(ptr, 10) };

    // И тут мы работаем с этими 40 байтами,
    // но нормальные из них только 4 байта в начале,
    // а остальные смотрят в глубь стека и меняют его
    // то есть перетирают адрес возврата и данные на стеке вызвавшей функции
    for pixel in buffer.iter_mut() {
        *pixel = 0x7d2b7500;
    }
}

function position(): MyPosition
function position(a:number, b:number): MyPosition
function position(a:number): MyPositionWithDefault

function position(a?: number, b?:number) {
    if (!a && !b) {
        return {x: undefined, b: undefined}
    }
    if(a && !b) {
        return {x: a, b: undefined, default: a.toString()}
    }
    return {x: a, y: b}
}

interface ReturnTypeOfPosition {
  x: undefined
  b: undefined
}

function position(): MyPosition
function position(a: number, b: number): MyPosition
function position(a: number): MyPositionWithDefault
function position(a?: number, b?: number): MyPosition | MyPositionWithDefault {
    if (!a && !b) {
        return {x: undefined, y: undefined}
    }
    if(a && !b) {
        return {x: a, y: undefined, default: a.toString()}
    }
    return {x: a, y: b}
}

У переменной a указан тип встроенный массив [T; n]. Но у такого типа нет метода get_unchecked_mut(). Он есть у среза на массив [T]

struct S {
    a: i32,
    f: fn(),
}

impl S {
    fn a(&self) {}
}

let s = S { a: 0, f: || {} };
s.a; // Доступ к полю
s.a(); // Вызов метода
(s.f)(); // Вызов функции по указателю, который лежит в поле f

S::a(s);
S::a(&s);
S::a(&mut s);
<S as Deref>::Target::a(S::deref(&s));
<S as DerefMut>::Target::a(S::deref_mut(&mut s));
<<S as Deref>::Target as Deref>::Target::a(<S as Deref>::Target::deref(S::deref(&s)));
<<S as DerefMut>::Target as DerefMut>::Target::a(<S as DerefMut>::Target::deref_mut(S::deref_mut(&mut s)));
// ...

impl<T, const N: usize> Deref for [T; N] {
    type Target = [T];
    fn deref(&self) -> &[T] {
        // ...
    }
}

Что тут делает unsafe код как раз понятно