Mensagens enviadas por: rodrigousp

Resposta curta...
getInputStream da classe process...

Java API wrote:The Runtime.exec methods may not work well for special processes on certain native platforms, such as native windowing processes, daemon processes, Win16/DOS processes on Microsoft Windows, or shell scripts. The created subprocess does not have its own terminal or console. All its standard io (i.e. stdin, stdout, stderr) operations will be redirected to the parent process through three streams (Process.getOutputStream(), Process.getInputStream(), Process.getErrorStream()). The parent process uses these streams to feed input to and get output from the subprocess. Because some native platforms only provide limited buffer size for standard input and output streams, failure to promptly write the input stream or read the output stream of the subprocess may cause the subprocess to block, and even deadlock.

Aqui tem um exemplo ...

Se você só quiser fazer um ping... aqui tem uma solução melhor.

[]´s

Depende de quem vai implementar... a melhor tecnologia é aquela que você conhece.
Se você se garante nas tecnologias acima... vai na fé. O resto é bla bla bla.
Não caia na conversa que uma tecnologia é melhor que outra se você não tem tempo ou condições de correr riscos.
Geralmente quem opta por tecnologia novas em projetos de prazos apertados "acabam desenvolvendo hábitos pouco ortodoxos, como andar pelo escritório batendo o próprio saco nas quinas dos cubículos".

E digo mais... a resposta do Rafael é mesmo muito boa!

Agora, faço a seguinte pergunta: Eu devo julgar os padrões pela intenção ou pela "implementação" (isto é, a descrição do Padrão no GoF, "obsessivo" por heranças)?

Rafael Ferreira wrote:
Vou deixar o John Vlissides responder essa:
?It seems you can?t overemphasize that a pattern?s Structure diagram is just an example, not a specification. It portrays the implementation we see most often. As such the Structure diagram will probably have a lot in common with your own implementation, but differences are inevitable and actually desirable. At very least you will rename the participants as appropriate for your domain. Vary the implementation trade-offs, and your implementation might start looking a lot different from the Structure diagram.
As for whether one is following the pattern or not, who cares? The pattern is a means to an end, not an end itself. Following it in any strict sense is immaterial. If the pattern solves your problem directly, that?s great; if you have to bend it a bit, that?s great too. Even if the pattern merely inspires you toward an altogether different solution, it has still proven useful. The only potential problem here lies in the documentation phase, when you?re describing your solution in terms of patterns. You don?t want to mislead someone with irrelevant patterns. If you identify a set of classes as adhering to a pattern, make sure they fulfill the pattern?s intent. If the connection is tenuous, don?t mention the pattern; otherwise you?re sure to confuse more than clarify. ?

Importante:

DTO não é um javabeans com getters e setters.
DTO não é o mesmo que um Value Object.
DTO não é um anti-padrão, nem o Fowler falou que DTO é um anti-padrão.

Recomendo:
(Re)Ler com atenção o que o Shoes, CV e Fowler (http://martinfowler.com/bliki/AnemicDomainModel.html) escreveram.

E, muito importante...
Padrões não são receitas!

Acho que o Birt é mais apropriado...

http://wiki.eclipse.org/Java_-_Build_Dynamic_Table_(BIRT)

[]´s

Sim, mas nesse caso é irrelevante.

Obs:
Eu sei que a multiplicação é implementado em microcódigo como um somatórios de shift. Agora, eu não sei como funciona a divisão.

http://en.wikipedia.org/wiki/Multiplication_algorithm
http://en.wikipedia.org/wiki/Bit_shift#Bit_shifts

Então... o shift é o seguinte...
digamos que x valha 19, em binário 10011.
x >> 1
10011 >> 1 = 1001
percebeu!? eu eliminei o bit menos significativo (o bit mais a esquerda).
Isso chama deslocamento a esquerda ou shift a esquerda.

É o mesmo efeito que o resultado da divisão inteira por 2. (x /2)

Mas o deslocamento de bits permite fazer divisões por outras potências de 2 também.
x >> 2
10011 >> 2 = 100
que é o mesmo que 19 / 4.

PS: Em tempo, seu programa funciona com d =d/2, no lugar de d = d >> 1.

[]´s

Acho que isso ajuda...

[]´s

Eu considero que vocês já acharam a resposta certa...

http://en.wikipedia.org/wiki/Eight_queens_puzzle

public class AgentTable {
	public final static int size = 8;
	byte[][] table;
	
	public AgentTable(){
		table = new byte[size][size];
		for (int i=0 ; i < size; i++) {
			table[i] = new byte[size]; 
		}
		for (int i=0 ; i < size; i++) {
			for (int j=0 ; j < size; j++) {
				table[i][j] = 0;
			}
		}
	}
	
	public void putQueen(int row, int col) {		
		for (int i =0; i < size; i++) {
			table[row][i]++;
		}
		for (int i =0; i < size; i++) {
			table[i][col]++;
		}
		
		for (int i = row, j = col; i >= 0 && j >= 0; i--,j--) {			
			table[i][j]++;
		}
		for (int i = row, j = col; i >= 0 && j < 8; i--,j++) {			
			table[i][j]++;
		}		
		for (int i = row, j = col; i < 8 && j < 8 ; i++,j++) {			
			table[i][j]++;
		}
		
		for (int i = row, j = col; i < 8 && j >= 0; i++,j--) {			
			table[i][j]++;
		}
		table[row][col] = 88;
	}
	
	public void removeQueen(int row, int col) {
		for (int i =0; i < size; i++) {
			table[row][i]--;
		}
		for (int i =0; i < size; i++) {
			table[i][col]--;
		}
		
		for (int i = row, j = col; i >= 0 && j >= 0; i--,j--) {			
			table[i][j]--;
		}
		for (int i = row, j = col; i >= 0 && j < 8 ; i--,j++) {			
			table[i][j]--;
		}
		for (int i = row, j = col; i < 8 && j < 8 ; i++,j++) {			
			table[i][j]--;
		}		
		
		for (int i = row, j = col; i < 8 && j >= 0; i++,j--) {			
			table[i][j]--;
		}
		table[row][col] = 0;
		
		
	}
	NumberFormat decimalFormat = new DecimalFormat("00");
	@Override
	public String toString() {
		StringBuffer buffer = new StringBuffer(); 		
		for (int i=0 ; i < size; i++) {
		buffer.append('-');
			for (int j=0 ; j < size; j++) {
				buffer.append(decimalFormat.format(table[i][j]));
				buffer.append('-');
			}
			buffer.append('\n');
		}
		return buffer.toString();		
	}
	
	public String getSequence(){
		StringBuffer buffer = new StringBuffer();
		for (int i=0 ; i < size; i++) {
			buffer.append('-');
				for (int j=0 ; j < size; j++) {
					if (table[i][j] > 80) {
						buffer.append(i*8 +j);
						buffer.append('-');						
					}
				}
			}
		return buffer.toString();
	}

}

Então, eu posso dar a resposta completa mais antes disso vou dar mais uma dica. Os números representam posições em um tabuleiro de xadrez (enumerado de 0 a 63).

A resposta correta é mesmo 59.

De fato o próximo número é ímpar (e isso não é mera coincidência!). Mas o que isso tem a ver com o intervalo 0-63?

Pelo menos o 56 é o mais popular por enquanto... mas esse não é o critério da seqüência...

Interessante seu raciocínio, mas ainda está errado. Insisto que vocês devem considerar a informação que o contra-domínio é o intervalo [0,63].

Pergunta aos participantes: como eu devo responder as respostas:
_ Eu devo responder que a lógica está certa ou errada e só falar que o número está certo quanto a lógica estiver correta? ou ...
_ Devo falar sim ou não para qualquer chute?

Notícias, artigos e o maior fórum brasileiro sobre Java