DASCTF 2023 0X401七月暑期挑战赛 Reverse部分题解

news2024/11/24 17:36:50

文章目录

  • controlflow
    • 1. 异或0x401
    • 2. 加i*i
    • 3. 异或i*(i+1)
    • 4. 减i
    • 5. 乘3
    • 6. swap
    • 7. judge
    • 解题脚本
  • webserver
    • 1.关键函数
    • 2. 求约束条件
    • 3.Z3求解

controlflow

动态调试观察执行情况

1. 异或0x401

请添加图片描述

2. 加i*i

请添加图片描述

3. 异或i*(i+1)

注意这里是从data[10+i]开始
请添加图片描述

4. 减i

请添加图片描述

5. 乘3

请添加图片描述

6. swap

注意这里是从data[10+i]开始
请添加图片描述

7. judge

进行数据比较并解密输出的两个字符串

请添加图片描述

解题脚本

#include<stdio.h>
int main() {
	unsigned int data[40] = { 0 };
	data[0] = 3279;
	data[1] = 3264;
	data[2] = 3324;
	data[3] = 3288;
	data[4] = 3363;
	data[5] = 3345;
	data[6] = 3528;
	data[7] = 3453;
	data[8] = 3498;
	data[9] = 3627;
	data[10] = 3708;
	data[11] = 3675;
	data[12] = 3753;
	data[13] = 3786;
	data[14] = 3930;
	data[15] = 3930;
	data[16] = 4017;
	data[17] = 4173;
	data[18] = 4245;
	data[19] = 4476;
	data[20] = 4989;
	data[21] = 4851;
	data[22] = 5166;
	data[23] = 5148;
	data[24] = 4659;
	data[25] = 4743;
	data[26] = 4596;
	data[27] = 5976;
	data[28] = 5217;
	data[29] = 4650;
	data[30] = 6018;
	data[31] = 6135;
	data[32] = 6417;
	data[33] = 6477;
	data[34] = 6672;
	data[35] = 6891;
	data[36] = 7056;
	data[37] = 7398;
	data[38] = 7650;
	data[39] = 7890;
	for (int i = 0; i < 20; i += 2) {
		data[10 + i] ^= data[10 + i + 1];
		data[10 + i + 1] ^= data[10 + i];
		data[10 + i] ^= data[10 + i + 1];
	}
	for (int i = 0; i < 40; i++)
		data[i] /= 3;
	for (int i = 0; i < 40; i++)
		data[i] += i;
	for (int i = 0; i < 20; i++) 
		data[10+i] ^= i * (i + 1);
	for (int i = 0; i < 40; i++) 
		data[i] -= i * i;
	for (int i = 0; i < 40; i++)
		data[i] ^= 0x401;
	for (int i = 0; i < 40; i++)
		printf("%c",data[i]);
	//DASCTF{TWpnemRuSTRkVzVsWVhOMmJqZzNOREoy}
	return 0;
}

webserver

1.关键函数

主函数发现不了什么,于是在函数列表逐个探查函数,最终找到一个可疑函数有赋值和矩阵乘法

这里的input定义为QWORD[24] 实际上前4个单元(4*8=32字节)没有被使用,后20个QWORD在循环时强转成DWORD(即40个单元),所以input是个4行10列矩阵,并且每行10个DWORD(实际有效内容仅1Byte)

第一个循环是进行矩阵乘法并修改data,第二个大循环是检查data是否为零矩阵,也就是说经过第一个大循环运算后data应该全0

请添加图片描述

2. 求约束条件

根据矩阵乘法求约束条件

#include<stdio.h>

int main() {
    unsigned char buffer[400] =
    {
      0x17, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x04, 0x00,
      0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
      0x29, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x21, 0x00,
      0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
      0x45, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x00,
      0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
      0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x50, 0x00,
      0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00,
      0x38, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x3E, 0x00,
      0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
      0x3F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x44, 0x00,
      0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
      0x5C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x10, 0x00,
      0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
      0x03, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x47, 0x00,
      0x00, 0x00, 0x3A, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
      0x40, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x47, 0x00,
      0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00,
      0x59, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x00, 0x00, 0x44, 0x00,
      0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00,
      0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x34, 0x00,
      0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x2C, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x20, 0x00,
      0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
      0x14, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x02, 0x00,
      0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x39, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x00, 0x00, 0x2B, 0x00,
      0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
      0x50, 0x00, 0x00, 0x00, 0x5C, 0x00, 0x00, 0x00, 0x5D, 0x00,
      0x00, 0x00, 0x3A, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
      0x4A, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x2D, 0x00,
      0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
      0x01, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x1E, 0x00,
      0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
      0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x4D, 0x00,
      0x00, 0x00, 0x5C, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
      0x25, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x3C, 0x00,
      0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
      0x4F, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x57, 0x00,
      0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00
    };
	unsigned int data[40] = { 0 };
    data[0] = 33211;
    data[1] = 36113;
    data[2] = 28786;
    data[3] = 44634;
    data[4] = 30174;
    data[5] = 39163;
    data[6] = 34923;
    data[7] = 44333;
    data[8] = 33574;
    data[9] = 23555;
    data[10] = 35015;
    data[11] = 42724;
    data[12] = 34160;
    data[13] = 49166;
    data[14] = 35770;
    data[15] = 45984;
    data[16] = 39754;
    data[17] = 51672;
    data[18] = 38323;
    data[19] = 27511;
    data[20] = 31334;
    data[21] = 34214;
    data[22] = 28014;
    data[23] = 41090;
    data[24] = 29258;
    data[25] = 37905;
    data[26] = 33777;
    data[27] = 39812;
    data[28] = 29442;
    data[29] = 22225;
    data[30] = 30853;
    data[31] = 35330;
    data[32] = 30393;
    data[33] = 41247;
    data[34] = 30439;
    data[35] = 39434;
    data[36] = 31587;
    data[37] = 46815;
    data[38] = 35205;
    data[39] = 0x50D1;

    unsigned int input[40] = { 0 };
    int k, m, n;
    unsigned int* mulbuf = (unsigned int*)buffer;
    for (k = 0; k <= 3; ++k)                // 矩阵乘法
    {
        for (m = 0; m <= 9; ++m)
        {
            printf("s.add(");
            for (n = 0; n <= 9; ++n)
            {
                if (n != 9)
                    printf("input[%d]*%d+", k*10+n, mulbuf[10 * n + m]);
                else
                    printf("input[%d]*%d", k * 10+ n, mulbuf[10 * n + m]);
            }
            printf("==%d)\n",data[10*k+m]);
               
        }
    }
	return 0;
}

3.Z3求解

from z3 import *
input=[BitVec('flag[%d]'%i,8)for i in range(40)]
s=Solver()
for i in input:
    s.add(i>=32,i<=127)
s.add(input[0]*23+input[1]*69+input[2]*56+input[3]*92+input[4]*64+input[5]*16+input[6]*20+input[7]*80+input[8]*1+input[9]*37==33211)
s.add(input[0]*13+input[1]*1+input[2]*19+input[3]*12+input[4]*83+input[5]*16+input[6]*63+input[7]*92+input[8]*99+input[9]*67==36113)
s.add(input[0]*4+input[1]*13+input[2]*62+input[3]*16+input[4]*71+input[5]*52+input[6]*2+input[7]*93+input[8]*30+input[9]*60==28786)
s.add(input[0]*48+input[1]*45+input[2]*70+input[3]*64+input[4]*52+input[5]*43+input[6]*99+input[7]*58+input[8]*28+input[9]*54==44634)
s.add(input[0]*41+input[1]*41+input[2]*23+input[3]*31+input[4]*99+input[5]*0+input[6]*0+input[7]*84+input[8]*56+input[9]*51==30174)
s.add(input[0]*41+input[1]*64+input[2]*63+input[3]*3+input[4]*89+input[5]*44+input[6]*57+input[7]*74+input[8]*1+input[9]*79==39163)
s.add(input[0]*42+input[1]*8+input[2]*30+input[3]*17+input[4]*76+input[5]*50+input[6]*79+input[7]*81+input[8]*12+input[9]*38==34923)
s.add(input[0]*33+input[1]*80+input[2]*68+input[3]*71+input[4]*68+input[5]*32+input[6]*43+input[7]*45+input[8]*77+input[9]*87==44333)
s.add(input[0]*30+input[1]*15+input[2]*17+input[3]*58+input[4]*1+input[5]*50+input[6]*71+input[7]*55+input[8]*92+input[9]*48==33574)
s.add(input[0]*3+input[1]*42+input[2]*56+input[3]*9+input[4]*99+input[5]*31+input[6]*19+input[7]*21+input[8]*4+input[9]*16==23555)
s.add(input[10]*23+input[11]*69+input[12]*56+input[13]*92+input[14]*64+input[15]*16+input[16]*20+input[17]*80+input[18]*1+input[19]*37==35015)
s.add(input[10]*13+input[11]*1+input[12]*19+input[13]*12+input[14]*83+input[15]*16+input[16]*63+input[17]*92+input[18]*99+input[19]*67==42724)
s.add(input[10]*4+input[11]*13+input[12]*62+input[13]*16+input[14]*71+input[15]*52+input[16]*2+input[17]*93+input[18]*30+input[19]*60==34160)
s.add(input[10]*48+input[11]*45+input[12]*70+input[13]*64+input[14]*52+input[15]*43+input[16]*99+input[17]*58+input[18]*28+input[19]*54==49166)
s.add(input[10]*41+input[11]*41+input[12]*23+input[13]*31+input[14]*99+input[15]*0+input[16]*0+input[17]*84+input[18]*56+input[19]*51==35770)
s.add(input[10]*41+input[11]*64+input[12]*63+input[13]*3+input[14]*89+input[15]*44+input[16]*57+input[17]*74+input[18]*1+input[19]*79==45984)
s.add(input[10]*42+input[11]*8+input[12]*30+input[13]*17+input[14]*76+input[15]*50+input[16]*79+input[17]*81+input[18]*12+input[19]*38==39754)
s.add(input[10]*33+input[11]*80+input[12]*68+input[13]*71+input[14]*68+input[15]*32+input[16]*43+input[17]*45+input[18]*77+input[19]*87==51672)
s.add(input[10]*30+input[11]*15+input[12]*17+input[13]*58+input[14]*1+input[15]*50+input[16]*71+input[17]*55+input[18]*92+input[19]*48==38323)
s.add(input[10]*3+input[11]*42+input[12]*56+input[13]*9+input[14]*99+input[15]*31+input[16]*19+input[17]*21+input[18]*4+input[19]*16==27511)
s.add(input[20]*23+input[21]*69+input[22]*56+input[23]*92+input[24]*64+input[25]*16+input[26]*20+input[27]*80+input[28]*1+input[29]*37==31334)
s.add(input[20]*13+input[21]*1+input[22]*19+input[23]*12+input[24]*83+input[25]*16+input[26]*63+input[27]*92+input[28]*99+input[29]*67==34214)
s.add(input[20]*4+input[21]*13+input[22]*62+input[23]*16+input[24]*71+input[25]*52+input[26]*2+input[27]*93+input[28]*30+input[29]*60==28014)
s.add(input[20]*48+input[21]*45+input[22]*70+input[23]*64+input[24]*52+input[25]*43+input[26]*99+input[27]*58+input[28]*28+input[29]*54==41090)
s.add(input[20]*41+input[21]*41+input[22]*23+input[23]*31+input[24]*99+input[25]*0+input[26]*0+input[27]*84+input[28]*56+input[29]*51==29258)
s.add(input[20]*41+input[21]*64+input[22]*63+input[23]*3+input[24]*89+input[25]*44+input[26]*57+input[27]*74+input[28]*1+input[29]*79==37905)
s.add(input[20]*42+input[21]*8+input[22]*30+input[23]*17+input[24]*76+input[25]*50+input[26]*79+input[27]*81+input[28]*12+input[29]*38==33777)
s.add(input[20]*33+input[21]*80+input[22]*68+input[23]*71+input[24]*68+input[25]*32+input[26]*43+input[27]*45+input[28]*77+input[29]*87==39812)
s.add(input[20]*30+input[21]*15+input[22]*17+input[23]*58+input[24]*1+input[25]*50+input[26]*71+input[27]*55+input[28]*92+input[29]*48==29442)
s.add(input[20]*3+input[21]*42+input[22]*56+input[23]*9+input[24]*99+input[25]*31+input[26]*19+input[27]*21+input[28]*4+input[29]*16==22225)
s.add(input[30]*23+input[31]*69+input[32]*56+input[33]*92+input[34]*64+input[35]*16+input[36]*20+input[37]*80+input[38]*1+input[39]*37==30853)
s.add(input[30]*13+input[31]*1+input[32]*19+input[33]*12+input[34]*83+input[35]*16+input[36]*63+input[37]*92+input[38]*99+input[39]*67==35330)
s.add(input[30]*4+input[31]*13+input[32]*62+input[33]*16+input[34]*71+input[35]*52+input[36]*2+input[37]*93+input[38]*30+input[39]*60==30393)
s.add(input[30]*48+input[31]*45+input[32]*70+input[33]*64+input[34]*52+input[35]*43+input[36]*99+input[37]*58+input[38]*28+input[39]*54==41247)
s.add(input[30]*41+input[31]*41+input[32]*23+input[33]*31+input[34]*99+input[35]*0+input[36]*0+input[37]*84+input[38]*56+input[39]*51==30439)
s.add(input[30]*41+input[31]*64+input[32]*63+input[33]*3+input[34]*89+input[35]*44+input[36]*57+input[37]*74+input[38]*1+input[39]*79==39434)
s.add(input[30]*42+input[31]*8+input[32]*30+input[33]*17+input[34]*76+input[35]*50+input[36]*79+input[37]*81+input[38]*12+input[39]*38==31587)
s.add(input[30]*33+input[31]*80+input[32]*68+input[33]*71+input[34]*68+input[35]*32+input[36]*43+input[37]*45+input[38]*77+input[39]*87==46815)
s.add(input[30]*30+input[31]*15+input[32]*17+input[33]*58+input[34]*1+input[35]*50+input[36]*71+input[37]*55+input[38]*92+input[39]*48==35205)
s.add(input[30]*3+input[31]*42+input[32]*56+input[33]*9+input[34]*99+input[35]*31+input[36]*19+input[37]*21+input[38]*4+input[39]*16==20689)

if s.check()==sat:
    print(s.model())

flag=[i for i in range(40)]

flag[26]=112
flag[0]=68
flag[2]=83
flag[16]=118
flag[18]=97
flag[20]=67
flag[23]=50
flag[13]=53
flag[5]=70
flag[4]=84
flag[15]=105
flag[1]=65
flag[21]=53
flag[27]=83
flag[30]=76
flag[32]=53
flag[31]=83
flag[34]=53
flag[37]=53
flag[7]=67
flag[8]=73
flag[9]=53
flag[24]=86
flag[25]=53
flag[38]=89
flag[11]=67
flag[14]=112
flag[28]=50
flag[6]=123
flag[29]=54
flag[19]=97
flag[17]=53
flag[36]=69
flag[12]=77
flag[33]=53
flag[10]=90
flag[39]=125
flag[35]=113
flag[22]=76
flag[3]=67

for i in flag:
    print(chr(i),end='')
#DASCTF{CI5ZCM5piv5aaC5L2V5pS26LS555qE5Y}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/781228.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

redis的简单入门

redis的简单入门

文章目录 一、前言1.1、什么是Redis? 二、简介三、Redis下载与安装四、Redis服务启动与停止五、Redis设置密码进行远程连接5.1、设置密码5.2、远程连接 六、Redis数据类型七、Redis常用命令7.1、字符串String命令7.2、哈希hash操作命令7.3、列表list操作命令7.4、集合set操作命…
阅读更多...
机器人SLAM导航学习-All in one

机器人SLAM导航学习-All in one

参考引用 张虎&#xff0c;机器人SLAM导航核心技术与实战[M]. 机械工业出版社&#xff0c;2022.本博客未详尽之处可自行查阅上述书籍 一、编程基础篇 1. ROS 入门必备知识 ROS学习笔记&#xff08;文章链接汇总&#xff09; 2. C 编程范式 《21天学通C》读书笔记&#xff0…
阅读更多...
leetcode743. 网络延迟时间 DJ

leetcode743. 网络延迟时间 DJ

https://leetcode.cn/problems/network-delay-time/ 有 n 个网络节点&#xff0c;标记为 1 到 n。 给你一个列表 times&#xff0c;表示信号经过 有向 边的传递时间。 times[i] (ui, vi, wi)&#xff0c;其中 ui 是源节点&#xff0c;vi 是目标节点&#xff0c; wi 是一个信…
阅读更多...
python_day13

python_day13

reduceByKey算子&#xff0c;聚合 列表中存放二元元组&#xff0c;元组中第一个为key&#xff0c;此算子按key聚合&#xff0c;传入计算逻辑 from pyspark import SparkConf, SparkContext import osos.environ["PYSPARK_PYTHON"] "D:/dev/python/python3.10…
阅读更多...
Geriit使用出错记录

Geriit使用出错记录

拉取服务器代码&#xff08;clone &#xff09; 1、执行&#xff1a;git clone ssh:xxxxxx && scp -p -P 29418 xxxxxxxxx 1、报错&#xff1a;Unable to negotiate with XX.XX.XX.XX port XX:: no matching key exchange method found. Their offer: diffie-hellman…
阅读更多...
第五章 编程之免交互

第五章 编程之免交互

免交互&#xff1a;不需要人为控制就可以完成的自动化操作&#xff08;自动化运维&#xff09; shell脚本和面交互是一个概念&#xff0c;但是两种写法 shell&#xff1a;默认解释器是bash 使用i/o&#xff08;输入/输出&#xff09;重定向的方式&#xff0c;将命令的列表提供…
阅读更多...
pytest钩子函数（二）：初始化钩子

pytest钩子函数（二）：初始化钩子

前言 pytest这个框架提供了非常多的钩子。通过这些钩子我们可以对pytest 用例收集、用例执行、报告输出等各个阶段进行干预&#xff0c;根据需求去开发对应的插件&#xff0c;以满足自己的使用场景。 01 什么是钩子函数&#xff1f; 钩子函数在pytest称之为Hook函数,它pytes…
阅读更多...
【头歌】二叉树的二叉链表存储及基本操作

【头歌】二叉树的二叉链表存储及基本操作

第1关：先序遍历创建二叉链表存储的二叉树及遍历操作 任务描述 本关任务：以二叉链表作存储结构存储二叉树，利用先序递归遍历创建二叉树，并依次进行二叉树的前序、中序、后序递归遍历。 相关知识 在顺序存储结构中，利用数组下标表示元素的位置及元素之间孩子或双亲的关系…
阅读更多...
失去中国市场的三星继续称霸全球，中国手机的份额反而进一步下降了

失去中国市场的三星继续称霸全球，中国手机的份额反而进一步下降了

市调机构canalys公布了二季度全球手机市场的数据&#xff0c;数据显示三星、苹果的市场份额保持稳定并位居全球前二&#xff0c;三星的表现显然让人称奇&#xff0c;一直被唱衰&#xff0c;却一直都稳稳占据全球手机市场第一名。 从Canalys公布的数据可以看到&#xff0c;三星以…
阅读更多...
【Go】 map 精髓理解

【Go】 map 精髓理解

map go map 的底层结构 hmap&#xff0c;的四个元素 然后再讲一下 buckets 的元素&#xff0c;讲一下 hash 冲突&#xff0c;和解决方法 再讲一下&#xff0c;增量扩容和等量扩容 再讲一下增删改查的过程&#xff0c;就查询过程 map 基础 向值为 nil 的 map 添加元素会发生 pa…
阅读更多...
青枫壁纸小程序V1.4.0（后端SpringBoot）

青枫壁纸小程序V1.4.0（后端SpringBoot）

引言 那么距离上次的更新已经过去了5个多月&#xff0c;期间因为忙着毕业设计的原因&#xff0c;更新的速度变缓了许多。所以&#xff0c;这次的更新无论是界面UI、用户功能、后台功能都有了非常大的区别。希望这次更新可以给用户带来更加好的使用体验 因为热爱&#xff0c;更…
阅读更多...
【湍流介质的三维传播模拟器】全衍射3-D传播模拟器，用于在具有随机和背景结构的介质中传播无线电和光传播（Matlab代码实现）

【湍流介质的三维传播模拟器】全衍射3-D传播模拟器，用于在具有随机和背景结构的介质中传播无线电和光传播（Matlab代码实现）

目录 &#x1f4a5;1 概述 &#x1f4da;2 运行结果 &#x1f389;3 参考文献 &#x1f308;4 Matlab代码实现 &#x1f4a5;1 概述 全衍射3-D传播模拟器是一种用于模拟在具有随机和背景结构的介质中传播无线电和光的工具。它可以帮助研究人员和工程师理解和预测无线电波和光波…
阅读更多...
多重感知机MLP：Mnist

多重感知机MLP：Mnist

文章目录 网络结构代码common_utils.pynetwork.pyprovider.pytrain.pytest.pyvisual.py 实验训练结果测试结果可视化 网络结构 输入过程输出28*28Flatten784784Linear300300Linear100100Linear10 代码 文件结构&#xff1a; common_utils.py 用来输出日志文件 # common_…
阅读更多...
基于扩展(EKF)和无迹卡尔曼滤波(UKF)的电力系统动态状态估计

基于扩展(EKF)和无迹卡尔曼滤波(UKF)的电力系统动态状态估计

1 主要内容 该程序对应文章《Power System Dynamic State Estimation Using Extended and Unscented Kalman Filters》&#xff0c;电力系统状态的准确估计对于提高电力系统的可靠性、弹性、安全性和稳定性具有重要意义&#xff0c;虽然近年来测量设备和传输技术的发展大大降低…
阅读更多...
Linux常用嗅探工具（1）：fping命令

Linux常用嗅探工具（1）：fping命令

fping的优点&#xff1a; 可以一次ping多个主机可以从主机列表文件ping结果清晰 便于脚本处理速度快 fping的安装&#xff1a; 前置安装cgg编译器 &#xff1a; yum -y install gcc 下载fping&#xff1a; wget http://fping.org/dist/fping-4.0.tar.gz 解压&#xff1a; …
阅读更多...
力扣 -- 918. 环形子数组的最大和

力扣 -- 918. 环形子数组的最大和

一、题目&#xff1a; 题目链接&#xff1a;918. 环形子数组的最大和 - 力扣&#xff08;LeetCode&#xff09; 二、解题步骤&#xff1a; 下面是用动态规划的思想解决这道题的过程&#xff0c;相信各位小伙伴都能看懂并且掌握这道经典的动规题目滴。 三、参考代码&#xff1…
阅读更多...
Redis 基础知识和核心概念解析：探索 Redis 的数据结构与存储方式

Redis 基础知识和核心概念解析：探索 Redis 的数据结构与存储方式

&#x1f337;&#x1f341; 博主 libin9iOak带您 Go to New World.✨&#x1f341; &#x1f984; 个人主页——libin9iOak的博客&#x1f390; &#x1f433; 《面试题大全》 文章图文并茂&#x1f995;生动形象&#x1f996;简单易学&#xff01;欢迎大家来踩踩~&#x1f33…
阅读更多...
F---图像识别---河南省第十三届ICPC大学生程序设计竞赛

F---图像识别---河南省第十三届ICPC大学生程序设计竞赛

链接&#xff1a;登录—专业IT笔试面试备考平台_牛客网 来源&#xff1a;牛客网 输入 10 10 ........*. ........*. ........*. ........*. ....#...*. ........*. ........*. ********** ........*. ........*. 输出 -4 3 解析&#xff1a; 遍历整个二维数组&#xff0…
阅读更多...
dubbo从基于注解方式转为基于xml配置方式的使用心得

dubbo从基于注解方式转为基于xml配置方式的使用心得

过程中遇到的问题百分之九十九的问题都是因为版本不兼容问题&#xff0c;所以在引入依赖的时候要注意这点&#xff0c;可以从maven central repository官方仓库这里看所要引用版本与其可兼容的版本
阅读更多...
畅想未来感汽车HMI设计的奇妙之旅！

畅想未来感汽车HMI设计的奇妙之旅！

当下智能电动汽车的发展势头越来越高涨&#xff0c;与智能电动汽车相关的汽车HMI设计也成为各个品牌重点发力的地方&#xff0c;汽车HMI设计正在前所未有的新高度&#xff0c;本篇文章就来聊聊HMI设计的那些事 ⬇⬇⬇点击获取更多设计资源 https://js.design/community?categ…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023