2024-08-11

在C语言中实现基本的凯撒密码加密和解密功能,以下是核心函数的示例代码:




#include <stdio.h>
#include <string.h>
 
// 确定密钥长度
#define KEY_LENGTH 26
 
// 基本的密钥映射
char key_map[KEY_LENGTH + 1];
 
// 初始化密钥映射
void init_key_map() {
    for (int i = 0; i < KEY_LENGTH; i++) {
        key_map[i] = 'A' + i;
    }
    key_map[KEY_LENGTH] = '\0'; // 字符串结束符
}
 
// 根据密钥生成密钥映射
void generate_key_map(char key[KEY_LENGTH]) {
    for (int i = 0; i < KEY_LENGTH; i++) {
        int j;
        for (j = 0; j < KEY_LENGTH; j++) {
            if (key[i] == key_map[j]) {
                break;
            }
        }
        // 如果是重复字符,则放在字母表的末尾
        if (j == KEY_LENGTH) {
            key_map[i] = key[i];
        } else {
            key_map[i] = key_map[(j + 1) % KEY_LENGTH];
        }
    }
}
 
// 加密函数
void encrypt(char plaintext[], char ciphertext[]) {
    for (int i = 0; plaintext[i] != '\0'; i++) {
        if (plaintext[i] >= 'A' && plaintext[i] <= 'Z') {
            ciphertext[i] = key_map[(plaintext[i] - 'A') % KEY_LENGTH];
        } else {
            ciphertext[i] = plaintext[i];
        }
    }
    ciphertext[strlen(plaintext)] = '\0'; // 字符串结束符
}
 
// 解密函数
void decrypt(char ciphertext[], char plaintext[]) {
    for (int i = 0; ciphertext[i] != '\0'; i++) {
        if (ciphertext[i] >= 'A' && ciphertext[i] <= 'Z') {
            for (int j = 0; j < KEY_LENGTH; j++) {
                if (key_map[j] == ciphertext[i]) {
                    plaintext[i] = 'A' + (j - 1 + KEY_LENGTH) % KEY_LENGTH;
                    break;
                }
            }
        } else {
            plaintext[i] = ciphertext[i];
        }
    }
    plaintext[strlen(ciphertext)] = '\0'; // 字符串结束符
}
 
int main() {
    char key[KEY_LENGTH] = "KEY";
    char plaintext[KEY_LENGTH + 1] = "HELLO";
    char ciphertext[KEY_LENGTH + 1];
    char decryptedtext[KEY_LENGTH + 1];
 
    init_key_map();
    generate_key_map(key);
 
    printf("Plaintext: %s\n", plaintext);
    encrypt(plaintext, ciphertext);
    printf("Ciphertext: %s\n", ciphertext);
 
    decrypt(ciphertext, decryptedtext);
    printf("Decryptedtext: %s\n", decryptedtext);
 
    return 0;
}

这段代码首先定义了密钥长度KEY_LENGTH,然后初始化了一个密钥映射数组key_mapinit_key_map函数用于初始化key_map数组。generate_key_map函数根据用户提供的密钥生成新的密钥映射。encryptdecrypt函数分别用于加密和解密文本。在main函数中,我们使用了示例密钥"KEY"和文本"HELLO"来演示加

2024-08-11



/* 设置一个容器使用伸缩布局 */
.container {
  display: flex; /* 设置为伸缩容器 */
  flex-direction: row; /* 设置主轴方向为水平 */
  justify-content: flex-start; /* 项目沿主轴起始端对齐 */
  align-items: center; /* 项目沿交叉轴居中对齐 */
  height: 100px; /* 设置容器高度 */
  background-color: #f0f0f0; /* 设置背景色 */
}
 
/* 设置伸缩项目 */
.item {
  flex: 1; /* 项目占据等分的空间 */
  margin: 8px; /* 项目之间的间隔 */
  text-align: center; /* 文字居中对齐 */
}
 
/* 设置特定项目的样式 */
.item:first-child {
  flex-grow: 2; /* 第一个项目的放大比例是其他项目的两倍 */
  background-color: #ffcccc; /* 设置背景色 */
}
 
.item:last-child {
  flex-basis: 150px; /* 最后一个项目的基准宽度 */
  background-color: #ccffcc; /* 设置背景色 */
}

这段代码展示了如何使用CSS的伸缩布局(flexbox)来创建一个简单的水平排列的容器,其中包含三个伸缩项目。第一个项目比其他项目大两倍,最后一个项目有一个固定宽度。这是一个很好的入门级示例,展示了伸缩布局的基本属性和概念。

2024-08-11

以下是使用Java、Python、C++和JavaScript实现的栈式算法解决方案。

Java实现:




import java.util.Arrays;
 
public class StackBlocks {
    public static int[] stackBlocks(int[] blocks) {
        Arrays.sort(blocks); // 对块进行排序
        int stacks = 1; // 初始化栈数为1
        int top = blocks[0]; // 栈顶块的高度初始化为数组中的第一个元素
 
        for (int i = 1; i < blocks.length; i++) {
            if (blocks[i] > top) { // 如果当前块比栈顶块高
                top = blocks[i]; // 更新栈顶块的高度
                stacks++; // 栈数增加
            }
        }
        return new int[]{stacks, top}; // 返回栈数和最高的块高
    }
 
    public static void main(String[] args) {
        int[] blocks = {5, 2, 3, 4, 1};
        int[] result = stackBlocks(blocks);
        System.out.println("栈的数量: " + result[0]);
        System.out.println("最高的块高: " + result[1]);
    }
}

Python实现:




def stack_blocks(blocks):
    blocks.sort()  # 对块进行排序
    stacks = 1     # 初始化栈数为1
    top = blocks[0]  # 栈顶块的高度初始化为数组中的第一个元素
 
    for block in blocks[1:]:
        if block > top:  # 如果当前块比栈顶块高
            top = block  # 更新栈顶块的高度
            stacks += 1  # 栈数增加
    return stacks, top  # 返回栈数和最高的块高
 
blocks = [5, 2, 3, 4, 1]
stacks, top = stack_blocks(blocks)
print("栈的数量:", stacks)
print("最高的块高:", top)

C++实现:




#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
vector<int> stackBlocks(vector<int>& blocks) {
    sort(blocks.begin(), blocks.end()); // 对块进行排序
    int stacks = 1; // 初始化栈数为1
    int top = blocks[0]; // 栈顶块的高度初始化为数组中的第一个元素
 
    for (int i = 1; i < blocks.size(); i++) {
        if (blocks[i] > top) { // 如果当前块比栈顶块高
            top = blocks[i]; // 更新栈顶块的高度
            stacks++; // 栈数增加
        }
    }
    return {stacks, top}; // 返回栈数和最高的块高
}
 
int main() {
    vector<int> blocks = {5, 2, 3, 4, 1};
    vector<int> result = stackBlocks(blocks);
    cout << "栈的数量: " << result[0] << endl;
    cout << "最高的块高: " << result[1] << endl;
    return 0;
}

JavaScript实现:




function stackBlocks(blocks) {
    blocks.sort((a, b) => a - b); // 对块进行排序
    let stacks = 1; // 初始化栈数为1
    let top = blocks[0]; // 栈顶块的高度初始化为数组中的第一个元素
 
    for (let i = 1; i < blocks.length; i++) {
        if (blocks[i] > top) { // 如果当前块比栈顶块高
            top = blocks[i]; // 更新栈顶块的高度
2024-08-10



function longestCommonSubsequence(text1, text2) {
    let m = text1.length;
    let n = text2.length;
    let dp = new Array(m + 1).fill(0).map(() => new Array(n + 1).fill(0));
 
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (text1[i - 1] === text2[j - 1]) {
                dp[i][j] = 1 + dp[i - 1][j - 1];
            } else {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
 
    return dp[m][n];
}
 
// 示例
console.log(longestCommonSubsequence("abcde", "ace")); // 输出应该是 3

这段代码首先定义了一个函数longestCommonSubsequence,它接受两个字符串参数text1text2,并返回它们的最长公共子序列的长度。函数内部,我们使用动态规划的方法创建了一个二维数组dp来存储中间结果。然后,我们遍历字符串text1text2的所有可能的子序列,并根据子序列是否相同来更新dp数组。最终,dp[m][n]存储的就是text1text2的最长公共子序列的长度。最后,我们打印出两个字符串的最长公共子序列长度。

2024-08-10



package main
 
import (
    "fmt"
    "github.com/bwmarrin/snowflake"
)
 
func main() {
    // 初始化一个雪花算法节点,如果你需要多个节点,可以为每个节点指定不同的节点标识符
    node, err := snowflake.NewNode(1)
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 生成一个唯一ID
    id := node.Generate()
    fmt.Printf("Generated Snowflake ID: %064b\n", id)
}

这段代码演示了如何在Go语言中使用bwmarrin/snowflake库来生成唯一的雪花算法ID。首先,我们初始化了一个雪花算法节点,然后通过调用Generate方法生成了一个ID并打印出来。这个例子简单明了地展示了如何在Go语言中应用雪花算法生成分布式唯一ID。

2024-08-10

麻雀算法是一种进化算法,可以被用来进行分布式无人机编队航迹规划和碰撞检测。以下是一个简化的例子,展示了如何使用麻雀算法进行无人机编队的航迹规划:




function [sol, fitness] = mA_SODA(params)
    % 参数初始化
    n = params.n; % 无人机数量
    % ... 其他参数初始化
 
    % 初始化麻雀群
    nAnt = 30; % 麻雀个体数量
    maxIter = 500; % 最大迭代次数
    rho = 0.2; % 麻雀参数
    Q = 1.0; % 麻雀参数
    p = 0.7; % 麻雀参数
    damp = 0.9; % 缓冲因子
    iter = 0; % 迭代计数器
    nIter = 0; % 无人机航迹改善的迭代次数
    sol = zeros(n, 2); % 存储最优解
    vel = zeros(n, 2); % 存储速度
    pBest = zeros(n, 2); % 存储每个麻雀的最优解
    gBest = zeros(n, 2); % 存储全局最优解
    fitness = zeros(nAnt, 1); % 存储每个麻雀的适应度
    % 初始化位置和速度
    for i = 1:nAnt
        sol(i, :) = rand(1, 2) * (params.ub - params.lb) + params.lb;
        vel(i, :) = rand(1, 2) * 2 * (params.ub - params.lb);
        fitness(i) = calculateFitness(sol(i, :), params); % 适应度评估
        if fitness(i) < fitness(1)
            pBest(i, :) = sol(i, :);
            gBest(i, :) = sol(i, :);
        else
            pBest(i, :) = sol(1, :);
            gBest(i, :) = sol(1, :);
        end
    end
 
    % 麻雀搜索迭代
    while iter < maxIter
        for i = 1:nAnt
            % 更新速度和位置
            vel(i, :) = vel(i, :) * damp + rho * rand(1, 2) * (pBest(i, :) - sol(i, :)) + Q * rand(1, 2) * (gBest(1, :) - sol(i, :));
            sol(i, :) = sol(i, :) + vel(i, :);
            % 边界处理
            sol(i, sol(i, :) > params.ub) = params.ub;
            sol(i, sol(i, :) < params.lb) = params.lb;
            % 适应度评估
            newFitness = calculateFitness(sol(i, :), params);
            fitness(i) = newFitness;
            % 更新个体最优和全局最优解
            if newFitness < fitness(1)
                pBest(i, :) = sol(i, :);
                if newFitness < fitness(1)
                    gBest(i, :) = sol(i, :);
                end
            else
                pBest(i, :) = pBest(1, :);
            end
        end
        % 更新全局最优解
        [~, minFitIdx] = min(fitness);
        if fitness(minFitIdx) < fitness(1)
            gBest(1, :) = pBest(minFitIdx, :);
            fitness(1) = fitness(minFitIdx);
            nIter = iter;
        end
        iter = iter + 1;
    end
    % 输出结果
    sol = gBest(1, :);
    fitness = fitness(1);
2024-08-10

Kubernetes为何会火?

Kubernetes是一个开源的,用于管理容器化应用的平台,其设计理念是让部署容器化的应用简单并且高效。它提供了应用部署,扩展和管理的自动化机制。

为什么Kubernetes会如此流行?

  1. 容器化部署的需求增加:随着微服务架构的流行,应用被拆分成更小的部分,容器化成为一种必然的选择。
  2. Google Borg/Omega:Kubernetes的设计和开发启发于Google内部使用的大型集群管理系统Borg/Omega。
  3. 云原生应用需求:随着云计算的发展,企业更倾向于构建和部署云原生的应用。
  4. Docker的普及:Docker作为容器化技术的代表,大大提高了容器化应用的可行性。
  5. CNCF(Cloud Native Computing Foundation)的推动:2015年,Google将Borg贡献给CNCF,并成立了新的项目——Kubernetes。
  6. 快速发展和广泛的生态系统:Kubernetes拥有庞大且活跃的社区,周边生态系统不断发展壮大,如Helm、Istio等。
  7. 无需改变应用代码:Kubernetes提供了服务发现和自动扩缩容等功能,大大减少了对应用代码的依赖。
  8. 便捷的部署和管理:Kubernetes提供了一个强大的命令行工具kubectl,以及丰富的UI工具,如Dashboard和Pods等。

2024年最新Golang算法相关面试题

  1. Golang的内存管理:Go语言的内存管理是自动的,它有一个垃圾回收器,可以自动释放不再使用的内存。
  2. Goroutines和channels:Goroutines是轻量级的线程,channels是用于Goroutines之间通信的管道。
  3. 切片(Slice):切片是一个动态数组,可以自动扩展。
  4. Map:Map是一种无序的键值对集合。
  5. 结构体(Struct):结构体是一种自定义的数据类型,可以包含多个字段。
  6. 接口(Interface):接口定义了一组方法,但是不包含实现。
  7. 并发与并行:Go语言支持并发,通过Goroutines和channels实现。
  8. 错误处理:Go语言中的错误处理是通过返回值来实现的,一般错误作为最后一个返回值。
  9. 指针:Go语言中的指针类似于C语言,可以直接操作内存。
  10. 异步IO:Go语言使用Goroutines和channels实现了异步IO。

以上是2024年最新的Golang算法相关面试题,为了保证内容的精简性,每个问题不会展开过多的细节。在实际的面试中,你可能需要根据每个问题展开更深入的讨论。

2024-08-10

在Flutter Web项目中,你可以使用Dart的package:js库来调用JavaScript代码,实现前端常用的算法。以下是10种常用算法的示例代码:

  1. 排序算法:快速排序



import 'package:js/js.dart';
 
@JS()
library js_quicksort_library {
  // 导入JavaScript的排序函数
  external void quickSort(List list);
}
 
void main() {
  List<int> numbers = [10, 2, 7, 4, 3, 5, 6, 8, 9, 1];
  js_quicksort_library.quickSort(numbers);
  print(numbers); // 输出排序后的数组
}
  1. 搜索算法:二分查找



import 'package:js/js.dart';
 
@JS()
library js_binarysearch_library {
  // 导入JavaScript的二分查找函数
  external int binarySearch(List list, num item);
}
 
void main() {
  List<num> numbers = [1, 3, 5, 7, 9, 11];
  int index = js_binarysearch_library.binarySearch(numbers, 7);
  print(index); // 输出7的索引,如果没找到则输出-1
}
  1. 哈希算法:哈希表操作



import 'package:js/js.dart';
 
@JS()
library js_hashtable_library {
  // 导入JavaScript的哈希表操作函数
  external void addItem(Object hashtable, var key, var value);
  external var getItem(Object hashtable, var key);
}
 
void main() {
  var hashtable = js_hashtable_library.JSHashtable();
  js_hashtable_library.addItem(hashtable, 'key1', 'value1');
  var value = js_hashtable_library.getItem(hashtable, 'key1');
  print(value); // 输出键对应的值
}
  1. 图算法:深度优先搜索



import 'package:js/js.dart';
 
@JS()
library js_dfs_library {
  // 导入JavaScript的DFS函数
  external void depthFirstSearch(Object graph, num startNode, Function visitCallback);
}
 
void main() {
  var graph = js_dfs_library.JSGraph();
  js_dfs_library.depthFirstSearch(graph, 1, allowInterop((node) {
    print(node); // 输出访问的节点
  }));
}
  1. 动态规划算法:0-1背包问题



import 'package:js/js.dart';
 
@JS()
library js_knapsack_library {
  // 导入JavaScript的0-1背包算法函数
  external List knapsack(List weights, List values, num capacity);
}
 
void main() {
  List weights = [1, 3, 4];
  List values = [15, 20, 30];
  int capacity = 4;
  List result = js_knapsack_library.knapsack(weights, values, capacity);
  print(result); // 输出背包装载的最大价值
}
  1. 数学问题:斐波那契数列



import 'package:js/js.dart';
 
@JS()
library js_fibonacci_library {
  // 导入JavaScript的斐波那契数列计算函数
  external int fibonacci(int n);
}
 
void main() {
  int n = 10;
  int result = js_fibonacci_library.fibonacci(n);
  print(result); // 输出斐波那契数列的第n项
}
  1. 字符串匹配算法:KMP算法
2024-08-10

在PHP中,可以使用openssl_encrypt函数来实现3DES算法(ECB模式和PKCS5填充)。以下是一个示例代码:




<?php
function des3_encrypt_ecb_pkcs5($data, $key) {
    $iv = openssl_random_pseudo_bytes(openssl_cipher_iv_length('3DES-ECB'));
    $cipher = openssl_encrypt($data, '3DES-ECB', $key, OPENSSL_RAW_DATA, $iv);
    return base64_encode($cipher);
}
 
$key = 'your-3des-key'; // 3DES密钥,长度需为24字节
$plaintext = 'Your plaintext data here';
 
$encrypted = des3_encrypt_ecb_pkcs5($plaintext, $key);
echo "Encrypted: " . $encrypted . "\n";
 
// 解密(这里仅作为示例,实际情况下不会解密3DES ECB模式,因为它不安全)
$decrypted = openssl_decrypt($encrypted, '3DES-ECB', $key, OPENSSL_RAW_DATA, $iv);
echo "Decrypted: " . $decrypted . "\n";
?>

确保你的密钥长度为24字节(3DES的密钥长度有三种选择:168位,112位或80位,但PHP通常需要64位的长度,即8字节,因此你需要重复输入密钥三次以匹配这个长度)。

注意:ECB模式不提供消息的保密性,因此不推荐用于传输敏感数据。此外,这个示例中展示了如何进行加密和解密,但通常不推荐在实际应用中使用3DES,因为它不安全。

2024-08-10

这是一个非常宽泛的问题,因为涉及到很多不同的技术点。我将尝试提供一些关键点的解答。

  1. HashMap: 这是一个常用的Java集合类,用于存储键值对。
  2. 线程池: 线程池是一种用于管理线程的工具,可以提高应用程序的性能。
  3. 算法: 在面试中,常常会问到一些基本的算法知识,比如排序、搜索等。
  4. 索引: 在数据库或者搜索引擎中,索引是提高数据检索效率的重要手段。
  5. 分布式锁: 在分布式系统中,实现锁的一致性是一个重要的问题。
  6. 中间件: 这是一种独立的系统软件或服务程序,中间件位于操作系统、网络和数据库等软件之上,为应用软件提供业务性的处理服务。

由于你的问题是关于“分享”,我将提供一些关于HashMap和线程池的简单示例代码。

HashMap示例:




import java.util.HashMap;
 
public class HashMapExample {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");
 
        System.out.println(map.get(1)); // 输出: Apple
    }
}

线程池示例:




import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 10; i++) {
            Runnable task = () -> System.out.println("Thread ID: " + Thread.currentThread().getId());
            executorService.execute(task);
        }
        executorService.shutdown();
    }
}

这些例子都非常基础,但它们展示了如何使用HashMap和线程池。在实际的面试中,你可能还需要深入讨论这些技术的特性、用途、优缺点以及如何在特定场景下选择合适的数据结构或算法。