deepseek可能是能免费使用的最强ai了

gyxsama · 2024 年12 月 17 日 08:47

最近在搞一个脱敏功能，由于设置条件较为复杂，我想试试让AI帮忙实现。我尝试了Claude3.5 Haiku、ChatGPT4o、Gemini 1.5 Flash模型（由于未订阅，使用的都是基础模型）。结果这些模型的表现都不太理想，尤其是Claude3.5 Haiku，完全没有理解我的需求，生成的方法测试后输出的结果与期望值完全不相干。另外两个模型生成的方法，虽然输出的结果部分正确，但仍无法完全满足需求。

就在我考虑尝试使用国内大模型生成测试时，突然想起来之前使用Copilot时曾用过DeepSeek。去DeepSeek官网发现它还提供了深度思考模式。我抱着试一试的心态测试了一下DeepSeek，结果它输出的结果完全符合我的需求，甚至无需任何调整。

深度思考有点过于降为打击了。

有其他ai会员订阅的可以试试，下边放问的问题，里边有规则

我需要设置一个对字符串进行掩码的方法.具体的掩码规则为

设置1: 开头显示, 规则: 不显示(全隐藏), 开头显示x个字符, 关键字(显示开头到关键字之间的字符, 其他的隐藏, 不包括关键字), 关键字包含(显示开头到关键字之间的字符, 其他的隐藏, , 包括关键字)

设置2: 结尾显示, 规则: 不显示(全隐藏), 结尾显示x个字符, 关键字(显示关键字到结尾的字符, 其他的隐藏, 不包括关键字), 关键字包含(显示关键字到结尾的字符, 其他的隐藏, 包括关键字)

设置3: 中间显示, 规则: 设置不被屏蔽的字符串, 多个字符串使用,符号分隔, 当屏蔽的内容包含该字符时, 该字符不被屏蔽

设置4: 掩码长度, 规则: 当开启该功能, 设置替换的掩码长度为设置的值

这些设置可以一起生效, 下面我会提供一些配置例子和期望结果:
案例1:  开头显示: 3个字符
        结尾显示: 全隐藏
        输入字符串: 这是一段测试掩码规则的字符串
        期望结果: 这是一***********
案例2:  开头显示: 3个字符
        结尾显示: 关键字  规则
        输入字符串: 这是一段测试掩码规则的字符串
        期望结果: 这是一*******的字符串
案例3:  开头显示: 关键字  测试
        结尾显示: 关键字包含  规则
        输入字符串: 这是一段测试掩码规则的字符串
        期望结果: 这是一段****规则的字符串
案例4:  开头显示: 3个字符
        结尾显示: 3个字符
        中间显示: 测试,规则
        输入字符串: 这是一段测试掩码规则的字符串
        期望结果: 这是一*测试**规则*字符串

案例5:  开头显示: 3个字符
        结尾显示: 3个字符
        中间显示: 测试,规则
        掩码长度: 1
        输入字符串: 这是一段测试掩码规则的字符串
        期望结果: 这是一*测试*规则*字符串      

案例6:  开头显示: 不显示
        结尾显示: 不显示
        中间显示: 测试,规则
        掩码长度: 1
        输入字符串: 这是一段测试掩码规则的字符串
        期望结果: *测试*规则*           

public class CustomizeConfig {

    private CustomizeType beginType; //开始类型

    private String beginParam; //开始参数

    private CustomizeType endType; // 结束类型

    private String endParam; // 结束参数

    private String show;  //中间显示, 多个值, 使用,符号分隔

    private boolean customizeDataMask; //开启掩码长度功能

    private int dataMaskLength; //掩码长度



    public enum CustomizeType {

        HIDE, //不显示(全隐藏)

        NUMBER,//开头或结尾显示x个字符

        KEYWORDS, //关键字(显示关键字以前的字符, 不包括关键字)

        KEYWORDS_INCLUDE //关键字包含(显示关键字以前的字符, 包括关键字)

    }

}

public class CustomizeUtil{

 public String handle(String source, CustomizeConfig config) {

    //实现方法

 }

}

deepseek生成的我放到test类里了

package com.example;

import com.example.config.CustomizeConfig;
import org.junit.jupiter.api.Test;

public class Customize3Test {

    private CustomizeConfig config;

    @Test
    public void test() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config.setBeginParam("3");
        config.setEndType(CustomizeConfig.CustomizeType.NUMBER);
        config.setEndParam("3");
        config.setShow("测试,规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一*测试**规则*字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test11() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.HIDE);
        config.setBeginParam(null);
        config.setEndType(CustomizeConfig.CustomizeType.HIDE);
        config.setEndParam(null);
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "**************");
        System.out.println("结果: " + text);
    }

    @Test
    public void test12() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.HIDE);
        config.setBeginParam(null);
        config.setEndType(CustomizeConfig.CustomizeType.NUMBER);
        config.setEndParam("3");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "***********字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test13() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.HIDE);
        config.setBeginParam(null);
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "**********的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test14() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.HIDE);
        config.setBeginParam(null);
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "********规则的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test21() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config.setBeginParam("3");
        config.setEndType(CustomizeConfig.CustomizeType.HIDE);
        config.setEndParam(null);
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一***********");
        System.out.println("结果: " + text);
    }

    @Test
    public void test22() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config.setBeginParam("3");
        config.setEndType(CustomizeConfig.CustomizeType.NUMBER);
        config.setEndParam("3");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一********字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test23() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config.setBeginParam("3");
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一*******的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test24() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config.setBeginParam("3");
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一*****规则的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test31() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.HIDE);
        config.setEndParam(null);
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段**********");
        System.out.println("结果: " + text);
    }

    @Test
    public void test32() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.NUMBER);
        config.setEndParam("3");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段*******字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test33() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段******的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test34() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段****规则的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test41() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.HIDE);
        config.setEndParam(null);
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段测试********");
        System.out.println("结果: " + text);
    }

    @Test
    public void test42() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.NUMBER);
        config.setEndParam("3");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段测试*****字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test43() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段测试****的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test44() {
        CustomizeConfig config = new CustomizeConfig();
        config.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setBeginParam("测试");
        config.setEndType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config.setEndParam("规则");
        String text = handle("这是一段测试掩码规则的字符串", config);
        System.out.println("期望: " + "这是一段测试**规则的字符串");
        System.out.println("结果: " + text);
    }

    @Test
    public void test0() {

        String source = "这是一段测试掩码规则的字符串";

        // 案例1: 开头显示3个字符, 结尾全隐藏
        CustomizeConfig config1 = new CustomizeConfig();
        config1.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config1.setBeginParam("3");
        config1.setEndType(CustomizeConfig.CustomizeType.HIDE);
        System.out.println("案例1: " + handle(source, config1));

        // 案例2: 开头显示3个字符, 结尾显示关键字
        CustomizeConfig config2 = new CustomizeConfig();
        config2.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config2.setBeginParam("3");
        config2.setEndType(CustomizeConfig.CustomizeType.KEYWORDS);
        config2.setEndParam("规则");
        System.out.println("案例2: " + handle(source, config2));

        // 案例3: 开头显示关键字, 结尾显示包含关键字
        CustomizeConfig config3 = new CustomizeConfig();
        config3.setBeginType(CustomizeConfig.CustomizeType.KEYWORDS);
        config3.setBeginParam("测试");
        config3.setEndType(CustomizeConfig.CustomizeType.KEYWORDS_INCLUDE);
        config3.setEndParam("规则");
        System.out.println("案例3: " + handle(source, config3));

        // 案例4: 开头显示3个字符, 结尾显示3个字符, 中间保留特定字符
        CustomizeConfig config4 = new CustomizeConfig();
        config4.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config4.setBeginParam("3");
        config4.setEndType(CustomizeConfig.CustomizeType.NUMBER);
        config4.setEndParam("3");
        config4.setShow("测试,规则");
        System.out.println("案例4: " + handle(source, config4));

        // 案例5: 开头显示3个字符, 结尾显示3个字符, 中间保留特定字符, 设置掩码长度为1
        CustomizeConfig config5 = new CustomizeConfig();
        config5.setBeginType(CustomizeConfig.CustomizeType.NUMBER);
        config5.setBeginParam("3");
        config5.setEndType(CustomizeConfig.CustomizeType.NUMBER);
        config5.setEndParam("3");
        config5.setShow("测试,规则");
        config5.setCustomizeDataMask(true);
        config5.setDataMaskLength(1);
        System.out.println("案例5: " + handle(source, config5));

        // 案例6: 全部隐藏, 仅保留中间特定字符
        CustomizeConfig config6 = new CustomizeConfig();
        config6.setBeginType(CustomizeConfig.CustomizeType.HIDE);
        config6.setEndType(CustomizeConfig.CustomizeType.HIDE);
        config6.setShow("测试,规则");
        config6.setCustomizeDataMask(true);
        config6.setDataMaskLength(1);
        System.out.println("案例6: " + handle(source, config6));
    }

    public String handle(String source, CustomizeConfig config) {
        if (source == null || source.isEmpty()) {
            return source;
        }

        int length = source.length();
        boolean[] showPositions = new boolean[length];

        // 处理开头显示规则
        switch (config.getBeginType()) {
            case HIDE:
                // 不显示开头部分
                break;
            case NUMBER:
                int beginNumber = Integer.parseInt(config.getBeginParam());
                for (int i = 0; i < beginNumber && i < length; i++) {
                    showPositions[i] = true;
                }
                break;
            case KEYWORDS:
                String beginKeyword = config.getBeginParam();
                int beginIndex = source.indexOf(beginKeyword);
                if (beginIndex != -1) {
                    for (int i = 0; i < beginIndex; i++) {
                        showPositions[i] = true;
                    }
                }
                break;
            case KEYWORDS_INCLUDE:
                String beginIncludeKeyword = config.getBeginParam();
                int beginIncludeIndex = source.indexOf(beginIncludeKeyword);
                if (beginIncludeIndex != -1) {
                    int endInclude = beginIncludeIndex + beginIncludeKeyword.length();
                    for (int i = 0; i < endInclude && i < length; i++) {
                        showPositions[i] = true;
                    }
                }
                break;
        }

        // 处理结尾显示规则
        switch (config.getEndType()) {
            case HIDE:
                // 不显示结尾部分
                break;
            case NUMBER:
                int endNumber = Integer.parseInt(config.getEndParam());
                for (int i = length - endNumber; i < length; i++) {
                    if (i >= 0) {
                        showPositions[i] = true;
                    }
                }
                break;
            case KEYWORDS:
                String endKeyword = config.getEndParam();
                int endIndex = source.indexOf(endKeyword);
                if (endIndex != -1) {
                    for (int i = endIndex + endKeyword.length(); i < length; i++) {
                        showPositions[i] = true;
                    }
                }
                break;
            case KEYWORDS_INCLUDE:
                String endIncludeKeyword = config.getEndParam();
                int endIncludeIndex = source.indexOf(endIncludeKeyword);
                if (endIncludeIndex != -1) {
                    for (int i = endIncludeIndex; i < length; i++) {
                        showPositions[i] = true;
                    }
                }
                break;
        }

        // 处理中间显示的字符串
        if (config.getShow() != null && !config.getShow().isEmpty()) {
            String[] showStrings = config.getShow().split(",");
            for (String showString : showStrings) {
                int index = source.indexOf(showString);
                while (index != -1) {
                    for (int i = index; i < index + showString.length() && i < length; i++) {
                        showPositions[i] = true;
                    }
                    index = source.indexOf(showString, index + 1);
                }
            }
        }

        // 替换隐藏的部分为掩码字符
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < length; i++) {
            if (showPositions[i]) {
                result.append(source.charAt(i));
            } else {
                // 找到连续的隐藏部分
                int j = i;
                while (j < length && !showPositions[j]) {
                    j++;
                }
                // 替换整个隐藏部分
                if (config.isCustomizeDataMask()) {
                    for (int k = 0; k < config.getDataMaskLength(); k++) {
                        result.append(MASK_CHAR);
                    }
                } else {
                    for (int k = i; k < j; k++) {
                        result.append(MASK_CHAR);
                    }
                }
                i = j - 1; // 已经处理了j-1，所以i要设为j-1
            }
        }

        return result.toString();
    }

    private static final char MASK_CHAR = '*';
}

CustomizeConfig类

package com.example.config;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class CustomizeConfig {

    private CustomizeType beginType; //开始类型
    private String beginParam; //开始参数
    private CustomizeType endType; // 结束类型
    private String endParam; // 结束参数
    private String show;  //中间显示, 多个值, 使用,符号分隔
    private boolean customizeDataMask; //开启掩码长度功能
    private int dataMaskLength; //掩码长度

    public enum CustomizeType {
        HIDE, //不显示(全隐藏)
        NUMBER,//开头或结尾显示x个字符
        KEYWORDS, //关键字(显示关键字以前的字符, 不包括关键字)
        KEYWORDS_INCLUDE //关键字包含(显示关键字以前的字符, 包括关键字)
    }
}

QAWS12g · 2024 年12 月 17 日 08:49

deepseek 代码这块，是国内最强的了

handsome · 2024 年12 月 17 日 08:52

是的，超强

zhong_little · 2024 年12 月 17 日 08:54

gemini 1.5 pro，gemini exp，gemini 2.0 flash 有话要说（虽然 gemini 编码任务确实不是长项）

yuaotian · 2024 年12 月 17 日 08:56

确实nb

Luis · 2024 年12 月 17 日 08:58

不错不错挺好的。

gyxsama · 2024 年12 月 17 日 08:58

gemini木有订阅啊, 所以只能说免费里最强了…
gemini 2.0 flash我也测了, 也是不行

zhong_little · 2024 年12 月 17 日 09:02

不用订阅也可以用 1.5 pro 和 exp 啊

gyxsama · 2024 年12 月 17 日 09:04

不能选啊

zhong_little · 2024 年12 月 17 日 09:04

aistudio 里能用，api 也支持

RichardChou · 2024 年12 月 17 日 09:06

deepseek 创始人都敢说国产模型和美国的差距主要在算力上，可见多自信。

duzhuo · 2024 年12 月 17 日 09:07

甚至还很便宜

yangtb2024 · 2024 年12 月 17 日 09:12

用api啊（网页版的话每个月开个谷歌小号，试用google one把大号拉到家庭就行）

gyxsama · 2024 年12 月 17 日 09:12

我去问问试一下

gyxsama · 2024 年12 月 17 日 09:15

gemini 1.5 pro 生成的直接报指标越界了

DS_touch_fish · 2024 年12 月 17 日 09:18

感谢 lz 支持

4396 · 2024 年12 月 17 日 09:26

目前我的排名是 deepseek > glm >>>> Qwen
不知道为什么那么多给Qwen好评的明明辣鸡的要命

Momokaa · 2024 年12 月 17 日 09:35

这个是 claude-3.5-sonnet的回答

代码


package com.example.util;

import com.example.config.CustomizeConfig;
import com.example.config.CustomizeConfig.CustomizeType;

import java.util.HashSet;
import java.util.Set;

public class CustomizeUtil {
    
    public String handle(String source, CustomizeConfig config) {
        if (source == null || source.isEmpty()) {
            return source;
        }

        // 获取需要显示的字符位置
        Set<Integer> showPositions = new HashSet<>();
        
        // 处理开头显示
        int beginPos = handleBegin(source, config, showPositions);
        
        // 处理结尾显示
        int endPos = handleEnd(source, config, showPositions);
        
        // 处理中间显示的关键字
        if (config.getShow() != null && !config.getShow().isEmpty()) {
            handleMiddle(source, config.getShow(), showPositions);
        }
        
        // 构建结果
        return buildResult(source, showPositions, beginPos, endPos, config);
    }

    private int handleBegin(String source, CustomizeConfig config, Set<Integer> showPositions) {
        if (config.getBeginType() == null) {
            return 0;
        }
        
        switch (config.getBeginType()) {
            case HIDE:
                return 0;
            case NUMBER:
                try {
                    int count = Integer.parseInt(config.getBeginParam());
                    for (int i = 0; i < Math.min(count, source.length()); i++) {
                        showPositions.add(i);
                    }
                    return count;
                } catch (NumberFormatException e) {
                    return 0;
                }
            case KEYWORDS:
            case KEYWORDS_INCLUDE:
                if (config.getBeginParam() != null) {
                    String keyword = config.getBeginParam();
                    int idx = source.indexOf(keyword);
                    if (idx >= 0) {
                        for (int i = 0; i < idx + (config.getBeginType() == CustomizeType.KEYWORDS_INCLUDE ? keyword.length() : 0); i++) {
                            showPositions.add(i);
                        }
                        return idx + (config.getBeginType() == CustomizeType.KEYWORDS_INCLUDE ? keyword.length() : 0);
                    }
                }
                return 0;
            default:
                return 0;
        }
    }

    private int handleEnd(String source, CustomizeConfig config, Set<Integer> showPositions) {
        if (config.getEndType() == null) {
            return source.length();
        }
        
        switch (config.getEndType()) {
            case HIDE:
                return source.length();
            case NUMBER:
                try {
                    int count = Integer.parseInt(config.getEndParam());
                    for (int i = Math.max(0, source.length() - count); i < source.length(); i++) {
                        showPositions.add(i);
                    }
                    return source.length() - count;
                } catch (NumberFormatException e) {
                    return source.length();
                }
            case KEYWORDS:
            case KEYWORDS_INCLUDE:
                if (config.getEndParam() != null) {
                    String keyword = config.getEndParam();
                    int idx = source.lastIndexOf(keyword);
                    if (idx >= 0) {
                        int startPos = idx + (config.getEndType() == CustomizeType.KEYWORDS_INCLUDE ? 0 : keyword.length());
                        for (int i = startPos; i < source.length(); i++) {
                            showPositions.add(i);
                        }
                        return startPos;
                    }
                }
                return source.length();
            default:
                return source.length();
        }
    }

    private void handleMiddle(String source, String show, Set<Integer> showPositions) {
        String[] keywords = show.split(",");
        for (String keyword : keywords) {
            if (keyword == null || keyword.isEmpty()) {
                continue;
            }
            int idx = source.indexOf(keyword);
            while (idx >= 0) {
                for (int i = 0; i < keyword.length(); i++) {
                    showPositions.add(idx + i);
                }
                idx = source.indexOf(keyword, idx + 1);
            }
        }
    }

    private String buildResult(String source, Set<Integer> showPositions, int beginPos, int endPos, CustomizeConfig config) {
        StringBuilder result = new StringBuilder();
        
        for (int i = 0; i < source.length(); i++) {
            if (showPositions.contains(i)) {
                result.append(source.charAt(i));
            } else if (i >= beginPos && i < endPos) {
                result.append("*");
                if (config.isCustomizeDataMask() && config.getDataMaskLength() > 0) {
                    // 如果设置了掩码长度，跳过后续的掩码字符
                    while (i + 1 < endPos && !showPositions.contains(i + 1)) {
                        i++;
                    }
                }
            }
        }
        
        return result.toString();
    }
}

meng_hao_hao · 2024 年12 月 17 日 09:53

确实日用起来最好用还是deepseek

Itachi · 2024 年12 月 17 日 09:55

deepseek yyds 可惜送的tokens过期了

话题		回复	浏览量
国内AI那家强，那家免费强，能接入new api 跳蚤市场人工智能 , 快问快答	28	690	2024 年12 月 19 日
智谱 AI 获得 30 亿元融资，2024 年商业化收入翻倍前沿快讯	30	555	2024 年12 月 17 日
OAI前脚刚推出O1满血版，Gemini Exp 1206就来了前沿快讯 Gemini , 人工智能	55	2120	2024 年12 月 8 日
关于国内外各大AI的比较开发调优 ChatGPT , 人工智能 , 快问快答	40	935	2024 年12 月 18 日
【白嫖分享】沉浸式翻译+DeepSeek 资源荟萃	201	11377	2024 年11 月 27 日

deepseek可能是能免费使用的最强ai了

相关话题