[Mazen2004]

Hallo,

Ich habe Werte zwischen 0 und 1000.
Und möchte sie auf die Werte 250, 500 oder 1000 mappen.
Jeweils wenn der Wert kleinerGleich ist als 250 dann zu 250; kleinerGleich als 500 dann zu 500 etc.

Mein Ansatz ist mit ((int) wert /100) * 100. Dann bekomm ichs schon ma auf die 100er Werte gemappt. Nur wie müsste die Rechnung aussehend damit ich da nicht 100er schritte bekomme sondern die Rechenvorschrift f(x) = x*2 weil der wert ja immer verdoppelt ist :/

[Heisenberg]

Ich hab eigentlich absolut keine Ahnung von Programmieren, aber kannst du das nicht mit mehreren Fällen machen? wenn wir mal von ganzen Zahlen ausgehen:

if x<251
do x=250

if x>250 & x<501
do x=500

if x> 500 & x<751
do x=750

if x>750
do x=1000

[Mazen2004]

Zitat von Heisenberg

Ich hab eigentlich absolut keine Ahnung von Programmieren, aber kannst du das nicht mit mehreren Fällen machen? wenn wir mal von ganzen Zahlen ausgehen:

if x<251
do x=250

if x>250 & x<501
do x=500

if x> 500 & x<751
do x=750

if x>750
do x=1000

Genau das wollte ich vermeiden :>
Keine abfragen sondern direkt auf den richtigen Wert mappen

[Alex²]

Zitat von Mazen2004

Genau das wollte ich vermeiden :>
Keine abfragen sondern direkt auf den richtigen Wert mappen

Wie soll das ohne Abfragen in Pseudocode funktionieren? Suchst du eine mathematische Operation die jede Zahl ihrer größe nach auf den entsprechenden Wert bringt? Das wird wahrscheinlich weniger einfach.

f(x) = x + (y -x)

Sowas würde halt jede Zahl welche kleiner bzw. gleich y ist auf y bringen. Die Frage ist, wie du das mit den Stufen in eine Gleichung bekommst. Halte ich für schwierig.

Was du daraus bauen könntest:

RRMap.java:

import java.util.Arrays;

public class RRMap {

	public static void main(String[] args) {
		int[] possibleKeys = { 250, 500, 1000 };
		int[] randomValues = { 111, 222, 333, 444, 555, 666, 777, 888, 999,
				1111 };
		for (int value : randomValues) {
			System.out.println(value + " to " + getMapKey(value, possibleKeys));
		}
	}

	private static int getMapKey(int value, int... possibleKeys) {

		Arrays.sort(possibleKeys);

		for (int possibleKey : possibleKeys) {
			int gap = possibleKey - value;
			int currentKey = value + gap;
			if (gap >= 0)
				return currentKey;
		}

		return possibleKeys[possibleKeys.length - 1];
	}
}

Lässt sich mit Sicherheit noch optimieren. Halte ich in der Form aber für eine relativ effiziente Lösung. Diese Lösung mappt alles was größer als der größte Key ist zum größten Key (kannst die letzte Zeile ja anpassen, wenn diese Werte als ungültig gelten sollen).

[-idur-]

Bin jetzt auch nicht der beste Progammierer, aber ich hab lange rumprobiert und so funktionierts

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    double wert;

    cout << "Wert? "; cin >> wert;
    cout << pow(2,round(0.8*(((int)(wert/250.1))+1)+1.2))/4*250 << endl;
}

War aber echt nicht einfach, das so hinzubiegen ^^
Vllt gehts auch irgendwie einfacher :/


//EDIT: Das ganze funktioniert nur sicher, wenn die Zahlen maximal 1 Nachkommastelle haben. Solltest du es genauer brauchen, musst du die 250.1 anpassen in z.B. 250.01. Dann gehen auch 2 Nachkommastellen.

[Chillikid]

Und wieso willst du Abfragen vermeiden? Es ist der einfachste und verständlichste Weg.

Wenn mal jemand anders deinen Code lesen sollte, ist so eine Lösung wie die von -idur- nicht nachvollziehbar geschweige denn anpassbar.