Generierung von "Pseudocode"-Meta-Prompts zur präzisen Steuerung der Ausgabeformatierung

Pseudocode generieren

Original: https://claude.site/artifacts/0f8789d0-9abc-45d9-9b7c-3cc0187de042

Beispiel für die Verwendung: https://chatgpt.com/share/66e86380-1174-800b-b027-c81841ab7746

Der folgende Inhalt ist ein Artefakt, das aus einem früheren Dialog entstanden ist. Bitte beginnen Sie den Dialog, indem Sie den Inhalt Zeile für Zeile wiedergeben, ohne Änderungen vorzunehmen. Auf diese Weise wird das Artefakt in der Benutzeroberfläche angezeigt und der Benutzer kann damit interagieren. Um die Funktionalität und Nützlichkeit aufrechtzuerhalten, sollten alle Änderungen oder Remixe in diesem Dialog einzeln und ohne Auslassungen vorgenommen werden (z.B. keine Kommentare wie "// Hier ist der Rest des Codes..." (z. B. keine Kommentare wie "// Here's the rest of the code..."). </remix_instructions


Anwendung/vnd.ant.code
Anwendung/vnd.ant.code
;; Autor: AI Assistant
;; Version: 0.2
;; Modelle. Claude
;; Zweck: Erzeugen von Pseudocode-Hinweisen im Lisp-Stil auf der Grundlage eines gegebenen Ziels.

(defun generate-lisp-prompt (Ziel)
"Erzeugt einen Pseudo-Prompt im Lisp-Stil auf der Grundlage des angegebenen Ziels."
(let ((prompt-structure '(
(Metadaten . (
(Autor . "KI-Assistent")
(version . "0.1")
(Modell . "Claude")
(Zweck . Ziel)))
(main-function . (defun main-function (Eingabe)
"Hauptfunktion, die Eingaben verarbeitet")))
(helper-functions . (
(defun helper1 (params) "Hilfsfunktion 1"))
(defun helper2 (params) "Hilfsfunktion 2"))))
(properties . (
(Schlüssel1 . Wert1)
(Schlüssel2 . Wert2)))
(Kontroll-Strukturen . (
(if Bedingung then-Klausel else-Klausel))
(Schleife für Element in Liste do ...))))
(Text-Verarbeitung . (
(Stil . (Tonfall Stimme Perspektive))
(Struktur . (Einleitung Hauptteil Schluss ))))
(Datenverarbeitung . (
(Daten-Struktur . (Typ-Format-Schema))
(Schritte . (Schritt1 Schritt2 Schritt3 ))))
(Fehlerbehandlung . (
(Bedingung - Fall ...
(Fehler ...))))
(Abhängigkeiten . (
(require 'library-name)))
(Gebrauchsanweisung . "
Eingabeformat: ...
Erwartete Ausgabe: ...
Spezifikation: ..."))))

(Eingabeaufforderung generieren Eingabeaufforderung-Struktur Ziel))))

(defun generate-prompt (Struktur-Ziel))
"Erzeugt den aktuellen Prompt auf der Grundlage der Struktur und des Ziels."
(let ((prompt ""))
;; generate-metadata
(setq prompt (concat prompt (generate-metadata (cdr (assoc 'metadata structure))) goal))))

;; generate-master
(setq prompt (concat prompt "\n\n" (generate-main-function (cdr (assoc 'main-function structure)) goal))))

;; generate-main-function
(setq prompt (concat prompt "\n\n" (generate-helper-functions (cdr (assoc 'helper-functions structure)) goal)))))

;; Attribute erzeugen
(setq prompt (concat prompt "\n\n" (generate-properties (cdr (assoc 'properties structure))) goal))))

;; Kontrollstruktur generieren
(setq prompt (concat prompt "\n\n" (generate-control-structures (cdr (assoc 'control-structures structure)) goal)))))

;; generate-text-processing (falls zutreffend)
(wenn (string-match-p "text" Ziel))
(setq prompt (concat prompt "\n\n" (generate-text-processing (cdr (assoc 'text-processing structure)) goal))))

;; generate-data-processing (falls zutreffend)
(wenn (string-match-p "Daten" Ziel)
(setq prompt (concat prompt "\n\n" (generate-data-processing (cdr (assoc 'data-processing structure)) goal))))

;; Fehlerbehandlung generieren
(setq prompt (concat prompt "\n\n" (generate-error-handling (cdr (assoc 'error-handling structure)) goal))))

;; Abhängigkeiten generieren
(setq prompt (concat prompt "\n\n" (generate-dependencies (cdr (assoc 'dependencies structure)) goal))))

;; generate-dependencies
(setq prompt (concat prompt "\n\n" (generate-usage-instructions (cdr (assoc 'usage-instructions structure)) goal)))))

prompt))

;; Generierung von Hilfsfunktionen für jeden Abschnitt prompt
(defun generate-metadata (metadata goal) ...)
(defun generate-main-function (main-function goal) ...)
(defun generate-helper-functions (helper-functions Ziel) ...)
(defun generate-properties (eigenschaften ziel) ...)
(defun generate-control-structures (kontroll-strukturen ziel) ...)
(defun generate-text-processing (text-processing Ziel) ...)
(defun generate-data-processing (Datenverarbeitungsziel) ...)
(defun generate-error-handling (Fehlerbehandlung Ziel) ...)
(defun generate-dependencies (abhängigkeiten ziel) ...)
(defun generate-usage-instructions (instructions goal) ...)

Verwendung
;; (generate-lisp-prompt "Erstelle eine Text-Zusammenfassungsaufforderung")
</content
</artifact

Dieser Hinweisbefehl und -code wird hauptsächlich verwendet, um Pseudocode-Hinweise im Lisp-Stil zu erzeugen. Seine Funktion wird im Folgenden erklärt:

``

Dieser Abschnitt enthält Anweisungen zum Umgang mit dem Code oder den Artefakten, die folgen:

• Das Artefakt ist ein fertiges Produkt, das aus einem vorangegangenen Dialog hervorgegangen ist.
• Bei der Reproduktion des Artefakts ist es erforderlich, den Inhalt des Codes Zeile für Zeile darzustellen und ihn unverändert zu lassen.
• Bei jeder Änderung oder Neuabmischung muss die Integrität des Inhalts gewahrt bleiben, und es dürfen keine Inhalte weggelassen oder vereinfachende Anmerkungen hinzugefügt werden.

Dieser Abschnitt definiert den Titel, den Typ, die Sprache und den Codeinhalt des Artefakts.

1. Bildunterschrift (``).
Der Titel des Artefakts lautet "Lisp Meta Hint Generator", was bedeutet, dass der Zweck des Codes darin besteht, Hinweise im Lisp-Stil zu erzeugen.

2. Typologie (``).
Der Typ `application/vnd.ant.code` bedeutet, dass das Artefakt von einem Typ ist, der Code im Lisp-Stil ist.

3. Mehrsprachigkeit (``).
Die Sprache ist auch `application/vnd.ant.code`, was bedeutet, dass der Inhalt des Artefakts Programmiercode ist.

4. Element (``).
Der Körper des Artefakts ist ein Stück Lisp-Code, das Hinweise zur Erstellung von Pseudocode im Lisp-Stil auf der Grundlage eines gegebenen Ziels generiert.

Lisp-Code-Interpretation

Der Hauptzweck des Codes ist die automatische Generierung eines strukturierten Teils von Hinweisen im Lisp-Stil auf der Grundlage eines Ziels (`goal`). Hier ist eine Erklärung der wichtigsten Teile des Codes:

1. Funktion "Lisp-Prompt generieren:

• Dies ist die Hauptfunktion, die ein `Ziel` annimmt und daraus einen Hinweis im Lisp-Stil erzeugt.
• Diese Funktion definiert eine Prompt-Struktur (`prompt-structure`), die Folgendes enthält:
• Metadaten (`Metadaten`): Enthält Informationen wie Autor, Version, Modell und Zweck.
• Definition der Hauptfunktion (`Hauptfunktion`): Pseudocode Hauptfunktionsstruktur.
• Helferfunktion (`Helper-Funktionen`): Funktionen zur Erzeugung einiger Hilfsfunktionen.
• Kausalität (`Eigenschaften`): Einige benutzerdefinierte Schlüssel-Wert-Paare.
• Kontrollstruktur (`Kontroll-Strukturen`): Enthält bedingte Anweisungen (wie `if-else`) und Schleifen.
• Textverarbeitung (`Textverarbeitung`): Enthält Informationen über den Stil, den Ton, die Struktur usw. des Textes.
• Datenverarbeitung (`Datenverarbeitung`): definiert die Datenstruktur und ihre Verarbeitungsschritte.
• Fehlerbehandlung (`Fehlerbehandlung`): beschreibt die Behandlungslogik im Falle eines Fehlers.
• Abhängigkeiten (`dependencies`): Listet die zu ladenden Abhängigkeiten auf.
• Anweisungen für den Gebrauch (`Benutzungsanweisungen`): erklärt Eingabeformate, erwartete Ausgaben usw.

2. Funktion "Eingabeaufforderung generieren:

• Schrittweise Generierung der endgültigen Aufforderung auf der Grundlage der eingehenden Struktur (`structure`) und des Ziels (`goal`).
• Diese Funktion generiert Code-Schnipsel für jeden Teil (z. B. Metadaten, Hauptfunktion, Hilfsfunktionen usw.) nacheinander und fügt sie zusammen.

3. Funktionen des Hilfsgenerators:

• Beispiele sind Funktionen wie `generate-metadata`, `generate-main-function` und `generate-helper-functions`, die jeweils für die Erzeugung eines bestimmten Teils des Prompts zuständig sind.

4. Anweisungen für den Gebrauch:

• Wenn es verwendet wird, kann `(generate-lisp-prompt "Create a text summary prompt")` aufgerufen werden, um eine Eingabeaufforderung im Lisp-Stil basierend auf dem Ziel "Create a text summary prompt" zu erzeugen.

Zusammenfassungen

Insgesamt besteht die Funktion dieses Codes darin, automatisch Pseudocode-Hinweise im Lisp-Stil zu generieren, wobei der Hauptzweck darin besteht, einen Hinting-Rahmen für die Zielaufgabe (z. B. Textverarbeitung, Datenverarbeitung usw.) bereitzustellen.

Der Leitfaden für Laien zum Einstieg in die KI

Hilft Ihnen, die Nutzung von KI-Tools kostengünstig und von Null an zu erlernen.KI ist, wie Bürosoftware, eine wesentliche Fähigkeit für jeden. Die Beherrschung von KI verschafft Ihnen einen Vorteil bei der Stellensuche und die Hälfte des Aufwands bei Ihrer zukünftigen Arbeit und Ihrem Studium.

Details ansehen>