www.jammni.de

data Bit = Null| Eins deriving (Read,Show,Eq,Ord,Enum)
type Bits =[Bit]


toBin c=umwandeln( laenge8 (toBinary(fromEnum c)))

toBin8 []=[]
toBin8 (c:cs) =(toBin c)++(toBin8 cs)

umwandeln [] = []
umwandeln (x:xs)
                    |(x==1) =Eins : (umwandeln xs)
                    | otherwise = Null : (umwandeln xs)

toBinary 0 = [0]
toBinary x = toBinary t ++ [x `mod` 2]
	     where t = x `div` 2

laenge8 (l:liste)
             |(length (l:liste) < 8) = laenge8 (0:(l:liste))
             |(length (l:liste) > 8)=  laenge8 liste
             |otherwise = (l:liste) 

hideMessage text= hideMessagehelp (splittetext text [])
hideMessagehelp []=[]
hideMessagehelp (x:xs) 
                  | ((findword x tupel)== []) = (toBin8 x): (hideMessagehelp xs)
                  |  otherwise = (findword x tupel): (hideMessagehelp xs)

findword x []=[]
findword x ((a,b):liste) 
			|(x==a) = [Eins]++ (toBin8 b)
                        |(x==b) = [Null]++ (toBin8 a)
                        |otherwise=findword x liste

splittetext [] acc =acc:[]
splittetext (x:xs) acc
		      |(x==' ') = acc:(splittetext xs [])
                      |otherwise = splittetext xs (acc++[x]) 

tupel=[("daß","dass"),("Paare","2-Tupel"),("Normalform","NF"),("schlimmsten","schlechtesten"),("Da","Weil"),("zeitgleich","simultan"),("welche","die"),("

erlaubt","gestattet"),("korrigieren","verbessern"),("gleiche","selbe"),("solches","derartiges"),("wandeln","konvertieren"),("falls","wenn"),("nun","jetzt

"),("verkünden","proklamieren"),("eigens","extra"),("Methode","Möglichkeit"),("hier","dabei"),("benutzen","verwenden"),("erweitern","ergänzen"),("auch","

sogar"),("absolut","vollständig"),("äußerst","extrem"),("braucht","benötigt"),("mit","mittels"),("einigermaßen","relativ"),("etwas","recht"),("zeigen","b

eweisen"),("Fehler","Irrtum"),("gleich","identisch"),("versteckt","verborgen"),("sollen","dürfen"),("Nachricht","Mitteilung"),("soll","sollte")]

txt ="daß Fehler äußerst oft in Nachrichten versteckt sind weiß man doch"
test=hideMessage "da"
test2= hideMessage txt
--------------------------------------------------


findMessage []=[]
findMessage (x:xs)
		  |(((length x)`mod` 8) ==0)= (fromBin x):(findMessage xs)
                  |otherwise=erstesbit x
                    where 
                        erstesbit (c:cs)
                                        |(vergleich c Eins)=(findword2 (fromBin cs) tupel ): (findMessage xs)
                                        |otherwise =(findword2 (fromBin cs) tupel )   : (findMessage xs)
                  



findword2 x []=[]
findword2 x ((a,b):liste) 
			|(x==a) = b
                        |(x==b) = a
                        |otherwise=findword2 x liste
          


toint [] = 0
toint (x:xs)
                |(x==1)  =( 2^( length (xs) ) )   +(toint xs)
                | otherwise = 0+ (toint xs)



frombin []=[]
fromBin (c) 
            |((length c)<=8)=[( toEnum(toint(umwandeln2 (take 8 c)))::Char )]
	    |otherwise =[( toEnum(toint(umwandeln2 (take 8 c)))::Char )] ++fromBin(drop 8 c)



umwandeln2 [] = []
umwandeln2 (x:xs)=if (vergleich x Eins) then (1 : (umwandeln2 xs)) else   (0:(umwandeln2 xs))

vergleich::Bit->Bit ->Bool
vergleich Eins Eins=True
vergleich Null Null=True
vergleich _ _     =False

--also hier wird der datentyp bit definiert
data Bit = Null| Eins deriving (Read,Show,Eq,Ord,Enum)
type Bits =[Bit]
--type Bits brauch man garnicht...

--toBin wandelt einen einzigen Buchstaben in ein Bit mit 8 zahlen um z.b. [Null,Eins,...,Null]
toBin c=umwandeln( laenge8 (toBinary(fromEnum c)))

--wandelt ein wort um
toBin8 []=[]
toBin8 (c:cs) =(toBin c)++(toBin8 cs)

--macht aus einer normalen liste von binärzahlen den eigenen datentyp
--"1" ein "Eins", und aus "0" Null
umwandeln [] = []
umwandeln (x:xs)
                    |(x==1) =Eins : (umwandeln xs)
                    | otherwise = Null : (umwandeln xs)
--macht aus einen Int ne Binärzahl z.b. aus 5 [1,0,1]
toBinary 0 = [0]
toBinary x = toBinary t ++ [x `mod` 2]
	     where t = x `div` 2
---sorgt dafür das jeder buchstabe aus wirklich 8 bit besteht...also es werden wenn es 9 bits sind 
--die ersten gelöscht und wenns weniger als 8 sind vorne Nullen davor geschrieben
laenge8 (l:liste)
             |(length (l:liste) < 8) = laenge8 (0:(l:liste))
             |(length (l:liste) > 8)=  laenge8 liste
             |otherwise = (l:liste) 
--verbirgt die nachricht
hideMessage text= hideMessagehelp (splittetext text [])
--hier wird zunächst mit findword geschaut ob das aktuelle wort zufällig ein wort aus der liste ist...
---wenn ja wird das andere wort aus dem tupel genommen und verschlüsselt...ansonsten wird jedes wort mit toBin8 binärcodiert
hideMessagehelp []=[]
hideMessagehelp (x:xs) 
                  | ((findword x tupel)== []) = (toBin8 x): (hideMessagehelp xs)
                  |  otherwise = (findword x tupel): (hideMessagehelp xs)
--sucht das wort aus der liste von tupelns raus
---wenn das wort nicht enthalten ist wird die leere liste zurrückgegeben...
---hier wird dann auch am anfang des wortes geschrieben welches wort aus den tupel genommen wurde
--NUll für den ersten teil des tupels eins für den zweiten
findword x []=[]
findword x ((a,b):liste) 
			|(x==a) = [Eins]++ (toBin8 b)
                        |(x==b) = [Null]++ (toBin8 a)
                        |otherwise=findword x liste

--zerlegt den text anhand der leerzeichen in eine liste von strings
splittetext [] acc =acc:[]
splittetext (x:xs) acc
		      |(x==' ') = acc:(splittetext xs [])
                      |otherwise = splittetext xs (acc++[x]) 

---die schlüsselwörter
tupel=[("daß","dass"),("Paare","2-Tupel"),("Normalform","NF"),("schlimmsten","schlechtesten"),("Da","Weil"),("zeitgleich","simultan"),("welche","die"),("

erlaubt","gestattet"),("korrigieren","verbessern"),("gleiche","selbe"),("solches","derartiges"),("wandeln","konvertieren"),("falls","wenn"),("nun","jetzt

"),("verkünden","proklamieren"),("eigens","extra"),("Methode","Möglichkeit"),("hier","dabei"),("benutzen","verwenden"),("erweitern","ergänzen"),("auch","

sogar"),("absolut","vollständig"),("äußerst","extrem"),("braucht","benötigt"),("mit","mittels"),("einigermaßen","relativ"),("etwas","recht"),("zeigen","b

eweisen"),("Fehler","Irrtum"),("gleich","identisch"),("versteckt","verborgen"),("sollen","dürfen"),("Nachricht","Mitteilung"),("soll","sollte")]

--beispiele zum testen
txt ="daß Fehler äußerst oft in Nachrichten versteckt sind weiß man doch"
test=hideMessage "da"
test2= hideMessage txt
--------------------------------------------------

--die hauptfunktion erhält eine liste von listen von Bit bsp[[String1],[String2],[String3]] die Strings sind natürlich
--als [Null,Eins,...,Null] codiert
--hier wird erstmal geschaut ob das liste [Null,Eins,...,Null]  durch 8 teilbar ist...wenn das der fall ist 
--dann wird das wort ganz normal wieder zurück gewandelt. falls es nicht durch 8 teilbar ist dann ist es ein wort aus
--der schlüsselwortliste...und das erstebit wird weggeworfen und der rest entschlüsselt und durch das wort aus der liste ersetzt
findMessage []=[]
findMessage (x:xs)
		  |(((length x)`mod` 8) ==0)= (fromBin x):(findMessage xs)
                  |otherwise=erstesbit x
                    where 
                        erstesbit (c:cs)
                                        |(vergleich c Eins)=(findword2 (fromBin cs) tupel ): (findMessage xs)
                                        |otherwise =(findword2 (fromBin cs) tupel )   : (findMessage xs)
                  


--sucht das wort aus der liste raus und gibt das jeweils andere aus dem tupel zurrück
findword2 x []=[]
findword2 x ((a,b):liste) 
			|(x==a) = b
                        |(x==b) = a
                        |otherwise=findword2 x liste
          

--wandelt eine liste von [1,0,1,0,..] in einen Int um
toint [] = 0
toint (x:xs)
                |(x==1)  =( 2^( length (xs) ) )   +(toint xs)
                | otherwise = 0+ (toint xs)


---mit die wichtigste funktion...wenn die länge der liste [1,0,1,..] kleiner gleich 8 ist dann wird hier das richtige buchstabe wiederhergestellt
frombin []=[]
fromBin (c) 
            |((length c)<=8)=[( toEnum(toint(umwandeln2 (take 8 c)))::Char )]
	    |otherwise =[( toEnum(toint(umwandeln2 (take 8 c)))::Char )] ++fromBin(drop 8 c)


--macht aus [Null,Eins,Null...] wieder [0,1,0,...]
umwandeln2 [] = []
umwandeln2 (x:xs)=if (vergleich x Eins) then (1 : (umwandeln2 xs)) else   (0:(umwandeln2 xs))

--vergleich ist zu vergleichen von Bit also Eins==Eins ;-)