[UchusNaDelhi7]

Сообщение от Pyro

PHP код:

const ABC: string = 'abcdefghijklmnopqrstuvwxyz'; 


остальной код тоже можно сократить, но за счёт скорости выполнения

А можно на счет скорости выполнения по подробней ?

[UchusNaDelhi7]

Сообщение от Pyro

PHP код:

const ABC: string = 'abcdefghijklmnopqrstuvwxyz'; 


Это вместо массива использовать ? Если можно объясните принцип с const .

[nixel]

Сообщение от UchusNaDelhi7

Это вместо массива использовать ? Если можно объясните принцип с const .

да, вместо массива. обращение такое же, как и в массиве - ABC[n], где n>1. ABC[0] = длине этой строки и к нему лучше напрямую не обращаться и туда не писать.
const - это раздел программы (по аналогии с type или var) - в нем ты указываешь, что данная переменная является константой и в программе значение этой переменной меняться не будет (тебе и компилятор не позволит это сделать). выигрыш - в использовании памяти. возможно еще и в скорости обработки, но тут я не уверен.

[nixel]

по поводу сокращения кода

Код:

a:=0;
 While a<=25 do   // 1 цикл
 begin
 a:=a+1;
 b:=0;
  While b<=25 do   // 2 цикл
  begin
  b:=b+1;
  c:=0;
   While c<=25 do   // 3 цикл
   begin
   c:=c+1;
   d:=0;
    While d<=25 do   // 4 цикл
    begin
    d:=d+1;
    e:=0;
     While e<=25 do   // 5 цикл
     begin
     e:=e+1;
     f:=0;
      While f<=25 do   // 6 цикл
      begin
      f:=f+1;
      g:=0;
       While g<=25 do   // 7 цикл
       begin
       g:=g+1;
       h:=0;
        While h<=25 do   // 8 цикл
        begin
        h:=h+1;
        i:=0;
         While i<=25 do   // 9 цикл
         begin
         i:=i+1;

 Memo1.Lines.Add(Abc[a]+Abc[b]+Abc[c]+Abc[d]+Abc[e]+Abc[f]+Abc[g]+Abc[h]+Abc[i]);

можно переписать так:

Код:

for a:= 1 to 26 do
  for b:= 1 to 26 do
    for c:= 1 to 26 do
      for d:= 1 to 26 do
        for e:= 1 to 26 do
          for f:= 1 to 26 do
            for g:= 1 to 26 do
              for h:= 1 to 26 do
                for i:= 1 to 26 do
                  Memo1.Lines.Add(Abc[a]+Abc[b]+Abc[c]+Abc[d]+Abc[e]+Abc[f]+Abc[g]+Abc[h]+Abc[i]);

соответственно это с учетом того, что используется строка ABC: string = 'abcdefghijklmnopqrstuvwxyz', у которой ABC[1] = a, а ABC[26] - z. это я к написанному выше о нулевом элементе.

[UchusNaDelhi7]

Сообщение от nixel

да, вместо массива. обращение такое же, как и в массиве - ABC[n], где n>1. ABC[0] = длине этой строки и к нему лучше напрямую не обращаться и туда не писать.
const - это раздел программы (по аналогии с type или var) - в нем ты указываешь, что данная переменная является константой и в программе значение этой переменной меняться не будет (тебе и компилятор не позволит это сделать). выигрыш - в использовании памяти. возможно еще и в скорости обработки, но тут я не уверен.

Все ясно . Спасибо !

[UchusNaDelhi7]

Сообщение от nixel

по поводу сокращения кода

Код:

a:=0;
 While a<=25 do   // 1 цикл
 begin
 a:=a+1;
 b:=0;
  While b<=25 do   // 2 цикл
  begin
  b:=b+1;
  c:=0;
   While c<=25 do   // 3 цикл
   begin
   c:=c+1;
   d:=0;
    While d<=25 do   // 4 цикл
    begin
    d:=d+1;
    e:=0;
     While e<=25 do   // 5 цикл
     begin
     e:=e+1;
     f:=0;
      While f<=25 do   // 6 цикл
      begin
      f:=f+1;
      g:=0;
       While g<=25 do   // 7 цикл
       begin
       g:=g+1;
       h:=0;
        While h<=25 do   // 8 цикл
        begin
        h:=h+1;
        i:=0;
         While i<=25 do   // 9 цикл
         begin
         i:=i+1;

 Memo1.Lines.Add(Abc[a]+Abc[b]+Abc[c]+Abc[d]+Abc[e]+Abc[f]+Abc[g]+Abc[h]+Abc[i]);

можно переписать так:

Код:

for a:= 1 to 26 do
  for b:= 1 to 26 do
    for c:= 1 to 26 do
      for d:= 1 to 26 do
        for e:= 1 to 26 do
          for f:= 1 to 26 do
            for g:= 1 to 26 do
              for h:= 1 to 26 do
                for i:= 1 to 26 do
                  Memo1.Lines.Add(Abc[a]+Abc[b]+Abc[c]+Abc[d]+Abc[e]+Abc[f]+Abc[g]+Abc[h]+Abc[i]);

соответственно это с учетом того, что используется строка ABC: string = 'abcdefghijklmnopqrstuvwxyz', у которой ABC[1] = a, а ABC[26] - z. это я к написанному выше о нулевом элементе.

Код намного меньше и красивей будет , сейчас переделаю . Заодно с константой познакомлюсь , никогда не работал с ними . Спасибо !

[UchusNaDelhi7]

Программу переписал с вашей помощью : с const намного удобнее , а цикл While я использовал по старой памяти ( всегда только его использовал ) , с оператором цикла for тоже намного удобнее . Вот код программы ( все работает ) :

Код:

 procedure TForm1.Button1Click(Sender: TObject);
var
a,b,c,d,e,f,g,h,i: integer;
const
Abc:string = 'abcdefghijklmnopqrstuvwxyz';
begin
 for a:= 1 to 26 do
  for b:= 1 to 26 do
    for c:= 1 to 26 do
      for d:= 1 to 26 do
        for e:= 1 to 26 do
          for f:= 1 to 26 do
            for g:= 1 to 26 do
              for h:= 1 to 26 do
                for i:= 1 to 26 do
Memo1.Lines.Add(Abc[a]+Abc[b]+Abc[c]+Abc[d]+Abc[e]+Abc[f]+Abc[g]+Abc[h]+Abc[i]);
end; 

Т.е. я правильно понимаю , в const все переменные постоянны ( их менять нельзя ) - как было сказано выше , а в массиве их можно менять ( например можно менять элементы массива ) ?

[m1sclick]

Все правильно.

[nixel]

если массив объявлен в поле const - то его элементы менять нельзя.
string - это, по сути, массив символов char. в данном случае ты объявляешь содержимое этого массива в поле const.

если массив/строку объявить в поле var, то можно менять и его содержимое и размер.

[Bargest]

Сообщение от nixel

выигрыш - в использовании памяти. возможно еще и в скорости обработки, но тут я не уверен.

Если говорить о константах числовых - то всё зависит от компилятора. Умный подставит значение везде, где она юзается, и выигрыш будет в одно обращение к памяти и в 4 байта (для integer) в памяти. А не очень умный создаст переменную, и выигрыша не будет вообще (например, так делают многие компиляторы Си; делфовский у меня только один, он подставляет числовые константы в код сразу).
А если говорить про строковые константы - тут несколько иначе. Экономия памяти байта в 4 (на фоне самой строки почти ничто), ускорение на 1 обращение к памяти: строка в делфи на деле есть указатель на строку, и получается, для обращения к обычной строке

Код:

var s: string;
...
Write(s);

будет сначала (1) браться значение из переменной s (являющееся адресом строки), потом (2) значение по этому адресу (сама строка). Для константных строк делфа пропускает первый шаг, т.е. везде сразу используется адрес строки.
Хотя вполне возможно, что другие компиляторы делфи (напр. FreePascal) не особо умны и используют константы как обычные переменные.
Вывод: если можно - лучше константы использовать. Медленнее точно не станет, а может даже чутка быстрее. Но и фанатично все пихать в константы особого смысла нет: прирост производительности не будет даже заметен. Если по коду с точки зрения читаемости логичнее сделать VAR, можно и оставить VAR.

[nixel]

спасибо за подробное разъяснение. Знал, что разница небольшая и исчисляется байтами и количеством обращений к памяти, но теперь буду знать подробно.

p.s. в данном примере, думаю, прирост в скорости будет ощутимый =) все таки обращений к строкам идет очень много.

p.s.s. а вообще еще на первом курсе преподаватель по программированию вбил в голову, что байты надо экономить и при необходимости считать =)

[Bargest]

Байты надо экономить и считать, да. Но без фанатизма.
Я не так давно тоже страдал таким: мол экономия аж 4 байта, надо юзать. Но когда окинул взглядом объемы современной памяти, понял, что это ерунда. Через пару лет 8 миллиардов байт оперативки (8гб) будет уже нормой жизни. Заполнить это просто нереально на десктопных ПК. Я ради эксперимента пару раз смотрел, сколько у меня памяти занято. Мощная игра - 1.2 ГБ. 3Д редакторы - около 300 мб. Остальное меньше 100 мб. Если всё сложить - едва ли на 2 ГБ хватит. Свободным остается еще очень, очень много места. Порой можно пожертвовать и 16 байт на структуру ради выравнивания и скорости.

По поводу прироста в конкретном случае - опять же, зависит от компилятора. На самом глупом компиляторе да, будет сильный прирост: 1 обращение * количество повторов = много. А вот с умным - не очень: первым же делом умный компилятор запишет адрес строки в регистр и будет дальше оперировать с ним, так что прирост будет всё в то же 1 обращение к памяти.

ЗЫЖ если циклиться на объемах памяти, то нужно полностью отказываться от ООП и тем более разного рода скриптов, юзать только ПОП и по возможности исключать из процесса написания кода языки высокого уровня. Но прогресс не стоит на месте, и ради удобства и уменьшения времени, затраченного на разработку ПО, обычно жертвуют памятью и скоростью. Хотя разумеется, при написании специфических приложений стоит по-максимуму оптимизировать отдельные участки кода, которые критичны в конкретной программе (если таковые имеются).

[Pyro]

PHP код:

//const ABC: string = 'abcdefghijklmnopqrstuvwxyz';
const first = 'a';
const last = 'z';
function next(c: char): char;
begin
  result := char(byte(c)+1);
end;

function GetNext(s: string): string;
var i, j: integer;
begin
  result := s;
  for i := length(result) downto 1 do
    if result[i] <> last then begin
      result[i] := next(result[i]);
      for j := i+1 to length(result) do result[j] := first;
      exit;
    end;
  SetLength(result, length(result) + 1);
  for i := 1 to length(result) do result[i] := first;
end; 


вот функция, из одной строки делает следующую
напр: a->b az->ba zz->aaa
максимальная гибкость, вроде бы

[nixel]

Сообщение от Pyro

PHP код:

function next(c: char): char; 
begin 
  result := char(byte(c)+1); 
end; 


Разве не

PHP код:

result := char(ord(c)+1); 


?

[Страдалецъ]

Вот не нравятся мне такие решения. А если надо 3 или 12 символов проверять? Весь код переписывать на 12 циклов? Может так интереснее будет?

Код:

Const
  CharSet: String = 'abcdefghijklmnopqrstuvxwz';
procedure PassGen(Pass: String; Depth: Integer);
Var
  i: Integer;
begin
 for i := 1 to Length(CharSet)
 do begin
    Pass[Depth] := CharSet[i];
    if Depth < Length(Pass)
    then PassGen(Pass, Depth + 1)
    else Memo1.Lines.Add(Pass);
    end;
end;

begin
 PassGen('123456', 1);
end;

Но 6 символов это будет 308,915,776 комбинаций. Не упаритесь ждать?
Ну а если нужен сложный пароль, то там вообще становится все грустно. Для пароля в 6 символов у вас уже будет 56,800,235,584 комбинций.
Но если это не пугает, то вот вам код для сложного пароля:

Код:

Const
  CharSet1: String = 'abcdefghijklmnopqrstuvxwz';
  CharSet2: String = 'ABCDEFGHIJKLMNOPQRSTUVXWZ';
  CharSet3: String = '0123456789';

Var
  CharSet: String;

procedure PassGen(Pass: String; Depth: Integer);
Var
  i: Integer;
begin
 for i := 1 to Length(CharSet)
 do begin
    Pass[Depth] := CharSet[i];
    if Depth < Length(Pass)
    then PassGen(Pass, Depth + 1)
    else begin
         Memo1.Lines.Add(Pass);
         Application.ProcessMessages
         end;
    end;
end;

begin
 CharSet := CharSet1 + CharSet2 + CharSet3;
 PassGen('123456', 1);
end;