标签算法下的文章

2024-08-15

排列组合是数学中的一个基本概念，主要有两种形式：排列和组合。

排列：排列是指将n个不同的元素，每个元素都有可能出现在每一个位置上。所以，对于n个元素的排列，总共有n!种可能。
组合：组合是指从n个不同的元素中，选取r个元素进行组合，这里不考虑顺序，所以，对于n个元素的组合，总共有C(n, r) = n! / (r! * (n-r)!)种可能。

以下是使用JavaScript实现排列和组合算法的示例代码：

排列算法：

function factorial(n) {
    if (n === 0 || n === 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

function permutation(n, k) {
    return factorial(n) / factorial(n - k);
}

console.log(permutation(5, 3)); // 输出: 60

在上述代码中，factorial函数用于计算一个数的阶乘，permutation函数用于计算排列数。

组合算法：

function factorial(n) {
    if (n === 0 || n === 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

function combination(n, k) {
    return factorial(n) / (factorial(k) * factorial(n - k));
}

console.log(combination(5, 3)); // 输出: 10

在上述代码中，combination函数用于计算组合数。

以上就是使用JavaScript实现排列和组合算法的简单示例。

System

2024-08-15

所有,javascript

题目描述：

给定一个字符串，请设计一个算法，将字符串中的所有空格替换成 "%20" 。

解决方案：

Java 解法：

public class Solution {
    public String replaceSpaces(StringBuffer str) {
        return str.toString().replace(" ", "%20");
    }
}

JavaScript 解法：

function replaceSpaces(str) {
    return str.replace(/ /g, '%20');
}

Python 解法：

class Solution:
    def replaceSpaces(self , S: str) -> str:
        return S.replace(' ', '%20')

C 解法：

#include <stdio.h>
#include <string.h>

void replaceSpaces(char str[]) {
    int i, j, len = strlen(str);
    for (i = j = 0; i < len; i++) {
        if (str[i] == ' ') {
            str[j++] = '%';
            str[j++] = '2';
            str[j++] = '0';
        } else {
            str[j++] = str[i];
        }
    }
    str[j] = '\0'; // 不要忘记添加结束符
}

int main() {
    char str[] = "Hello World!";
    replaceSpaces(str);
    printf("%s", str);
    return 0;
}

C++ 解法：

#include <iostream>
#include <string>
#include <algorithm>

std::string replaceSpaces(std::string str) {
    std::replace(str.begin(), str.end(), ' ', '%20');
    return str;
}

int main() {
    std::string str = "Hello World!";
    std::string replacedStr = replaceSpaces(str);
    std::cout << replacedStr;
    return 0;
}

以上代码提供了不同语言的实现方法，主要使用了字符串替换的方法。对于 Java 和 JavaScript，使用了 String 类的 replace 方法；对于 Python，使用了 str 的 replace 方法；对于 C 和 C++，使用了标准库中的算法 replace。

- 阅读更多 -

【LeetCode算法成长之路】滑动窗口算法总结与经典题目分析

System

2024-08-14

所有,java

滑动窗口算法是一种用于处理字符串或数组中子串问题的高效方法。它通过维护一个窗口，在遍历字符串或数组的过程中，不断更新窗口大小，从而找出满足条件的子串或子序列。

在LeetCode上，滑动窗口算法常见于以下问题类型：

子串问题：找出字符串中最长/最短的子串满足某种条件。
字符统计：计算字符串中字符出现的次数。
字母异位词：判断两个字符串是否由相同的字母构成，可以考虑使用滑动窗口。

以下是一些使用滑动窗口解决的经典问题：

无重复字符的最长子串
滑动窗口最大值
最小滑动窗口范围
滑动窗口中的最大值

解决这些问题通常需要设置两个指针，一个代表窗口的开始，另一个代表窗口的结束，根据需要更新窗口的大小或移动窗口。

以下是无重复字符的最长子串的示例代码：

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        # 使用哈希集合记录字符是否出现过
        occ = set()
        n = len(s)
        # 右指针，初始值为-1表示还没有开始移动
        rk, ans = -1, 0
        for i in range(n):
            if i != 0:
                # 左指针向右移动
                occ.remove(s[i - 1])
            while rk + 1 < n and s[rk + 1] not in occ:
                # 不断扩大窗口直到出现重复字符
                occ.add(s[rk + 1])
                rk += 1
            # 更新最长无重复子串的长度
            ans = max(ans, rk - i + 1)
        return ans

滑动窗口算法是一种非常实用的技巧，可以解决许多字符串和数组问题。理解和熟练运用该算法对于高效解决编程问题至关重要。

- 阅读更多 -

java中使用雪花算法(Snowflake)为分布式系统生成全局唯一ID

System

2024-08-14

所有,java

在Java中使用雪花算法生成全局唯一ID的示例代码如下：

import java.util.concurrent.atomic.AtomicLong;

public class SnowflakeIdGenerator {
    // 64位ID的各个部分所占的位数
    private final long twepoch = 1288834974657L; // 起始时间戳 (2010-11-04 09:42:54.657)
    private final long workerIdBits = 5L; // 工作机器ID所占的位数
    private final long datacenterIdBits = 5L; // 数据中心ID所占的位数
    private final long sequenceBits = 12L; // 序列号所占的位数

    // 这些位都是直接按位或（|）运算，所以这里需要左移运算符（<<）
    private final long workerIdShift = sequenceBits;
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    private final long timestampShift = sequenceBits + workerIdBits + datacenterIdBits;

    private final long sequenceMask = -1L ^ (-1L << sequenceBits); // 生成序列的掩码

    private long workerId; // 工作机器ID
    private long datacenterId; // 数据中心ID
    private long sequence = 0L; // 序列号
    private long lastTimestamp = -1L; // 上一次生成ID的时间戳

    private AtomicLong id = new AtomicLong(0);

    // 构造函数，传入工作机器ID和数据中心ID
    public SnowflakeIdGenerator(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException("workerId can't be greater than %d or less than 0");
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException("datacenterId can't be greater than %d or less than 0");
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    // 生成下一个ID
    public synchronized long nextId() {
        long timestamp = timeGen();

        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0;
        }

        lastTimestamp = timestamp;

        id.set((timestamp - twepoch) << timestampShift | (datacenterId << datacenterIdShift) | (workerId << workerIdShift) | sequence);
        return id.get();
    }

    // 获取当前时间戳
    protected long timeGen() {
        return System.currentTimeMillis();
    }

    // 等待下一个毫秒的到来，用于解决时钟回拨问题
    protected long tilNextMil

- 阅读更多 -

在 Linux 中配置 SSH 连接的加密算法

System

2024-08-14

所有,linux

在Linux中配置SSH连接的加密算法，你需要编辑SSH服务器的配置文件sshd_config，通常位于/etc/ssh/sshd_config。

以下是配置SSH使用特定加密算法的步骤：

打开sshd_config文件：
```
sudo nano /etc/ssh/sshd_config
```
Bash
找到或添加以下配置行，并设置所需的加密算法。例如，仅使用Curve25519加密：
```
KexAlgorithms curve25519@libssh.org
Ciphers aes256-ctr
MACs hmac-sha2-256
```
保存并关闭文件。
重启SSH服务以应用更改：
```
sudo systemctl restart sshd
```
Bash

请注意，更改加密算法可能会影响客户端和服务器之间的兼容性。确保你的客户端也支持你所配置的算法。

这里是一个配置示例，仅使用Curve25519加密算法：

# 编辑sshd_config
sudo nano /etc/ssh/sshd_config

# 添加或修改以下行
KexAlgorithms curve25519@libssh.org
Ciphers aes256-ctr
MACs hmac-sha2-256

# 保存退出并重启SSH服务
sudo systemctl restart sshd

确保在进行任何更改之前备份sshd_config文件，并在对生产环境进行更改之前在测试环境中验证配置。

- 阅读更多 -

Go语言的sort包与排序算法

System

2024-08-14

所有,golang

Go语言的sort包提供了各种用于切片排序的函数。以下是一些使用sort包进行排序的示例代码：

package main

import (
    "fmt"
    "sort"
)

func main() {
    // 对整数切片进行排序
    ints := []int{7, 2, 4, 1, 5, 9}
    sort.Ints(ints)
    fmt.Println(ints) // 输出：[1 2 4 5 7 9]

    // 对字符串切片进行排序
    strings := []string{"banana", "apple", "cherry"}
    sort.Strings(strings)
    fmt.Println(strings) // 输出：[apple banana cherry]

    // 对自定义类型切片进行排序
    type Person struct {
        Name string
        Age  int
    }
    people := []Person{
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35},
    }
    // 按年龄排序
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })
    fmt.Println(people) // 输出：[{Bob 25} {Alice 30} {Charlie 35}]
}

在这个例子中，我们展示了如何使用sort包中的Ints、Strings和Slice函数来对整数、字符串和自定义类型的切片进行排序。对于自定义类型的排序，我们提供了一个排序函数作为Slice函数的参数。这个函数定义了切片元素的排序逻辑。

- 阅读更多 -

JS使用dijkstra算法实现查找最短路径

System

2024-08-14

所有,javascript

function dijkstra(graph, start, finish) {
    const distances = {};
    const previous = {};
    const visited = new Set();
    const nodes = Object.keys(graph);

    // 初始化距离和前驱节点
    for (let node of nodes) {
        distances[node] = Infinity;
        previous[node] = null;
    }
    distances[start] = 0;

    // 循环直到找到最短路径
    while (nodes.length) {
        let currentNode = findClosestNode(nodes, distances, visited);
        if (currentNode === finish) break; // 找到最短路径
        visited.add(currentNode);

        // 更新当前节点的邻居节点的距离
        for (let neighbor in graph[currentNode]) {
            if (visited.has(neighbor)) continue;
            let newDistance = distances[currentNode] + graph[currentNode][neighbor];
            if (newDistance < distances[neighbor]) {
                distances[neighbor] = newDistance;
                previous[neighbor] = currentNode;
            }
        }
    }

    // 构建最短路径
    const buildPath = (prev, node) => {
        if (prev[node] && prev[node] !== start) {
            return buildPath(prev, prev[node]) + '->' + node;
        } else {
            return node;
        }
    };

    return {
        distances: distances,
        path: buildPath(previous, finish)
    };
}

// 测试用例
const graph = {
    'start': {'a': 6, 'b': 2},
    'a': {'finish': 1},
    'b': {'a': 3, 'finish': 5},
    'finish': {}
};

const shortestPath = dijkstra(graph, 'start', 'finish');
console.log(shortestPath.distances);
console.log('Shortest Path:', shortestPath.path);

这段代码实现了Dijkstra算法，用于找到加权图中两个节点之间的最短路径。它首先初始化距离和前驱节点，然后通过循环找到最短路径，并构建最短路径的路径字符串。

- 阅读更多 -

Java岗斩获offer：Spring+JVM+并发锁+分布式+算法

System

2024-08-14

所有,分布式

这个问题似乎是在寻求一个关于Java技术栈的面试复习计划，而不是具体的代码问题。然而，我可以提供一些关键概念的概述和示例代码片段，帮助你准备面试。

Spring: 控制反转(IOC)和依赖注入(DI)是Spring的核心概念。

@Controller
public class MyController {
    @Autowired
    private MyService myService;
    // ...
}

JVM: 理解内存结构、垃圾回收算法和JVM调优是重要的。

// 查看JVM内存使用情况
java -XX:+PrintFlagsFinal -version | grep -i heapsize

并发锁: 学习使用不同级别的锁，如synchronized, ReentrantLock等。

public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

分布式: 理解分布式系统的设计和开发，如分布式锁、消息队列等。

// 使用Redis实现分布式锁
String lockKey = "myLockKey";
try {
    if (redisTemplate.opsForValue().setIfAbsent(lockKey, "locked")) {
        // 获取锁成功，执行业务逻辑
    }
} finally {
    // 释放锁
    redisTemplate.delete(lockKey);
}

算法: 对于Java岗，常见的算法和数据结构是必备知识，如排序、搜索、数组和链表操作。

public class SortExample {
    public static void main(String[] args) {
        int[] array = {4, 3, 2, 10, 1};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

这些概念和代码片段可以帮助你回忆和准备Java相关的面试问题。在实际的面试中，你可能还需要根据公司的具体需求和业务场景来展示你的技术深度和广度。

System

2024-08-14

所有,分布式

这个问题似乎是在询问如何在2个月内掌握Java 7的核心知识，包括分布式、JVM和Java基础等。由于Java 7已经于2011年被淘汰，它不再是当前使用最广泛的Java版本。因此，这里提供的答案将基于一些常见的核心知识点，并假设学习路径是按照分布式系统、JVM、Java基础、算法和并发编程的顺序进行的。

分布式系统
- 学习分布式系统的基础知识，包括CAP定理、BASE理论以及一致性协议如Paxos和Raft。
- 了解分布式事务、分布式锁、分布式协议等。
JVM
- 学习JVM的内存结构、垃圾收集器、JIT编译器等。
- 分析JVM的启动和优化配置。
Java基础
- 重新审视Java的语言特性，如泛型、注解、并发工具等。
- 学习Java集合框架和IO系统。
算法
- 学习常用的排序算法和数据结构，如链表、栈、队列、哈希表和二叉树。
并发编程
- 理解并发的原理，包括线程、线程池、同步机制等。
- 学习JUC包中的并发工具类，如AtomicInteger、ConcurrentHashMap等。
设计模式
- 熟悉常用的设计模式，如单例、工厂、观察者等，并在适当的场景中应用。
网络编程
- 了解网络编程基础，包括TCP/IP协议、Socket编程等。
持续集成和持续部署
- 学习自动化构建和部署工具，如Maven、Jenkins等。
学习资源
- 使用在线教育平台、书籍或者官方文档学习。
实践

通过编写代码、参与开源项目或者实际项目来应用所学知识。

以下是一个简单的计划安排，以2个月内掌握上述知识为目标：

第1周：分布式系统基础和JVM概念

第2-3周：Java基础和数据结构

第4-5周：算法和并发编程

第6-7周：设计模式和网络编程

第8-9周：持续集成和持续部署

第10-11周：深入学习JVM和并发包，复习和实践

第12-13周：查漏补缺，进行最后的实践和复习

注意：这只是一个概览性的计划，实际学习进度会根据个人理解速度和实际情况调整。每个人的知识体系和背景不同，因此每个人的学习路径也会有所区别。始终保持对知识的好奇心和对实践的坚持是非常重要的。

System

2024-08-14

所有,分布式

由于原始代码较为复杂且涉及专业背景，我们将提供一个简化版本的核心函数示例，展示如何在MATLAB中定义和使用遗传算法来解决电源选址和定容的问题。

function [best_solution, best_fitness] = ga_power_optimization(params)
    % 初始化遗传算法参数
    population_size = params.population_size;
    generations = params.generations;
    crossover_probability = params.crossover_probability;
    mutation_probability = params.mutation_probability;

    % 初始化种群
    population = rands(population_size, 2); % 假设有2个目标

    % 计算初始适应度
    fitness = calculate_fitness(population);

    % 选择操作
    for generation=1:generations
        % 选择父代
        selected = selection(population, fitness);

        % 交叉操作
        offspring = crossover(selected, crossover_probability);

        % 变异操作
        mutated = mutate(offspring, mutation_probability);

        % 更新种群和适应度
        population = [selected; mutated];
        fitness = calculate_fitness(population);

        % 更新最佳个体
        [best_solution, best_fitness] = find_best(population, fitness);
    end
end

function calculate_fitness(population)
    % 根据population计算适应度
    % 这里是示例，应根据实际问题定义适应度函数
end

function selection(population, fitness)
    % 选择算子的实现
end

function crossover(population, crossover_probability)
    % 交叉算子的实现
end

function mutate(population, mutation_probability)
    % 变异算子的实现
end

function [best_solution, best_fitness] = find_best(population, fitness)
    % 寻找最佳个体
end

这个示例展示了如何定义一个遗传算法来优化电源选址和定容问题。在实际应用中，你需要定义适应度函数calculate_fitness，选择操作selection，交叉操作crossover，以及变异操作mutate。同时，你需要定义find_best来找到最佳个体。这个简化的代码示例提供了一个基本框架，你可以在此基础上根据具体问题进行更详细的实现。

- 阅读更多 -