Bit Operationen NOR!

T

Tsa

Mitglied
Hey,
ich soll eine Java Methode schreiben, die nur mit & und ~ eine Zahl "Nor"t ;)
Jetzt bin ich auch ganz gut weit nur der letzte schliff fehlt noch und ich kam nach mehreren Stunden intensiven grübelns nicht drauf.
Bisher sieht das so aus: (~a&~b)
so nach der Logik funktionierts ja auch, nur bleiben halt in Java die doofen Einsen vorne übrig. Ich hab beim besten Willen keine Idee wie ich die wegbekomme!
Wenn ich das jetzt negiere hab ich halt das negierte von dem ergebnis was ich will... und dann? :confused::confused::confused:

Hoffe mir kann wer helfen, auch wenn es nicht nur um Java geht!! :)
Liebe Grüße,
Jens
 
Hallo,

schau mal hier:
Java: 
package de.tutorials;

public class NOR {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*
a   b	OUT
0	0	1
0	1	0
1	0	0
1	1	0
		 */

		byte[] a = { 
				0, 
				0, 
				1, 
				1 
				};

		byte[] b = { 
				0, 
				1, 
				0, 
				1
				};

		for (int i = 0; i < a.length; i++) {
			System.out.println(nor(a[i], b[i]));
		}

	}

	private static byte nor(byte a, byte b) {
		// Siehe: http://de.wikipedia.org/wiki/NOR-Gatter
		return (byte) nand(nand(nand(a, a), nand(b, b)), nand(nand(a, a), nand(b, b)));
	}

	private static byte nand(byte a, byte b) {
		return (byte) not(and(a, b));
	}

	private static byte and(byte a, byte b) {
		return (byte) (a & b);
	}

	private static byte not(byte a) {
		return (byte) (~(a) & 1); //invert only the last bit
	}

}

Ausgabe:
Code: 
1
0
0
0

Gruß Tom
 
Hey,
das ist sehr nett, aber das bringt mich nicht wirklcih weiter.
Ich brauche alles als Integer. Und für Integer klappts nicht ;)
Außerdem hab ich es noch nicht richtig verstanden, was du da machst.
Also insbesondere die Methode not ist mir total unklar.
1 als bit ist ja: 00000001 wenn ich das jetzt mit UND mit irgendeiner beliebigen Zahl
verknüpfe, dann hab ich ja maximal 00000001!
Mal kurz was ich bisher habe als Java Quelltext und wo mein Problem dabei liegt.
Code: 
public class LogischeOperationen
{
	public static int bitNor(int x, int y)
	{
		return ((~x) & (~y));
	}
	
	public static int bitXor(int x, int y)
	{
		return ~((~(x&~y))&(~(~x&y)));
	}
	
	public static void main(String[] args)
	{
		System.out.println(bitNor(8,2));
		System.out.println(bitXor(2,4));
	}
}

Jetzt habe ich zwar das richtige Ergebnis in der Zahl stehen. für die Integer 2,4 wäre das NOR-Ergebnis ja 1, dann steht in meiner Zahl auch 001 drin.
Aaaaaaaaaaber: ein Integer hat ja 32 Bit und die ersten 29 sind mit 1 belegt in diesem Fall also irgendwie so:
11111111[...]1001
Da ich ja eine allgemeingültige Lösung will, kann ich die auch nicht einfahc wegshiften... leider ;)
Wie bekomme ich die weg mit den Operatoren & und ~?
Liebe Grüße
 
Hallo,

das klappt doch auch mit int wunderbar:
Java: 
package de.tutorials;

public class NOR {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*
		 * IN1 IN2 OUT 0 0 1 0 1 0 1 0 0 1 1 0
		 */

	  int[] a = { 
				0, 
				0, 
				1, 
				1 
				};

		int[] b = { 
				0, 
				1, 
				0, 
				1
				};

		for (int i = 0; i < a.length; i++) {
			System.out.println(nor(a[i], b[i]));
		}

	}

	private static int nor(int a, int b) {
		return nand(nand(nand(a, a), nand(b, b)), nand(nand(a, a), nand(b, b)));
	}

	private static int nand(int a, int b) {
		return not(and(a, b));
	}

	private static int and(int a, int b) {
		return (a & b);
	}

	private static int not(int a) {
		return (~(a) & 1);
	}

}

Ausgabe:
Code: 
1
0
0
0

Mit ~ invertierst du alle bits. d.h. aus 000....0001 wird -> 111....1110 -> Wenn du hier nur am letzten bit interessiert bist kannst du das ganze Ergebnis wieder mit 1 ver-unden ( .... & 00000001 -> ... & 1) dann werden die "führenden" 1en ausgelöscht.

Gruß Tom
 
Ok, aber ich hab ja beliebige Zahlen! Also ich weiß ja erstmal gar nicht welche bits richtig sind und welche nur führende 1 die durchs invertieren entstanden sind. Also bei dem Beispiel klappt das so, aber wenn ich 16,8 NOR nehmen würde, wäre ja 111, aber wenn ich dann mit deiner methode arbeite, dann kommt 1 raus, weil nur das letzte Bit "gesichert" wird. Wie sowas funktioniert weiß ich eigentlich ganz gut, dazu mussten wir im Studium grade sehr viel machen :D
Aber was mir halt nicht klar ist, wie ich jetzt beim beispiel 16,8 nach meiner Methode mit nor => 111111[...]100111 die 1 wegbekomme bis auf hinten die 7 :|
Also klar könnt ich mit &7 die 1 vorne wegbekommen, aber das wäre mir zu manuell, es soll ja per bitoperation gemacht werden. :)
 
Hallo,

achso... ich dachte du wolltest nur ein Beispiel für NOR mit 0/1.

Schau mal hier:
Java: 
package de.tutorials;

import static java.lang.Integer.highestOneBit;
import static java.lang.Integer.toBinaryString;

public class NOR {
  public static void main(String[] args) {
    int a = 16;
    int b = 8;
    int result = (~a & highestOneBit(a) - 1) & (~b & highestOneBit(b) - 1);

    System.out.println(toBinaryString(a));
    System.out.println(toBinaryString(b));
    System.out.println(toBinaryString(result));
  }
}

Ausgabe:
Code: 
10000
1000
111

Gruß Tom
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück