Question

嗨朋友我从基础知识学习java .. 我自己写了火焰程序，我对某些事情感到震惊，请帮助我。

我的代码

import java.util.*;


class Solution
 {
public static void main(String arg[])
{
    int i,j,count=0;
    String f ="FLAMES";
    char[] fl = f.toCharArray();

    Scanner sc = new Scanner(System.in);
    String s1 = sc.nextLine();
    String s2 = sc.nextLine();

    for(i=0;i<s1.length();i++)
    {
        for(j=0;j<s2.length();j++)
        {
         if(s1.charAt(i)==s2.charAt(j))
         {
             count+=1;
             break;
         }
        }
    }
    int x=(s1.length()+s2.length())-(count*2);
    for(i=0;i<=x;i++)
    {
        */need logic here/*

    }
    System.out.print(fl);

   }
  }

我已计算两个字符串中不匹配字母的数量。现在我必须找到并打印计数ex：F或A或M

的匹配

注意

我阅读了很多程序示例但是使用完全不同。

我需要删除＆＃34; FLAMES＆＃34;中的元素。字符串并显示剩下的一个。

请帮助我......

Answer 1

我也以与你所做的相同的方式做了火焰计划...只是查看我的，你的用户理解我使用的逻辑...检查一些名字，如果你不明白不要犹豫要问我......

import java.util.*;
public class Flames
{
     public static void main()
     {
        int sp=0;
        Scanner sc=new Scanner(System.in);
        System.out.println("enter two names");
        String s=sc.nextLine();
        String s1=sc.nextLine();
        String p="flames";
        String p1="flames";
        String s2="";
        String m="";
        for(int i=0;i < s.length();i++)
        {
           if(s.charAt(i)==' ') 
           {
           }
           else
           {
              m=m+s.charAt(i);
           } 
        }
        s=m;
        m="";
        for(int i=0;i < s1.length();i++)
        {
           if(s1.charAt(i)==' ')
           {
           }
           else
           {
              m=m+s1.charAt(i);
           }
        }
        s1=m;
        m="";
        int l=s.length();
        int l1=s1.length();
        for(int i=0;i < l;i++)
        {
           int sl=0;
           for(int j=0;j < s1.length();j++)
           {
               if(s.charAt(i)==s1.charAt(j))
               {
                  if(sl==0)
                  {
                     sl++;sp++;s2=s2+" " ;
                  }
                  else
                  {
                     s2=s2+s1.charAt(j);
                  }
                }
                else
                {
                    s2=s2+s1.charAt(j);
                }
             }
             s1=s2;
             s2="";
         }
         sp=sp*2;
         int c=(l-1)+(l1-1)-(sp-1);
         for(int i=1;;i++)
         {
            String z="";p=p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p;
            String mn="";
            char c1=p.charAt(c);
            for(int j=0;j < p1.length();j++)
            {
                if(c1==p1.charAt(j))
                {
                   mn=p1.substring(j+1)+mn;
                       break;
                }
                else
                {
                   mn=mn+p1.charAt(j);
                }
             }
            for(int k=0;k < p1.length();k++)
            {
                if(c1==p1.charAt(k))
                {
                }
                else
                {
                   z=z+p1.charAt(k);
                }
            }
            p1=z;
            p=mn;
            if(mn.length()==1)
            {
              System.out.println(mn);
                   break;
            }
       }
   }
}

Answer 2

现在，你得到了计数，即无法计数，现在，你必须迭代字母火焰并删除每一个，直到剩下一个，这是两个人之间所需的关系。

现在，想想一个12小时的时间。当有人说时间16时，你解释为4.为什么，因为你正在检查0-12范围内的数字。你从头开始添加多余的东西，即0.

16 =（16÷12）给出4。

火焰中共有6个字母。范围为0-5指数。一旦删除了字母，它就会达到0-4的范围。最后，它来到了一个。

所以让我们考虑17的计数。

第一步：

17在5的范围内。 startIndex = 0 17÷5给出2。

第二个索引是A.所以删除A. 从

中的M开始

FLMES

。现在M是2。

第二步：

范围：4 startIndex = 2 （2 + 17）÷4 =（19÷4）= 3。现在删除第三个索引E.

FLMS

第三步：

范围：3 startIndex = 3 （3 + 17）÷3 = 2.删除第二个索引。

FLS

第四步：

范围：2 startIndex = 2。（2 + 17）÷2 = 1.删除第一个索引字母。

FS

第五步：

范围：1 startIndex = 1 （1 + 17）÷1 = 0。删除第0个索引字母F，保留为'F'

F是答案

start
startIndex = 0
Iterate over  5 i.e beginning range
starIndex  = ( startIndex + count) ÷ range;
remove letter at starIndex.
end

最好将火焰存储在列表中，这将负责索引的删除和重新排序。

注意：

不匹配的计数是两个单词中每个字母的计数差异的总和。

unMatchedCount = abs( count[a] in firstWord - count[a] in secondWord)
                  + abs( count[b] in firstWord - count[b] in secondWord)
                  ..............
                  + .............. till z.

因此，使用散列计算计数以获得更好的性能会更好。

混乱：Flames程序使用简单的逻辑

2 个答案: