Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Windrichtung bestimmen (Selektionen)

Im Kreis einer Windrose werden die Himmelsrichtungen durch die vier Hauptrichtungen Nord (N), Ost (O), Süd (S) und West (W) bestimmt.

 

Diese Viererteilung kann durch eine Halbierung der Winkel, also eine Einteilung in 45°-Abteilungen präzisiert werden. Die so erhaltenen 8 Richtungen sind N, NO, O, SO, S, SW, W, NW.

 

Diese wiederum halbiert, teilen den Kreis in Abteilungen von 22½°- ein, 16 an der Zahl: N, NNO, NO, ONO, O, OSO, SO, SSO, S, SSW, SW, WSW, W, WNW, NW, NNW.

 

Auf diese Weise ein weiteres Mal präzisiert, erhält man insgesamt 32 Windrichtungen als Teilung des Kreises in Winkeln von 11¼°, also N, NzO (sprich: Nord zu Ost), NNO, NOzN, NO, NOzO, ONO, OzN, O, OzS, OSO, SOzO, SO, SOzS, SSO, SzO, S, SzW, SW, SWzW, WSW, WzS, W, WzN, WNW, NWzW, NW, NWzN, NNW, NzW.

 

Windrose mit Gradeinteilungen

 

Ihre Aufgabe:
Verfassen Sie einen Algorithmus, der eine Gradzahl und eine Kreiseinteilung (in 4, 8, 16 oder 32 Abschnitte) entgegennimmt, und die entsprechende Himmelsrichtung zurückgibt. Ist keine Kreisteilung angegeben, soll als Standard die Einteilung in 16 Teilungen verwendet werden.

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

2 Lösung(en)

public class Main {

	public static List<String> nosw = new ArrayList<String>();
	public static Scanner sc;

	public static void main(String[] args) {
		addRichtungen();
		getWindrichtung();
	}

	public static void addRichtungen() {
		// 4 Himmelsrichtungen
		nosw.add("0°4°N");
		nosw.add("90°4°O");
		nosw.add("180°4°S");
		nosw.add("270°4°W");
		nosw.add("360°4°N");

		for (int i = 0; i < 4; i++) {
			// GetDatas
			String[] s = nosw.get(i).split("°");
			int grad = Integer.parseInt(s[0]);
			String now = s[2];
			String next = "";

			if (i == 3) {
				next = nosw.get(0).split("°")[2];
			} else {
				next = nosw.get(i + 1).split("°")[2];
			}

			// 8 Himmelsrichtungen
			nosw.add((grad + 45) + "°8°" + swapIfNeeded(now + next));

			// 16 Himmelsrichtungen
			nosw.add((grad + 22.5) + "°16°" + swapIfNeeded2(now + next + now));
			nosw.add((grad + 67.5) + "°16°" + swapIfNeeded2(next + now + next));

			// 32 Himmelsrichtungen
			nosw.add((grad + 11.25) + "°32°" + now + "z" + next);
			nosw.add((grad + 33.75) + "°32°" + swapIfNeeded(now + next) + "z" + now);
			nosw.add((grad + 56.25) + "°32°" + swapIfNeeded(now + next) + "z" + next);
			nosw.add((grad + 78.75) + "°32°" + next + "z" + now);
		}
	}

	public static String swapIfNeeded(String str) {
		if (str.startsWith("O") || str.startsWith("W")) {
			char[] c = str.toCharArray();
			char temp = c[0];
			c[0] = c[1];
			c[1] = temp;

			return new String(c);
		} else {
			return str;
		}
	}

	public static String swapIfNeeded2(String str) {
		if (str.startsWith("N") || str.startsWith("S")) {
			char[] c = str.toCharArray();
			char temp = c[1];
			c[1] = c[0];
			c[2] = temp;

			return new String(c);
		} else {
			return str;
		}
	}

	public static void getWindrichtung() {
		System.out.println(System.lineSeparator() + "Windrichtung: " + getSearched(getKreiseinteilung(), getGrad()));
	}

	public static int getKreiseinteilung() {
		try {
			sc = new Scanner(System.in);
			System.out.println("Kreiseinteilung in 4, 8, 16 oder 32 angeben!");
			System.out.print("Kreiseinteilung: ");
			
			return Integer.parseInt(sc.nextLine());
		} catch (Exception e) {
			System.out.print(System.lineSeparator() + "Die Kreiseinteilung wurde automatisch auf 16 gesetzt!" + System.lineSeparator());
			return 16;
		}
	}

	public static double getGrad() {
		try {
			sc = new Scanner(System.in);
			System.out.print("Grad: ");
			
			return Double.parseDouble(sc.nextLine());
		} catch (Exception e) {
			System.out.println(System.lineSeparator() + "Der Grad wurde automatisch auf 0 gesetzt!" + System.lineSeparator());
			return 0;
		}
	}

	public static String getSearched(int k, double g) {
		HashMap<Double, String> unsorted = new HashMap<Double, String>();

		for (int i = 0; i < nosw.size(); i++) {
			String[] s = nosw.get(i).split("°");

			if (k >= Integer.parseInt(s[1])) {
				unsorted.put(Double.parseDouble(s[0]), s[2]);
			}
		}

		List<Double> array = new ArrayList<Double>(unsorted.keySet());

		if (!array.contains(g)) {
			array.add(g);
		} else {
			return unsorted.get(g);
		}
		
		double[] sorted = convertListToDoubles(array);
		Arrays.sort(sorted);
		int searched = Arrays.binarySearch(sorted, g);

		return unsorted.get(getLowest(sorted, getTemp1(sorted, searched), getTemp2(sorted, searched), searched));
	}

	public static double[] convertListToDoubles(List<Double> array) {
		double[] list = new double[array.size()];
		for (int i = 0; i < list.length; i++) {
			list[i] = array.get(i).doubleValue();
		}

		return list;
	}

	public static double getTemp1(double[] array, int searched) {
		try {
			if ((array[searched - 1]) > array[searched]) {
				return (array[searched - 1]) - array[searched];
			} else {
				return array[searched] - (array[searched - 1]);
			}
		} catch (IndexOutOfBoundsException e) {
			return 1000;
		}
	}

	public static double getTemp2(double[] array, int searched) {
		if ((array[searched + 1]) > array[searched]) {
			return (array[searched + 1]) - array[searched];
		} else {
			return array[searched] - (array[searched + 1]);
		}
	}

	public static double getLowest(double[] array, double a, double b, int searched) {
		double min = Math.min(a, b);

		if (min == a) {
			return array[searched - 1];
		} else if (min == b) {
			return array[searched + 1];
		}

		return -1;
	}
}
                

Lösung von: Linus Götz (Lichtenberg-Gymnasium Cuxhaven)

function getHeading(degrees, precision) {
  var precision = precision || 16,
      directions = [],
      direction = 0,
      step = 360 / precision,
      i = step / 2;

  switch (precision) {
    case  4: directions = "N O S W".split(" "); break;
    case  8: directions = "N NO O SO S SW W NW".split(" "); break;
    case 16: directions = ("N NNO NO ONO O OSO SO " +
      "SSO S SSW SW WSW W WNW NW NNW").split(" ");
      break;
    case 32: directions = ("N NzO NNO NOzN NO NOzO ONO OzN O OzS OSO " +
      "SOzO SO SOzS SSO SzO S SzW SSW SWzS SW SWzW WSW WzS W WzN " +
      "WNW NWzW NW NWzN NNW NzW").split(" ");
      break;
    default: throw("Invalid precision argument.");
  }

  if (degrees < 0 || degrees > 360) throw("Invalid degrees argument.");
  if (degrees <= i || degrees >= 360 - i) return "N";
  while (i <= degrees) {
    direction++;
    i += step;
  }
  return directions[direction];
}

console.log(getHeading(240, 4));
console.log(getHeading(240, 8));
console.log(getHeading(240));
console.log(getHeading(240, 32));                           // lissalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

Verifikation/Checksumme:

Grad Präzision
(Kreiseinteilung) 
Windrichtung
240 4 W
240 8 SW
240 16 WSW
240 32 SWzW

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 0.5
Schwierigkeit: Leicht
Webcode: ibbn-2e7d
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen