Buchstaben eine Zahl zuweisen ?

Dafür kannst ein assoziatives Array einsetzen, beispielsweise:
PHP: 
$map = array(
	'a' => 1,
	'b' => 2,
	// …
);
Oder hast du an eine spezielle Abbildung gedacht?
 
Eigendlich soll es eine Art Geheimsprache werden.

PHP: 
$map = array(
    'a' => 1,
    'h' => 2,
    'l' => 3,
    'o' => 4,
    // …
);
und die Ausgabe in diesem Fall wäre 21334
 
Prinzipiell:
PHP: 
<?php
$string = "hallo!";
$map = array(
    'a' => 1,
    'h' => 2,
    'l' => 3,
    'o' => 4
    // ...
    );

$length  = strlen( $string );
$encoded = "";

for ( $i = 0; $i < $length; ++$i ) {
    $encoded .= isset( $map[ $string{ $i } ] )
              ? $map[ $string{ $i } ]
              : "0";
}
var_dump( $encoded );

Das ist jedoch bei mehr als 9 unterschiedlichen Zeichen mehrdeutig, weshalb ich zu einer etwas eindeutigeren Methode empfehlen würde, wie zB:
PHP: 
<?php
$string = "Hallo!";
$map = array(
    'a' => "-01",
    'h' => "-02",
    'l' => "-03",
    'o' => "-04",
    'H' => "+02",
    // ...
    );

$length  = strlen( $string );
$encoded = "";

for ( $i = 0; $i < $length; ++$i ) {
    $encoded .= isset( $map[ $string{ $i } ] )
              ? $map[ $string{ $i } ]
              : "000";
}
var_dump( $encoded );

Am besten jedoch ist ein in PHP implementierter Verschlüsselungsalgorithmus (kein Hashalgorithmus!), da diese wohl die besseren Ergebnisse zurückliefern können als so ein kleiner, linearer Algorithmus ^^.
 
Ich hätte da eine Frage zu diesem Code:
PHP: 
<?php
$map = array(
    'a' => "-01",
    'h' => "-02",
    'l' => "-03",
    'o' => "-04",
    'H' => "+02",
    // ...
    );

Was muss ich anstellen damit z.B. Buchstaben oder Zahlen die nicht im Array vorkommen, trotzdem einen Wert zugeordnet werden?

Also: Aus "a" wird "-01" aber was ist wenn man z.B. "F" eingibt und "F" in der Liste nicht definiert ist? Ich möchte also das Buchstaben/Zahlen die nicht in der Liste vorkommen auch einen allgemeinen Wert bekommen wie z.B. "3".

Ist dies möglich? Wenn ja wie?

Danke im Vorraus. :)
 
Wer genau hinschauet der findet ;)
PHP: 
for ( $i = 0; $i < $length; ++$i ) {
    $encoded .= isset( $map[ $string{ $i } ] )
              ? $map[ $string{ $i } ]
              : "000"; // <-- Da ist dein allgemeiner Wert
}
 
Schön und gut. aber so lassen sich die nicht definierten Buchstaben nicht zurückwandeln.
Ich hab auch mal ein wneig spielerei betrieben und bin dabei auf das folgende gekommen.

Mit HEX-Werten lässt sich schön arbeiten.. Nun, Hexwerte erkennt sofort jeden. Darum habe ich noch 2 zusatzstufen eingebaut.
1) Eine Tabelle mit eigenen Werten. Also die $map von euren Beispielen
2) Jeder zweite Hexwert wird verdreht. Also aus 7F wird dann F7. 'OZ' -> '4F5A' -> '4FA5'
3) Ein Flag. true oder false. Anhand dieses Flags wird die Reihenfolge für 2) geändert.
Flag=false: 'OZ' -> '4F5A' -> '4FA5' ............ Flag=true: 'OZ' -> '4F5A' -> 'F45A'
Dieser Flag muss aber beiden Seiten bekannt sein, da beim ver und entschlüsseln der gleiche Flag verwednet werden muss.

Diese drei einfachen funktionen machen den verschlüsselten String zwar nicht sicher, aber nicht ganz einfach zu lesen für unbeteiligte. Man kann natürlich noch diverse weitere Dinge einbauen.

Aber wahrscheinlich kann das Ding eh zuviel und du brauchst was viel einfacheres. Das Basteln hat trotzdem Spass gemacht

PHP: 
<?php 
//Test
$flag = true;
echo "<b>Input:</b><br />\n";
echo $text = "Hallo Welt,<br />\nhallo zum 2'ten";
echo "<hr />\n";
echo "<b>Verschlüsselt:</b><br />\n";
echo $encryptedText = Map::encrypt($text, $flag);
echo "<hr />\n";
echo "<b>Entschlüsselt:</b><br />\n";
echo Map::decrypt($encryptedText, $flag);


class Map{
    const C_FLAG_DEFAULT = false;
    //Pseudo-Hexwerte immer Gross
    //Die Werte sollten über '7F' liegen, damit keine Probleme auftauchen
    //Die Extendes ASCII-Codes werden so zwar überschrieben, aber diebraucht man eh fast nie. Ansonsten
    //sollte der Wert halt über 'FF' liegen. Hier sind auch Werte wie 'GF' etc. zulässig
    protected static $map = array('h' =>'F1', 'H' => 'A1', 'd' => '9F', 'e' => 'EF');
    protected static $switcher = C_FLAG_DEFAULT;
    protected static $cruptFunc = '';

    /**
     * verschlüsselt einen Text
     * @static
     * @param String    $text   zu verschlüsselnder Text
     * @param Boolean   $flag   Flag, true oder afalse der mitgegeben werden kann. 
     *                          Dieser beinflusst den Switcher. Zum verschlüssen und entschlüsseln muss
     *                          der gleiche Wert verwendet werden!
     *                          Default ist false
     * @return  String          Verschlüsselter Text
     */
    public static function encrypt($text, $flag = self::C_FLAG_DEFAULT){
        return self::convert(str_split($text), $flag, 'encryptLetter');
    }

    /**
     * entschlüsselt einen Text
     * @static
     * @param String    $string Verschlüsselter Text
     * @param Boolean   $flag   Flag analog zum Parameter $flag von encrypt
     */
    public static function decrypt($string, $flag = self::C_FLAG_DEFAULT){
        return self::convert(str_split($string, 2), $flag, 'decryptLetter');
    }
    
    /**
     * setzt die Initial-Parameter und ruft über alle Elemente die Ver/Entschlüsselung auf
     * @static
     * @param Array<String> $array
     * @param Boolean       $flag
     * @param String        $func
     * @return  String
     */
    protected static function convert($array, $flag, $func){
        self::$switcher=$flag;
        self::$cruptFunc = $func;
        //Alle Elemente des Arrays zusammenführen
        return array_reduce($array, array(self, 'reduce'));        
    }
    
    /**
     * Funktion zum ver-/entschlüsseln und zusammenfügen aller Buchstaben
     * Diese Callback-Funktion wird für array_reduce() verwendet
     * @static
     * @param String    $a      1. Buchstabe 
     * @param String    $b      2. Buchstabe
     * @return  String          zusammengehängte Buchstaben
     */
    protected static function reduce($a, $b){
        return $a. call_user_func(array(self, self::$cruptFunc), $b, self::$switcher = !self::$switcher);
    }
    
    /**
     * Verschlüsseln eines Buchstabens
     * @static
     * @param String    $letter     Entschlüsselter Buchstabe
     * @param Boolean   $reverse    
     * @return  String              Verschlüsselter Buchstabe
     */
    protected static function encryptLetter($letter, $reverse=false){
        //prüfen ob der Buchstabe im map-array ist. Wenn ja, diesen Wert nehmen. Ansonsten den Hex-Wert
        $hex = array_key_exists($letter, self::$map) ? self::$map[$letter] : strtoupper(dechex(ord($letter)));
        //Sicherstellen dass der String 2 Zeichen lang ist. 'A' -> '0A'
        $hex = str_pad($hex, 2, '0', STR_PAD_LEFT);
        //Hex-Wert umkehren
        return $reverse ? strrev($hex) : $hex; 
    }

    /**
     * entschlüsseln eines Buchstabens
     * @static
     * @param String    $hex        Verschlüsselter Buchstabe
     * @param Boolean   $reverse    
     * @return  String              Entschlüsselter Buchstabe
     */
    protected function decryptLetter($hex, $reverse = false){
        //Hex-Wert umkehren
        $hex = strtoupper($reverse ? strrev($hex) : $hex);
        //Im map-array suchen und ggf passenden Wert zurückgeben. Ansonsten den Hexwert zurückwandeln
        return ($letter = array_search($hex, self::$map)) ? $letter : chr(hexdec($hex));
    }
}
?>

Ausgabe:

Input:
Hallo Welt,
hallo zum 2'ten
Verschlüsselt:
A1166CC66F0257FE6C472CC3622720F23EA0F1166CC66F027A576D02327274FE6E
Entschlüsselt:
Hallo Welt,
hallo zum 2'ten


Und mal so zum Vergleich in Sachen Flag:
Code: 
Flag = true:  A1166CC66F0257FE6C472CC3622720F23EA0F1166CC66F027A576D02327274FE6E
Flag = false: 1A61C66CF62075EFC674C23C2672022FE30A1F61C66CF620A775D620232747EFE6
 
Man könnte in den String jetzt noch zusätzlich nicht im hexadezimalen Zahlensystem vorkommende Buchstaben einbauen um andere Nutzer zu verwirren. (Diese kann man beim entschlüsseln einfach entfernen). Fällt aber wahrscheinlich auch unter "zu aufwendig" für die kleine Geheimsprache ;)
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück