[PHP] Waarden in array "roteren"

[mcdronkz]

Ik zit met een probleem waar ik niet uitkom. Het ontbreekt me aan het logisch denkvermogen denk ik.

Een ieder van jullie kent de codering "ROT". Hierbij wordt het alfabet geroteerd. Ik wou dus als experiment een scriptje maken waarmee ik ook ROT 4 dingen zou kunnen decoderen.

Probleem is alleen, hoe ga je zoiets doen ? Je kunt natuurlijk een array maken en daar alle waarden intikken, maar dat lijkt me niet de juiste manier.

PHP heeft de functie range(..) waarmee je het alfabet in een array kunt zetten, dus ik kwam op zoiets uit:

PHP:

<?php
$ROTchars = range("a","z");
print_r($ROTchars);
?>

Er is nu dus keurig een array gevuld met het alfabet. Maar dán ? Hoe kan ik zorgen dat m'n array als volgt wordt:

X Y Z A B C D E F G..... etc etc. ?

Ik heb tot op heden hier geen functie voor gevonden, dus die moet ik waarschijnlijk zelf schrijven. Geen probleem, ik hou van uitdagingen, maar voel dat ik toch even op weg geholpen moet worden.

[Swaptor]

Een sub-array nemen van het n-de element tot het laatste, die plaatsen in een nieuwe array van 26 plaatsjes vanaf de eerste plek. Daarna de eerste n elementen er achteraan plakken.

En vice versa.

A B C D E F G

. . . . . . . 

. . . A B C D

E F G A B C D

Overigens is het voorbeeldje dus precies volgens mijn laatste opmerking

[ Voor 31% gewijzigd door Swaptor op 07-03-2007 00:00 ]

[RobIII]

Eh? Waarom pak je niet gewoon de ASCII waarde +4 (of voor de-ROT -4) van een bepaalde letter? Moet je alleen even oppassen voor je boundaries...

[DataGhost]

Je kan elk teken zelf bewerken met iets als
$nieuwteken = $minascii + ((($teken - $minascii) + $x) % 26);
of iets dergelijks simpels. Dit neemt wel aan dat je alle tekens eerst even ord(). Dan heb je opzich geen array nodig

RobIII, doesnie zo snel

[ Voor 9% gewijzigd door DataGhost op 07-03-2007 00:00 ]

[CodeCaster]

Ongeveer zo?

PHP:

$rotstart = 4;
$i = 0;
$array_in = range("a","z");

foreach($array_in as $letter) {
 $array_out[$i + $rotstart] = $letter;
 $i++;
 if ($i == 26) {
  $rotstart = -$rotstart;
 }
}

Niet getest, en niet netjes.

edit:
en nog niet op tijd ook.

[ Voor 6% gewijzigd door CodeCaster op 07-03-2007 00:03 ]

[Verwijderd]

waarom niet gewoon even de manual door lezen? wat je zoekt is array_pop en array_unshift.

voorbeeldje

PHP:

 $alphabet = rang("a", "z"); 
 $rot_max = 4;
 $rot_n = 0;

 while($rot_n < $rot_max){
  $rot_add = array_pop();
  array_unshift($alphabet, $rot_add);
  $rot_n++;
 }

dit werkt zelfs voor een elke mogelijke rot van ROT-1 tot ROT-2147483647 omdat php's integer 32bit is. duurt ook wel een tijdje denk ik voordat je 2147483647 ROT's hebt gedaan

php manual page's:
http://www.php.net/manual/en/ref.array.php
http://www.php.net/manual/en/function.array-pop.php
http://www.php.net/manual/en/function.array-unshift.php

[ Voor 3% gewijzigd door Verwijderd op 07-03-2007 03:16 ]

[Verwijderd]

Verwijderd schreef op woensdag 07 maart 2007 @ 02:58:
...
dit werkt zelfs voor een elke mogelijke rot van ROT-1 tot ROT-2147483647 omdat php's integer 32bit is. duurt ook wel een tijdje denk ik voordat je 2147483647 ROT's hebt gedaan
...

lol

ik had een rotor-functie gemaakt, kan alleen nog een crappy variant vinden. Uiteindelijke idee was

code:

function rotor($value, $min, $max) {
  zolang $value niet tussen $min en $max zit
    if $value>$max { $value=- $max; }
    if $value<$min { $value=+ $min; }
    
};

Zodat buitenliggende indexwaarden vanzelf teruggeschaald worden.

[sjhgvr]

PHP:

<?php
$alphabet = range("a", "z");
$rot_4_alphabet = array_merge(array_splice($alphabet, -4), $alphabet);
print_r($rot_4_alphabet);
?>

Output:

code:

Array ( [0] => w [1] => x [2] => y [3] => z [4] => a [5] => b [6] => c [7] => d [8] => e [9] => f [10] => g [11] => h [12] => i [13] => j [14] => k [15] => l [16] => m [17] => n [18] => o [19] => p [20] => q [21] => r [22] => s [23] => t [24] => u [25] => v )

[Verwijderd]

Verwijderd schreef op woensdag 07 maart 2007 @ 03:16:
[...]


lol

ik had een rotor-functie gemaakt, kan alleen nog een crappy variant vinden. Uiteindelijke idee was

code:

function rotor($value, $min, $max) {
  zolang $value niet tussen $min en $max zit
    if $value>$max { $value=- $max; }
    if $value<$min { $value=+ $min; }
    
};

Zodat buitenliggende indexwaarden vanzelf teruggeschaald worden.

lol ben niet de enige die ligt te slapen blijkbaar. ik post hierboven een rotor functie en niet een ROT codeer functie.

nieuwe poging,

PHP:

 $alphabet = range("a", "z");
 $forward = true; 
 $rot_count = 4;

 foreach($alphabet as $alphabet_key => $alphabet_val){
  $alphabet_chr = ord($alphabet_val);
  $capital = false;
   if(($alphabet_chr >= 96 ) AND ($alphabet_chr <= 122)){
    $alphabet_chr = $alphabet_chr -32;
    $capital = true;
   }

   if(($alphabet_chr >= 64) AND ($alphabet_chr <= 90)){
     if($forward == true){
      $alphabet_chr = $alphabet_chr + $rot_count;
     }else{
      $alphabet_chr = $alphabet_chr - $rot_count;
     }

     if($alphabet_chr > 90){
      $alphabet_chr = 64 + ($alphabet_chr -90); 
     }elseif($alphabet_chr < 64){
      $alphabet_chr = 90 - (64 - $alphabet_chr);
     }
   
     if($capital == true){
      $alphabet_chr = $alphabet_chr + 32;
     }
   }

  $alphabet[$alphabet_key] = chr($alphabet_chr);
 }

zo, niet gestest maar deze ROT codeer en decodeer functie werkt nog steeds met een willekeurig aantal ROT's en houdt rekening met Hoofdletters en kleine letter's en laat andere leestekens en cijfers ongemoeid. door van $forward false te maken werkt deze functie in de tegengestelde richting.

*Edit DaPi zat ook al op het verkeerde pad en levert een nog simpelere versie van een rotor functie.

een rotor functie roteert de array maar dat is wat anders dan ROT codeering waar de TS het over heeft. bij ROT codeering schijft elke letter n plaatsen op in het alphabet. dus bij rot4 wordt elke A in de string een D, elke B wordt een E, elke C wordt een F en elke D wordt een H etc. en elke X wordt een B. het is alsof je het alphabet roteert maar niet de leterlijke plek van elk teken in de string zelf.

maarja, het is laat.

[ Voor 13% gewijzigd door Verwijderd op 07-03-2007 03:47 ]

[sjhgvr]

Verwijderd schreef op woensdag 07 maart 2007 @ 03:40:
[...]


lol ben niet de enige die ligt te slapen blijkbaar. ik post hierboven een rotor functie en niet een ROT codeer functie.

nieuwe poging,

PHP:

 $alphabet = range("a", "z");
 $forward = true; 
 $rot_count = 4;

 foreach($alphabet as $alphabet_key => $alphabet_val){
  $alphabet_chr = ord($alphabet_val);
  $capital = false;
   if(($alphabet_chr >= 96 ) AND ($alphabet_chr <= 122)){
    $alphabet_chr = $alphabet_chr -32;
    $capital = true;
   }

   if(($alphabet_chr >= 64) AND ($alphabet_chr <= 90)){
     if($forward == true){
      $alphabet_chr = $alphabet_chr + $rot_count;
     }else{
      $alphabet_chr = $alphabet_chr - $rot_count;
     }

     if($alphabet_chr > 90){
      $alphabet_chr = 64 + ($alphabet_chr -90); 
     }elseif($alphabet_chr < 64){
      $alphabet_chr = 90 - (64 - $alphabet_chr);
     }
   
     if($capital == true){
      $alphabet_chr = $alphabet_chr + 32;
     }
   }

  $alphabet[$alphabet_key] = chr($alphabet_chr);
 }

zo, niet gestest maar deze ROT codeer en decodeer functie werkt nog steeds met een willekeurig aantal ROT's en houdt rekening met Hoofdletters en kleine letter's en laat andere leestekens en cijfers ongemoeid. door van $forward false te maken werkt deze functie in de tegengestelde richting.

*Edit DaPi zat ook al op het verkeerde pad en levert een nog simpelere versie van een rotor functie.

een rotor functie roteert de array maar dat is wat anders dan ROT codeering waar de TS het over heeft. bij ROT codeering schijft elke letter n plaatsen op in het alphabet. dus bij rot4 wordt elke A in de string een D, elke B wordt een E, elke C wordt een F en elke D wordt een H etc. en elke X wordt een B. het is alsof je het alphabet roteert maar niet de leterlijke plek van elk teken in de string zelf.

maarja, het is laat.

Aha ik snap t nu.
Overigens: Bij de originele ROT13 word de A een N dus bij ROT4 word de A een E en geen D zoals jij aangeeft.

Dit is wat ik net in elkaar geknutselt heb:

[EDIT] .... Onderstaande code werkt niet naar behoren, voor de verbeterde versie klik hier.

PHP:

<?php
function rot_4($in, $encode = 0) {

    $orig = $alphabet = range("a", "z");
    $splice = array_splice($alphabet, 0, 4);
    $rot_4_alphabet = array_merge($alphabet, $splice);
    
    if ($encode)
        $dic = array_combine($orig, $rot_4_alphabet);
    else
        $dic = array_combine($rot_4_alphabet, $orig);
    
    for ($i = 0; $i < strlen($in); $i++) {
    
        foreach ($dic as $old => $new) {
        
            if ($in{$i} == $old) {
            
                @$out .= $new;
                break;
            
            } else if (strtoupper($in{$i}) == strtoupper($old)) {
            
                @$out .= strtoupper($new);
                break;
                
            } 
            
        }
        
    }
    
    return $out;
    
}

// ROT4 Encoding
echo rot_4('DaPi', 1); // Outputs: HeTm

// ROT4 Decoding
echo rot_4('HeTm'); // Outputs: DaPi
?> 

Veel plezier ermee

[ Voor 6% gewijzigd door sjhgvr op 07-03-2007 05:32 . Reden: Decode functie toegevoegd ;) // Bugje gefixed .. eek lol ]

[Verwijderd]

klopt, het is plaats_in_alphabet + keren_roteren = nieuw_plaats_in_alphabet. dus bij rot13 verschuift de A van plek 1, 13 keer en komt dus op plek 14 terecht en bij ROT4 verschijft de A, 4 keer en komt dus op plek 5 terecht oftewel de E.

damn, er zit een best wel nasty bug in jouw versie DaPi, in plaats van dat deze leestekens onvermoeid laat of ze ook ROT gooit deze ze gewoon weg.

dOcey ==> hSgic
Dapi ==> HeTm
dOceyDaPi ==> hSgicHeTm
Ts ==> Xw
dOceyDaPiTs ==> hSgicHeTmXw oftewel hSgic + HeTm + Xw.
dOcey8DaPi_Ts ==> hSgicHeTmXw !!! waar zijn de 8 en de underscore gebleven???

toch leuk om te zien dat er s'nachts nog zo actief wordt ge-code terwijl de TS al lang op een oor ligt.

[sjhgvr]

Verwijderd schreef op woensdag 07 maart 2007 @ 05:17:
damn, er zit een best wel nasty bug in jouw versie DaPi, in plaats van dat deze leestekens onvermoeid laat of ze ook ROT gooit deze ze gewoon weg.

Idd, kwam ik zelf net ook achter.
Hier de verbeterde versie:

PHP:

<?php
function rot_4($in, $encode = 0) {

    $orig = $alphabet = range("a", "z");
    $splice = array_splice($alphabet, 0, 4);
    $rot_4_alphabet = array_merge($alphabet, $splice);
    
    if ($encode)
        $dic = array_combine($orig, $rot_4_alphabet);
    else
        $dic = array_combine($rot_4_alphabet, $orig);
    
    for ($i = 0; $i < strlen($in); $i++) {
        
        $found = 0;
    
        foreach ($dic as $old => $new) {
        
            if ($in{$i} == $old) {

                @$out .= $new;
                $found = 1;
                break;

            } else if (strtoupper($in{$i}) == strtoupper($old)) {

                @$out .= strtoupper($new);
                $found = 1;
                break;

            }
            
        }
        
        if (!$found)
            @$out .= $in{$i};
        
    }
    
    return $out;
    
}

// ROT4 Encoding
echo rot_4('DaPi loves PHP', 1); // Outputs: HeTm psziw TLT

// ROT4 Decoding
echo rot_4('HeTm psziw TLT'); // Outputs: DaPi loves PHP
?>

[chris]

Ik heb het ook eens in haskell geprobeerd:

Haskell:

import Maybe
rot x ls = take (length ls) $ drop x $ cycle ls
swap (a,b) = (b,a)
r2a = mkr2a ['a'..'z'] ++ mkr2a ['A'..'Z']
  where mkr2a x = zip x $  rot 4 x
a2r = map swap r2a
rot4encode = map $ flip lookup' r2a
rot4decode = map $ flip lookup' a2r
lookup' x = fromMaybe x . lookup x

En de output:

*Main> rot4encode "DaPi loves PHP"
"HeTm psziw TLT"
*Main> rot4decode "HeTm psziw TLT111"
"DaPi loves PHP111"

[Verwijderd]

Nog een betere versie welke werkt met elk willekeurig ROT nummer dus zowel ROT-4, ROT-13 als ook ROT-47 of ROT-26

deze maakt gebruik van een hashtable wat vooral voor grotere stukken tekst veel sneller is. eerst worden voor alle ASCII tekens tussen start en stop de ROT versie's berekent en daarna wordt de tekst gewoon byte for byte gelezen en bewerkt waar nodig.

ook heb ik argument checking toegevoegd omdat dat wel zo netjes is.

PHP:

    function rot_gentable($start, $stop, $rot_count)
    {
     if((!is_int($start)) OR ($start < 0) OR ($start >= 256)){
       trigger_error("Starting ASCII for generating ROT-Table is not an valid integer value.", E_USER_WARNING);
      return false;
     }
     if((!is_int($stop)) OR ($stop < 0) OR ($stop >= 256)){
       trigger_error("Stopping ASCII for generating ROT-Table is not an valid integer value.", E_USER_WARNING);
      return false;
     }
     if($start >= $stop){
       trigger_error("Starting ASCII for generating ROT-Table is beyond stopping ASCII.", E_USER_WARNING);
      return false;
     }
     if((!is_int($rot_count)) OR ($rot_count <= 0)){
       trigger_error("ROT Count for generating ROT-Table is not an valid integer value.", E_USER_WARNING);
      return false;
     }
     
        $rot_table  = array();
        $posistion  = $start;
            
            while($posistion < $stop){
             $rot_add = $posistion;
             $rot_pos = 0;
                while($rot_pos < $rot_count){
                 $rot_pos++;
                 $rot_add++;
                    if($rot_add > $stop){
                     $rot_add = $start;
                    }
                }
                 
             $rot_table[chr($posistion)] = chr($rot_add);
             $posistion++;
            }
            
     return $rot_table;
    }
    
    function rot_n($input, $rot_count=4, $forward=true, $large_alphabet=false)
    {
     if((!is_string($input)) OR (strlen($input) <= 0)){
       trigger_error("String to ROT is not an valid string.", E_USER_WARNING);
      return false;
     }
     if((!is_int($rot_count)) OR ($rot_count <= 0)){
       trigger_error("Times to ROT is not an valid positive integer value.", E_USER_WARNING);
      return false;
     }
     if(!is_bool($forward)){
       trigger_error("Direction to ROT is not an boolean value.", E_USER_WARNING);
      return false;
     }
     
        $rot_table  = array();
        if($large_alphabet === true){
         $rot_table = rot_gentable(33, 126, $rot_count);
        }else{
         $rot_1 = rot_gentable(65, 90, $rot_count);
         $rot_2 = rot_gentable(97, 122, $rot_count);
         $rot_table = array_merge($rot_1, $rot_2);
        }
        
        print_r($rot_table);
        
        $input_len = strlen($input);
        $input_pos = 0;
            while($input_pos <= $input_len){
                if(isset($rot_table[$input{$input_pos}])){
                 $input{$input_pos} = $rot_table[$input{$input_pos}];
                }
                
             $input_pos++;
            }
        
     return $input;
    }

    print("\r\n >".$argv[1]." ROT_N: ".rot_n($argv[1], 3315)."");
    print("\r\n >".$argv[1]." ROT13: ".str_rot13($argv[1])."");

ook worden ROT's die groter zijn dan het alphabet correct ondersteunt waar vorige versie's van zowel DaPi als mij dat niet deden. ROT 3315 geeft het zelfde resultaat als ROT13 alleen wordt het alphabet dus correct 3315 keer geroteerd.

op lijn 65 wordt de huidige ROT table gedumpt maar er mag gerust een commentje voor

rot_gentable ontvangt 3 integer waardes.
- de minimum ASCII waar gaat in $start.
- de maximum ASCII waarde gaat in $stop
- en het aantal ROT rotatie's gaat in $rot_count.

je krijgt dan een array met voor elke ASCII tussen minimum en maxium de rot versie. ge-index bij de ascii key met de ROT als waarde. gebruik dus zowel ord voor de key als de waarde om het ASCII nummer te krijgen.

rot_n ontvangt 4 argumenten.
- $input bevat de string die rot_n bewerkt
- $rot_count bevat het aantal ROT rotaties.
- $forward is een boolean welke de richting aangeeft. true voor encoderen, fals voor decoderen.
- $large_alphabet, als deze true is worden alle ascii waardes tussen 33(!) en 126(~) gebruikt, en elke ander waarde gebruikt alleen de letters a-z en A-Z.

rot_n geeft de bewerkte string weer terug. als rot_n een teken tegenkomt dat niet in de rotatie tabel staat dan slaat hij deze over en doet er niks mee.

zo, dan nu is het tijd voor een ontbijt. goedemorgen.

[DataGhost]

Zal ik de boel dan nog even vlug komen verpesten? Pff, wat een gigantische scripts komen hier langs voor zoiets simpels...

PHP:

function rot($input, $n) {
    $n %= 26;
    if($n < 0) $n += 26;
    $ret = "";
    for($i=0; $i<strlen($input); $i++) {
        $tmp = ord($input[$i]);
        if($tmp >= 65 && $tmp <= 90) {
            $ret .= chr(65 + ((($tmp - 65) + $n) % 26));
        } elseif($tmp >= 97 && $tmp <= 122) {
            $ret .= chr(97 + ((($tmp - 97) + $n) % 26));
        }
    }
    return $ret;
}

DAT is nou de kracht van de Postbank modulo!

Edit: Sorry Docey, maar...

PHP:

$str = "aBcDeFgHiJkLmNoPqRsTuVwXyZ";
for($i=0;$i<10;$i++) {
        echo rot_n($str, 123456 + $i) . "\n";
}

code:

helios hackthissite # time php rot.php       
iJkLmNoPqRsTuVwXyZaBcDeFgH
jKlMnOpQrStUvWxYzAbCdEfGhI
kLmNoPqRsTuVwXyZaBcDeFgHiJ
lMnOpQrStUvWxYzAbCdEfGhIjK
mNoPqRsTuVwXyZaBcDeFgHiJkL
nOpQrStUvWxYzAbCdEfGhIjKlM
oPqRsTuVwXyZaBcDeFgHiJkLmN
pQrStUvWxYzAbCdEfGhIjKlMnO
qRsTuVwXyZaBcDeFgHiJkLmNoP
rStUvWxYzAbCdEfGhIjKlMnOpQ

real    0m0.108s
user    0m0.080s
sys     0m0.030s

helios hackthissite # time php rot_Docey.php 
iJkLmNoPqRsTuVwXyZaBcDeFgZ
jKlMnOpQrStUvWxYzAbCdEfGhZ
kLmNoPqRsTuVwXyZaBcDeFgHiZ
lMnOpQrStUvWxYzAbCdEfGhIjZ
mNoPqRsTuVwXyZaBcDeFgHiJkZ
nOpQrStUvWxYzAbCdEfGhIjKlZ
oPqRsTuVwXyZaBcDeFgHiJkLmZ
pQrStUvWxYzAbCdEfGhIjKlMnZ
qRsTuVwXyZaBcDeFgHiJkLmNoZ
rStUvWxYzAbCdEfGhIjKlMnOpZ

real    1m29.545s
user    1m28.910s
sys     0m0.040s

Edit2: Hm, ik zie nou pas dat je output ook niet klopt (zie het laatste teken).

[ Voor 48% gewijzigd door DataGhost op 07-03-2007 09:08 ]

[Grijze Vos]

DataGhost schreef op woensdag 07 maart 2007 @ 08:49:
DAT is nou de kracht van de Postbank modulo!

Juist, alleen substr gebruiken om een char in een string aann te spreken is natuurlijk overkill.

$string[X] will do just fine.

[DataGhost]

Grijze Vos schreef op woensdag 07 maart 2007 @ 08:57:
[...]

Juist, alleen substr gebruiken om een char in een string aann te spreken is natuurlijk overkill.

$string[X] will do just fine.

Hm, toch wel? Ik heb expres substr gebruikt omdat het gisteren niet werkte met een directe index.
Verrek! Dan heb ik gisteren vast ergens anders een foutje gemaakt Aangepast trouwens

[ Voor 11% gewijzigd door DataGhost op 07-03-2007 09:11 ]

[Verwijderd]

DataGhost schreef op woensdag 07 maart 2007 @ 08:49:
Zal ik de boel dan nog even vlug komen verpesten? Pff, wat een gigantische scripts komen hier langs voor zoiets simpels...

PHP:

function rot($input, $n) {
    $n %= 26;
    if($n < 0) $n += 26;
    $ret = "";
    for($i=0; $i<strlen($input); $i++) {
        $tmp = ord($input[$i]);
        if($tmp >= 65 && $tmp <= 90) {
            $ret .= chr(65 + ((($tmp - 65) + $n) % 26));
        } elseif($tmp >= 97 && $tmp <= 122) {
            $ret .= chr(97 + ((($tmp - 97) + $n) % 26));
        }
    }
    return $ret;
}

DAT is nou de kracht van de Postbank modulo!

Edit: Sorry Docey, maar...

PHP:

$str = "aBcDeFgHiJkLmNoPqRsTuVwXyZ";
for($i=0;$i<10;$i++) {
        echo rot_n($str, 123456 + $i) . "\n";
}

code:

helios hackthissite # time php rot.php       
iJkLmNoPqRsTuVwXyZaBcDeFgH
jKlMnOpQrStUvWxYzAbCdEfGhI
kLmNoPqRsTuVwXyZaBcDeFgHiJ
lMnOpQrStUvWxYzAbCdEfGhIjK
mNoPqRsTuVwXyZaBcDeFgHiJkL
nOpQrStUvWxYzAbCdEfGhIjKlM
oPqRsTuVwXyZaBcDeFgHiJkLmN
pQrStUvWxYzAbCdEfGhIjKlMnO
qRsTuVwXyZaBcDeFgHiJkLmNoP
rStUvWxYzAbCdEfGhIjKlMnOpQ

real    0m0.108s
user    0m0.080s
sys     0m0.030s

helios hackthissite # time php rot_Docey.php 
iJkLmNoPqRsTuVwXyZaBcDeFgZ
jKlMnOpQrStUvWxYzAbCdEfGhZ
kLmNoPqRsTuVwXyZaBcDeFgHiZ
lMnOpQrStUvWxYzAbCdEfGhIjZ
mNoPqRsTuVwXyZaBcDeFgHiJkZ
nOpQrStUvWxYzAbCdEfGhIjKlZ
oPqRsTuVwXyZaBcDeFgHiJkLmZ
pQrStUvWxYzAbCdEfGhIjKlMnZ
qRsTuVwXyZaBcDeFgHiJkLmNoZ
rStUvWxYzAbCdEfGhIjKlMnOpZ

real    1m29.545s
user    1m28.910s
sys     0m0.040s

Edit2: Hm, ik zie nou pas dat je output ook niet klopt (zie het laatste teken).

dat is mischien leuk voor als je ROT13 wilt doen maar wat als je nou ROT-47 wilt? dat gaat dus mooi niet lukken met jouw versie. je negeert alles buiten het alphabet terwijl ROT-47 dat nou juist vereist. met jouw versie kom je niet verder dan ASCII 65 tot 90 en 96 tot 122. wat als je nou een ROT wilt doen met de extended ASCII zeg 30 tot 255. juist dan wordt jouw versie ook wel wat groter.

daarnaast checked jouw versie compleet niet wat er in de functie wordt gevoerd en is dus slordig. wat als ik nou rot(array(array(0)), false) in jouw functie voer? krijg ik dan een keurige false waarde en een E_WARNING? nee. goede code wordt herkend door goede error-handeling en als je kijkt zie je dat ik zo'n 26 regels code hier aan besteedt.

daarnaast maak ik ook gebruik van white-space zodat mijn code goed leesbaar is, niet alleen voor mij zelf maar ook voor anderen die het willen gebruiken. jouw code zit zo op mekaar gedrukt dat het niet makkelijk leest. een paar extra white regels er tussen en wat correcte error-handeling er bij en jij zit ook op 40+ regels.

daarnaast hoe presteert jouw code als je 100KB wilt ROT'en. voor elk teken wordt weer opnieuw uitgerekend wat zijn ROT variant is. daarnaast zou je mijn functie zonder problemen kunnen aanpassen om de ROT-tabel te bewaren en mee te geven als een functie argument. oke voor die paar honderd bytes is jouw versie sneller, maar veel meer bytes moeten er niet bij komen.

ook kan je met jouw code compleet niet decoden. nou is dat voor ROT13 geen probleem maar voor ROT-vul-een-getal-in wel. daar moet dus weer een aparte functie voor worden geschreven.

begrijp me niet verkeerd maar mijn regels code zijn teminste:
- functioneel
- leesbaar
- correct in error-handeling
- en voor grotere stukken tekst veel sneller
- makkelijk aanpasbaar door gedeelde opzet.

als je vindt dat 85 regels te veel is en liever alles op die miezerige 10regels pleurt en je je als programmeur je wilt mag zoeken naar wat er fout ging en waarom, ga je gang maar ik code liever in een keer goed inplaats van het wiel elke paar maand voor elke opdracht weer opnieuw uit te vinden.

die laatste-teken bug zal ik nog wel even naar kijken. heb je de gebruikte rot_table er bij?

*edit, zie het probleem al waarschijnlijk, vervang op regel 69 de < operator voor <=. hij slaat de laatste byte over in de bewerkings loop. kleine maar duidelijke leesbare bug.

[ Voor 3% gewijzigd door Verwijderd op 07-03-2007 12:34 ]

[DataGhost]

Verwijderd schreef op woensdag 07 maart 2007 @ 12:30:Verhaal

Je vergeet nog iets, mijn code kan geen raketten lanceren. Lees nog eens wat er in de topicstart gevraagd werd

dat is mischien leuk voor als je ROT13 wilt doen maar wat als je nou ROT-47 wilt? dat gaat dus mooi niet lukken met jouw versie.

rot($input, -47);
Als jij dat niet snapt, moet je je eens gaan verdiepen in het princiepe van ROT, en wat modulo precies doet.
[quote]je negeert alles buiten het alphabet terwijl ROT-47 dat nou juist vereist.[quote]
Aha... De TS vroeg om het alfabet, dan doe ik dat ook. Waarom 'ROT-47 dat vereist' snap ik niet, sorry.

met jouw versie kom je niet verder dan ASCII 65 tot 90 en 96 tot 122. wat als je nou een ROT wilt doen met de extended ASCII zeg 30 tot 255. juist dan wordt jouw versie ook wel wat groter.

Juist kleiner. De else if kan weg, 30 t/m 255 kan afgehandeld worden in de eerste if. Wat ik wel zie is dat ik vergeten ben

PHP:

else {
$ret .= chr($tmp);
}

te doen. Verder is er geen probleem.

daarnaast checked jouw versie compleet niet wat er in de functie wordt gevoerd en is dus slordig. wat als ik nou rot(array(array(0)), false) in jouw functie voer? krijg ik dan een keurige false waarde en een E_WARNING? nee. goede code wordt herkend door goede error-handeling en als je kijkt zie je dat ik zo'n 26 regels code hier aan besteedt.

PHP:

if (preg_match("/.+/", $input) && is_numeric($n))

Zo beter?

daarnaast maak ik ook gebruik van white-space zodat mijn code goed leesbaar is, niet alleen voor mij zelf maar ook voor anderen die het willen gebruiken. jouw code zit zo op mekaar gedrukt dat het niet makkelijk leest. een paar extra white regels er tussen en wat correcte error-handeling er bij en jij zit ook op 40+ regels.

Met alle bovenstaande toevoegingen betekent dat minstens 1 spatie tussen elke regel. Je gaat mij niet vertellen dat dat opeens leesbaarder is. Voor kleine stukken code als deze is het nauwelijks nodig en als je dat wel vindt, weinig moeite ze ertussen te zetten.

daarnaast hoe presteert jouw code als je 100KB wilt ROT'en. voor elk teken wordt weer opnieuw uitgerekend wat zijn ROT variant is. daarnaast zou je mijn functie zonder problemen kunnen aanpassen om de ROT-tabel te bewaren en mee te geven als een functie argument. oke voor die paar honderd bytes is jouw versie sneller, maar veel meer bytes moeten er niet bij komen.

Ik kan ook zonder problemen van alles aanpassen...

rot25, 10 runs, 100kB lorem ipsum

code:

helios hackthissite # time php rot.php       

real    0m4.040s
user    0m4.010s
sys     0m0.030s
helios hackthissite # time php rot_Docey.php 

real    0m2.244s
user    0m2.210s
sys     0m0.020s

rot25000, 10 runs, 100kB lorem ipsum

code:

helios hackthissite # time php rot.php             

real    0m4.067s
user    0m4.060s
sys     0m0.010s
helios hackthissite # time php rot_Docey.php     

real    0m20.165s
user    0m20.070s
sys     0m0.020s

ook kan je met jouw code compleet niet decoden. nou is dat voor ROT13 geen probleem maar voor ROT-vul-een-getal-in wel. daar moet dus weer een aparte functie voor worden geschreven.

Meen je dit serieus?
rot(rot($string, 9876), -9876);
Dat versleutelt en ontsleutelt weer...

begrijp me niet verkeerd maar mijn regels code zijn teminste:
- functioneel
- leesbaar
- correct in error-handeling
- en voor grotere stukken tekst veel sneller
- makkelijk aanpasbaar door gedeelde opzet.

Voor jou misschien, net als mijn code voor mij leesbaar is. Je hebt totaal niet gedocumenteerd en ik vind het vrij lastig te lezen.

als je vindt dat 85 regels te veel is en liever alles op die miezerige 10regels pleurt en je je als programmeur je wilt mag zoeken naar wat er fout ging en waarom, ga je gang maar ik code liever in een keer goed inplaats van het wiel elke paar maand voor elke opdracht weer opnieuw uit te vinden.

Voor de gestelde specificatie is het ruim voldoende. Als je er van alles bij gaat verzinnen kan ik ook een verkooppraatje houden dat het beter is.

[Verwijderd]

Wat een geklaag naar elkaar. Als de functie echt zo modulair moet zijn pak dan mijn rotor-functie (Zie ergens boven in Pseudocode) hooguit 6 regels code met het validaten van parameters ($min<$max,(int)$value). Dan hoeft het niet nodig te zijn te roteren van array-items omdat als je de array-grootte ($max) voorbij gaat de functie hem zelf roteert.

Als je alles op 85 regels moet plaatsen voor deze functionaliteit dan moet er nog wat uitgekristalliseerd worden

[chris]

Die van mij is ook generiek, werkt zelfs op alle lijsten inplaats van alleen Strings, en is maar 9 regels. Zonder onleesbaar te zijn (als je Haskell kan). 85 regels vind ik ook wel erg veel.

[Grijze Vos]

chris schreef op donderdag 08 maart 2007 @ 00:11:
Die van mij is ook generiek, werkt zelfs op alle lijsten inplaats van alleen Strings, en is maar 9 regels. Zonder onleesbaar te zijn (als je Haskell kan). 85 regels vind ik ook wel erg veel.

Ik vraag me het nut af van je bijdrage, aangezien er [PHP] in de topictitel staat...

[Verwijderd]

chris schreef op donderdag 08 maart 2007 @ 00:11:
Die van mij is ook generiek, werkt zelfs op alle lijsten inplaats van alleen Strings, en is maar 9 regels. Zonder onleesbaar te zijn (als je Haskell kan). 85 regels vind ik ook wel erg veel.

ik heb geen ervaring met Haskell en weet dus ook niet of Haskell loose-typed is etc.

@Dataghost:
Ik ben mischien wat voorbij geschoten aan dat wat de Topic-Starter er mee wil en nee, mijn script kan ook geen raketten lanceren, daarom toch nog even een toelichting en een revisie.

PHP:

if (preg_match("/.+/", $input) && is_numeric($n))

dit is natuurlijk geen argumenten checken, laat staan error-handeling. ik heb mischien geen ver gaande ervaring met het werken met modulo maar jij hebt blijkbaar ook geen kaas gegeten van integers en het memory-managment van php. enzo blijkt dat we allebei nog wel wat te lezen hebben, ik over hoe modulo met floats omgaat en jij over interger-conversie.

Juist kleiner. De else if kan weg, 30 t/m 255 kan afgehandeld worden in de eerste if. Wat ik wel zie is dat ik vergeten ben

geeft niet hoor, fouten maken is menselijk. klopt het dat dit dus jouw code is met de correctie? (in mijn code style dan wel welliswaar).

PHP:

    function rot($input, $n) 
    {
     $n %= 26;
     if($n < 0){
      $n += 26;
     }
        
        $time = microtime_float();
        $ret  = "";
        for($i=0; $i<strlen($input); $i++){
         $tmp = ord($input[$i]);
            if($tmp >= 65 && $tmp <= 90){
             $ret .= chr(65 + ((($tmp - 65) + $n) % 26));
            }elseif($tmp >= 97 && $tmp <= 122){
             $ret .= chr(97 + ((($tmp - 97) + $n) % 26));
            }else{
             $ret .= chr($tmp);
            }
        }
        
        print("\r\n >Run-Time: ".(microtime_float() - $time).".");
     return $ret;
    }

ik heb op lijn 8 en 21 een kleine stopwatch in gebouwd. deze mogen dus zonder problemen worden verwijdert. ik gebruikte ze alleen om te kijken welke van onze 2 versie's sneller is.

de gebruikte microtime_float functie:

PHP:

    function microtime_float()
    {
        list($usec, $sec) = explode(" ", microtime());
     return ((float)$usec + (float)$sec);
    }

Met alle bovenstaande toevoegingen betekent dat minstens 1 spatie tussen elke regel. Je gaat mij niet vertellen dat dat opeens leesbaarder is. Voor kleine stukken code als deze is het nauwelijks nodig en als je dat wel vindt, weinig moeite ze ertussen te zetten.

oke, code-stijl is mischien een persoonlijk punt. als jij jouw code lekker vindt lezen, wie ben ik dan om dat jouw te verbieden. maar voor anderen is blanco-regel hier en daar wel een stuk beter te lezen.

daarnaast hoe presteert jouw code als je 100KB wilt ROT'en. voor elk teken wordt weer opnieuw uitgerekend wat zijn ROT variant is. daarnaast zou je mijn functie zonder problemen kunnen aanpassen om de ROT-tabel te bewaren en mee te geven als een functie argument. oke voor die paar honderd bytes is jouw versie sneller, maar veel meer bytes moeten er niet bij komen.

als je mijn stukje nog eens goed doorleest had ik het niet over of je 1 byte ROT4 vs 1byte ROT2500 maar over of je 1byte ROT4'd of dat je 102400bytes ROT4'd. en daar zit wel degelijk een verschill in. als je even een paar microtime's in mijn code had gezet dan zie dat 80% van de tijd bezig is met het opstellen van de rotatie-tabel en ja ik geeft toe, dat was inderdaad niet zo handig, zeker als je bedenkt dat de TS waarschijnlijk geen ROT2500 gaat doen.

daarom hier een aangepaste versie die gewoon een rot-table slikt:

PHP:

    function rot_n($input, $rot_count=4, $rot_table=false, $forward=true)
    {
     if((!is_string($input)) OR (strlen($input) <= 0)){
       trigger_error("String to ROT is not an valid string.", E_USER_WARNING);
      return false;
     }
     if((!is_int($rot_count)) OR ($rot_count <= 0)){
       trigger_error("Times to ROT is not an valid positive integer value.", E_USER_WARNING);
      return false;
     }
     if(!is_bool($forward)){
       trigger_error("Direction to ROT is not an boolean value.", E_USER_WARNING);
      return false;
     }
     if((!is_array($rot_table)) OR (count($rot_table) <= 0)){
       trigger_error("Rotation Table is not in valid array format.", E_USER_WARNING);
      return false;
     }
        
        if($forward !== true){
         $rot_table = array_flip($rot_table);
        }
        
        $run_time   = microtime_float();
        $input_len  = strlen($input);
        $input_pos  = 0;
            while($input_pos < $input_len){
                if(isset($rot_table[$input{$input_pos}])){
                 $input{$input_pos} = $rot_table[$input{$input_pos}];
                }
                
             $input_pos++;
            }
        
        print("\r\n >Run-Time: ".(microtime_float() - $run_time).".");
     return $input;
    }

en de gebruikte test code:

PHP:

    $rot_input = file_get_contents("Lorem_Ipsum_100kb.txt");
    $rot_table = array('A' => 'N', 'B' => 'O', 'C' => 'P', 'D' => 'Q',
                'E' => 'R', 'F' => 'S', 'G' => 'T', 'H' => 'U', 'I' => 'V',
                'J' => 'W', 'K' => 'X', 'L' => 'Y', 'M' => 'Z', 'N' => 'A',
                'O' => 'B', 'P' => 'C', 'Q' => 'D', 'R' => 'E', 'S' => 'F',
                'T' => 'G', 'U' => 'H', 'V' => 'I', 'W' => 'J', 'X' => 'K',
                'Y' => 'L', 'Z' => 'M', 'a' => 'n', 'b' => 'o', 'c' => 'p',
                'd' => 'q', 'e' => 'r', 'f' => 's', 'g' => 't', 'h' => 'u',
                'i' => 'v', 'j' => 'w', 'k' => 'x', 'l' => 'y', 'm' => 'z',
                'n' => 'a', 'o' => 'b', 'p' => 'c', 'q' => 'd', 'r' => 'e',
                's' => 'f', 't' => 'g', 'u' => 'h', 'v' => 'i', 'w' => 'j',
                'x' => 'k', 'y' => 'l', 'z' => 'm');
    
    $dataghost = rot(rot($rot_input, 4), -4);
    $docey      = rot_n(rot_n($rot_input, 4, $rot_table, true), 4, $rot_table, false);

    print("\r\n >SIZE : ".strlen($rot_input)." bytes. ".md5($rot_input).".");
    print("\r\n >ROT_4: ".md5($dataghost)."");
    print("\r\n >ROT_N: ".md5($docey)."");

zoals je ziet maak ik nu gebruik van een statische rotatie table voor ROT4. omdat het Lorem_Ipsum verhaal wat te groot is om op fouten te controlleren maak ik eer een md5-hash van. hier het resultaat:

code:

 >Run-Time: 0.391242027283.
 >Run-Time: 0.393701076508.
 >Run-Time: 0.203727006912.
 >Run-Time: 0.204609870911.
 >SIZE : 72134 bytes. ef3e37118d2cf7a777e84fc9f352e8d7.
 >ROT_4: ef3e37118d2cf7a777e84fc9f352e8d7
 >ROT_N: ef3e37118d2cf7a777e84fc9f352e8d7

zoals je ziet is mijn aanpak wellicht 20 regels meer code, maar zeker op de wat grotere teksten bijna een factor 2 sneller omdat het gewoon een copy&paste methode is met een vooraf ge-creerde rotatie tabel. een opvallend puntje is dat jouw versie iets over het algemeen iets langzamer is met encoden dan met decoden terwijl mijn versie precies het tegenovergestelde heeft, waarschijnlijk door de array_flip die ik gebruikt heb.

kortom de TS heeft nu meerder versie's om tussen te kiezen en zal zelf die afweging moeten maken.

[sjhgvr]

Iemand intresse om mijn nieuwe rot4 functies te benchen? Ik denk dat dit een van de snellere zal zijn. (Ga dan niet met kleine inputs werken maar gebruik wat Lorum Ipsum.)

Offtopic: ik doe maar wat, doe ik iets verkeerd, laat t me weten, daar leer ik van

De code:

PHP:

function rot_4_encode($in) {

    $dic = array('a' => 'e', 'b' => 'f', 'c' => 'g', 'd' => 'h', 'e' => 'i', 'f' => 'j', 'g' => 'k',
    'h' => 'l', 'i' => 'm', 'j' => 'n', 'k' => 'o', 'l' => 'p', 'm' => 'q', 'n' => 'r', 'o' => 's', 
    'p' => 't', 'q' => 'u', 'r' => 'v', 's' => 'w', 't' => 'x', 'u' => 'y', 'v' => 'z', 'w' => 'a', 
    'x' => 'b', 'y' => 'c', 'z' => 'd', 'A' => 'E', 'B' => 'F', 'C' => 'G', 'D' => 'H', 'E' => 'I', 
    'F' => 'J', 'G' => 'K', 'H' => 'L', 'I' => 'M', 'J' => 'N', 'K' => 'O', 'L' => 'P', 'M' => 'Q', 
    'N' => 'R', 'O' => 'S', 'P' => 'T', 'Q' => 'U', 'R' => 'V', 'S' => 'W', 'T' => 'X', 'U' => 'Y', 
    'V' => 'Z', 'W' => 'A', 'X' => 'B', 'Y' => 'C', 'Z' => 'D');
    
    $out = '';
    
    for ($i = 0; $i < strlen($in); $i++)
        $out .= isset($dic[$in{$i}]) ? $dic[$in{$i}] : $in{$i};
    
    return $out;
    
}

function rot_4_decode($in) {

    $dic = array('e' => 'a', 'f' => 'b', 'g' => 'c', 'h' => 'd', 'i' => 'e', 'j' => 'f', 'k' => 'g',
    'l' => 'h', 'm' => 'j', 'n' => 'j', 'o' => 'k', 'p' => 'l', 'q' => 'm', 'r' => 'n', 's' => 'o', 
    't' => 'p', 'u' => 'q', 'v' => 'r', 'w' => 's', 'x' => 't', 'y' => 'u', 'z' => 'v', 'a' => 'w', 
    'b' => 'x', 'c' => 'y', 'd' => 'z', 'E' => 'A', 'F' => 'B', 'G' => 'C', 'H' => 'D', 'I' => 'E', 
    'J' => 'F', 'K' => 'G', 'L' => 'H', 'M' => 'I', 'N' => 'J', 'O' => 'K', 'P' => 'L', 'Q' => 'M', 
    'R' => 'N', 'S' => 'O', 'T' => 'P', 'U' => 'Q', 'V' => 'R', 'W' => 'S', 'X' => 'T', 'Y' => 'U', 
    'Z' => 'V', 'A' => 'W', 'B' => 'X', 'C' => 'Y', 'D' => 'Z');
    
    $out = '';
    
    for ($i = 0; $i < strlen($in); $i++)
        $out .= isset($dic[$in{$i}]) ? $dic[$in{$i}] : $in{$i};
    
    return $out;
    
}

[chris]

Grijze Vos schreef op donderdag 08 maart 2007 @ 09:01:
[...]

Ik vraag me het nut af van je bijdrage, aangezien er [PHP] in de topictitel staat...

Dat is waar . Goed punt. Ik krijg altijd de neiging om te replyen met "in Haskell kan het korter", maar heb een hekel aan mensen die alleen maar roepen zonder code te laten zien. Ik vond het ook wel een leuk probleem, dus toch maar even opgelost, en toen ook maar gepost. Ik dacht dat het prima als inspiratie bruikbaar is voor de php-versie, het is alleen even een andere denkwijze.