Java Ystävyysluvut

En tahtonut aloittaa uutta keskustelua, joten päätin kysyä tässä että on kenelläkään muulla ollut ongelmia saada laajalle levinnyt RandomMosaicWalk toimimaan? Tässä nyt vaikka kaksi versiota siitäkin. En jaksanut poistaa niistä tekijän turhia kommentteja.

/**
* This program opens a window full of randomly colored squares. A "disturbance"
* moves randomly around in the window, randomly changing the color of each
* square that it visits. The program runs until the user closes the window.
*/

public class RandomMosaicWalk {

static int currentRow; // Row currently containing the disturbance.
static int currentColumn; // Column currently containing disturbance.

/**
* The main program creates the window, fills it with random colors,
* and then moves the disturbakcs in a random wals around the window
* as long as the window is open.
*/
public static void main(String[] args) {
Mosaic.open(10,20,10,10);
fillWithRandomColors();
currentRow = 5; // start at center of window
currentColumn = 10;
while (Mosaic.isOpen()) {
changeToRandomColor(currentRow, currentColumn);
randomMove();
Mosaic.delay(20);
}
} // end main

/**
* Fills the window with randomly colored squares.
* Precondition: The mosaic window is open.
* Postcondition: Each square has been set to a random color.
*/
static void fillWithRandomColors() {
for (int row=0; row < 10; row ) {
for (int column=0; column < 20; column ) {
changeToRandomColor(row, column);
}
}
} // end fillWithRandomColors

/**
* Changes one square to a new randomly selected color.
* Precondition: The specified rowNum and colNum are in the valid range
* of row and column numbers.
* Postcondition: The square in the specified row and column has
* been set to a random color.
* @param rowNum the row number of the square, counting rows down
* from 0 at the top
* @param colNum the column number of the square, counting columns over
* from 0 at the left
*/
static void changeToRandomColor(int rowNum, int colNum) {
int red = (int)(256*Math.random()); // Choose random levels in range
int green = (int)(256*Math.random()); // 0 to 255 for red, green,
int blue = (int)(256*Math.random()); // and blue color components.
Mosaic.setColor(rowNum,colNum,red,green,blue);
} // end changeToRandomColor

/**
* Move the disturbance.
* Precondition: The global variables currentRow and currentColumn
* are within the legal range of row and column numbers.
* Postcondition: currentRow or currentColumn is changed to one of the
* neighboring positions in the grid -- up, down, left, or
* right from the current position. If this moves the
* position outside of the grid, then it is moved to the
* opposite edge of the grid.
*/
static void randomMove() {
int directionNum; // Randomly set to 0, 1, 2, or 3 to choose direction.
directionNum = (int)(4*Math.random());
switch (directionNum) {
case 0: // move up
currentRow--;
if (currentRow < 0)
currentRow = 9;
break;
case 1: // move right
currentColumn ;
if (currentColumn >= 20)
currentColumn = 0;
break;
case 2: // move down
currentRow ;
if (currentRow >= 10)
currentRow = 0;
break;
case 3: // move left
currentColumn--;
if (currentColumn < 0)
currentColumn = 19;
break;
}
} // end randomMove

} // end class RandomMosaicWalk

************************************************

public class RandomMosaicWalk {

/*
This program shows a window full of randomly colored
squares. A "disturbance" moves randomly around
in the window, randomly changing the color of
each square that it visits. The program runs
until the user closes the window.
*/

static int currentRow; // row currently containing the disturbance
static int currentColumn; // column currently containing disturbance

public static void main(String[] args) {
// Main program creates the window, fills it with
// random colors, then moves the disturbance in
// a random walk around the window.
Mosaic.open(10,20,10,10);
fillWithRandomColors();
currentRow = 5; // start at center of window
currentColumn = 10;
while (Mosaic.isOpen()) {
changeToRandomColor(currentRow, currentColumn);
randomMove();
Mosaic.delay(20);
}
} // end of main()

static void fillWithRandomColors() {
// fill every square, in each row and column,
// with a random color
for (int row=0; row < 10; row ) {
for (int column=0; column < 20; column ) {
changeToRandomColor(row, column);
}
}
} // end of fillWithRandomColors()

static void changeToRandomColor(int rowNum, int colNum) {
// change the square in row number rowNum and
// column number colNum to a random color.
int red = (int)(256*Math.random()); // choose random levels in range
int green = (int)(256*Math.random()); // 0 to 255 for red, green,
int blue = (int)(256*Math.random()); // and blue color components
Mosaic.setColor(rowNum,colNum,red,green,blue);
} // end of changeToRandomColor()

static void randomMove() {
// Randomly move the disturbance in one of
// four possible directions: up, down, left, or right;
// if this moves the disturbance outside the window,
// then move it to the opposite edge of the window.
int directionNum; // Randomly set to 0, 1, 2, or 3 to choose direction.
directionNum = (int)(4*Math.random());
switch (directionNum) {
case 0: // move up
currentRow--;
if (currentRow < 0)
currentRow = 9;
break;
case 1: // move right
currentColumn ;
if (currentColumn >= 20)
currentColumn = 0;
break;
case 2: // move down
currentRow ;
if (currentRow >= 10)
currentRow = 0;
break;
case 3:
currentColumn--;
if (currentColumn < 0)
currentColumn = 19;
break;
}
} // end of randomMove()

} // end of class RandomMosaicWalk

Nyt on koodissa jokin pahempi virhe. Muutin vahingolliset if-else tai merkinnät ja merkinnöiksi ja nyt sen sijaan, että kaikki luvut 1-10000 olisivat 10000:n ystävyys lukuja ohjelma eliminoi kaikki luvut, vaikka 1-10000 välillä on 2 tai 3 ystävyyslukuparia. No, tässä uusi ohjelma vaikka muutokset ovat pienet.

public class YstavyysLuvut {
   public static void main (String[] args) {
      
      int raja=10000;
      int luku1=0;
      int luku2=0;
      int jakaja=0;
      int summa=0;
      int summa2=0;
      boolean ystävyysluvut=false;
      
      do {
         
         luku1 ;
         luku2=0;
         
         do {
            
            luku2 ;
            jakaja=0;
            summa=0;
               
            do {
               
               jakaja ;
               
               if (luku1%jakaja==0) {
                  
                  summa=summa jakaja;
               }
            } while (jakaja

En tiedä mitä meinaat tarkoittaa ystävyysluvuilla, mutta softa toimii niin kuin se on tehtykkin. Eli siinä on hiton motonta do while lausetta ja ulommaisessa kasvatetaan luku1:stä yhdellä ja sisimmäisessä luku2:sta 1:llä niin kauan, että se on 1000 ja ulommaisessa loopin lopussa todetaan että luku1 ystäväluku luku2:lle eikä tätä ystavaluku muuttujaa koskaan alusteta takaisin false:ksi joten se on aina true.

Ei millään pahalla, mutta pieni määrä koodia näyttää tosi sekavalta ja tehottomalta (ainakin mun macbookissa).

Kannattaisi varmaan jakaa ongelma pienempiin osiin. Kirjoita vaikka metodi

private static int jakajienSumma(int n),

jonka avulla saat tehtyä lukujen ystävyyden selvittävän metodin:

private static boolean onYstavyysluvut(int a, int b) {
return b*jakajienSumma(a) == a*jakajienSumma(b);
}

Pääohjelmassa teet sitten sisäkkäiset silmukat a=0...10000 ja b=a 1...10000 jne.