Java 计费系统-编程

我需要一些关于以下逻辑的输入

这是一种计费系统，它接受输入并具有与之相关的值

A = 2 , 3A = 5
B = 3
C = 1 , 4C = 3

我的代码，应该是这样的，取abccabaca，输出值应该是16

我现在的解决方案是，计算字符串中的每一个元素，它们的模数是3，对于A，对于C，就像上面的例子一样，对于B，不需要每个元素来得到结果

---

我不知道应该使用什么样的数据结构来实现这样的系统。

好吧，模运算符对你没有帮助，因为你每次都会得到0，每次都是3或5的倍数，这取决于你正在评估的字母，如果这是你试图描述的，对不起，如果我弄错了

我认为最简单的方法是扫描字符串并添加值

当你遇到第三个a时，你只需加1，而不是2，因为你必须减去4，然后再加5 与C类似，当遇到第四个C时，只需添加0，而不是1

您需要另外两个变量来保持A和C的实例，是的，您可以使用模运算符来知道您是否刚刚到达一个倍数，其中必须添加1或0，具体取决于情况

希望这有点帮助

编辑： 在这里，我做了一个快速的实现。如果你真的需要，可以随意优化它

    String value = "ABCCBAACCA";
    int numA =0;
    int numC =0;
    int endResult = 0;

    for (int x = 0; x < value.length(); x++)
    {
        if (value.charAt(x) =='A')
        {
            numA = numA +1;

           endResult = endResult + ((numA%3 == 0)?1:2);
        }
        else if (value.charAt(x) =='B')
        {
            endResult = endResult +3;
        }
        else if (value.charAt(x) =='C')
        {
            numC = numC +1;
            endResult = endResult + ((numC%4 == 0)?0:1);
        }
    }

    System.out.println(endResult);  //16 as expected

---

好的，模运算符对你没有帮助，因为你每次都会得到0，是3或5的倍数，这取决于你正在评估的字母，如果这是你想要描述的，对不起，如果我弄错了

我认为最简单的方法是扫描字符串并添加值

当你遇到第三个a时，你只需加1，而不是2，因为你必须减去4，然后再加5 与C类似，当遇到第四个C时，只需添加0，而不是1

您需要另外两个变量来保持A和C的实例，是的，您可以使用模运算符来知道您是否刚刚到达一个倍数，其中必须添加1或0，具体取决于情况

希望这有点帮助

编辑： 在这里，我做了一个快速的实现。如果你真的需要，可以随意优化它

    String value = "ABCCBAACCA";
    int numA =0;
    int numC =0;
    int endResult = 0;

    for (int x = 0; x < value.length(); x++)
    {
        if (value.charAt(x) =='A')
        {
            numA = numA +1;

           endResult = endResult + ((numA%3 == 0)?1:2);
        }
        else if (value.charAt(x) =='B')
        {
            endResult = endResult +3;
        }
        else if (value.charAt(x) =='C')
        {
            numC = numC +1;
            endResult = endResult + ((numC%4 == 0)?0:1);
        }
    }

    System.out.println(endResult);  //16 as expected

---

在伪代码中，我相信它是：

数一数所有的A、B和C

将A除以3，再乘以5

模A乘以3再乘以2

将B乘以3

将C除以4，再乘以3

模C乘以4

将5个结果相加

在Ruby中，它可能像这样：

input = "ABCCBAACCA"
letters = ["A", "B", "C"]
total = 0

def score(letter,count)
  if letter == "A"
    ((count/3)*5)+((count%3)*2)
  elsif letter == "B"  
    count*3
  else letter == "C"  
    ((count/4)*3)+(count%4)
  end  
end 

letters.each do |letter|   
  puts "#{letter}: #{score(letter, input.count(letter))}"
  total += score(letter, input.count(letter))
end

puts "Total: #{total}"

public static void main(String[] args) {
    // FIXME
    String inputString = null;

    Map<Character, Integer> map = new HashMap<Character, Integer>();

    for (Character c : inputString.toCharArray()) {
        map = countCharacters(map, c);
    }
}

private static Map<Character, Integer> countCharacters(Map<Character, Integer> map,
        Character charatcer) {
    map.put(charatcer,
            (map.get(charatcer) != null) ? map.get(charatcer) + 1 : 
                Integer.valueOf(1));

    return map;
}

产生：

A: 7
B: 6
C: 3
Total: 16

---

在伪代码中，我相信它是：

数一数所有的A、B和C

将A除以3，再乘以5

模A乘以3再乘以2

将B乘以3

将C除以4，再乘以3

模C乘以4

将5个结果相加

在Ruby中，它可能像这样：

input = "ABCCBAACCA"
letters = ["A", "B", "C"]
total = 0

def score(letter,count)
  if letter == "A"
    ((count/3)*5)+((count%3)*2)
  elsif letter == "B"  
    count*3
  else letter == "C"  
    ((count/4)*3)+(count%4)
  end  
end 

letters.each do |letter|   
  puts "#{letter}: #{score(letter, input.count(letter))}"
  total += score(letter, input.count(letter))
end

puts "Total: #{total}"

public static void main(String[] args) {
    // FIXME
    String inputString = null;

    Map<Character, Integer> map = new HashMap<Character, Integer>();

    for (Character c : inputString.toCharArray()) {
        map = countCharacters(map, c);
    }
}

private static Map<Character, Integer> countCharacters(Map<Character, Integer> map,
        Character charatcer) {
    map.put(charatcer,
            (map.get(charatcer) != null) ? map.get(charatcer) + 1 : 
                Integer.valueOf(1));

    return map;
}

产生：

A: 7
B: 6
C: 3
Total: 16

---

好吧，我会从这样的事情开始：

input = "ABCCBAACCA"
letters = ["A", "B", "C"]
total = 0

def score(letter,count)
  if letter == "A"
    ((count/3)*5)+((count%3)*2)
  elsif letter == "B"  
    count*3
  else letter == "C"  
    ((count/4)*3)+(count%4)
  end  
end 

letters.each do |letter|   
  puts "#{letter}: #{score(letter, input.count(letter))}"
  total += score(letter, input.count(letter))
end

puts "Total: #{total}"

public static void main(String[] args) {
    // FIXME
    String inputString = null;

    Map<Character, Integer> map = new HashMap<Character, Integer>();

    for (Character c : inputString.toCharArray()) {
        map = countCharacters(map, c);
    }
}

private static Map<Character, Integer> countCharacters(Map<Character, Integer> map,
        Character charatcer) {
    map.put(charatcer,
            (map.get(charatcer) != null) ? map.get(charatcer) + 1 : 
                Integer.valueOf(1));

    return map;
}

---

然后从第二步到第五步介绍@Vlasts，因为上面的代码是他的伪代码的第一步。它通过制作字符映射来计算字符串中的所有字符：它的出现，如果以前没有这样的字符，它会将1放入映射中。

好吧，我将从以下内容开始：

input = "ABCCBAACCA"
letters = ["A", "B", "C"]
total = 0

def score(letter,count)
  if letter == "A"
    ((count/3)*5)+((count%3)*2)
  elsif letter == "B"  
    count*3
  else letter == "C"  
    ((count/4)*3)+(count%4)
  end  
end 

letters.each do |letter|   
  puts "#{letter}: #{score(letter, input.count(letter))}"
  total += score(letter, input.count(letter))
end

puts "Total: #{total}"

public static void main(String[] args) {
    // FIXME
    String inputString = null;

    Map<Character, Integer> map = new HashMap<Character, Integer>();

    for (Character c : inputString.toCharArray()) {
        map = countCharacters(map, c);
    }
}

private static Map<Character, Integer> countCharacters(Map<Character, Integer> map,
        Character charatcer) {
    map.put(charatcer,
            (map.get(charatcer) != null) ? map.get(charatcer) + 1 : 
                Integer.valueOf(1));

    return map;
}

class CharBucket
  attr_accessor :count

  def initialize(thresholds)
    @thresholds = thresholds
    @count = 0
  end

  def total
    @thresholds.inject([0, @count]) do |sum_left, a|
      sum = sum_left[0]
      left = sum_left[1]
      sum += (left / a[0]) * a[1]
      left %= a[0]
      [sum, left]
    end[0]
  end
end

a = CharBucket.new({3 => 5, 1 => 2})
b = CharBucket.new({1 => 3})
c = CharBucket.new({4 => 3, 1 => 1})
buckets = {'A' => a, 'B' => b, 'C' => c}

"ABCCBAACCA".each_char{|c| buckets[c].count += 1 }
total = buckets.values.inject(0){|sum, b| sum += b.total} # => 16

---

然后从第二步到第五步介绍@Vlasts，因为上面的代码是他的伪代码的第一步。它通过绘制字符地图来计算字符串中的所有字符：它的出现，如果以前没有这样的字符，它会将1放入地图。

也许你不应该在这里问家庭作业问题？？？是的，这不是一个家庭问题。这是一个编程逻辑，我试图在我的工作场所实现。一次扫描所有字符串，然后计算价格就可以解决问题了。但我想让它结痂，我想看看有没有可能使它更快。我不明白你是如何得到你的阿巴卡输出。你有四个A，两个B和四个C。结果不应该是4*2+2*3+4*1=18吗？3A=5意味着什么？这是否意味着如果字符串有三个As，那么它们的总数应该是5而不是通常的6？在这种情况下，ABCCBAACA将评估为5+2+6+3=16。感谢Kevin，我错误地解释了它，3A的值应该是5，但4A的值应该是3A+A，因此ABCCBAACA的值是3A+A+B+B+4C=5+2+3+3=16。因此，四个值为5+2，两个值为6，四个值为3。5+2+6+3 = 16. 那么，为什么你说ABCCBAACA要13英镑？也许你不应该在这里问家庭作业问题？？？是的，这不是一个家庭问题。这是一个编程逻辑，我试图在我的工作场所实现。一次扫描所有字符串，然后计算价格就可以解决问题了。但我想让它结痂，我想看看有没有可能使它更快。我不明白你是如何得到你的阿巴卡输出。你有四个A，两个B和四个C。结果不应该是4*2+2*3+4*1=18吗？3A=5意味着什么？是吗

class CharBucket
  attr_accessor :count

  def initialize(thresholds)
    @thresholds = thresholds
    @count = 0
  end

  def total
    @thresholds.inject([0, @count]) do |sum_left, a|
      sum = sum_left[0]
      left = sum_left[1]
      sum += (left / a[0]) * a[1]
      left %= a[0]
      [sum, left]
    end[0]
  end
end

a = CharBucket.new({3 => 5, 1 => 2})
b = CharBucket.new({1 => 3})
c = CharBucket.new({4 => 3, 1 => 1})
buckets = {'A' => a, 'B' => b, 'C' => c}

"ABCCBAACCA".each_char{|c| buckets[c].count += 1 }
total = buckets.values.inject(0){|sum, b| sum += b.total} # => 16

---

如果字符串有三个As，那么它们的总数应该是5，而不是通常的6？在这种情况下，ABCCBAACA将评估为5+2+6+3=16。感谢Kevin，我错误地解释了它，3A的值应该是5，但4A的值应该是3A+A，因此ABCCBAACA的值是3A+A+B+B+4C=5+2+3+3=16。因此，四个值为5+2，两个值为6，四个值为3。5+2+6+3 = 16. 那么，你为什么说abccabaca要13英镑呢？我喜欢你把所有的As、Bs和Cs都计算在内的想法，因为字符串中字母的顺序似乎并不重要。但是其余的伪代码很难阅读。你能用数学符号、/、*、%、+和括号重写它吗？我喜欢你计算所有As、Bs和Cs的想法，因为字符串中字母的顺序似乎并不重要。但是其余的伪代码很难阅读。你能用数学符号、/、*、%、+和括号重写它吗？我很喜欢这个答案。优雅。我真的很喜欢这个答案。优雅的