xml复制代码<!--mysql依赖--><dependency>    
<groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<!--引入jdbc stater-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

sql复制代码CREATE TABLE `user` (
  `id` int(11) NOT NULL COMMENT '主键id',
  `name` varchar(255) NOT NULL COMMENT '用户名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `sex` varchar(2) DEFAULT NULL COMMENT '性别',
  `address` varchar(255) DEFAULT NULL COMMENT '住址',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

yaml复制代码spring:
  profiles:
    # 控制使用哪套环境变量
    active: dev

yaml复制代码#开发环境数据库信息
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/springboot_db?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456   #数据库名、用户名和密码改为自己的
    driver-class-name: com.mysql.cj.jdbc.Driver

kotlin复制代码package com.example.demo.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;import java.util.Map;

@RestController
@RequestMapping("/user")
public class UserController {

    //注入JDBC模板接口
    @Autowired
    private JdbcTemplate jdbcTemplate;


    /**
     * 查询所有用户信息
     */
    @GetMapping("/get-users")
    public List<Map<String, Object>> getUserList(){
        //查询sql语句
        String sql = "select * from user";
        List<Map<String, Object>> list =  jdbcTemplate.queryForList(sql);
        //返回结果
        return list;
    }
}

scss复制代码public class HalfPackageServer {

    public static void main(String[] args) {

        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            //设置服务器接收端缓冲区大小为10
            serverBootstrap.option(ChannelOption.SO_RCVBUF,10);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            //此处打印输出，看看收到的内容是10次16字节，还是一次160字节
                            printBuf((ByteBuf) msg);
                            super.channelRead(ctx, msg);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            //阻塞等待连接
            channelFuture.sync();
            //阻塞等待释放连接
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            System.out.println("server error:" + e);
        } finally {
            // 释放EventLoopGroup
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    static void printBuf(ByteBuf byteBuf){
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i< byteBuf.writerIndex();i++) {
            stringBuilder.append(byteBuf.getByte(i));
            stringBuilder.append(" ");
        }

        stringBuilder.append("| 长度：");
        stringBuilder.append(byteBuf.writerIndex());
        stringBuilder.append("字节");
        System.out.println(stringBuilder);
    }
}

java复制代码public class HalfPackageClient {
    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        //建立连接成功后，会触发active事件
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            //循环发送，每次16字节，共10次
                            for (int i = 0; i < 10; i++) {
                                ByteBuf buffer = ctx.alloc().buffer();
                                buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
                                ctx.writeAndFlush(buffer);
                            }
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            //释放连接
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            System.out.println("client error :" + e);
        } finally {
            //释放EventLoopGroup
            worker.shutdownGracefully();
        }
    }
}

复制代码0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | 长度：160字节

scss复制代码public class HalfPackageServer {

    public static void main(String[] args) {

        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            //设置服务器接收端缓冲区大小为10
            serverBootstrap.option(ChannelOption.SO_RCVBUF,10);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            //此处打印输出，看看收到的内容是10次16字节，还是一次160字节
                            printBuf((ByteBuf) msg);
                            super.channelRead(ctx, msg);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            //阻塞等待连接
            channelFuture.sync();
            //阻塞等待释放连接
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            System.out.println("server error:" + e);
        } finally {
            // 释放EventLoopGroup
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    static void printBuf(ByteBuf byteBuf){
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i< byteBuf.writerIndex();i++) {
            stringBuilder.append(byteBuf.getByte(i));
            stringBuilder.append(" ");
        }

        stringBuilder.append("| 长度：");
        stringBuilder.append(byteBuf.writerIndex());
        stringBuilder.append("字节");
        System.out.println(stringBuilder);
    }
}

复制代码0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 | 长度：36字节
4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 | 长度：40字节
12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 | 长度：40字节
4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 | 长度：40字节
12 13 14 15 | 长度：4字节

scss复制代码public class FixedLengthServer {

    public static void main(String[] args) {

        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new FixedLengthFrameDecoder(8));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            //此处打印输出，看看收到的内容是10次16字节，还是一次160字节
                            printBuf((ByteBuf) msg);
                            super.channelRead(ctx, msg);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            //阻塞等待连接
            channelFuture.sync();
            //阻塞等待释放连接
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            System.out.println("server error:" + e);
        } finally {
            // 释放EventLoopGroup
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    static void printBuf(ByteBuf byteBuf) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < byteBuf.writerIndex(); i++) {
            stringBuilder.append(byteBuf.getByte(i));
            stringBuilder.append(" ");
        }

        stringBuilder.append("| 长度：");
        stringBuilder.append(byteBuf.writerIndex());
        stringBuilder.append("字节");
        System.out.println(stringBuilder);
    }
}

ini复制代码public class FixedLengthClient {
    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        //建立连接成功后，会触发active事件
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            // 发送内容随机的数据包
                            Random r = new Random();
                            char c = 1;
                            ByteBuf buffer = ctx.alloc().buffer();
                            for (int i = 0; i < 10; i++) {
                                byte[] bytes = new byte[8];
                                for (int j = 0; j < r.nextInt(8); j++) {
                                    bytes[j] = (byte) c;
                                }
                                c++;
                                buffer.writeBytes(bytes);
                            }
                            ctx.writeAndFlush(buffer);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            //释放连接
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            System.out.println("client error :" + e);
        } finally {
            //释放EventLoopGroup
            worker.shutdownGracefully();
        }
    }
}

复制代码1 1 0 0 0 0 0 0 | 长度：8字节
2 2 2 2 0 0 0 0 | 长度：8字节
3 0 0 0 0 0 0 0 | 长度：8字节
4 4 4 0 0 0 0 0 | 长度：8字节
5 5 5 5 0 0 0 0 | 长度：8字节
6 0 0 0 0 0 0 0 | 长度：8字节
7 0 0 0 0 0 0 0 | 长度：8字节
8 8 0 0 0 0 0 0 | 长度：8字节
9 9 9 0 0 0 0 0 | 长度：8字节
10 10 10 10 10 0 0 0 | 长度：8字节

java复制代码public class LineBasedServer {

    public static void main(String[] args) {

        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            ByteBuf byteBuf = (ByteBuf) msg;
                            System.out.println(byteBuf.toString(StandardCharsets.UTF_8));
                            super.channelRead(ctx, msg);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            //阻塞等待连接
            channelFuture.sync();
            //阻塞等待释放连接
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            System.out.println("server error:" + e);
        } finally {
            // 释放EventLoopGroup
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }
}

java复制代码public class LineBasedClient {
    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        //建立连接成功后，会触发active事件
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            // 发送带有分隔符的数据包
                            ByteBuf buffer = ctx.alloc().buffer();
                            String str = "hello world\nhello world\n\rhello world\nhello world";
                            buffer.writeBytes(str.getBytes(StandardCharsets.UTF_8));
                            ctx.writeAndFlush(buffer);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            //释放连接
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            System.out.println("client error :" + e);
        } finally {
            //释放EventLoopGroup
            worker.shutdownGracefully();
        }
    }
}

复制代码hello world
hello world
hello world

java复制代码protected void initChannel(SocketChannel ch) throws Exception {
                    ByteBuf buffer = ch.alloc().buffer();
                    buffer.writeBytes("||".getBytes(StandardCharsets.UTF_8));
                    ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, buffer));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            ByteBuf byteBuf = (ByteBuf) msg;
                            System.out.println(byteBuf.toString(StandardCharsets.UTF_8));
                            super.channelRead(ctx, msg);
                        }
                    });
                }

ini复制代码String str = "hello world||hello world||hello world||hello world";

java复制代码public LengthFieldBasedFrameDecoder(
            int maxFrameLength,
            int lengthFieldOffset, 
            int lengthFieldLength,
            int lengthAdjustment, 
            int initialBytesToStrip)

java复制代码/**
 * @description： TODO
 * @author：weirx
 * @date：2021/11/12 15:34
 * @version：3.0
 */
public class LineBasedServer {

    public static void main(String[] args) {

        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024,1,4,1,5));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            ByteBuf byteBuf = (ByteBuf) msg;
                            System.out.println(byteBuf.readByte() + "|" + byteBuf.toString(StandardCharsets.UTF_8));
                            super.channelRead(ctx, msg);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            //阻塞等待连接
            channelFuture.sync();
            //阻塞等待释放连接
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            System.out.println("server error:" + e);
        } finally {
            // 释放EventLoopGroup
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }
}

scss复制代码public class LineBasedClient {
    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        //建立连接成功后，会触发active事件
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                           send(ctx,"hello, world");
                            send(ctx,"HI!");
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            //释放连接
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            System.out.println("client error :" + e);
        } finally {
            //释放EventLoopGroup
            worker.shutdownGracefully();
        }
    }

    static void send(ChannelHandlerContext ctx,String msg){
        ByteBuf buffer = ctx.alloc().buffer();
        byte[] bytes = msg.getBytes();
        int length = bytes.length;
        //先写Header 1
        buffer.writeByte(1);
        //再写长度
        buffer.writeInt(length);
        //再写Header 2
        buffer.writeByte(2);
        //最后写内容
        buffer.writeBytes(bytes);
        ctx.writeAndFlush(buffer);
    }
}

复制代码2|hello, world
2|HI!

csharp复制代码/// <summary>
    /// 栈接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    interface IStack<T>
    {
        /// <summary>
        /// 清空栈
        /// </summary>
        /// <returns></returns>
        bool ClearStack();
        /// <summary>
        /// 判断栈是否为空
        /// </summary>
        /// <returns>true:空、false：不空</returns>
        bool IsEmptyStack();
        /// <summary>
        /// 获取栈顶元素
        /// </summary>
        /// <returns></returns>
        T GetTopStack();
        /// <summary>
        /// 入栈
        /// </summary>
        /// <returns></returns>
        bool PushStack(T val);
        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns></returns>
        bool PopStack();
        /// <summary>
        /// 获取栈长度
        /// </summary>
        /// <returns></returns>
        int LengthStack();
        /// <summary>
        /// 判断栈是否已满
        /// </summary>
        /// <returns></returns>
        bool IsFull();
        /// <summary>
        /// 打印栈
        /// </summary>
        void paint();
    }

csharp复制代码/// <summary>
        /// 顺序栈的容量（数组最大长度）
        /// </summary>
        private int maxsize;
        /// <summary>
        /// 数组，用于存储顺序栈中的数据元素
        /// </summary>
        private T[] data;
        /// <summary>
        /// 指示顺序栈的栈顶(top = -1 时表示栈为空)
        /// </summary>
        private int top;

csharp复制代码public class StackList<T> : IStack<T>
    {
        /// <summary>
        /// 顺序栈的容量（数组最大长度）
        /// </summary>
        private int maxsize;
        /// <summary>
        /// 数组，用于存储顺序栈中的数据元素
        /// </summary>
        private T[] data;
        /// <summary>
        /// 指示顺序栈的栈顶(top = -1 时表示栈为空)
        /// </summary>
        private int top;
        /// <summary>
        /// 构造函数
        /// </summary>
        public StackList(int size)
        {
            data = new T[size];
            maxsize = size;
            top = -1;
        }
        /// <summary>
        /// 清空栈(这里不需要将数组清空，只要将顶栈赋值为-1就好)
        /// </summary>
        /// <returns></returns>
        public bool ClearStack()
        {
            top = -1;
            return true;
        }
        /// <summary>
        /// 获取栈顶
        /// </summary>
        /// <returns></returns>
        public T GetTopStack()
        {
            T res = data[top];
            return res;
        }
        /// <summary>
        /// 是否是空栈
        /// </summary>
        /// <returns></returns>
        public bool IsEmptyStack()
        {
            if (top == -1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 获取栈的长度
        /// </summary>
        /// <returns></returns>
        public int LengthStack()
        {
            return top + 1;
        }
        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns></returns>
        public bool PopStack()
        {
            if (IsEmptyStack())
            {
                Console.WriteLine("栈为空，无法删除！");
                return false;
            }
            T temp = default(T);
            data[top] = temp;
            top--;
            return true;
        }
        /// <summary>
        /// 入栈
        /// </summary>
        /// <returns></returns>
        public bool PushStack(T val)
        {
            if (IsFull())
            {
                Console.WriteLine("栈已满，写入失败！");
                return false;
            }
            top++;
            data[top] = val;
            return true;
        }
        /// <summary>
        /// 判断栈是否已满
        /// </summary>
        /// <returns></returns>
        public bool IsFull()
        {
            if (top == maxsize - 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 打印栈
        /// </summary>
        public void paint()
        {
            Console.WriteLine("栈顶："+top);
            for (int i = 0; i < data.Length; i++)
            {
                Console.WriteLine("index:"+i + " | data:"+data[i]);
            }
        }
    }

ini复制代码Input: n = 0
Output: 0

vbnet复制代码Input: n = 3
Output: 2
Explanation: The binary representation of 3 is "11".
"11" -> "01" with the 2nd operation since the 0th bit is 1.
"01" -> "00" with the 1st operation.

vbnet复制代码Input: n = 6
Output: 4
Explanation: The binary representation of 6 is "110".
"110" -> "010" with the 2nd operation since the 1st bit is 1 and 0th through 0th bits are 0.
"010" -> "011" with the 1st operation.
"011" -> "001" with the 2nd operation since the 0th bit is 1.
"001" -> "000" with the 1st operation.

ini复制代码Input: n = 9
Output: 14

ini复制代码Input: n = 333
Output: 393

复制代码0 <= n <= 109

python复制代码class Solution(object):
    
    def __init__(self):
        self.d = {}
        self.t = {}
        
    def minimumOneBitOperations(self, n):
        """
        :type n: int
        :rtype: int
        """
        return(self.dfs(bin(n)[2:]))
    
    def dfs(self, s):
        if s == '0' : return 0
        if s == '1' : return 1
        if s in self.d : return self.d[s]
        if  s[0] == '0': return self.dfs(s[1:])
        m = s[1:]
        n = list(s[1:])
        n[0] = '1'
        for i in range(1, len(n)):
            n[i] = '0'
        n = ''.join(n)
        self.d[s] = self.convert(m) + 1 + self.dfs(n)
        return self.d[s]
    
    def convert(self, s):
        if s == '0' : return 1
        if s == '1' : return 0
        if s in self.t : return self.t[s]
        if s[0] == '1': 
            self.t[s] = self.dfs(s[1:])
        else:
            m = s[1:]
            n = list(s[1:])
            n[0] = '1'
            for i in range(1, len(n)):
                n[i] = '0'
            n = ''.join(n)
            self.t[s] = self.convert(m) + 1 + self.dfs(n)
        return self.t[s]

erlang复制代码Runtime: 44 ms, faster than 5.17% of Python online submissions for Minimum One Bit Operations to Make Integers Zero.
Memory Usage: 13.3 MB, less than 77.59% of Python online submissions for Minimum One Bit Operations to Make Integers Zero.

js复制代码package main

import (
   "flag"
   "log"
)

func main() {
   var file string
   var name string
   var ssl bool
   flag.StringVar(&file, "f", "", "需要上传的文件")
   flag.StringVar(&name, "n", "", "上传后名称")
   flag.BoolVar(&ssl, "s", false, "开关，默认关闭")
   flag.Parse()

   if flag.NFlag() < 2 {
      log.Println(flag.NFlag())
      log.Fatalln("最少传2个参数!!!")
   }
   log.Println(file,name,ssl)
}

js复制代码package main

import (
   "flag"
   "log"
   "os"
)

func main() {

   message := flag.String("message", "", "消息通知")
   number := flag.Int("number",0,"发送数量，默认0条")
   status := flag.Bool("status",false,"通知开关，默认关闭")
   delay := flag.Duration("delay",0,"是否延迟，默认关闭")
   flag.Parse()

   if len(os.Args) < 4 {
      log.Println(len(os.Args))
      log.Fatalln("最少传4个参数!!!")
   }
   log.Println(*message,*number,*status,delay)
}

java复制代码persistent://core/order/create-order

java复制代码王者荣耀洛克王国版模拟游戏
1、系统需求：
用户方：
1、登录 输入用户名 密码 进行登录 
2、选择英雄进行游戏
包括： 英雄的类型、英雄的攻击值、攻击命中率
目前类型为：妲己和貂蝉
3、游戏开始后，英雄发起攻击，根据英雄的攻击值和命中率，计算分数
4、游戏结束后可将分数记录下来
5、可以查看以前的游戏分数

java复制代码管理员方：
1、登录 默认 用户名：admin 密码：123 ,后期从XML文件中读出
用户名密码输入三次错误，则退出游戏
2、新增玩家
3、修改玩家
4、删除玩家
5、查询玩家
6、查询游戏
7、分数统计
8、参数设置

java复制代码2、系统界面：

1、首页

~~~~~~~~~~~~~~~菜单界面~~~~~~~~~~~~~~~~~~

	   王者荣耀的洛克王国版

1.玩家登陆

2.管理员登录

3.退出

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
请输入您想选择模式前的数值：

java复制代码
2、选择“1、玩家登录”
******************************************************

玩 家 登 录

请输入用户名：
请输入密码：

******************************************************
如果用户名和密码输入正确（需要管理员添加玩家）
则出现界面如下：

恭喜登陆成功！

java复制代码
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	  王者荣耀洛克王国版

1·开始游戏
2·查看成绩
0·返回上级
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
请选择：

java复制代码	2.1开始游戏
	您以选择成功！
	开始游戏!
	欢迎来到王者荣耀洛克王国版虚拟画面
	妲己：主法术攻击技能有三
	技能一：月刃   攻击值100
	技能二：魅惑   攻击值150
	技能三：狐之殇  攻击值300
	请输入您要使用的技能：
	1
	技能：月刃
	描述：对敌方造成法术伤害
	
	太棒了教对面做人！

java复制代码
	
	妲己：主法术攻击技能有三
	技能一：月刃   攻击值100
	技能二：魅惑   攻击值150
	技能三：狐之殇  攻击值300
	请输入您要使用的技能：
	2
	
	哎呀，打偏了我的我的！
	
	
	妲己：主法术攻击技能有三
	技能一：月刃   攻击值100
	技能二：魅惑   攻击值150
	技能三：狐之殇  攻击值300
	请输入您要使用的技能：
	3
	技能：狐之殇
	描述：对地方造成法术伤害+加减速效果
	
	成功超神！


java复制代码	攻击结束鲁迅您的得分：400
	是否继续？(是或否)


	2.2查看成绩
游戏时间				        分数
2021-08-07 00:00:00.0		600
2021-08-08 07:56:37.0		450
2021-08-08 16:38:03.0		400
1、返 回 上 级
	2.3返回上级

 返回首页

java复制代码
3、选择“2、管理员登录”
******************************************************

管 理 员 登 录

请输入用户名：
请输入密码：

******************************************************
如果用户名和密码输入正确（默认都为admin）
则出现界面如下：
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1·新增玩家
2·修改玩家
3·删除玩家
4·查询玩家
5·查询游戏英雄
6·分数统计
7·参数设置
0·返回上级
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
如果密码输错三次则退出游戏。系统关闭

java复制代码

	3.1 新增玩家
新增玩家：
请输入玩家的登录名：（必须要有字母，且在系统中唯一）
请输入玩家的密码：（必须要有字母和数字，且最少不能少于6位）
请输入玩家的昵称：
请输入玩家的性别：（只可输入男或女）
请输入玩家的年龄：（只可输入正整数，且最大不可大于99）


新增玩家成功！
1、继续新增玩家
0、返 回 上 级

java复制代码
	3.2 修改玩家
请选择要修改的玩家：
1、xx1	2、xx2	3、xx3	4、XX4
选“1”修改xx1
选择要修改的属性：
1、玩家的密码：（必须要有字母和数字，且最少不能少于6位）
2、玩家的昵称：
3、玩家的性别：（只可输入男或女）
4、玩家的年龄：（只可输入正整数，且最大不可大于100）

0、返回上级

java复制代码

	3.3 删除玩家
请选择要删除的玩家：
1、xx1	2、xx2	3、xx3	4、XX4
选“1”删除xx1
全部删除后不可再删除

0、返回上级

java复制代码
	3.4 查询玩家
	1·查询全部玩家
	2·根据登陆名查找
	0·回退
	loginname	 nickname	 sex	 age	
	周树人	    鲁迅	       男	18
	阿秀	       领导人	    男	20
	李大钊	    守常	       男	19
	123a	肥学	男	23


0、返 回 上 级
********************************************************************

java复制代码

	3.5 查询游戏英雄
*******************************************************************************
英雄名：妲己
一技能：月刃  攻击力：100  命中率：90
二技能：魅惑  攻击力：150  命中率：80
三技能：狐之殇  攻击力：300  命中率：60
英雄名：貂蝉
一技能：独舞  攻击力：90  命中率：90
二技能：谗诱  攻击力：150  命中率：80
三技能：拜月  攻击力：200  命中率：80

java复制代码
	3.6分数统计
玩家	     总分	  战力指数
	周树人   1450      ¤¤¤¤¤

java复制代码
	3.7参数设置
	1·管理员的登陆名
	2·管理员密码
	3·管理员的最大登录次数
	
	以下仅作英雄详情展示
	英雄ID：1  英雄名：妲己
	技能一 伤害值：100: 命中率：90
	技能二 伤害值：150: 命中率：80
	技能三 伤害值：300: 命中率：60
	~~~
	英雄ID：2  英雄名：貂蝉
	技能一 伤害值：90: 命中率：90
	技能二 伤害值：150: 命中率：80
	技能三 伤害值：200: 命中率：80
	~~~
4、选择“0、退出”
系统提示“游戏结束。。。。。。”系统关闭

java复制代码public class AdminManager {
	/**
	 * 登录
	 * @throws SQLException 
	 */
	//
	DBUtil db=new DBUtil();
	SysManager sm=new SysManager();
	PlayerDao pd=new PlayerDao();
	GameDao gd=new GameDao();
	public boolean AdminOperate() throws SQLException {
		boolean b=false;
		for(int i=0;i<DataInit.login.getLogintime();i++) {
			Login login=Menu.getLoginUI();
			b=this.checkoutLogin(login);
			if(b) {
				System.out.println("恭喜登录成功！！！\n\n");
				//循环这个管理员界面使不按0推出就不会返回上一层
				boolean feixue=true;
				while(feixue) {
				int c=Menu.getAdminUI();
				
				feixue=this.adminOperate2(c);
				
				}
			}
			else {
				System.out.println("请重新登陆！");
				if(DataInit.login.getLogintime()-i>0) {
					System.out.println("还可以输入"+(DataInit.login.getLogintime()-i)+"次");
				}
			}
		}
		return b;
	}

java复制代码//游戏过程
	public void play() throws SQLException {
		System.out.println("欢迎来到王者荣耀洛克王国版虚拟画面");
		int score=0;
		//选择英雄
		hero h=heros;
		for(int i=0;i<3;i++){
		score=this.selectSkill(h)+score;
		System.out.println("\n");
		}
		System.out.println("攻击结束"+player.get("nickname")+"您的得分："+score);
		//保存游戏记录
		Game game=new Game();
		game.setPid(Integer.parseInt(player.get("id")));
		game.setScore(score);
		gd.insertGame(game);
	}
	
	//技能展示
	public int selectSkill(hero h) {
		//生成随机数
		double ran=Math.random()*10;
		//展示每个英雄的技能
		h.display();
		System.out.println("请输入您要使用的技能：");
		int s=InputHelper.getInt();

		switch(s) {
		case 1:
			
			int pro1 =h.probability1/10;
			if(ran<=pro1) {
				h.skill1();
				System.out.println("\n太棒了教对面做人！");
				return h.skill1;
			}else {
				System.out.println("\n哎呀，打偏了！");
			}
			break;
		case 2:
			
			int pro2 =h.probability2/10;
			if(ran<=pro2) {
				h.skill2();
				System.out.println("\n666");
				return h.skill2;
			}
			else {
				System.out.println("\n哎呀，打偏了我的我的！");
			}
			break;
		case 3:
			int pro3 =h.probability3/10;
			if(ran<=pro3) {
				h.skill3();
				System.out.println("\n成功超神！");
				return h.skill3;
			}else {
				System.out.println("\n大哥你技术不行呀！");
			}
			break;
		default:
			System.out.println("请输入正确的技能！");
		
		}
		return 0;
	}

java复制代码public class GameDao {
	DBUtil db=new DBUtil();
	//新增游戏即重新开始
	public int insertGame(Game game) throws SQLException {
		//now（）自带函数获取档当前时间
		String sql="insert into wzry_game(pid,playtime,score) values(?,now(),?)";
		Object[] obj= {game.getPid(),game.getScore()};
		return db.upDate(sql, obj);
	}
	//玩家查询自己的游戏记录
	public List<Map<String,String>> queryGameByPid(int id) throws SQLException{
		String sql="select b.*,a.loginname from wzry_player a,wzry_game b where a.id=b.pid and pid=?";
		Object[] obj= {id};
		List<Map<String,String>> list=db.query(sql, obj);
		return list;
	}
	//查询
	public List<Map<String,String>> queryAllGame() throws SQLException{
		String sql="select b.*,a.loginname from wzry_player a,wzry_game b where a.id=b.pid";
		List<Map<String,String>>list=db.query(sql, null);
		
		return list;
		
	}
	//分数统计
	
	public List<Map<String,String>> queryGameScore() throws SQLException {
		String sql="select a.loginname as 玩家,sum(b.score) as 总分,case "
		            +" when sum(b.score)>=500 then '¤¤¤¤¤' "
				    +" when sum(b.score)>=400 and sum(b.score)<500 then '¤¤¤¤' else '¤¤¤' end 'lucky'"
		            +" from wzry_player as a inner join wzry_game as b on a.id=b.pid"
					+" group by a.loginname";
		
		return db.query(sql, null);
	}
	//查询所有英雄
	public List<Map<String,String>> queryAllHeros() throws SQLException{
		String sql="select * from heros";
		List<Map<String,String>> heros=db.query(sql, null);
		return heros;
	}
	

}

Sql复制代码## 创建表 username 长度为8
CREATE TABLE `test` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(8) DEFAULT NULL,
  `pwd` varchar(8) DEFAULT NULL,
  `seq` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `username` (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=168 DEFAULT CHARSET=utf8;


## 插入 username 长度为9的值
INSERT INTO `test`(`username` , `pwd` , `seq`)
VALUES
	(
		'123456789' ,
		'133aaa' ,
		NULL
	);

## 插入成功
No errors;1 row affected,taking 3.2 ms

## 查询发现值被截断
select username from test;
> 12345678


## 改变sql_mode
set SESSION sql_mode  = 'STRICT_ALL_TABLES';

## 再次插入长度相同的值
INSERT INTO `test`(`username` , `pwd` , `seq`)
VALUES
	(
		'123456789' ,
		'133aaa' ,
		NULL
	);
	
## 报错
Data too long for column 'username' at row 1

Sql复制代码SET GLOBAL sql_mode = 'A,B,C……'; ## 全局 重连生效
SET SESSION sql_mode = 'A,B,C……';## 当前会话 即时生效

sql复制代码- SELECT @@GLOBAL.sql_mode 
- SELECT @@SESSION.sql_mode

Sql复制代码insert into temp values('2019-02-31 01:01:01');

Incorrect datetime value: '2019-02-31 01:01:01' for column 'dt' at row 1

Sql复制代码set SESSION sql_mode  = 'ALLOW_INVALID_DATES';
insert into temp values('2019-02-31 01:01:01');

No errors;1 row affected,taking 3.2 ms

Sql复制代码truncate table "temp";

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"temp"' at line 1

Sql复制代码set SESSION sql_mode  = 'ANSI_QUOTES';
truncate table "temp";

No errors;0 row affected,taking 0.2 ms

Sql复制代码select not 1;
> 0

select 1 between -1 and 2;
> 1

select not 1 between -1 and 2;
> 0

## 设置sql_mode
set SESSION sql_mode  = 'HIGH_NOT_PRECEDENCE';
select not 1 between -1 and 2;
> 0

Sql复制代码select count(0) ct,username from test group by pwd;
> 2 | 12345678




## 设置sql_mode
set SESSION sql_mode  = 'ONLY_FULL_GROUP_BY';

select count(0) ct,username from test group by pwd;
Expression #2 of SELECT list is not in GROUP BY clause and contains nonaggregated column 'test.test.username' which is not functionally dependent on columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by

ini复制代码<?xml version="1.0" encoding="utf-8"?>
<DirectionalLayout
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:alignment="center"
    ohos:orientation="vertical">

    <!-- ohos:id定义组件的id，注意格式固定$+id:xxxx   -->
    <!--match_content 表示包裹内容，按钮的大小与按钮内的文字大小一致-->
    <Text
        ohos:id="$+id:text"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:text="各位看官大人，万福金安！"
        ohos:text_size="15fp"
        />
    
    <Button
        ohos:id="$+id:button"
        ohos:width="match_content"
        ohos:height="match_content"
        ohos:text="请双击"
        ohos:text_size="19fp"
        ohos:text_color="#FFFFFF"
        ohos:top_padding="8vp"
        ohos:bottom_padding="8vp"
        ohos:right_padding="70vp"
        ohos:left_padding="70vp"
        ohos:center_in_parent="true"
        ohos:margin="10vp"
        ohos:background_element="#007DFF"
        />
    
</DirectionalLayout>

java复制代码package com.liziba.demo.slice;

import com.liziba.demo.ResourceTable;
import ohos.aafwk.ability.AbilitySlice;
import ohos.aafwk.content.Intent;
import ohos.agp.components.Button;
import ohos.agp.components.Component;
import ohos.agp.components.Text;

public class MainAbilitySlice extends AbilitySlice{

    /** 提取Text组件为成员变量，后续方法需要使用 */
    Text text = null;

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        super.setUIContent(ResourceTable.Layout_ability_main);

        // 1、找到组件
        // button - 按钮组件
        Button button = (Button) this.findComponentById(ResourceTable.Id_button);
        // 文本组件
        text = (Text) this.findComponentById(ResourceTable.Id_text);

        // 2、绑定双击事件（给需要点击的组件添加双击事件）
        button.setDoubleClickedListener(this::onDoubleClick);
    }

    @Override
    public void onActive() {
        super.onActive();
    }

    @Override
    public void onForeground(Intent intent) {
        super.onForeground(intent);
    }

    public void onDoubleClick(Component component) {

        // component表示的是被双击的组件对象
        int id = component.getId();
        if (ResourceTable.Id_button == id) {
            text.setText("大家好，我是李子捌！");
        }
    }
}

java复制代码
public class DeadLock implements Runnable{
    private static final Logger logger = LoggerFactory.getLogger(DeadLock.class);

    private static Object object1 = new Object();
    private static Object object2 = new Object();

    private int flag;

    public DeadLock(int flag) {
        super();
        this.flag = flag;
    }

    @Override
    public void run() {
        if(flag == 1){
            synchronized (object1){
                logger.info("Thread-1-1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (object2){
                    logger.info("Thread-1-2");
                }
            }
        } else {
            synchronized (object2){
                logger.info("Thread-2-1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (object1){
                    logger.info("Thread-2-2");
                }
            }
        }
    }
}

csharp复制代码public  void test(){
    new Thread(new DeadLock(1)).start();
    new Thread(new DeadLock(2)).start();
}

perl复制代码ps -ef|grep java

复制代码jps -l

bash复制代码jstack -l > /Users/wukong/Desktop/tool/tdump.tdump  32430

ruby复制代码-Xms50m -Xmx50m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/Users/wukong/Desktop/tool/heapdump.hprof

ini复制代码public static void test(){
    List<Student> list = new ArrayList<>();
    for (int i = 0; i < 1000000; i++){
        Student student = new Student(i, "张寿臣、马三立、常宝堃、侯宝林、刘宝瑞、李伯祥、高英培、马季、唐杰忠、李文华、侯耀文、石富宽、苏文茂、李金斗、冯巩、郭德纲、于谦、姜昆、岳云鹏、孙越等.");
        list.add(student);
    }
}

bash复制代码java.lang.OutOfMemoryError: GC overhead limit exceeded
Dumping heap to /Users/wukong/Desktop/tool/heapdump.hprof ...
Heap dump file created [27428405 bytes in 0.147 secs]