TOP 10: Porovnání verzí

Z Wiki UnArt Slavičín
Skočit na navigaciSkočit na vyhledávání
Bez shrnutí editace
Bez shrnutí editace
 
(Není zobrazeno 36 mezilehlých verzí od stejného uživatele.)
Řádek 1: Řádek 1:
__TOC__
==Verze 1==
Tato verze přeřadí 10 uživatelů s největším počtem stažených dat z parentu wifi do parentu stahovaci.
#Autor: Michal Kliment
#Datum: prosinec 2008
#Popis: Tento skript preradi 10 uzivatelu s nejvetsim poctem stazenych dat z parentu wifi do parentu stahovaci
:global x 0
#v promenne myParent je nazev parentu, s kterym budeme pracovat
:global myParent "wifi"
#v promenne badParent je nazev parentu, kam budeme prerazovat stahovace
:global badParent "stahovaci"
:global userBytes 0/0
:global users 0,0
:global userDownload 0
:global maxDownload 0,0
#v promenne top je ulozeny pocet uzivatelu, ktere budeme prerazovat
:global top 10
:global hArray1
:global hArray2
:global downloadI
:global downloadJ
:global userI
:global userJ
:global hInt
/queue simple
#vsechny uzivatele zaradime ze "spatneho" parentu do defaultniho
:foreach i in=[find parent=$badParent] do={
set $i parent=$myParent;
}
#najdeme si vsechny uzivatele
:foreach i in=[find] do={
#zjistime zda-li jsou z nami hledaneho parentu
:if ([get $i parent]=$myParent) do={
#do userBytes ulozime celkovy pocet bytu uzivatele (upload/download)
:set userBytes [get $i bytes];
#a v ni najdeme pozici /
:local slashPosition [:find $userBytes /];
#do userDownload ulozime cast za /
:set userDownload [:pick $userBytes ($slashPosition+1) [:len $userBytes]];
#do pole users pridame hodnotu id uzivatele
:set users ($users + $x)
#do pole maxDownload pridame hodnotu downloadu uzivatele
:set maxDownload ($maxDownload + $userDownload)
#do pomocnych poli hArray1 a hArray2 ulozime hodnoty poli maxDownload a users
:set hArray1 $maxDownload
:set hArray2 $users
#tady zacina samotne razeni pole, bubble sort, dva cykly for
:for i from 0 to=([:len $maxDownload]-2) do={
:for j from ($i+1) to=([:len $maxDownload]-1) do={
#pole hArray1 a hArray2 vynulujeme
:set hArray1 0;
:set hArray2 0;
#do downloadI ulozime hodnotu z pole maxDownload na pozici i
:set downloadI [:pick $maxDownload $i ($i+1)];
#do downloadJ ulozime hodnotu z pole maxDownload na pozici j
:set downloadJ [:pick $maxDownload $j ($j+1)];
#do userI ulozime hodnotu z pole users na pozici i
:set userI [:pick $users $i ($i+1)];
#do userJ ulozime hodnotu z pole maxDownload na pozici j
:set userJ [:pick $users $j ($j+1)];
#pokud je downloadI<downloadJ
:if ($downloadI<$downloadJ) do={
#prehodime hodnoty downloadI,downloadJ
:set hInt $downloadI;
:set downloadI $downloadJ;
:set downloadJ $hInt;
#a hodnoty userI,userJ
:set hInt $userI;
:set userI $userJ;
:set userJ $hInt;
}
#na nasledujicich nekolika radcich pak dochazi k samotnemu prehozeni hodnot v poli
#je zde nekolik osetreni, nektere jsou zjisteny zkousenim
:set hArray1 ([:pick $maxDownload 0 $i] + $downloadI);
:set hArray2 ([:pick $users 0 $i] + $userI);
:if (($i+1)<$j) do={
:set hArray1 ($hArray1 + [:pick $maxDownload ($i+1) $j]);
:set hArray2 ($hArray2 + [:pick $users ($i+1) $j]);
}
:set hArray1 ($hArray1 + $downloadJ);
:set hArray2 ($hArray2 + $userJ);
:if (($j+1)<[:len $maxDownload]) do={
:set hArray1 ($hArray1 + [:pick $maxDownload ($j+1) ([:len $maxDownload])])
:set hArray2 ($hArray2 + [:pick $users ($j+1) ([:len $users])])
}
:set maxDownload $hArray1
:set users $hArray2
}
}
#pole maxDownload a users orezeme na velikost danou v promenne top
:set maxDownload [:pick $maxDownload 0 $top]
:set users [:pick $users 0 $top]
}
#inkrementace promenne x (ukazuje index aktualniho uzivatele)
:set x ($x+1);
}
#cyklus, ktery projde vsechny uzivatele z pole users
:for i from 0 to=([:len $users]-1) do={
#a preradi je vsechny do "spatneho" parentu
set [:pick $users $i ($i+1)] parent=$badParent;
}
==Verze 2==
Toto verze funguje takřka stejně jako verze 1, porovnává navíc i počet uploadovaných dat (nefunguje však správně).
  :global x 0
  :global x 0
  :global myParent "wifi"
  :global myParent "wifi"
:global badParent "stahovaci"
  :global userBytes 0/0
  :global userBytes 0/0
  :global users 0,0
  :global users 0,0
  :global userDownload 0
  :global userDownload 0
:global userUpload 0
  :global maxDownload 0,0
  :global maxDownload 0,0
  :global top 5
:global maxUpload 0,0
  :global top 10
  :global hArray1
  :global hArray1
  :global hArray2
  :global hArray2
:global hArray3
  :global a
  :global a
  :global b
  :global b
  :global c
  :global c
  :global d
  :global d
:global e
:global f
  :global hInt
  :global hInt
   
   
  /queue simple
  /queue simple
:foreach i in=[find parent=$badParent] do={
  set $i parent=$myParent;
}
   
   
  :foreach i in=[find] do={
  :foreach i in=[find] do={
Řádek 23: Řádek 145:
     :local slashPosition [:find $userBytes /];
     :local slashPosition [:find $userBytes /];
     :set userDownload [:pick $userBytes ($slashPosition+1) [:len $userBytes]];
     :set userDownload [:pick $userBytes ($slashPosition+1) [:len $userBytes]];
    :set userUpload [:pick $userBytes 0 $slashPosition];
     :set users ($users + $x)
     :set users ($users + $x)
     :set maxDownload ($maxDownload + $userDownload)
     :set maxDownload ($maxDownload + $userDownload)
    :set maxUpload ($maxUpload + $userUpload)
     :set hArray1 $maxDownload
     :set hArray1 $maxDownload
     :set hArray2 $users
     :set hArray2 $maxUpload
    :set hArray3 $users
     :for i from 0 to=([:len $maxDownload]-2) do={
     :for i from 0 to=([:len $maxDownload]-2) do={
       :for j from ($i+1) to=([:len $maxDownload]-1) do={
       :for j from ($i+1) to=([:len $maxDownload]-1) do={
         :set hArray1 0;
         :set hArray1 0;
         :set hArray2 0;
         :set hArray2 0;
        :set hArray3 0;
         :set a [:pick $maxDownload $i ($i+1)];
         :set a [:pick $maxDownload $i ($i+1)];
         :set b [:pick $maxDownload $j ($j+1)];
         :set b [:pick $maxDownload $j ($j+1)];
         :set c [:pick $users $i ($i+1)];
         :set c [:pick $maxUpload $i ($i+1)];
         :set d [:pick $users $j ($j+1)];
        :set d [:pick $maxUpload $j ($j+1)];
         :if ($a<$b) do={
        :set e [:pick $users $i ($i+1)];
         :set f [:pick $users $j ($j+1)];
         :if ($a<$b or $c<$d) do={
           :set hInt $a;
           :set hInt $a;
           :set a $b;
           :set a $b;
Řádek 42: Řádek 175:
           :set c $d;
           :set c $d;
           :set d $hInt;
           :set d $hInt;
          :set hInt $e;
          :set e $f;
          :set f $hInt;
         }
         }
         :set hArray1 ([:pick $maxDownload 0 $i] + $a);
         :set hArray1 ([:pick $maxDownload 0 $i] + $a);
         :set hArray2 ([:pick $users 0 $i] + $c);
         :set hArray2 ([:pick $maxUpload 0 $i] + $c);
        :set hArray3 ([:pick $users 0 $i] + $e);
         :if (($i+1)<$j) do={
         :if (($i+1)<$j) do={
           :set hArray1 ($hArray1 + [:pick $maxDownload ($i+1) $j]);
           :set hArray1 ($hArray1 + [:pick $maxDownload ($i+1) $j]);
           :set hArray2 ($hArray2 + [:pick $users ($i+1) $j]);
           :set hArray2 ($hArray2 + [:pick $maxUpload ($i+1) $j]);
          :set hArray3 ($hArray3 + [:pick $users ($i+1) $j]);
         }
         }
         :set hArray1 ($hArray1 + $b);
         :set hArray1 ($hArray1 + $b);
         :set hArray2 ($hArray2 + $d);
         :set hArray2 ($hArray2 + $d);
        :set hArray3 ($hArray3 + $f);
         :if (($j+1)<[:len $maxDownload]) do={
         :if (($j+1)<[:len $maxDownload]) do={
           :set hArray1 ($hArray1 + [:pick $maxDownload ($j+1) ([:len $maxDownload])])
           :set hArray1 ($hArray1 + [:pick $maxDownload ($j+1) ([:len $maxDownload])])
           :set hArray2 ($hArray2 + [:pick $users ($j+1) ([:len $users])])
           :set hArray2 ($hArray2 + [:pick $maxUpload ($j+1) ([:len $maxUpload])])
          :set hArray3 ($hArray3 + [:pick $users ($j+1) ([:len $users])])
         }
         }
         :set maxDownload $hArray1
         :set maxDownload $hArray1
         :set users $hArray2
        :set maxUpload $hArray2
         :set users $hArray3
       }
       }
     }
     }
     :set maxDownload [:pick $maxDownload 0 $top]
     :set maxDownload [:pick $maxDownload 0 $top]
    :set maxUpload [:pick $maxUpload 0 $top]
     :set users [:pick $users 0 $top]
     :set users [:pick $users 0 $top]
   }
   }
   :set x ($x+1);
   :set x ($x+1);
}
:for i from 0 to=([:len $users]-1) do={
  set [:pick $users $i ($i+1)] parent=$badParent;
}
==Verze 3 - řazení podle mediánu==
Všechny uživatele, kteří stáhnou 2x více než uživatel s mediánem, přeřadí z parentu wifi do parentu stahovaci. Problém je, že seřazení uživatelů v poli podle stažených dat pak trvá výrazně déle (na Vláře s cca 50 uživateli kolem minuty), chtělo by to najít nějakou lepší metodu než bubble sort...
:global x 0
:global myParent "wifi"
:global badParent "stahovaci"
:global userBytes 0/0
:global users 0,0
:global userDownload 0
:global maxDownload 0,0
:global top 10
:global N 2
:global hArray1
:global hArray2
:global a
:global b
:global c
:global d
:global hInt
:global all
:global countAll
:global median
:global i
/queue simple
#do all si načteme všechny uživatele z našeho parentu
:set all [find parent=$myParent]
#do countAll si uložíme jejich počet
:set countAll [:len $all]
#nakonec do top uložíme polovinu tohoto počtu
:set top ($countAll / 2)
:foreach i in=[find parent=$badParent] do={
set $i parent=$myParent;
}
:foreach i in=[find] do={
:if ([get $i parent]=$myParent) do={
:set userBytes [get $i bytes];
:local slashPosition [:find $userBytes /];
:set userDownload [:pick $userBytes ($slashPosition+1) [:len $userBytes]];
:set users ($users + $x)
:set maxDownload ($maxDownload + $userDownload)
:set hArray1 $maxDownload
:set hArray2 $users
:for i from 0 to=([:len $maxDownload]-2) do={
:for j from ($i+1) to=([:len $maxDownload]-1) do={
:set hArray1 0;
:set hArray2 0;
:set a [:pick $maxDownload $i ($i+1)];
:set b [:pick $maxDownload $j ($j+1)];
:set c [:pick $users $i ($i+1)];
:set d [:pick $users $j ($j+1)];
:if ($a<$b) do={
:set hInt $a;
:set a $b;
:set b $hInt;
:set hInt $c;
:set c $d;
:set d $hInt;
}
:set hArray1 ([:pick $maxDownload 0 $i] + $a);
:set hArray2 ([:pick $users 0 $i] + $c);
:if (($i+1)<$j) do={
:set hArray1 ($hArray1 + [:pick $maxDownload ($i+1) $j]);
:set hArray2 ($hArray2 + [:pick $users ($i+1) $j]);
}
:set hArray1 ($hArray1 + $b);
:set hArray2 ($hArray2 + $d);
:if (($j+1)<[:len $maxDownload]) do={
:set hArray1 ($hArray1 + [:pick $maxDownload ($j+1) ([:len $maxDownload])])
:set hArray2 ($hArray2 + [:pick $users ($j+1) ([:len $users])])
}
:set maxDownload $hArray1
:set users $hArray2
}
}
:set maxDownload [:pick $maxDownload 0 $top]
:set users [:pick $users 0 $top]
}
:set x ($x+1);
}
:set median [:pick $maxDownload ([:len $maxDownload]-1) [:len $maxDownload]]
:set i 0;
:while ([:pick $maxDownload $i ($i+1)]>$N*$median) do={
set [:pick $users $i ($i+1)] parent=$badParent;
:set i ($i+1);
  }
  }

Aktuální verze z 5. 1. 2009, 00:57

Verze 1

Tato verze přeřadí 10 uživatelů s největším počtem stažených dat z parentu wifi do parentu stahovaci.

#Autor: Michal Kliment
#Datum: prosinec 2008
#Popis: Tento skript preradi 10 uzivatelu s nejvetsim poctem stazenych dat z parentu wifi do parentu stahovaci

:global x 0
#v promenne myParent je nazev parentu, s kterym budeme pracovat
:global myParent "wifi"
#v promenne badParent je nazev parentu, kam budeme prerazovat stahovace
:global badParent "stahovaci"
:global userBytes 0/0
:global users 0,0
:global userDownload 0
:global maxDownload 0,0
#v promenne top je ulozeny pocet uzivatelu, ktere budeme prerazovat
:global top 10
:global hArray1
:global hArray2
:global downloadI
:global downloadJ
:global userI
:global userJ
:global hInt
/queue simple
#vsechny uzivatele zaradime ze "spatneho" parentu do defaultniho
:foreach i in=[find parent=$badParent] do={
set $i parent=$myParent;
}
#najdeme si vsechny uzivatele
:foreach i in=[find] do={
#zjistime zda-li jsou z nami hledaneho parentu
:if ([get $i parent]=$myParent) do={ 
#do userBytes ulozime celkovy pocet bytu uzivatele (upload/download)
:set userBytes [get $i bytes];
#a v ni najdeme pozici /
:local slashPosition [:find $userBytes /];
#do userDownload ulozime cast za /
:set userDownload [:pick $userBytes ($slashPosition+1) [:len $userBytes]];
#do pole users pridame hodnotu id uzivatele
:set users ($users + $x)
#do pole maxDownload pridame hodnotu downloadu uzivatele
:set maxDownload ($maxDownload + $userDownload)
#do pomocnych poli hArray1 a hArray2 ulozime hodnoty poli maxDownload a users
:set hArray1 $maxDownload
:set hArray2 $users
#tady zacina samotne razeni pole, bubble sort, dva cykly for
:for i from 0 to=([:len $maxDownload]-2) do={ 
:for j from ($i+1) to=([:len $maxDownload]-1) do={
#pole hArray1 a hArray2 vynulujeme
:set hArray1 0;
:set hArray2 0;
#do downloadI ulozime hodnotu z pole maxDownload na pozici i
:set downloadI [:pick $maxDownload $i ($i+1)];
#do downloadJ ulozime hodnotu z pole maxDownload na pozici j
:set downloadJ [:pick $maxDownload $j ($j+1)];
#do userI ulozime hodnotu z pole users na pozici i
:set userI [:pick $users $i ($i+1)];
#do userJ ulozime hodnotu z pole maxDownload na pozici j
:set userJ [:pick $users $j ($j+1)];
#pokud je downloadI<downloadJ
:if ($downloadI<$downloadJ) do={
#prehodime hodnoty downloadI,downloadJ
:set hInt $downloadI;
:set downloadI $downloadJ;
:set downloadJ $hInt;
#a hodnoty userI,userJ
:set hInt $userI;
:set userI $userJ;
:set userJ $hInt;
}
#na nasledujicich nekolika radcich pak dochazi k samotnemu prehozeni hodnot v poli
#je zde nekolik osetreni, nektere jsou zjisteny zkousenim
:set hArray1 ([:pick $maxDownload 0 $i] + $downloadI);
:set hArray2 ([:pick $users 0 $i] + $userI);
:if (($i+1)<$j) do={
:set hArray1 ($hArray1 + [:pick $maxDownload ($i+1) $j]);
:set hArray2 ($hArray2 + [:pick $users ($i+1) $j]); 
} 
:set hArray1 ($hArray1 + $downloadJ);
:set hArray2 ($hArray2 + $userJ); 
:if (($j+1)<[:len $maxDownload]) do={ 
:set hArray1 ($hArray1 + [:pick $maxDownload ($j+1) ([:len $maxDownload])])
:set hArray2 ($hArray2 + [:pick $users ($j+1) ([:len $users])]) 
}
:set maxDownload $hArray1
:set users $hArray2 
}
}
#pole maxDownload a users orezeme na velikost danou v promenne top
:set maxDownload [:pick $maxDownload 0 $top]
:set users [:pick $users 0 $top]
}
#inkrementace promenne x (ukazuje index aktualniho uzivatele)
:set x ($x+1);
}
#cyklus, ktery projde vsechny uzivatele z pole users
:for i from 0 to=([:len $users]-1) do={
#a preradi je vsechny do "spatneho" parentu
set [:pick $users $i ($i+1)] parent=$badParent;
}

Verze 2

Toto verze funguje takřka stejně jako verze 1, porovnává navíc i počet uploadovaných dat (nefunguje však správně).

:global x 0
:global myParent "wifi"
:global badParent "stahovaci"
:global userBytes 0/0
:global users 0,0
:global userDownload 0
:global userUpload 0
:global maxDownload 0,0
:global maxUpload 0,0
:global top 10
:global hArray1
:global hArray2
:global hArray3
:global a
:global b
:global c
:global d
:global e
:global f
:global hInt

/queue simple

:foreach i in=[find parent=$badParent] do={

  set $i parent=$myParent;

}

:foreach i in=[find] do={

  :if ([get $i parent]=$myParent) do={

    :set userBytes [get $i bytes];
    :local slashPosition [:find $userBytes /];
    :set userDownload [:pick $userBytes ($slashPosition+1) [:len $userBytes]];
    :set userUpload [:pick $userBytes 0 $slashPosition];
    :set users ($users + $x)
    :set maxDownload ($maxDownload + $userDownload)
    :set maxUpload ($maxUpload + $userUpload)
    :set hArray1 $maxDownload
    :set hArray2 $maxUpload
    :set hArray3 $users

    :for i from 0 to=([:len $maxDownload]-2) do={

      :for j from ($i+1) to=([:len $maxDownload]-1) do={

        :set hArray1 0;
        :set hArray2 0;
        :set hArray3 0;
        :set a [:pick $maxDownload $i ($i+1)];
        :set b [:pick $maxDownload $j ($j+1)];
        :set c [:pick $maxUpload $i ($i+1)];
        :set d [:pick $maxUpload $j ($j+1)];
        :set e [:pick $users $i ($i+1)];
        :set f [:pick $users $j ($j+1)];

        :if ($a<$b or $c<$d) do={

          :set hInt $a;
          :set a $b;
          :set b $hInt;
          :set hInt $c;
          :set c $d;
          :set d $hInt;
          :set hInt $e;
          :set e $f;
          :set f $hInt;

        }

        :set hArray1 ([:pick $maxDownload 0 $i] + $a);
        :set hArray2 ([:pick $maxUpload 0 $i] + $c);
        :set hArray3 ([:pick $users 0 $i] + $e);

        :if (($i+1)<$j) do={

          :set hArray1 ($hArray1 + [:pick $maxDownload ($i+1) $j]);
          :set hArray2 ($hArray2 + [:pick $maxUpload ($i+1) $j]);
          :set hArray3 ($hArray3 + [:pick $users ($i+1) $j]);

        }

        :set hArray1 ($hArray1 + $b);
        :set hArray2 ($hArray2 + $d);
        :set hArray3 ($hArray3 + $f);

        :if (($j+1)<[:len $maxDownload]) do={

          :set hArray1 ($hArray1 + [:pick $maxDownload ($j+1) ([:len $maxDownload])])
          :set hArray2 ($hArray2 + [:pick $maxUpload ($j+1) ([:len $maxUpload])])
          :set hArray3 ($hArray3 + [:pick $users ($j+1) ([:len $users])])

        }

        :set maxDownload $hArray1
        :set maxUpload $hArray2
        :set users $hArray3

      }

    }

    :set maxDownload [:pick $maxDownload 0 $top]
    :set maxUpload [:pick $maxUpload 0 $top]
    :set users [:pick $users 0 $top]

  }

  :set x ($x+1);

}

:for i from 0 to=([:len $users]-1) do={

  set [:pick $users $i ($i+1)] parent=$badParent;

}

Verze 3 - řazení podle mediánu

Všechny uživatele, kteří stáhnou 2x více než uživatel s mediánem, přeřadí z parentu wifi do parentu stahovaci. Problém je, že seřazení uživatelů v poli podle stažených dat pak trvá výrazně déle (na Vláře s cca 50 uživateli kolem minuty), chtělo by to najít nějakou lepší metodu než bubble sort...

:global x 0
:global myParent "wifi"
:global badParent "stahovaci"
:global userBytes 0/0
:global users 0,0
:global userDownload 0
:global maxDownload 0,0
:global top 10
:global N 2
:global hArray1
:global hArray2
:global a
:global b
:global c
:global d
:global hInt
:global all
:global countAll
:global median
:global i
/queue simple
#do all si načteme všechny uživatele z našeho parentu
:set all [find parent=$myParent]
#do countAll si uložíme jejich počet
:set countAll [:len $all]
#nakonec do top uložíme polovinu tohoto počtu
:set top ($countAll / 2)
:foreach i in=[find parent=$badParent] do={
set $i parent=$myParent;
}
:foreach i in=[find] do={
:if ([get $i parent]=$myParent) do={ 
:set userBytes [get $i bytes];
:local slashPosition [:find $userBytes /];
:set userDownload [:pick $userBytes ($slashPosition+1) [:len $userBytes]];
:set users ($users + $x)
:set maxDownload ($maxDownload + $userDownload)
:set hArray1 $maxDownload
:set hArray2 $users 
:for i from 0 to=([:len $maxDownload]-2) do={ 
:for j from ($i+1) to=([:len $maxDownload]-1) do={ 
:set hArray1 0;
:set hArray2 0;
:set a [:pick $maxDownload $i ($i+1)];
:set b [:pick $maxDownload $j ($j+1)];
:set c [:pick $users $i ($i+1)];
:set d [:pick $users $j ($j+1)];
:if ($a<$b) do={
:set hInt $a;
:set a $b;
:set b $hInt;
:set hInt $c;
:set c $d;
:set d $hInt;
}
:set hArray1 ([:pick $maxDownload 0 $i] + $a);
:set hArray2 ([:pick $users 0 $i] + $c);
:if (($i+1)<$j) do={
:set hArray1 ($hArray1 + [:pick $maxDownload ($i+1) $j]);
:set hArray2 ($hArray2 + [:pick $users ($i+1) $j]); 
} 
:set hArray1 ($hArray1 + $b);
:set hArray2 ($hArray2 + $d); 
:if (($j+1)<[:len $maxDownload]) do={ 
:set hArray1 ($hArray1 + [:pick $maxDownload ($j+1) ([:len $maxDownload])])
:set hArray2 ($hArray2 + [:pick $users ($j+1) ([:len $users])]) 
} 
:set maxDownload $hArray1
:set users $hArray2 
}
}
:set maxDownload [:pick $maxDownload 0 $top]
:set users [:pick $users 0 $top]
}
:set x ($x+1);
}
:set median [:pick $maxDownload ([:len $maxDownload]-1) [:len $maxDownload]]
:set i 0;
:while ([:pick $maxDownload $i ($i+1)]>$N*$median) do={
set [:pick $users $i ($i+1)] parent=$badParent;
:set i ($i+1);
}