Java 如何显示可以从一串数字创建的所有IP地址组合？_Java_Data Structures

Java 如何显示可以从一串数字创建的所有IP地址组合？

java data-structures

Java 如何显示可以从一串数字创建的所有IP地址组合？,java,data-structures,Java,Data Structures,我需要将输入字符串格式化为IP地址格式，因此我有以下代码；但是，数字是固定的，我不知道如何为单个输入生成不同的值其他限制是确保没有一组数字超过255，但在本例中，我只想将它们分为四个单独的组，每个组必须有1到3个成员维姆的问题：根据提供的字符串19216801，我认为您无法确定确切的ip。它可以是192.168.0.1或19.216.80.1或任何其他组合回答：我没有寻找任何特定的IP，我只需要显示所有可能的组合样本格式一些组合如下所示 Expected result | num

我需要将输入字符串格式化为IP地址格式，因此我有以下代码；但是，数字是固定的，我不知道如何为单个输入生成不同的值

其他限制是确保没有一组数字超过255，但在本例中，我只想将它们分为四个单独的组，每个组必须有1到3个成员

维姆的问题：根据提供的字符串19216801，我认为您无法确定确切的ip。它可以是192.168.0.1或19.216.80.1或任何其他组合

回答：我没有寻找任何特定的IP，我只需要显示所有可能的组合

样本格式

一些组合如下所示

   Expected result | number of input characters

   1.1.1.1             4 
     ....
   1.1.1.2             5
   1.1.2.1  
   1.2.1.1  
   2.1.1.1 
     ....       
   1.1.1.3             6
   1.1.3.1  
   1.3.1.1   
   3.1.1.1  
     ....
   2.2.2.1             7
   2.2.1.2 
     ....
   2.2.2.2             8
   3.2.2.1 
   1.2.2.3 
     ....
   2.2.2.3             9 
   3.3.2.1 
   1.2.3.3 
     ....
   3.3.3.1             10
   3.3.1.3  
   3.1.3.3
   1.3.3.3 
     ....
   3.3.3.2             11
   3.3.2.3 
   3.2.3.3 
     ....
   3.3.3.3             12

代码

String number = "19216801";
if (number.length() == 4) {
    StringBuilder sb = new StringBuilder(number)
            .insert(1, ".")
            .insert(1, ".")
            .insert(1, ".")
            .insert(1, ".");
    String output = sb.toString();
    System.out.println(output);
}
 if (number.length() == 8) {
    StringBuilder sb = new StringBuilder(number)
            .insert(2, ".")
            .insert(2, ".")
            .insert(2, ".")
            .insert(2, ".");
    String output = sb.toString();
    System.out.println(output);
}
  if (number.length() == 12) {
    StringBuilder sb = new StringBuilder(number)
            .insert(3, ".")
            .insert(3, ".")
            .insert(3, ".")
            .insert(3, ".");
    String output = sb.toString();
    System.out.println(output);
}

如果没有进一步的信息，您必须依靠推测从可变长度字符串形成IP地址

您应该禁止这样做，并确保字符串长度为12个字符

但是，一旦形成了候选IP地址，就可以使用以下正则表达式（使用

String.matches

）对其进行验证

如果没有进一步的信息，您必须依靠推测从可变长度字符串形成IP地址

您应该禁止这样做，并确保字符串长度为12个字符

但是，一旦形成了候选IP地址，就可以使用以下正则表达式（使用

String.matches

）对其进行验证

用下一种方式重新表述任务

假设ip部分可以有零位，因此

…

是有效的

然后我们有number.length（）-3个元素，需要在任意位置放置3个点

将

，

作为零件的长度

第一部分可以是任意长度的（int a=0；a

对于（int b=0；b。

与第三条相同，总长度必须为l。所以l>=a+b+c是约束。C

把要点放在适当的地方

第一部分之后的第一个点（不要忘记在第一步我们从每个部分切下一个数字）

第二个在第一部分、第一个点和第二部分之后（（a+1）+1+（b+1））

第三个也一样。跳过第一部分（a+1）、点（+1）、第二部分（+b+1）、第二部分（+1）和第三部分（c+1）=a+b+c+5

String number = "19216801";
int l = number.length() - 3;
for(int a = 0; a < l; a++) {
    for(int b = 0; b < l-a; b++){
        for(int c = 0; c <l-a-b; c++){
            StringBuilder sb = new StringBuilder(number);
            sb.insert(a+1, ".");
            sb.insert(a+b+3, ".");
            sb.insert(a+b+c+5, ".");
            System.out.println(sb);
        }
    }
}

String number=“19216801”；
int l=number.length（）-3；
对于（int a=0；a对于（int c=0；c用下一种方式重新表述任务
假设ip部分可以有零位，因此…
是有效的
然后我们有number.length（）-3个元素，需要在任意位置放置3个点
将a
，b
，c
作为零件的长度
第一部分可以是任意长度的（int a=0；a


对于（int b=0；b。
与第三个相同，总长度必须是l。因此l>=a+b+c是约束。c
把要点放在适当的地方
第一部分之后的第一个点（不要忘记在第一步我们从每个部分切下一个数字）
第二个在第一部分、第一个点和第二部分之后（（a+1）+1+（b+1））
第三部分相同。跳过第一部分（a+1）、点（+1）、第二部分（+b+1）、第二部分（+1）和第三部分（c+1）=a+b+c+5
String number = "19216801";
int l = number.length() - 3;
for(int a = 0; a < l; a++) {
    for(int b = 0; b < l-a; b++){
        for(int c = 0; c <l-a-b; c++){
            StringBuilder sb = new StringBuilder(number);
            sb.insert(a+1, ".");
            sb.insert(a+b+3, ".");
            sb.insert(a+b+c+5, ".");
            System.out.println(sb);
        }
    }
}

String number=“19216801”；
int l=number.length（）-3；
对于（int a=0；a公共类IP地址{
静态队列队列=新建LinkedList（）；
静态整数计数=0；
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
try（扫描仪阅读器=新扫描仪（System.in））{
String str=reader.nextLine（）；
if（init（str）=-1）
System.out.println（“无法形成IPAddress”）；
ipAddress（）；
}
}
私有静态无效IP地址（）{
//TODO自动生成的方法存根
int noOfGroups=4；
int group=noOfGroups-1；
int countInOneLevel=1，childCount=0；
而（！queue.isEmpty（）&&countInOneLevel>0&&group>0）{
List=queue.poll（）；
countInOneLevel--；
StringBuilder currentGroup=list.get（组）；
StringBuilder prevGroup=list.get（组-1）；
while（currentGroup.length（）>1）{
prevGroup.append（currentGroup.charAt（0））；
currentGroup=currentGroup.deleteCharAt（0）；
if（makeiPAddress（列表、组）==1）{
childCount++；
}
}
如果（countInOneLevel==0）{//当前级别已完成
countInOneLevel=childCount；
组--；
childCount=0；
}
}
System.out.println（“可能的IP地址数：+count”）；
}
私有静态int init（字符串str）{
//TODO自动生成的方法存根
int length=str.length（）；
如果（长度12）
返回-1；
StringBuilder strgGroup[]=新StringBuilder[4]；
int组=4；
对于（int i=0；i公共类IP地址{
静态队列队列=新建LinkedList（）；
静态整数计数=0；
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
try（扫描仪阅读器=新扫描仪（System.in））{
String str=reader.nextLine（）；
if（init（str）=-1）
System.out.println（“无法形成IPAddress”）；
ipAddress（）；
}
}
私有静态无效IP地址（）{
//TODO自动生成的方法存根
int noOfGroups=4；
int group=noOfGroups-1；
int countInOneLevel=1，childCount=0；
而（！queue.isEmpty（）&&countInOneLevel>0
public class IPAddress {
    static Queue<List<StringBuilder>> queue=new LinkedList<List<StringBuilder>>();
    static int count =0;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try(Scanner reader=new Scanner(System.in)){
            String str=reader.nextLine();
            if(init(str)==-1)
                System.out.println("IPAddress cannot be formed");
            ipAddress();
        }


    }

    private static void ipAddress() {
        // TODO Auto-generated method stub

        int noOfGroups=4;


        int group=noOfGroups-1;
        int countInOneLevel=1, childCount=0;
            while(!queue.isEmpty() && countInOneLevel>0 && group>0){
                List<StringBuilder> list=queue.poll();
                countInOneLevel--;
                StringBuilder currentGroup=list.get(group);
                StringBuilder prevGroup=list.get(group-1);
                while(currentGroup.length()>1){
                    prevGroup.append(currentGroup.charAt(0));
                    currentGroup=currentGroup.deleteCharAt(0);
                    if(makeIPAdress(list, group)==1 ){
                        childCount++;
                    }

                }
                if(countInOneLevel==0){//current level complete
                    countInOneLevel=childCount;
                    group--;
                    childCount=0;
                }


            }


        System.out.println("No. of possible IPAddress: "+count);

}

    private static int init(String str) {
        // TODO Auto-generated method stub
        int length=str.length();
        if(length<4 || length>12)
            return -1;
        StringBuilder strgroup[]= new StringBuilder[4];
        int groups=4;
        for(int i=0;i<groups-1;i++){
            strgroup[i]=new StringBuilder(str.substring(i,i+1));
        }
        strgroup[groups-1]=new StringBuilder(str.substring(3,length));
        List<StringBuilder> list=new ArrayList<StringBuilder>();
        for(int i=0;i<groups;i++){
            list.add(strgroup[i]);
        }
        return makeIPAdress(list,groups-1);

    }

    private static int makeIPAdress(List<StringBuilder> list, int i) {
        // TODO Auto-generated method stub
        if(isValidIPAdress(list)){
            List<StringBuilder> list1=new ArrayList<StringBuilder>();
            for(int k=0;k<4;k++){
                StringBuilder s=new StringBuilder(list.get(k).toString());
                list1.add(s);
            }
            queue.offer(list1);
            display(list);
            count++;
            return 1;
        }
        for(int group=i;group>0;group--){
            StringBuilder currentGroup=list.get(group);
            StringBuilder prevGroup=list.get(group-1);
            int num=Integer.parseInt(currentGroup.toString());
            while(num<0|| num>255){
                prevGroup.append(currentGroup.charAt(0));
                currentGroup=currentGroup.deleteCharAt(0);
                num=Integer.parseInt(currentGroup.toString());
            }

        }
        StringBuilder firstGroup=list.get(0);
        int num=Integer.parseInt(firstGroup.toString());
        if(num>=0 && num<=255){
            List<StringBuilder> list1=new ArrayList<StringBuilder>();
            for(int k=0;k<4;k++){
                StringBuilder s=new StringBuilder(list.get(k).toString());
                list1.add(s);
            }

            queue.offer(list1);
            display(list);
            count++;
            return 1;
        }
        return -1;

    }

    private static boolean isValidIPAdress(List<StringBuilder> list) {
        // TODO Auto-generated method stub
        for(int group=0;group<4;group++){
            int num=Integer.parseInt(list.get(group).toString());
            if(num<0 || num>255)
                return false;
        }
        return true;
    }

    private static void display(List<StringBuilder> list) {
        // TODO Auto-generated method stub
        Iterator<StringBuilder> i=list.iterator();
        while(i.hasNext()){
            StringBuilder s=i.next();
            if(!i.hasNext())
                System.out.print(s);
            else
                System.out.print(s+".");

        }
        System.out.println();
    }

}

Sample Input:
2252555

Sample Output:
2.25.25.55
2.25.255.5
2.252.55.5
225.25.5.5
22.52.55.5
225.2.55.5
No. of possible IPAddress: 6

public static void main(String[] args){

    System.out.println(findIPs("1234567", 3));
}

public static List<String> findIPs(String s,int dots){

    List<String> ips = new ArrayList<>();

    for(int i =1 ;i<=3 && i < s.length(); i++){

        String cip = s.substring(0,i);

        if(Integer.parseInt(cip) < 256){
            if(dots == 1){
                if( Integer.parseInt(s.substring(i)) < 256) {
                    ips.add(cip + "." + s.substring(i));
                }
            }else {
                for (String ip : findIPs(s.substring(i), dots - 1)) {
                    ips.add(cip + "." + ip);
                }
            }
        }
    }

    return ips;

}

    private static List<String> ips = new ArrayList<>();
    public static void main(String[] args) {

        Date d = new Date();
        System.out.println(posIps("19216801"));
        System.out.println(new Date().getTime() - d.getTime());

    }

    private static List<String> posIps(String number) {
        int l = number.length() - 3;
        for (int a = 0; a < 3 && a < l; a++) {
            for (int b = 0; b < 3 && b < l - a; b++) {
                for (int c = 0; c < 3 && c < l - a - b; c++) {
                    StringBuilder sb = new StringBuilder(number);
                    if (Integer.parseInt(sb.substring(0, a + 1 )) < 256
                            && Integer.parseInt(sb.substring(a + 1, a + b + 2)) < 256
                            && Integer.parseInt(sb.substring(a + b + 2, a + b + c + 3)) < 256
                            && Integer.parseInt(sb.substring(a + b + c + 3)) < 256) {
                        sb.insert(a + 1, ".");
                        sb.insert(a + b + 3, ".");
                        sb.insert(a + b + c + 5, ".");
                        ips.add(sb.toString());
                    }
                }
            }
        }
        return ips;
    }

public static void main(String[] args) {
    String input = "121212111";
    for (String ipAddress : generatePossibleIpAddresses(input, 3)) {
        System.out.println(ipAddress);
    }
}

public static ArrayList<String> generatePossibleIpAddresses(String ipAddress, int dot) {
    ArrayList<String> list = new ArrayList<String>();

    if (ipAddress == null || ipAddress.length() == 0) {
        return list;
    }

    if (dot == 0) {
        int i = Integer.parseInt(ipAddress);
        if (i < 256) {
            list.add(ipAddress);
        }
        return list;
    }

    for (int i = 1; i <= 3; i++) {
        int num = Integer.parseInt(ipAddress.substring(0, i));
        if (num < 256) {
            for (String str : generatePossibleIpAddresses(ipAddress.substring(i), dot - 1)) {
                list.add(num + "." + str);
            }
        }
    }
    return list;
}