Java 查找给定输入的十进制二进制

任何人都能找到十进制二进制数的解决方案（十进制数包含0和1，如100、111、101等，而12、13和5551等数字不是十进制二进制数）

这里使用的数字是十进制的，只有二进制格式。

输出不是二进制格式。输出中所有数字的总和应与输入相同。例如，下面的输入是十进制4，输出是十进制1,1,1和1。当添加所有输出时，我们可以得到输入

若输入是11，那个么这是一个十进制二进制，所以我们不想转换它。因此，输出将与输入11相同

对于输入4
输出应为1

其他情况如下

IP: 4
OP: 1 1 1 1

IP: 21
OP: 10 11 

IP: 11
OP: 11

IP: 100 
OP: 100 

IP: 99
OP: 11 11 11 11 11 11 11 11 11

我试过了，但解决不了

---

编辑：这不是我的问题的重复，也不是一个子集问题，与问题完全不同。这里的逻辑似乎是将一组写入的二进制数（由1或0组成）作为十进制数相加，直到求和得到所需的数字

所以你所要做的就是找到最大可能的“十进制二进制”，然后 只要你有你的总数

要打印或查找最大decbinary，需要当前decbinary的“长度”

log10

会有所帮助

Java代码：

package de.test.lang.stackexchange;

import java.util.Collection;
import org.apache.commons.lang.StringUtils;

public class DeciBins {

    public static void main(String[] args) {
        printDeciBin(1);
        printDeciBin(4);
        printDeciBin(10);
        printDeciBin(11);
        printDeciBin(19);
        printDeciBin(21);
        printDeciBin(99);
        printDeciBin(100);
    }

    @SuppressWarnings("UseOfSystemOutOrSystemErr")
    public static void printDeciBin(int number) {
        System.out.println(String.format("%d -> %s", number, StringUtils.join(findDeciBins(number), " ")));
    }

    // finds the array of deciBins by determining the maximum possible
    // deciBin and subtract it, until 0.
    static Collection<Integer> findDeciBins(int number) {
        Collection<Integer> decis = new java.util.ArrayList<>();
        int deciBin = number;
        while (deciBin > 0) {
            int y = find_maximum_decibinary(deciBin); // (e.g. for 99 => 11)
            deciBin -= y;
            decis.add(y);
        }
        return decis;
    }

    // finds the maximum decibin by determining the max length and substract 1
    // until the val is smaller or equal the requested value x.
    static int find_maximum_decibinary(int x) {
        int l = (int) Math.ceil(Math.log10(x + 1));
        int currMax = (1 << l) - 1;
        while (currMax > 0) {
            int curVal = Integer.parseInt(Integer.toBinaryString(currMax));
            if (curVal <= x) {
                return curVal;
            }
            currMax--;
        }
        return 1;
    }
}

package de.test.lang.stackexchange；
导入java.util.Collection；
导入org.apache.commons.lang.StringUtils；
公共类决策器{
公共静态void main（字符串[]args）{
printDeciBin（1）；
printDeciBin（4）；
printDeciBin（10）；
printDeciBin（11）；
printDeciBin（19）；
printDeciBin（21）；
printDeciBin（99）；
printDeciBin（100）；
}
@SuppressWarnings（“UseofSystemAutoorSystemEmer”）
公共静态无效打印决策码（整数）{
System.out.println（String.format（“%d->%s”，number，StringUtils.join（findDeciBins（number），”））；
}
//通过确定可能的最大值来查找分贝数组
//抽取并减去它，直到0。
静态收集findDeciBins（整数）{
Collection decis=new java.util.ArrayList（）；
int deciBin=数字；
而（分贝>0）{
int y=查找最大值十进制（deciBin）；/（例如，对于99=>11）
deciBin-=y；
十加（y）；
}
返回小数；
}
//通过确定最大长度和减1来查找最大分贝
//直到val小于或等于要求的值x。
静态int find_max_decibinary（int x）{
intl=（int）Math.ceil（Math.log10（x+1））；
int currMax=（10）{
int curVal=Integer.parseInt（Integer.toBinaryString（currMax））；
如果（曲线另一种方法略有不同的解决方案

public static void main(String[] args) {
    printDeciBin(1);
    printDeciBin(4);
    printDeciBin(10);
    printDeciBin(11);
    printDeciBin(19);
    printDeciBin(21);
    printDeciBin(99);
    printDeciBin(100);
}

public static void printDeciBin(int number) {
    System.out.println(String.format("%d -> %s", number, findDeciBins(number).stream()
            .map(Object::toString)
            .collect(Collectors.joining(" "))));
}

static Collection<Integer> findDeciBins(int number) {
    List<Integer> l = new ArrayList<>();
    while (number != 0) {
        l.add(number % 10);
        number /= 10;
    }
    Collections.reverse(l);


    List<Integer> result = new ArrayList<>();
    while (true) {
        boolean stop = true;
        int curr = 0;
        for (int i = 0; i < l.size(); i++) {
            curr *= 10;
            if (l.get(i) != 0) {
                curr++;
                l.set(i, l.get(i) - 1);
                stop = false;
            }
        }
        if (stop){
            break;
        }
        result.add(curr);
    }

    return result;
}

publicstaticvoidmain（字符串[]args）{
printDeciBin（1）；
printDeciBin（4）；
printDeciBin（10）；
printDeciBin（11）；
printDeciBin（19）；
printDeciBin（21）；
printDeciBin（99）；
printDeciBin（100）；
}
公共静态无效打印决策码（整数）{
System.out.println（String.format（“%d->%s”），number，findDeciBins（number.stream）（）
.map（对象：：toString）
.collect（collector.joining（“”））；
}
静态收集findDeciBins（整数）{
列表l=新的ArrayList（）；
while（数字！=0）{
l、 添加（编号%10）；
数目/=10；
}
收藏。反面（l）；
列表结果=新建ArrayList（）；
while（true）{
布尔停止=真；
int curr=0；
对于（int i=0；i
这里的逻辑是什么？你能分享你尝试过的吗？请分享你的代码片段。为什么
99
->
11
？请解释“十进制二进制”似乎有各种不同的定义。你的定义是什么？考虑到最小分割计数，问题可以简化为最小硬币问题(参见“硬币”[1,10,11100101111011110001001101010111100，…]“该方法要求构建“硬币”"-列出值并将其输入到算法中。为什么
21
->
1011
？那么它不应该是
1110
？有效参数。不知道，也许可以在之后对十进制数组排序。或者可能只是颠倒列表。无论如何，在作者解释他想要实现的目标之前，这不是正确答案。@talex order不是mat好的，出去吧。