Liczba wampirza

Witam wszystkich. Mam takie zadanie, lecz ni cholery nie wiem nawet od czego zacząć Może ktoś podsunie jakieś sugestie?? Oto treść:

Liczba wampirza posiada parzystą liczbę cyfr, a tworzy się tworząc pary liczb zawierające po połowie cyfr wyniku. 
Cyfry mogą być wybierane z pierwotnej liczby w dowolnej kolejności. Nie dopuszcza się w liczbie par zer na końcu 
liczby(tzn. dwóch zer na końcu liczby). Oto przykłady:
 
1260 = 21 * 60
1827 = 21 * 87
2187 = 27 * 81 
Napisz program, który wyszuka wszystkie cztero cyfrowe liczby wampirze.

for(int i=1000; i<9999; ++i) {
    if( //tutaj sprawdzasz warunki dla danej liczby czyli dla i ) {
        cout << i << " ";
    }
}

@up, to jest kod C a nie Javy, poza tym liczba 9999 też jest czterocyfrowa
// uprzytomniłem sobie, że napisałem niżej głupoty, więc je usuwam, BS

spróbuj od drugiej strony

int[] cyfry1={0,0,0,0};
int[] cyfry2={0,0,0,0};

for (int i=10;i<=99;i++)
  for (int j=10;j<=99;j++)
  {
     l=i*j;
     if(l>=1000 && !(l%100==0)) // l jest czterocyfrowa i nie dzieli się przez 100 więc nie ma pary zer na końcu
     {
        cyfry1[0]=i/10;
        cyfry1[1]=i%10;
        cyfry1[2]=j/10;
        cyfry1[3]=j%10;
        Arrays.sort(cyfry1);
        int pom=l;
        for(int k=0;k<4;k++)
        {
            cyfry2[k]=pom%10;
            pom=pom/10;
        }
        Arrays.sort(cyfry2);
        if(Arrays.equals(cyfry1,cyfry2)
           System.out.println(l+" = "+i+"*"+j);
     }
  } 

Dzieki @bogdans wielkie [browar] dla ciebie:)
Jeden błąd maly tylko miales, zamiast:

for(int k=0;k<4;k++)
        {
            cyfry2[i]=pom%10;
            pom=pom/10;
        }

powinno byc:

for(int k=0;k<4;k++)
        {
            cyfry2[k]=pom%10;
            pom=pom/10;
        }

Można to zrobić np. korzystając z tekstowej reprezentacji liczby

Oto kod

for(int i=10; i<99; i++){
for(int j=10; j<99; j++){
int res = i*j;
String res_str = Integer.toString(res);
if(res_str.length() == 4 && !res_str.substring(2, 4).equals("00")){
System.out.println(res + " = " + i + " * " + j);
}
}
}

Trochę inne podejście (nie powtarza tych samych liczb):

import java.io.;
import java.util.;
import static net.mindview.util.Print.*;

public class HelloDate {

public static void main(String[] args) throws IOException {

// Random rand = new Random();
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in), 1);

int [] cyfry={0,0,0,0};
for(int i = 1001; i < 9999; i++)
{
if(i % 100 == 0) continue; // nie może być 00 na końcu
cyfry[0] = i / 1000;
cyfry[1] = (i % 1000) / 100;
cyfry[2] = (i % 100) / 10;
cyfry[3] = (i % 10);

  skok:
  for(int k0 = 0; k0 < 4; k0++)
	  for(int k1 = 0; k1 < 4; k1++)
		  for(int k2 = 0; k2 < 4; k2++)
			  for(int k3 = 0; k3 < 4; k3++)
				  if(k0 != k1 && k2 != k3 && k0 != k2 && k0 != k3 && k1 != k3 && k1 != k2)
					  if(((cyfry[k0]*10+cyfry[k1])*(cyfry[k2]*10+cyfry[k3])) == i)
					  {
						  print(i + " = " + (cyfry[k0]*10+cyfry[k1]) + " * "+
								  (cyfry[k2]*10+cyfry[k3])); 
						  break skok;
					  }
  
  

}

}

}
/*
Odpowiedzi:
1260 = 21 * 60
1395 = 15 * 93
1435 = 41 * 35
1530 = 51 * 30
1827 = 87 * 21
2187 = 27 * 81
6880 = 86 * 80
*/

Jakby ktoś szukał:
Zadanie to można znaleźć w książce Bruce Eckel`a "Thinking in Java".
Autor w rozwiązaniach podaje następującą odpowiedź:

/****************** Exercise 10 *********************
* A vampire number has an even number of digits and
* is formed by multiplying a pair of numbers containing
* half the number of digits of the result. The digits
* are taken from the original number in any order.
* Pairs of trailing zeroes are not allowed. Examples
* include:
* 1260 = 21 * 60
* 1827 = 21 * 87
* 2187 = 27 * 81
* Write a program that finds all the 4-digit vampire
* numbers. (Suggested by Dan Forhan.)
****************************************************/

public class E10_Vampire 
{
	public static void main(String[] args) 
	{
		int[] startDigit = new int[4];
		int[] productDigit = new int[4];
		for(int num1 = 10; num1 <= 99; num1++)
		for(int num2 = num1; num2 <= 99; num2++) 
		{
			// Pete Hartley's theoretical result:
			// If x·y is a vampire number then
			// x·y == x+y (mod 9)
			if((num1 * num2) % 9 != (num1 + num2) % 9)
			continue;
			int product = num1 * num2;
			startDigit[0] = num1 / 10;
			startDigit[1] = num1 % 10;
			startDigit[2] = num2 / 10;
			startDigit[3] = num2 % 10;
			productDigit[0] = product / 1000;
			productDigit[1] = (product % 1000) / 100;
			productDigit[2] = product % 1000 % 100 / 10;
			productDigit[3] = product % 1000 % 100 % 10;
			int count = 0;
			for(int x = 0; x < 4; x++)
				for(int y = 0; y < 4; y++)
				{
					if(productDigit[x] == startDigit[y]) 
					{
						count++;
						productDigit[x] = -1;
						startDigit[y] = -2;
						if(count == 4)
							System.out.println(num1 + " * " + num2 + " : " + product);
					}
				}
		}
		
	}
} /* Output:
15 * 93 : 1395
21 * 60 : 1260
21 * 87 : 1827
27 * 81 : 2187
30 * 51 : 1530
35 * 41 : 1435
80 * 86
*/

Ale osobiście znalazłem inną, może mniej wydajną, ale mieszczącą się w granicach mojego rozumowania :)

public class Program
{
	static void check(int i1, int i2)
	{
		int l = i1 * i2, kontrol= 0;
		if(l < 1000 || l% 100 == 0) return;
		String liczba = Integer.toString(l);
		String slowo = Integer.toString(i1) + Integer.toString(i2);
		char licz[] = liczba.toCharArray();
		char slow[] = slowo.toCharArray();

		et1:
		for(int st1 = 0;st1 <4 ; st1++)
		{	
			for(int st2 = 0;st2 <4; st2++)
			{
				if(slow[st1] == licz[st2])
				{
					
					
					licz[st2] = Character.MAX_VALUE;
					kontrol ++;
					continue et1;
				}
				
			}
			
		}
		
		if(kontrol ==4)
			System.out.println(l + " = " + i1+ " * " + i2);	
		
	}
	public static void main(String args[])
	{
		for(int i1 = 10; i1 < 100; i1++)
		{
			for(int i2 = 10; i2 < 100; i2++)
			{
				if(i2 > i1) break;
				
				check(i1,i2);
			}
		}
	}
}
/*OUTPUT:
1435 = 41 * 35
1530 = 51 * 30
1260 = 60 * 21
2187 = 81 * 27
6880 = 86 * 80
1827 = 87 * 21
1395 = 93 * 15
*/

Też właśnie przerabiam książkę Thinking in Java. Do problemu podszedłem w zupełnie inny sposób, najbardziej dla mnie logiczny. Jako, że dopiero się uczę javy kod nie wygląda zbyt pięknie - już teraz widzę, że mógł być napisany lepiej(bez tych obiektów itp). Ale działać działa ;-)

class sprawdzanie {
	String kombinacje[] = { "abcd", "abdc", "bacd", "badc", "acbd", "acdb", "cabd", "cadb", "cbad", "cbda", " bcad", "bcda", "dabc", "dacb", "adbc", "adcb", "cdab", "cdba", "dcab", "cdba", "bdac", "bdca", "dbac", "dbca" };
	
	sprawdzanie( int x ) {
		testuj liczba = new testuj();
		for( int y = 0; y < 24; ++y )
			if( liczba.sprawdz( x , kombinacje[y] ) == true )
				break;
	}
}

class testuj {
	boolean sprawdz( int dane, String kod ) {
        int tab[] = new int[4];
		int a = dane / 1000,
			b = (dane % 1000) / 100,
			c = (dane % 100) / 10,
			d = dane % 10;
		
		for( int y = 0; y < 4; ++y ) {
			switch( kod.charAt(y) ) {
				case 'a': tab[y] = a;
					break;
				case 'b': tab[y] = b;
					break;
				case 'c': tab[y] = c;
					break;
				case 'd': tab[y] = d;
					break;
			}
		}
				
		StringBuffer ab = new StringBuffer();
		ab.append( tab[0] );
		ab.append( tab[1] );
		
		StringBuffer cd = new StringBuffer();
		cd.append( tab[2] );
		cd.append( tab[3] );
		
		if( Integer.parseInt( ab.toString() ) * Integer.parseInt( cd.toString() ) == dane ) {
			System.out.println( dane + ", bo " + Integer.parseInt( ab.toString() ) + " * " + Integer.parseInt( cd.toString() ) + " == " + Integer.parseInt( ab.toString() ) * Integer.parseInt( cd.toString() ) );
			return true;
		}
		else 
			return false;
	}
}

public class vampir {
	
	public static void main(String[] args) {

		System.out.println( "Liczby wampirze z przedzialu [1000...9999]: " );
		for( int x = 1000; x < 9999; ++x )
			new sprawdzanie( x );
	}

}

Jako, że mamy rok 2017, a ja właśnie przeglądam Thinking in Java... moja interpretacja:

package vampireNumbers;

public class Vampire {

String number1;
String number2;
int check;

public static void main(String[] args) {
	Vampire vampire = new Vampire();
	vampire.getVampireNumbers();
}

public void getVampireNumbers() {
	
	for(int i = 10; i<99; i++) {
		for(int j=10; j<99; j++) {
			if((i*j)>1000 && (i*j)%100==0){
				continue;
			}
			if(i*j>1000) {
				number1=String.valueOf(i*j);
				number2=(i + "" + j);
				check=0;
				for(int k = 0; k<4; k++) {
					
					if(number1.contains(number2.substring(0, 1))){
						number1 = number1.replaceFirst(number2.substring(0, 1), "");
						number2 = number2.substring(1, number2.length());
						check++;
					}
				}
				if(check==String.valueOf((i*j)).length()) {
					System.out.println((i*j) + " = " + i + " * " + j);
				}
			}
		}
	}
}

}

Witam w 2017. Dostałam to zadanie od informatyka tydzień temu. Właśnie pracuję nad rozpracowaniem co tu jest wyżej napisane. Pozdrawiam :*