480. Sliding Window Median

LeetCode hard original: C# #array #csharp #hard #leetcode #sliding-window #sort

Der Aufgabentext wird für die gewählte Sprache aus dem Russischen übersetzt. Code bleibt unverändert.

LeetCode Static

Медиана — это среднее значение в упорядоченном списке целых чисел. Если размер списка четный, среднего значения не существует, поэтому медианой считается среднее значение двух средних чисел.

НаBeispiel, если arr = [2, 3, 4], медиана равна 3.

НаBeispiel, если arr = [1, 2, 3, 4], медиана равна (2 + 3) / 2 = 2.5.

Вам дан Ganzzahl Array nums и Ganzzahl k. Существует скользящее окно размера k, которое перемещается от самого левого края Arrayа до самого правого. Вы можете видеть только k чисел в окне. Каждый раз скользящее окно перемещается вправо на одну позицию.

return Array медиан для каждого окна в исходном Arrayе. Ответы с точностью до 10^-5 будут приниматься.

Beispiel:

Input: nums = [1,3,-1,-3,5,3,6,7], k = 3

Output: [1.00000,-1.00000,-1.00000,3.00000,5.00000,6.00000]

Explanation:

Window position Median

--------------- -----

[1 3 -1] -3 5 3 6 7 1

1 [3 -1 -3] 5 3 6 7 -1

1 3 [-1 -3 5] 3 6 7 -1

1 3 -1 [-3 5 3] 6 7 3

1 3 -1 -3 [5 3 6] 7 5

1 3 -1 -3 5 [3 6 7] 6

C# Lösung

zugeordnet/original

using System;
using System.Collections.Generic;
using System.Linq;
public class Solution {
    public IList<double> MedianSlidingWindow(int[] nums, int k) {
        List<double> medians = new List<double>();
        for (int i = 0; i + k <= nums.Length; i++) {
            int[] window = new int[k];
            Array.Copy(nums, i, window, 0, k);
            Array.Sort(window);
            if (k % 2 == 1) {
                medians.Add(window[k / 2]);
            } else {
                medians.Add((window[k / 2 - 1] + window[k / 2]) / 2.0);
            }
        }
        return medians;
    }
}

C++ Lösung

Auto-Entwurf, vor dem Einreichen prüfen

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public IList<double> MedianSlidingWindow(vector<int>& nums, int k) {
        List<double> medians = new List<double>();
        for (int i = 0; i + k <= nums.size(); i++) {
            vector<int>& window = new int[k];
            Array.Copy(nums, i, window, 0, k);
            sort(window.begin(), window.end());
            if (k % 2 == 1) {
                medians.push_back(window[k / 2]);
            } else {
                medians.push_back((window[k / 2 - 1] + window[k / 2]) / 2.0);
            }
        }
        return medians;
    }
}

Java Lösung

zugeordnet/original

import java.util.*;

public class Solution {
    public double[] medianSlidingWindow(int[] nums, int k) {
        List<Double> medians = new ArrayList<>();

        for (int i = 0; i + k <= nums.length; i++) {
            int[] window = Arrays.copyOfRange(nums, i, i + k);
            Arrays.sort(window);

            if (k % 2 == 1) {
                medians.add((double) window[k / 2]);
            } else {
                medians.add((window[k / 2 - 1] + window[k / 2]) / 2.0);
            }
        }

        double[] result = new double[medians.size()];
        for (int i = 0; i < medians.size(); i++) {
            result[i] = medians.get(i);
        }

        return result;
    }
}

JavaScript Lösung

zugeordnet/original

var medianSlidingWindow = function(nums, k) {
    let medians = [];

    for (let i = 0; i + k <= nums.length; i++) {
        let window = nums.slice(i, i + k).sort((a, b) => a - b);

        if (k % 2 === 1) {
            medians.push(window[Math.floor(k / 2)]);
        } else {
            medians.push((window[k / 2 - 1] + window[k / 2]) / 2);
        }
    }

    return medians;
};

Python Lösung

zugeordnet/original

from typing import List

def medianSlidingWindow(nums: List[int], k: int) -> List[float]:
    medians = []

    for i in range(len(nums) - k + 1):
        window = sorted(nums[i:i + k])

        if k % 2 == 1:
            medians.append(window[k // 2])
        else:
            medians.append((window[k // 2 - 1] + window[k // 2]) / 2)

    return medians

Go Lösung

zugeordnet/original

package main

import (
    "sort"
)

func medianSlidingWindow(nums []int, k int) []float64 {
    var medians []float64

    for i := 0; i + k <= len(nums); i++ {
        window := append([]int(nil), nums[i:i+k]...)
        sort.Ints(window)

        if k % 2 == 1 {
            medians = append(medians, float64(window[k/2]))
        } else {
            medians = append(medians, float64(window[k/2-1]+window[k/2])/2.0)
        }
    }

    return medians
}

Algorithm

Сохраняйте числа в контейнере окна размера k, выполняя следующие операции: Вставка Eingabeящего elementа. Удаление Ausgabeящего elementа.

Отсортируйте окно, чтобы find медианы. Вместо того чтобы каждый раз копировать и сортировать k последовательных elementов из Eingabeных данных, вставляйте и удаляйте по одному elementу при каждом сдвиге окна.

Поддерживайте окно в отсортированном состоянии до и после операций вставки и удаления.

😎

Stellen zu dieser Aufgabe

aktive Stellen with overlapping task tags are angezeigt.

Alle Stellen

Es gibt noch keine aktiven Stellen.