Все...сделал. Знаю что быдлокод явно выраженный, но идеи уже закончились...Читал рассказ про программиста: "приходишь домой и еще весь вечер недоумеваешь, как твой код может работать" У меня сейчас примерно тоже самое)

<script>
var let = []
for(i=0;i<33;i++) {
var r = Math.random() * 33 | 0
let[i] = r
}
alert(let)
var i = 100;
while(i>0) {
  for(k=0;k<=let.length;k++) { 
 
    for(j=0;j<let.length;j++) {
 
      if(k!=j) {
      if(let[k]==let[j]) {
 
        let[k] = Math.random() * 33 | 0
        for(a=0;a<j;a++) {
          if(let[a]==let[j]) {
            let[a] = Math.random() * 33 | 0
    	    }
          }
        } 
      }
    }
  }
--i
}
alert(let)
function ch() {
var c = 0
  for(aa=0;aa<=let.length;aa++) {
    for(b=0;b<let.length;b++) {
      if(aa!=b) {
        if(let[aa] == let[b]) {
          c+=1
        } else { 
          c+=0 
        }
   }
     }
}
alert(c)
}
ch()
</script>

P.S. если последний алерт возвращает 0, значит совпадений не найдено, если же другое число, то оно означает сколько найдено совпадений

9xakep, да сделай ты уже рекурсивную функцию

monolithed,
знать бы что это такое :D Ф-ия которая вызывает саму себя изнутри? Тогда все тот же вопрос ниже
=========
И зачем?

Есть одна функция, которая принимает массив, в теле функции всего один цикл, который перебирает элементы и заменят повторяющиеся на какое-то рандомное значение, до тех пор пока повторения не исчезнут.
При этом чтобы сократить количество вызовов и повысить эффективность алгоритма, нужно делать проверку перед вставкой элемента на его наличие в массиве.

Это собственно и было самое сложное...Ладно...завтра может попробую

Бугага)) Шифратор готов, monolithed, да-да, я ничего не переделал, но это в будущем

<input type='text' value='' id='text'>
<input type='button' value='шифровать' onclick='w()'>
<script>
var let = []
for(i=0;i<33;i++) {
var r = Math.random() * 33 | 0
let[i] = r
}
var i = 100;
while(i>0) {
  for(k=0;k<=let.length;k++) { 
    for(j=0;j<let.length;j++) {
      if(k!=j) {
      if(let[k]==let[j]) {
        let[k] = Math.random() * 33 | 0
        for(a=0;a<j;a++) {
          if(let[a]==let[j]) {
            let[a] = Math.random() * 33 | 0
    	    }
          }
        } 
      }
    }
  }
--i
}
let[33] = '_'
function w() {
var buk = ['А','Б','В','Г','Д','Е','Ё','Ж','З','И','Й','К','Л','М','Н','О','П','Р','С','Т','У','Ф','Х','Ц','Ч','Ш','Щ','Ъ','Ы','Ь','Э','Ю','Я',' ']
var b = document.getElementById('text').value
var b = b.toUpperCase()
var b1 = b.match(/./g)
for(a=0;a<b1.length;a++) {
  for(b=0;b<=buk.length;b++) {
    if(b1[a]==buk[b]) {
      b1[a] = let[b];
      var b2 = ''+b2 + b1[a];
      var b3 = b2.replace(/undefined/, '')
      }  
  }
}
document.write(b3)
}
</script>

Как работает:
1) Генерирует 33 числа
2) Заносит в массив
3) Делает их не повторяемыми
4) Пишем строку
5) Создаем массив русских букв
6) "Связываем" букву в строке, с буквой массиве, заменяем букву на цифру. Делаем со всеми также...
P.S. это укороченный вариант :D Кому интересно копайтесь в коде :p
=============
Произошла накладка с пробелом...Заработает через минут 5

monolithed, по идее, циклы без тела работают быстрее :D
(сорри, только первую страницу прочел перед ответом)

Блин, объясните мне этот парадокс?! Почему, при написании...короче скрин:

Вот лог:

b1[0] :А, buk[0]: А // он нашел букву А, нашел букву А в массиве
А: 0 // нашел первый элемент массива случ. чисел: 0
b1[0] :0, buk[33]: // какого он снова начинает искать?
0: _
b1[1] :А, buk[0]: А
А: 0
b1[1] :0, buk[33]:
0: _

Вот лог любой другой цифры:

b1[0] :А, buk[0]: А // нашел первую букву, нашел ее в массиве
А: 24 // заменил ее на число в массиве случ. чисел
b1[1] :А, buk[0]: А // пошел дальше
А: 24

Так происходит если какая-нибудь буква по рандому равна 0?
=======
Короче нашел пока единственной решение, не генерировать 0. Поставил при генерации проверку. Теперь генерируется 34 числа, ни одно из которых != 0