Java 来自作业联机的高级字符串操作

我刚在网上查了一家公司，但我没能回答好这个问题

期待下一次在线评估的改进

问题是: 给定的1输入字符串，格式如下：

当前：目标

   where current = Company,Stock or Bond,amount

   and target = Company,Stock or Bond,amount

“：”分隔当前和目标

例如：

    Vodafone,STOCK,10|Google,STOCK,15|Microsoft,BOND,15:Vodafone,STOCK,15|Google,STOCK,10|Microsoft,BOND,15

输出应该是一个字符串，该字符串使输入与输出相匹配。在这种情况下，它将是：

  SELL,Google,STOCK,5
  BUY,Vodafone,STOCK,5

正如你所看到的，输出应该按字母顺序排列（谷歌在沃达丰之前），债券也应该出现在股票之前

以下是一些帮助您的设置代码：

public class main {


    public static void main(String[] args){
        String input = "Vodafone,STOCK,10|Google,STOCK,15|Microsoft,BOND,15:Vodafone,STOCK,15|Google,STOCK,10|Microsoft,BOND,15";
        String output = matchBenchmark(input);
        System.out.println(output);
    }

    public static String matchBenchmark(String input){

    }
}

---

您可能应该将输入解析为映射：

• 地图键应为

  ，

• 映射值可以是

  {，}

然后在地图上迭代（您可能希望对键进行排序），并根据当前值和新值之间的差异打印

SELL

或

BUY

。

Smth。就像这样：

public final class Market {

    private final Pattern patternLine = Pattern.compile("(?<current>.+):(?<target>.+)");
    private final Pattern patternData = Pattern.compile("(?<name>\\w+),(?<active>\\w+),(?<amount>[-]?\\d+)");
    private final Pattern patternDataSplit = Pattern.compile("\\|");

    public String matchBenchmark(String input) {
        Matcher matcher = patternLine.matcher(input);

        if (!matcher.matches())
            throw new IllegalArgumentException();

        Map<String, Data> current = getData(matcher.group("current"));
        Map<String, Data> target = getData(matcher.group("target"));

        return calc(current, target).stream()
                                    .map(data -> data.getName() + ',' + data.getActive() + ',' + data.getAmount())
                                    .collect(Collectors.joining("\n"));
    }

    private Map<String, Data> getData(String str) {
        return Arrays.stream(patternDataSplit.split(str))
                     .map(patternData::matcher)
                     .filter(Matcher::matches)
                     .map(m -> new Data(m.group("name"), m.group("active"), Integer.parseInt(m.group("amount"))))
                     .collect(Collectors.toMap(Data::getName, Function.identity()));
    }

    private static final String BUY = "BUY";
    private static final String SELL = "SELL";

    private static Queue<Data> calc(Map<String, Data> current, Map<String, Data> target) {
        Queue<Data> queue = new PriorityQueue<>(Data.SORT_BY_NAME_ACTIVE_ASC);

        Set<String> names = new HashSet<>(current.keySet());
        names.addAll(target.keySet());

        for (String name : names) {
            Data dataCurrent = current.get(name);
            Data dataTarget = target.get(name);

            if (dataCurrent == null) {
                if (dataTarget.amount != 0)
                    queue.add(new Data(dataTarget.amount > 0 ? BUY : SELL, dataTarget.name, Math.abs(dataTarget.amount)));
            } else if (dataTarget == null) {
                if (dataCurrent.amount != 0)
                    queue.add(new Data(dataCurrent.amount > 0 ? SELL : BUY, dataCurrent.name, Math.abs(dataCurrent.amount)));
            } else if (dataCurrent.amount != dataTarget.amount)
                queue.add(new Data(dataTarget.amount > dataCurrent.amount ? BUY : SELL, dataCurrent.name,
                        Math.abs(dataTarget.amount - dataCurrent.amount)));
        }

        return queue;
    }

    public static final class Data {

        public static final Comparator<Data> SORT_BY_NAME_ACTIVE_ASC = Comparator.comparing(Data::getActive).thenComparing(Data::getName);

        private final String name;
        private final String active;
        private final int amount;

        public Data(String name, String active, int amount) {
            this.name = name;
            this.active = active;
            this.amount = amount;
        }

        public String getName() {
            return name;
        }

        public String getActive() {
            return active;
        }

        public int getAmount() {
            return amount;
        }
    }

}

公开期末班市场{
私有最终模式patternLine=Pattern.compile（（？。+）：（？。+）”；
private final Pattern Pattern data=Pattern.compile（（？\\w+），（？\\w+），（？[-]？\\d+）；
私有最终模式patternDataSplit=Pattern.compile（“\\\\”）；
公共字符串匹配基准（字符串输入）{
Matcher Matcher=patternLine.Matcher（输入）；
如果（！matcher.matches（））
抛出新的IllegalArgumentException（）；
Map current=getData（matcher.group（“current”）；
Map target=getData（matcher.group（“target”）；
返回计算（当前，目标）.stream（）
.map（data->data.getName（）+'、'+data.getActive（）+'、'+data.getAmount（））
.collect（收集器.加入（“\n”））；
}
私有映射getData（字符串str）{
返回Arrays.stream（patternDataSplit.split（str））
.map（patternData:：matcher）
.filter（Matcher:：matches）
.map（m->新数据（m.group（“名称”）、m.group（“活动”）、Integer.parseInt（m.group（“金额”））
.collect（Collectors.toMap（Data:：getName，Function.identity（））；
}
私有静态最终字符串BUY=“BUY”；
私有静态最终字符串SELL=“SELL”；
专用静态队列计算（映射当前、映射目标）{
Queue Queue=new PriorityQueue（Data.SORT\u BY\u NAME\u ACTIVE\u ASC）；
Set names=新的HashSet（current.keySet（））；
names.addAll（target.keySet（））；
for（字符串名称：名称）{
数据dataCurrent=current.get（名称）；
数据dataTarget=target.get（名称）；
if（dataCurrent==null）{
如果（dataTarget.amount！=0）
添加（新数据（dataTarget.amount>0？买入：卖出，dataTarget.name，Math.abs（dataTarget.amount））；
}else if（dataTarget==null）{
如果（dataCurrent.amount！=0）
添加（新数据（dataCurrent.amount>0？销售：BUY、dataCurrent.name、Math.abs（dataCurrent.amount））；
}else if（dataCurrent.amount！=dataTarget.amount）
queue.add（新数据（dataTarget.amount>dataCurrent.amount？买入：卖出，dataCurrent.name，
abs（dataTarget.amount-dataCurrent.amount））；
}
返回队列；
}
公共静态最终类数据{
public static final Comparator按\u NAME\u ACTIVE\u ASC=Comparator.comparating（Data:：getActive）。然后比较（Data:：getName）；
私有最终字符串名；
私有最终字符串处于活动状态；
私人最终整数金额；
公共数据（字符串名称、字符串活动、整数金额）{
this.name=名称；
这个.active=active；
这个。金额=金额；
}
公共字符串getName（）{
返回名称；
}
公共字符串getActive（）{
主动返回；
}
公共整数getAmount（）{
退货金额；
}
}
}

@asasasadada这个f。s花了10分钟的时间编写。@oleg.cheredenik这是为了实习。。。我不确定他们是否希望我们知道regex。。。更不用说使用优先级队列、流、哈希映射、模式、匹配或其他什么了。难道没有更简单的解决办法吗？