2D Array von Zeichenformatierung

Question

Also schreibe ich ein Programm, wo ich aus einer Datei lesen muss, die Koordinatenpunkte enthält und dann die Handlung anzeigen. Zum Beispiel habe ich dies als die erste Zeile, 20 10. Was mein Programm tun soll, ist dies mit einem 2D-Array von Zeichen. Ein 'X' ist für die Punkte zu verwenden.

So berechnete ich die Steigung und die Formel für die Regressionslinie.

float xMean = xSum/count; 
    float yMean = ySum/count; 
    float n = count; 
    float slope = (xySum - n* xMean * yMean)/(xSqSum - n * xMean * xMean); 

I unten Methode zu drucken ‚-‘ Zeichen, wenn es keine ‚X‘ Zeichen ist und wenn es dann ein ‚*‘ Zeichen.

for (int i = 0; i < graph.length; i++) { 
     int yPred = Math.round(yMean + slope * (i - xMean)); // calculate regression value 
     graph[21-1-yPred][i + 1] = graph[21-1-yPred][i + 1 ] == 'X' ? '*' : '-'; 
    } 

korrekte Ausgabe, die ich für

Ziel bin

jedoch diese Ausgabe Ich erhalte:

Was ich versuche, bin zu erreichen ing ist, dass mein Programm würde drucken „-“ s wie die Segmente Regressionslinie, und „*“ s, wo ein Liniensegment und ein Punkt an der gleichen Stelle befinden

aber ich bin immer wenige Striche in meinem Programm verglichen mit der richtigen Ausgabe. Auch das Sternchen ist nicht in der Mitte wo es sein soll.

Dies ist die Textdatei, die ich verwende. Ich konnte die Validierung mit meinem Programm durchführen lassen. ** x-Koordinaten im Bereich von [0, 40] und y-Koordinaten im Bereich von [1, 20]. **

Answer 1

Okay, also lasst uns dieses Problem beseitigen! Erstens, nach 15 Minuten verbringen oder so Linien auf dem Bildschirm Schuss Textdatei setzen, hier ist das Bild, das ich entwarf (das Original natürlich Darstellung):

Nun erwähnten, Sie eine Zeile oder Eingabe von ein "X" sollst du aufstellen. Dies ist auch eine Textdatei, und Sie lesen es aus der Datei, also hier ist, was sagte Datei (nennen wir es 'coords.txt' für dieses Beispiel).

20 10 

Mit 20 und 10 sind die Koordinaten, gelesen das Line-Overlay-Bild basiert der I hergestellt, glaube ich, dass (20 10) zur x-Achse korrelieren würde = 21, y-Achse = 10 (Das Off um Eins ist wahrscheinlich eine einfache Indizierung um einen Fehler - lesen Sie mehr hereIch behandelte im Grunde nur die Grafik wie eine Grafik).

Dies ist eine Möglichkeit, diesen Punkt/Daten in aus einer Datei zu lesen und bereiten sie aufgetragen werden: 20 10 von

aus Datei lesen

Scanner s = new Scanner(new File("coords.txt")); 
int x = 0; 
int y = 0; 
if (s.hasNext()) 
    x = s.nextInt(); 
if (s.hasNext()) 
    y = s.nextInt(); 
s.close(); 

Dieser Code ist leicht genug, dass es ein Scanner macht Objekt um den Inhalt unserer Datei zu lesen. Dann deklarieren Sie eine x und y Ganzzahl, um unsere Koordinatenwerte zu speichern. Hinweis: s.hasNext() ist wertvolle Logik im Allgemeinen zu überprüfen, um sicherzustellen, dass etwas in der Textdatei zu lesen ist, bevor Sie versuchen, es zu lesen - Sie könnten auch s.hasNextInt() anpassen, um nur nach einem Integer-Token als nächstes zu lesen aus Datei.

Allerdings habe ich bemerkt, dass Sie mehrere X-marks-the-Spot auf Ihrem Ergebnisdiagramm haben. Wenn Sie zu dem Bild zurückkehren, das ich erstellt habe, um die Koordinaten zu sehen, die Sie wahrscheinlich in Ihrer nicht explizit erwähnten Datei 'coords.txt' hätten, würden Sie in diesem Beispiel eine Datei mit den folgenden Zeilen haben:

Jetzt basieren diese Zahlen auf dem ursprünglichen Bild, das ich Linien über zeichnete, jedoch respektierte ich den off-by-one Fehler, deshalb stimmen sie nicht direkt mit Koordinaten auf diesem Bild überein, weil der Korrektur dieser einseitige Fehler.

Jetzt mit mehreren Coords, wie man diesen Input auf eine effizientere Weise liest? Hier ist eine Möglichkeit:

import java.io.File; 
import java.io.IOException; 
import java.util.Scanner; 

public class App { 
    public static final int SIZE = 100; 
    public static void main(String[] args) throws IOException { 
     Scanner s = new Scanner(new File("C:\\Users\\Nick\\Desktop\\coords.txt")); 
     int x = 0; 
     int y = 0; 
     int[] xCoords = new int[SIZE]; 
     int[] yCoords = new int[SIZE]; 
     int index = 0; 
     while (s.hasNextLine()) { 
      if (s.hasNextInt()) { 
       x = s.nextInt(); 
      } else { 
       System.out.println("had a next line, but no integers to read"); 
       break; 
      } 
      if (s.hasNextInt()) { 
       y = s.nextInt(); 
      } else { 
       System.out.println("had a next line, but no integers to read"); 
       break; 
      } 
      xCoords[index] = x; 
      yCoords[index] = y; 
      index++; 
     } 
     s.close(); 
    } 
} 

Dieser Code nimmt mehrere Dinge an, darunter:;

1. wir denken nicht, dass wir mehr als 100 Koordinaten zum Plotten lesen werden. (Wenn Sie diese Nummer kennen, bearbeiten Sie einfach den SIZE Wert auf den vorgegebenen Wert. Wenn Sie den Wert nicht kennen, dann schauen Sie in die Java-Listen-Schnittstelle growing/expanding an array oder java.util.List und tutorial).
2. Die xCoords und yCoords Integer-Arrays sind übereinstimmend/spiegeln, dass sie beide zu einem bestimmten Index gefüllt werden sollten, um eine plotfähige Koordinate (X-marks-the-spot) darzustellen.
3. ebenfalls zum vorherigen Punkt, in der While-Schleife wird angenommen, dass jede Zeile zwei ganzzahlige Werte zum Lesen enthält, die einer Koordinate ähneln.
4. Die ganze Zahl index Wert erhöht sich nach jeder Schleife, um den nächsten Punkt zum Einlesen bereit zu machen und uns auch zu informieren, wie viele Punkte eingelesen wurden, während die while Schleife Schleife war.

den obigen Code Laufen zum Lesen der ‚coords.txt‘ Datei, und das Hinzufügen von ein paar einfachen System.out.println() ‚s nach der while-Schleife, aber vor den s.close(); hilft zeigen, was in gelesen. Hier ist die zweite Version des Eingangs Lesen, zusammen mit dem Ausgang zu zeigen, was passiert ist:

import java.io.File; 
import java.io.IOException; 
import java.util.Scanner; 

public class App { 
    public static final int SIZE = 100; 
    public static void main(String[] args) throws IOException { 
     Scanner s = new Scanner(new File("C:\\Users\\Nick\\Desktop\\coords.txt")); 
     int x = 0; 
     int y = 0; 
     int[] xCoords = new int[SIZE]; 
     int[] yCoords = new int[SIZE]; 
     int index = 0; 
     while (s.hasNextLine()) { 
      if (s.hasNextInt()) { 
       x = s.nextInt(); 
      } else { 
       System.out.println("had a next line, but no integers to read"); 
       break; 
      } 
      if (s.hasNextInt()) { 
       y = s.nextInt(); 
      } else { 
       System.out.println("had a next line, but no integers to read"); 
       break; 
      } 
      xCoords[index] = x; 
      yCoords[index] = y; 
      index++; 
     } 
     System.out.println("Output from what was read in from file:"); 
     for (int i = 0; i < index; ++i) { 
      System.out.print(xCoords[i] + ", "); 
      System.out.println(yCoords[i]); 
     } 
     s.close(); 
    } 
} 

und die jeweilige Ausgabe:

had a next line, but no integers to read 
Output from what was read in from file: 
20, 10 
0, 1 
40, 20 
13, 17 
10, 20 

Die ersten beiden Zeilen sind nur Kommentare, die entfernt werden können. Es ist gut zu sehen, dass wir unsere Daten effektiv einlesen können!

Auf den Brot-und-Butter-Teil des Problems, die volle Leistung. Um das Beispielbild auszugeben, müssen wir effektiv ein 2D-Zeichenfeld ausdrucken (das ist die Idee, die ich hier verwenden werde).

Wir wissen (basierend auf dem mit Linien markierten Diagramm), dass wir Abmessungen von 21 x 42 für eine vollständige Replik-Ausgabe haben müssen. Dies liegt an den Achsenmarkierungen selbst. Also, beginnen wir mit der Deklaration eines 2D-Arrays wie zum Beispiel:

char[][] graph = new char[21][42]; 

Das ist großartig! Wir haben eine unsichtbare Grafik! Lasst uns diese miesen NULL-Charaktere rausholen und ein paar gute alte Räume einbauen! Immerhin ist dies die Ursache für das Drucken alles aus funky, können Sie nicht erwarten, dass der char Wert von '\0' sich genauso verhalten wie ' '.

for (int i = 0; i < graph.length; ++i) 
    for (int j = 0; j < graph[0].length; ++j) 
     graph[i][j] = ' '; 

Jetzt fangen wir an, es mit der bloßen Achse zu markieren. Zunächst wird die y-Achse:

for (int i = 0; i < graph.length; ++i) { 
    graph[i][0] = '/'; 
} 
graph[20][0] = '+'; 

Hinweis: wir mit dem + Symbol betrügen kann, da es ganz am Ende kommt. Die For-Schleife könnte verwenden und if Anweisung und markieren Sie den letzten Index mit der + aber lassen Sie uns versuchen, auch intuitiv zu sein.

Dann wird für die x-Achse:

for (int i = 1; i < graph[0].length; ++i) { 
    graph[20][i] = '-'; 
} 

Da wir wissen, wo das Ende ist, wir einfach die hartcodierte verwenden Wert von 20 und eine Schleife über den Index zur Eingabe der X-Achsen-Symbole/char -.

Schauen wir uns diese neu erstellte Diagramm mit dem folgenden Code einen Blick:

for (int i = 0; i < graph.length; ++i) { 
    for (int j = 0; j < graph[0].length; ++j) { 
     System.out.print(graph[i][j]); 
    } 
    System.out.println(); 
} 

, die die folgende Ausgabe sollte:

/           
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
/          
+----------------------------------------- 

Lassen Sie uns das Grundstück X-Marken-Ort jetzt , basierend auf dem, was Sie mit den Koordinaten aus dem früheren Code verwendet haben.

Dies kann durch Schleifen über die Spiegel-Integer-Arrays (xCoords und yCoords) und die Verwendung dieser Koordinaten zum Plotten auf den 2D char[][] graph erfolgen.

for (int i = 0; i < index; ++i) { 
    graph[21 - 1 - yCoords[i]][xCoords[i] + 1] = 'X'; 
} 

Aufbrechen der Informationen hier (siehe oben), wird die [21 - 1 - yCoords[i]] bedeuten die y-Koordinate an der entsprechenden Stelle in dem Array 2D dargestellt zu übersetzen, indem ein Offset von dem oberen Wert des Graphen rückwärts dargestellt (daher unter Verwendung von Verwenden Sie 21, um von oben zu beginnen) und auch ein anderer minus ein Offset wegen der Achse selbst (zB die Zeichen '/' und '-' und '+').Für die xCoords wird einfach ein plus für den Achsenoffset verwendet.

ist hier, dass die Ausgabe:

/   X        X 
/          
/          
/   X       
/          
/          
/          
/          
/          
/          
/     X      
/          
/          
/          
/          
/          
/          
/          
/          
/X           
+----------------------------------------- 

sehr Sieht aus wie ein frühes Stadium dieser Bilder von dem, was die Ausgabe sein annehmen wird!

Alles in allem ist es das, was wie mein letzter Code sah:

import java.io.File; 
import java.io.IOException; 
import java.util.Scanner; 

public class App { 
    public static final int SIZE = 100; 
    public static void main(String[] args) throws IOException { 
     Scanner s = new Scanner(new File("C:\\Users\\Nick\\Desktop\\coords.txt")); 
     int x = 0; 
     int y = 0; 
     int[] xCoords = new int[SIZE]; 
     int[] yCoords = new int[SIZE]; 
     int index = 0; 
     while (s.hasNextLine()) { 
      if (s.hasNextInt()) { 
       x = s.nextInt(); 
      } else { 
       System.out.println("had a next line, but no integers to read"); 
       break; 
      } 
      if (s.hasNextInt()) { 
       y = s.nextInt(); 
      } else { 
       System.out.println("had a next line, but no integers to read"); 
       break; 
      } 
      xCoords[index] = x; 
      yCoords[index] = y; 
      index++; 
     } 
     System.out.println("Output from what was read in from file:"); 
     for (int i = 0; i < index; ++i) { 
      System.out.print(xCoords[i] + ", "); 
      System.out.println(yCoords[i]); 
     } 
     s.close(); 
     char[][] graph = new char[21][42]; 
     for (int i = 0; i < graph.length; ++i) 
      for (int j = 0; j < graph[0].length; ++j) 
       graph[i][j] = ' '; 
     for (int i = 0; i < graph.length; ++i) 
      graph[i][0] = '/'; 
     graph[20][0] = '+'; 
     for (int i = 1; i < graph[0].length; ++i) 
      graph[20][i] = '-'; 
     for (int i = 0; i < index; ++i) 
      graph[21 - 1 - yCoords[i]][xCoords[i] + 1] = 'X'; 
     for (int i = 0; i < graph.length; ++i) { 
      for (int j = 0; j < graph[0].length; ++j) 
       System.out.print(graph[i][j]); 
      System.out.println(); 
     } 
    } 
} 

Wenn Sie mehr Details enthalten sein sollen, z.B. multiple '-' für Regression und '*' für Punkt, würde ich ermutigen, diese Informationen zu verwenden, um zu lernen und sich anzupassen, um diese Koordinaten für diese zusätzlichen Informationen zu lesen und sie auf dieses Beispiel anzuwenden. Es gibt jedoch keine Informationen darüber, daher werde ich mich nicht mit angeblichen Textdateien und Coords beschäftigen, entweder in der Frage bearbeiten oder es selbst ausprobieren und etwas lernen. :) Prost

Answer 2

Warum nicht einfach array[x][y] = 'X';?

Auch, was stellst du in den Rest des Arrays? Wenn Sie dort nichts eingeben, wird standardmäßig 0 angezeigt, was auf dem Terminal als nichts angezeigt wird. Ich nehme an, Sie wollten die unbenutzten Einträge mit Leerzeichen und Zeilenumbrüchen füllen