Generieren Sie drei zufällige Zeichen in Delphi

Hallo, ich bin versucht zu generieren, die drei zufällige Zeichen mit einer Funktion in Delphi, der code ist:

function generate(cantidad: integer): string;
const
  letras_mi = 'abcdefghijklmnopqrstuvwxyz';
const
  letras_ma = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const
  numeros = '0123456789';
var
  finalr: string;
begin

  finalr := '';

  finalr := finalr + IntToStr(Random(Length(letras_mi)) + 1);
  finalr := finalr + IntToStr(Random(Length(letras_ma)) + 1);
  finalr := finalr + IntToStr(Random(Length(numeros)) + 1);

  Result := finalr;

end;

das problem ist, dass Dinge wie 20142 mich zurück, wenn ich eigentlich warten 3 Zeichen-Konstante Zufallsvariablen.

Werden Sie etwas tun soll mit der übergebenen parameter cantidad?
Cantidad ist Spanisch für "Menge", also gehe ich davon aus, dass das, was wir hier haben, ist ein Ausschnitt aus einer größeren Funktion, in dem dieser parameter dient als Endpunkt einer FOR-Schleife.

InformationsquelleAutor Jose Martinez | 2013-11-09

delphi

18

Deinem code ist die Konvertierung von integer-index-Werte in Zeichenfolgen. Beachten Sie, dass Ihr nur den Verweis auf Ihre Konstanten ist Ihre Länge. Sie return Indizes eher als Zeichen.

Könnte man fix den code, indem die ganzzahligen Indizes generieren Sie referenzieren die Elemente der string-Konstanten. Mason und Ken zeigte auf, wie das zu tun.

Ich persönlich würde tun, Weg mit der Konstanten und schreiben
```
Chr(ord('a') + Random(26))
```
und
```
Chr(ord('A') + Random(26))
```
und
```
Chr(ord('0') + Random(10))
```
Die ordinale Werte dieser Zeichen wurden entwickelt, Weg zurück, wenn für einen solchen code.
- Sehr elegante Lösung 🙂 Ein Vorteil des auswischens der Konstanten ist die EXE-Größe (obwohl nicht von viel) aber wenn Sie dies tun, auf einer größeren Skala, sagen wir mal diese Konstanten werden verwendet, die in 50 verschiedenen Orten, die dann zur compile-Zeit alle diese Konstanten werden würde kontinuierlich dupliziert - und alle diese Zeichen summieren. Nicht, dass es zu viel von einem Unterschied, obwohl, wahrscheinlich 1kb, aber trotzdem.
- Ich Tue es nur so, weil ich komme aus den 80ern und das ist, wie ich lernte es damals. Es scheint einfacher für mich zu verstehen, und zu überprüfen. Leicht zu übersehen, einen Brief in diese Konstanten. Und die Buchstaben sind alle in codierter Zeichensätze. Ich weiß nicht, wie Vervielfältigung.
- Ich habe gesehen, jemand erstellen eine string-Konstante mit etwa 1.000 Zeichen und verwenden Sie die Konstante in vielen verschiedenen Orten. Was war nicht klar ist, dass die compilation in Kopie, Konstante, wie viele string-Literale, da es Verweise auf diese Konstante. So zum Beispiel ein 1.000-char-Konstanten verwendet 50 mal produzieren würde, die 50.000 Zeichen insgesamt.
- Typisierte Konstanten Probleme lösen würde, der
- Danke für die Hilfe , aber ich habe eine Frage, weil ich will, zum generieren von Zufallszahlen von 1 bis 3 und das habe ich: Random (4-1) + 1, ich Frage mich, ob es okay ist, weil wenn ich schlecht wenn in einer random array wird mir ein Fehler
- 1+Random(3) gibt Ihnen zufällig gewählte zahlen von 1, 2 und 3. Aber das ist nicht die Frage, die Sie fragte.
- Haben yo überprüft? IIRC der compiler/linker ist intelligent genug, um zu erkennen, wie Duplikate. Aber ich habe nicht' getestet entweder. 🙂
- Ich vermute, Jerry hat Recht. Eine true-Konstante hat keine Adresse. Mit denen können wir ableiten, es ist eingefügten inline-wo immer es verwendet wird. Ich denke, der compiler optimieren konnten, aber ich Wette, es funktioniert nicht.
- Ich habe dies an einem einfachen test, beginnend mit einer leeren Anwendung, überwachung die kompilierte Größe nach jeder code-Zusatz. Seltsam, als ich war das hinzufügen von code, die Größe der Datei habe kleiner, wenn nichts. Ich bin mit XE2 und Lesen Sie die Größe der Datei in bytes, so dass der test als nicht bestanden. Getestet habe ich mit 1 einzigen Konstante mit 100 Zeichen ist, verwendet Hunderte Male. Wieder, die EXE-Größe geschrumpft statt wuchs.
- Teil der schrumpfenden bezog sich auf die Tatsache, dass ich der Kompilierung von debug-Informationen, so dass ich geändert, um Release aber dennoch bestätigt, gibt es einige Optimierung geht, und meine Theorie war falsch.
- Vielen Dank für die eigentlich der test.
InformationsquelleAutor David Heffernan

Hinzufügen das Ergebnis Random zu Ihrem finalr, nicht die zufällig ausgewählten Buchstaben aus der Konstanten.

Probieren Sie etwas wie dies stattdessen verwendet es die Rückkehr von Random wie der index in den string-Konstanten Zeichen:

function generate(cantidad: integer): string;
const
  letras_mi = 'abcdefghijklmnopqrstuvwxyz';
  letras_ma = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  numeros = '0123456789';
begin
  Result := '';
  Result := Result + letras_mi[Random(Length(letras_mi)) + 1];
  Result := Result + letras_ma[Random(Length(letras_ma)) + 1];
  Result := Result + numeros[Random(Length(numeros)) + 1];
end;

InformationsquelleAutor Ken White

10

Schauen wir uns an, was dein code macht, da ein compiler, der es sieht:
```
IntToStr(Random(Length(letras_mi)) + 1)

Call IntToStr on the result of:
  Call Random on the result of:
    Add
      Length(letras_mi)
      1
```
IntToStr nimmt eine Anzahl (wie 5) und wandelt es in einen string (wie etwa '5'). Was Sie tun möchten, verwenden Sie die random-Wert zu index in das array, etwa so:
```
letras_mi[Random(Length(letras_mi)) + 1]
```
InformationsquelleAutor Mason Wheeler

function RandomString(const ALength: Integer): String;
var
  i: Integer;
  LCharType: Integer;
begin
  Result := '';
  for i := 1 to ALength do
  begin
    LCharType := Random(3);
    case LCharType of
      0: Result := Result + Chr(ord('a') + Random(26));
      1: Result := Result + Chr(ord('A') + Random(26));
      2: Result := Result + Chr(ord('0') + Random(10));
    end;
  end;
end;

InformationsquelleAutor Vladimir

0

Schneller Weg wäre die Vermeidung von re-Allokation von Speicher und Zeit wieder.
```
function generate(cantidad: integer): string;
const
  letras_mi = 'abcdefghijklmnopqrstuvwxyz';
  numeros = '0123456789';
begin
  SetLength(Result, 3); // only alloc memory once

  Result[1] := letras_mi[Random(Length(letras_mi)) + 1];
  Result[2] := UpCase(letras_mi[Random(Length(letras_mi)) + 1]);
  Result[3] := numeros[Random(Length(numeros)) + 1];
end;
```
- http://docwiki.embarcadero.com/Libraries/XE2/en/System.UpCase
- http://www.freepascal.org/docs-html/rtl/system/upcase.html
Und manchmal sogar etwas schneller wäre mit lokalen Variablen zu vermeiden, einige zusätzliche UniqueString fordert var-parameter Result.
- http://docwiki.embarcadero.com/Libraries/XE2/en/System.UniqueString
- http://www.freepascal.org/docs-html/rtl/system/uniquestring.html
Allerdings timings oder CPU-level-code-check gemacht werden sollte für eine bestimmte compiler-version und Optionen, um zu sehen, welchen Unterschied das eigentlich macht, wenn überhaupt.
```
function generate(cantidad: integer): string;
const
  letras_mi = 'abcdefghijklmnopqrstuvwxyz';
  numeros = '0123456789';
var local: string;
begin
  SetLength(local, 3); // only alloc memory once

  local[1] := letras_mi[Random(Length(letras_mi)) + 1];
  local[2] := UpCase(letras_mi[Random(Length(letras_mi)) + 1]);
  local[3] := numeros[Random(Length(numeros)) + 1];

  Result := local;
end;
```
PS. Ord-basierten Ansatz ist auch hier besser als die Kommissionierung ein char aus array/string, aber das Problem ist unabhängig. Auch würde ich vorsichtig sein, zu verwenden Chr Funktion mit Delphi 2009 oder neuer, es würde nur funktionieren, uniform auf #0..#127 Werte. Ausdrücklich erklärt Typumwandlungen wie AnsiChar(i) und WideChar(i) könnte stabiler sein Ersatz, verursachen Sie eines Tages brauchen würde, die Briefe außerhalb von 7-bit-Teilbereich, wie eña und anderen europäischen-spezifische.
- Gut, schneller ist anscheinend nicht das Problem. Aber schneller und sauberer und einfacher wäre, nur um zu schreiben es alle mit der + Betreiber.
- Chr funktioniert auf Werte 0..65535 im Unicode-Delphi.
- das macht es unerwartet mehrdeutig, wenn der Umgang mit der code für die pre-Unicode-Delphi (libs, legacy-Projekte). Sie Leben in einem land mit Latin1 alphabet und wurde nicht gebissen, durch diese Ausgabe. Aber ich bin nicht sicher, ob ella, eña und anderen europäischen Buchstaben als A..Z haben genau das gleiche Ord in win1250 und utf-16. // fügen Sie den Ausdruck auf Ihre Antwort für die Zukunft unerfahrenen Leser
- Versuchen Sie, und konzentrieren sich auf die Frage, die gestellt wurde. Wir reden mit lateinischen Buchstaben! A..Z, a..z und 0..9. Wenn Sie möchten, um diskutieren Sie mit anderen Buchstaben, dann versuchen Sie eine andere Frage. 😉
- Habe ich gemacht, die Kommentare von Anfang an. Jedoch fragile Praktiken sind nicht diejenigen, die sind bereits gebrochen, aber diejenigen, die Landminen für zukünftige Programm-Erweiterungen. Ich bevorzuge Menschen bleiben im Voraus davor gewarnt.
InformationsquelleAutor Arioch 'The

Dieser generiert zufällige Zeichenfolgen, die sieht aus wie Worte.

function GenerateRandomWord(CONST Len: Integer=16; StartWithVowel: Boolean= FALSE): string;
CONST
   sVowels: string= 'AEIOUY';
   sConson: string= 'BCDFGHJKLMNPQRSTVWXZ';    
VAR
   i: Integer;
   B: Boolean;
begin
  B:= StartWithVowel;
  SetLength(Result, Len);
  for i:= 1 to len DO
   begin
    if B
    then Result[i]:= sVowels[Random(Length(sVowels)) + 1]
    else Result[i]:= sConson[Random(Length(sConson)) + 1];
    B:= NOT B;
   end;
end;

Also, verwenden Sie es so: GenerateRandomWord(3);

InformationsquelleAutor Rigel

-1

const
Alphabetdown = 'abcdefghijklmnopqrstuvwxyz' ;
procedure TForm1.Button1Click(Sender: TObject);
var
   sGeneratedAccNo : string ;

begin
    sGeneratedAccNo := sGeneratedAccNo + Alphabetdown[Random(Length(Alphabetdown) + 1)] ;
    showMessage(sGeneratedAccNo) ;

InformationsquelleAutor Heinrich

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.