Programmierung on kenji.blog

So entfernen Sie Metadaten (persönliche Informationen) stapelweise aus Excel, Word usw. mit PowerShell

Wed, 30 Jul 2025 02:42:40 +0900

“So entfernen Sie Metadaten (persönliche Informationen) stapelweise aus Excel, Word usw. mit PowerShell”

Office-Dateien wie Excel speichern automatisch „Metadaten (persönliche Informationen)“ wie den Ersteller, die letzte Person, die die Datei geändert hat, und den Firmennamen. Es gibt viele Fälle, in denen Sie diese Informationen entfernen möchten, z. B. wenn Sie eine Datei außerhalb des Unternehmens teilen.

In diesem Artikel erklären wir detailliert, wie Sie Excel-Metadaten mithilfe von PowerShell entfernen, wobei der Schwerpunkt auf ** der Stapelverarbeitung innerhalb eines Ordners ** und ** der Anwendung auf andere Office-Dateien wie Word und PowerPoint ** liegt.

1. Entfernen von Metadaten aus einer einzelnen Excel-Datei

Dies ist das einfachste Skript zum Entfernen persönlicher Informationen aus einer einzelnen Excel-Datei. Es ruft das COM-Objekt von Excel auf, setzt die Eigenschaft RemovePersonalInformation auf $true und speichert die Datei durch Überschreiben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Starten der Excel-Anwendung unsichtbar
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

# Datei öffnen (*Bitte geben Sie den absoluten Pfad an)
$filePath = "C:\Path\To\Your\File.xlsx"
$wb = $excel.Workbooks.Open($filePath)

# Aktivieren der Einstellung zum Entfernen von Metadaten (persönlichen Informationen)
$wb.RemovePersonalInformation = $true

# Speichern und schließen
$wb.Save()
$wb.Close($false)

# Excel beenden und Speicher freigeben
$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

** Achtung: ** Stellen Sie sicher, dass Sie den ** absoluten Pfad (vollständigen Pfad) ** für den an Workbooks.Open() übergebenen Pfad angeben. Ein relativer Pfad kann zu einem Fehler führen.

2. Stapelverarbeitung aller Excel-Dateien in einem Ordner

In der Praxis möchten Sie oft “alle Metadaten aus Dutzenden von Excel-Dateien in einem bestimmten Ordner auf einmal löschen”. Dies kann durch Verwendung einer Schleifenverarbeitung in Kombination mit Get-ChildItem erreicht werden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


$targetFolder = "C:\Path\To\Your\Folder"

# Abrufen aller .xlsx und .xls Dateien im Ordner
$excelFiles = Get-ChildItem -Path $targetFolder -Include "*.xlsx", "*.xls" -Recurse

if ($excelFiles.Count -eq 0) {
 Write-Host "Keine Excel-Datei gefunden."
 exit
}

$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

foreach ($file in $excelFiles) {
 Write-Host "Entfernen von Metadaten aus $($file.Name)..."

 # Datei öffnen
 $wb = $excel.Workbooks.Open($file.FullName)

 # Metadaten entfernen und speichern
 $wb.RemovePersonalInformation = $true
 $wb.Save()
 $wb.Close($false)
}

$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

Write-Host "Die gesamte Verarbeitung ist abgeschlossen!"

3. Entfernen von Metadaten aus anderen Office-Dateien (Word / PowerPoint)

Metadaten können nicht nur in Excel, sondern auch in Word und PowerPoint mit genau derselben Logik entfernt werden. Lediglich der Name des aufzurufenden COM-Objekts ist unterschiedlich, und es ist üblich, dass die Eigenschaft RemovePersonalInformation bereitgestellt wird.

Für Word

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$word = New-Object -ComObject Word.Application
$word.Visible = $false
$word.DisplayAlerts = 0

$doc = $word.Documents.Open("C:\Path\To\Your\File.docx")
$doc.RemovePersonalInformation = $true
$doc.Save()
$doc.Close()

$word.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($word) | Out-Null

Für PowerPoint

Für PowerPoint ist die Einstellung der Eigenschaft RemovePersonalInformation ähnlich, aber das Verhalten des versteckten Starts ist etwas anders.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ppt = New-Object -ComObject PowerPoint.Application

# Öffnen durch Angabe des versteckten Modus (msoFalse) usw. mit dem 2. bis 4. Argument
$presentation = $ppt.Presentations.Open("C:\Path\To\Your\File.pptx", $false, $false, $false)
$presentation.RemovePersonalInformation = $true
$presentation.Save()
$presentation.Close()

$ppt.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($ppt) | Out-Null

Fazit

Durch die Nutzung von PowerShell und COM-Objekten können Sie die Entfernung von Metadaten aus Office-Dateien vollständig automatisieren. Es ist sehr nützlich, vor der Auslieferung ein Stapelverarbeitungsskript zur Hand zu haben, um das unbeabsichtigte Durchsickern vertraulicher Informationen oder persönlicher Namen zu verhindern.

Schritte, um TinyLLaMA aus C++ aufzurufen (unter Verwendung von llama.cpp)

Sat, 19 Jul 2025 09:40:53 +0900

✅ Einrichtung von TinyLLaMA × C++ (mit `llama.cpp`)

🔧 Schritt 1: llama.cpp vorbereiten

1-1. Erforderliche Umgebung (Minimum)

OS: Windows / Linux / macOS
Entwicklungsumgebung: g++ / clang / MSVC
Git / CMake

1-2. llama.cpp abrufen und kompilieren

1
2
3
4
5
6


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build
cmake ..
cmake --build . --config Release

Unter Windows ist es am einfachsten, die Visual Studio Developer Command Prompt mit cmake --build . --config Release zu verwenden.

📦 Schritt 2: TinyLLaMA-Modell herunterladen und konvertieren

2-1. Originalmodell von HuggingFace beziehen

Beispiel: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# Falls erforderlich, transformers zum Herunterladen verwenden
pip install transformers huggingface_hub

python3 -m transformers.models.llama.convert_llama_weights_to_hf \
 --input_dir ./TinyLlama-1.1B-Chat \
 --model_size 1B \
 --output_dir ./hf_model

Dies ist der Schritt zur Konvertierung in das Hugging Face-Format.

2-2. In das GGUF-Format konvertieren (für `llama.cpp`)

1
2


cd llama.cpp
python3 convert.py ./hf_model --outfile tinyllama.gguf

2-3. Modellquantisierung (Größenreduzierung)

1

./quantize ./tinyllama.gguf ./tinyllama-q4.gguf q4_0

q4_0 steht für 4-Bit-Quantisierung. Die Modellgröße schrumpft auf etwa ** 350MB ** .

🧪 Schritt 3: Das Modell aus C++ aufrufen (Codebeispiel)

3-1. Einfacher C++-Code (Inferenz)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include "llama.h"
#include <iostream>

int main() {
 llama_model_params model_params = llama_model_default_params();
 llama_context_params ctx_params = llama_context_default_params();

 llama_model *model = llama_load_model_from_file("tinyllama-q4.gguf", model_params);
 llama_context *ctx = llama_new_context_with_model(model, ctx_params);

 std::string prompt = "Der Benutzer sagt, dass er Excel-Daten laden, filtern und speichern möchte. Wie sieht die Knotenkonfiguration aus?";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // Tokenisierung
 std::vector<llama_token> tokens(prompt.size() + 8);
 int n = llama_tokenize(model, prompt.c_str(), tokens.data(), tokens.size(), true);
 tokens.resize(n);

 for (size_t i = 0; i < tokens.size(); ++i) {
 batch.token[i + 1] = tokens[i];
 }

 batch.n_tokens = tokens.size() + 1;
 llama_decode(ctx, batch);

 // Inferenz-Ergebnis abrufen
 for (int i = 0; i < 50; ++i) {
 llama_token next = llama_sample_token(ctx, nullptr);
 std::cout << llama_token_to_str(model, next);
 llama_batch next_batch = llama_batch_init(1, 0, 1);
 next_batch.token[0] = next;
 next_batch.n_tokens = 1;
 llama_decode(ctx, next_batch);
 }

 llama_free(ctx);
 llama_free_model(model);
 return 0;
}

🧱 Schritt 4: Kompilierungsmethode (Beispiel)

1

g++ -I./llama.cpp main.cpp ./llama.cpp/build/libllama.a -o tiny_infer -pthread -std=c++11

libllama.a wird nach der Erstellung im Verzeichnis build/ generiert.

✅ Beispiel für die Struktur der Artefakte (Organisation)

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # Quantisiertes Modell (~350MB)
├── main.cpp # Obiger C++-Code
├── llama.cpp/ # llama.cpp-Quellcode
└── build/
 └── libllama.a # Kompilierte Bibliothek

🧠 Zusätzliche Hinweise zur Anwendung auf Anwendungsfälle

Code in C++ einbauen, um die Ausgabe entgegenzunehmen und Knoten-Templates abzugleichen/auszuwählen.
Beispiel: Wenn “Excel”, “Filter”, “Speichern” enthalten sind → entsprechende Knotengruppen generieren.
Dieser Teil kann mit einer einfachen Struktur wie if-Anweisungen + Laden von JSON-Vorlagen umgesetzt werden.

📌 Zusammenfassung

Element	Beschreibung
Empfohlenes Modell	TinyLLaMA-1.1B-Chat v1.0 (GGUF + Quantisierung)
Größe	~350 bis 450MB (4-Bit-Quantisierung)
C++-Integration	Möglich durch `llama.cpp`, fast keine externen Abhängigkeiten
Verarbeitungsleistung	Ausreichend für einfache Intentionserkennung und Satzgenerierung (Natürliche Sprache → Struktur)
Erweiterbarkeit	Kann durch Kombination mit Slot-Filling und Template-Aufrufen zu einer KI für Knotengenerierung werden

Vor- und Nachteile der Programmerstellung mit Win32API + C++

Sat, 12 Jul 2025 12:30:35 +0900

Der Reiz und die Herausforderungen der Entwicklung mit Win32API + C++

Für diejenigen, die die Windows-App-Entwicklung meistern möchten, ist Win32API + C++ nach wie vor eine leistungsstarke Option. Diese Kombination, die die engstmögliche Interaktion mit dem Betriebssystem ermöglicht, bietet sowohl Geschwindigkeit als auch Flexibilität.

Andererseits erfordert die Beherrschung Entschlossenheit, da sie sich erheblich von modernen Entwicklungsstilen unterscheidet.

Auf dieser Seite werden wir die Vor- und Nachteile aus der Perspektive eines aktiven Windows-App-Entwicklers klar erläutern.

Vorteile

Ultraschnelle Native Ausführung

Da C++ und Win32API auf der Schicht operieren, die dem Betriebssystem am nächsten ist, gibt es fast keinen unnötigen Overhead. Die CPU- und Speichernutzung ist äußerst effizient und bietet eine überwältigende Ausführungsgeschwindigkeit .

Hohe Flexibilität und Freiheit

Sie können das gesamte App-Verhalten selbst fein steuern , wie z. B. Fenstersteuerung, asynchrone Verarbeitung, COM-Integration und Prozessverwaltung. Es ist auch möglich, spezialisierte Tools und eigene originelle Frameworks zu erstellen.

Einfach zu Verteilen Ohne Laufzeitbedarf

Da keine externen Laufzeitumgebungen wie .NET oder Java erforderlich sind, kann es als einzelne ausführbare Datei verteilt werden . Es ist weniger anfällig für Probleme bei der Neuverteilung und lässt sich ohne Installationsprogramm leicht ausführen.

Kann Leichtgewichtige Apps Erstellen

Da es nur die absolut notwendige Konfiguration erfordert, ist seine Eigenschaft ein sehr geringer Speicherbedarf . Es läuft auch auf leistungsschwachen PCs oder in virtuellen Maschinenumgebungen komfortabel.

Fortgeschrittene Steuerung auf Betriebssystemebene Möglich

Sie können auch Steuerungen realisieren, die mit normalen Sprachen und Bibliotheken schwierig sind , wie z. B. globale Maus- und Tastatur-Hooks, Feinabstimmung von Fensterstilen und Systemmenüoperationen.

Nachteile

Geringe Entwicklungseffizienz

Selbst der Aufbau der GUI muss vollständig in Code erfolgen, und manchmal sind Dutzende Zeilen Code erforderlich, nur um eine einzige Schaltfläche zu erstellen . Das Ändern des Designs ist ebenfalls kompliziert, und die Produktivität ist im Vergleich zur Entwicklung mit UI-Frameworks geringer.

Leicht Verringerte Wartbarkeit

Es gibt viele Codes mit speziellen Strukturen , wie z. B. Nachrichtenschleifen und Fensterprozeduren, was die Lesbarkeit und Wiederverwendbarkeit beeinträchtigt. Es hat auch Aspekte, die für die Teamentwicklung und die langfristige Wartung ungeeignet sind.

Schwierige Unterstützung Moderner UI

Es ist schwierig, die in den letzten Jahren geforderte UX zu unterstützen , wie z. B. High-DPI-Unterstützung, Touch-Interfaces, Barrierefreiheit und Dark Mode. Sie müssen jede manuell behandeln, was viel Mühe erfordert.

Keine Plattformübergreifende Unterstützung

Da es sich um eine vollständig Windows-exklusive API handelt, kann es nicht auf macOS oder Linux portiert werden . Wenn Sie eine plattformübergreifende Bereitstellung planen, müssen Sie andere Technologien auswählen.

Extrem Hohe Lernkosten

Sie müssen Konzepte und Mechanismen verstehen, die heute selten verwendet werden , wie z. B. Handles, GDI, COM und OLE. Viele Dokumente sind alt und erfordern Zeit und Geduld zum Lernen.

Geeignete Anwendungen

Leichtgewichtige Tools wie Datei-Launcher und Hotkey-Unterstützer
Systemdienstprogramme wie Zwischenablagenmanipulation und IME-Steuerung
Native steuerungsbasierte Apps wie globale Hooks und Fenstererfassung
Treiber-Support-Tools , die eng mit der Hardware verbunden sind

Ungeeignete Anwendungen

Allgemeine Verbraucher-Apps , bei denen moderne UI / UX wichtig sind
Prototyping und MVP-Entwicklung , die mit Blick auf Geschwindigkeit erstellt wurden
Großprojekte , die auf langfristigem Betrieb und Teamentwicklung basieren
Plattformübergreifende Produkte , die mehrere Betriebssysteme unterstützen müssen

Bewertungszusammenfassung

Standpunkt	Bewertung
Ausführungsgeschwindigkeit	◎ Sehr Schnell
Speichereffizienz	◎ Hervorragend
Entwicklungsgeschwindigkeit	× Langsam
Wartbarkeit	× Gering
Plattformübergreifende Unterstützung	× Nicht Unterstützt
Moderne UI-Unterstützung	× Schwach
Freiheit der OS-Steuerung	◎ Überwältigend Hoch

Fazit

Win32API + C++ ist ein Werkzeug für Entwickler, die “alles im Betriebssystem selbst handhaben wollen”. Während seine Leistung immens ist, erfordern Lernen und Betrieb eine entsprechende Entschlossenheit.

Ob es sich lohnt, “mutig zu wählen”, hängt von der Art der App ab, die Sie anstreben.

In die Welt von #include <windows.h> einzutauchen, ohne sich auf GUI-Frameworks oder moderne Sprachen zu verlassen ―― Diese Entscheidung ist auch heute noch sinnvoll.

FizzBuzz

Fri, 18 Apr 2025 00:58:11 +0900

Was genau ist eigentlich FizzBuzz?

Hallo!

Heute möchte ich über „FizzBuzz“ schreiben.

Egal, ob du denkst „Ah, das kenne ich!“, oder ob du sagst „Ich habe davon gehört, es aber nicht wirklich verstanden“, bitte bleib einen Moment bei mir. Es dauert nur wenige Minuten, es zu lesen, und vielleicht denkst du danach: „Das ergibt Sinn.“

Stimmt es, dass man „als Programmierer versagt hat, wenn man FizzBuzz nicht schreiben kann“?

FizzBuzz ist kurz gesagt so etwas.

1
2
3
4
5
6
7
8
9


for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else:
 print(i)

Ja, das ist das berühmte „FizzBuzz-Problem“.

Man betrachtet nacheinander die Zahlen von 1 bis 100,
wenn es ein Vielfaches von 3 ist, gibt man „Fizz“ aus, wenn es ein Vielfaches von 5 ist, „Buzz“,
wenn es ein Vielfaches von beiden ist, gibt man „FizzBuzz“ aus – es ist wirklich sehr einfach.

Und dennoch wird es aus irgendeinem Grund oft als „der minimale Test für einen Programmierer“ behandelt. Es taucht in Vorstellungsgesprächen auf, und in den sozialen Medien sieht man Kommentare wie „Jemand, der nicht einmal FizzBuzz schreiben kann…“.

Aber Moment mal.

Können wir wirklich behaupten, dass „FizzBuzz nicht schreiben können = nicht programmieren können“ bedeutet?

Es geht nicht um das Können, sondern darum, ob man den „Zustand“ dafür hat

Es stimmt, dass FizzBuzz das Verständnis von Syntax und grundlegendem logischem Denken erfordert. Daher ist es nachvollziehbar, dass es zur „Überprüfung der Grundlagen“ verwendet wird.

Aber hier ist der Punkt.

Wenn die Umgebung anders ist, sind auch die Ergebnisse anders.

Zum Beispiel,

Wenn man vor einem Interviewer nervös ist, den man gerade erst kennengelernt hat
Wenn einem plötzlich ein Whiteboard übergeben wird und man keinen Editor zur Hand hat
Wenn einem nicht sofort einfällt: „Warte, was ist noch mal Modulo?“

…Kommt das nicht vor? Wir sind Menschen. Ich denke, das passiert.

Deshalb glaube ich, dass die Frage, „ob man sich in einen Zustand versetzen kann, in dem man FizzBuzz schreiben kann“, eigentlich viel wichtiger ist, als einfach nur „ob man FizzBuzz schreiben kann“.

Die Falle des üblichen Ratschlags „Einfach üben, dann wird alles gut“

Wenn dieses Thema aufkommt, neigen die Leute oft zu dem Ratschlag: „Dann übe jeden Tag!“.

Es ist wahr, dass wiederholte Übung dazu führt, dass man es fließend schreiben kann, und das ist an sich eine gute Sache. Aber wenn wir von der Prämisse ausgehen, dass „man disqualifiziert ist, wenn man FizzBuzz nicht schreiben kann“, kann sich das leicht in bloße Angst verwandeln.

Mit anderen Worten, es neigt dazu, eine Struktur zu schaffen, in der man das Gefühl hat: „Ich habe einen Fehler gemacht = ich bin nutzlos.“

Zum Beispiel, wenn man an einem Tag verschläft, neigt man dann nicht dazu zu denken: „Ich bin faul…“? Aber es könnte einfach sein, dass der Körper in diesem Moment erschöpft war.

Bei FizzBuzz ist es genauso.

Abgesehen davon ist FizzBuzz immer noch eine gute Frage

Trotzdem ist FizzBuzz nichts Schlechtes.

Vielmehr denke ich, dass es eine sehr gut durchdachte Frage ist. Die Regeln sind einfach und es lässt sich leicht erweitern. Wenn man es zum Beispiel so ändert, wird das Denken vertieft.

1
2
3
4
5
6
7


for i in range(1, 101):
 output = ""
 if i % 3 == 0:
 output += "Fizz"
 if i % 5 == 0:
 output += "Buzz"
 print(output or i)

Dies ist ein Beispiel dafür, dass „man es auch ohne if-elif-else schreiben kann“. Das ist ziemlich smart, oder?

Mit anderen Worten, bei FizzBuzz geht es nicht nur darum, „ob man es geschafft hat“, sondern es dient auch als Einstiegspunkt, um zu sehen, „wie man es schreibt“ und „wie viel man versteht“.

Zusammenfassend

Ich denke, wir sollten der Frage, ob man FizzBuzz programmieren kann oder nicht, zu viel Bedeutung beimessen.

Selbst wenn man es nicht schreiben konnte, könnte es einfach daran liegen, dass „man sich gerade nicht wohlgefühlt hat“, und oft kann man es später tun, wenn man sorgfältig darüber nachdenkt.

Keine Eile, lass uns langsam vorankommen.

Code wird von Menschen geschrieben. Weil wir Menschen sind, vergessen wir manchmal Dinge und sind nervös. Wenn wir das akzeptieren, reicht es meiner Meinung nach aus, wenn wir Stück für Stück vorankommen können.

Lass uns also auch heute wieder ganz entspannt Code schreiben.

Türme von Hanoi

Thu, 17 Apr 2025 22:23:14 +0900

Türme von Hanoi

Hallo!

Heute möchte ich Ihnen die “Türme von Hanoi” anhand eines Python-Beispielprogramms erklären.

Was sind die Türme von Hanoi?

Die Türme von Hanoi sind ein Puzzle, das 3 Stäbe und mehrere Scheiben verwendet. Die Scheiben sind unterschiedlich groß und liegen zu Beginn der Größe nach absteigend auf einem Stab. Die Regeln lauten wie folgt:

Es kann immer nur eine Scheibe bewegt werden.
Eine größere Scheibe darf nicht auf eine kleinere Scheibe gelegt werden.

Dieses Puzzle gilt als hervorragendes Lehrmaterial, um rekursives Denken zu erlernen. Rekursion ist eine Methode zur Lösung eines Problems, indem man es in kleinere Probleme derselben Art zerlegt. Bei den Türmen von Hanoi wiederholen wir die Operation, n-1 Scheiben zu bewegen, um n Scheiben zu bewegen.

Lösen wir die Türme von Hanoi mit Python

Unten sehen Sie einen Beispielcode zur Lösung der Türme von Hanoi in Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def hanoi(n, source, target, auxiliary):
 if n == 1:
 print(f"Move disk 1 from {source} to {target}")
 return
 hanoi(n - 1, source, auxiliary, target)
 print(f"Move disk {n} from {source} to {target}")
 hanoi(n - 1, auxiliary, target, source)

# Beispiel: 3 Scheiben von A nach C bewegen
hanoi(3, 'A', 'C', 'B')

In diesem Code wird die Funktion hanoi rekursiv aufgerufen, und die Schritte zum Bewegen der Scheiben werden angezeigt. Bei 3 Scheiben erhält man beispielsweise die folgende Ausgabe:

1
2
3
4
5
6
7


Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C

Auf diese Weise lassen sich komplexe Probleme durch einen rekursiven Ansatz einfach lösen.

Wie lange dauert es, 64 Scheiben zu bewegen?

Die Anzahl der Züge bei den Türmen von Hanoi erfordert mindestens 2^n - 1 mal. Um 64 Scheiben zu bewegen, sind also 2^64 - 1 Züge, etwa 1,84×10^19 Züge erforderlich. Selbst wenn Sie einen Zug pro Sekunde machen könnten, würde es etwa 584,9 Milliarden Jahre dauern. Das ist etwa das 42-fache des Alters des Universums (etwa 13,7 Milliarden Jahre).

Mit zunehmender Anzahl von Scheiben steigt also die Anzahl der erforderlichen Züge exponentiell an. Daher ist es unrealistisch, in der Praxis 64 Scheiben zu bewegen.

Zusammenfassung

Die Türme von Hanoi sind ein perfektes Puzzle, um rekursives Denken zu lernen. Mit Python können Sie die Lösung leicht implementieren. Seien Sie jedoch vorsichtig, da die Anzahl der erforderlichen Züge drastisch ansteigt, wenn die Anzahl der Scheiben zunimmt.

Indem Sie den rekursiven Ansatz verstehen und versuchen, tatsächlich Code zu schreiben, können Sie Ihre Programmierfähigkeiten verbessern. Bitte versuchen Sie sich an der Herausforderung der Türme von Hanoi.

Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL

Wed, 16 Apr 2025 01:58:03 +0900

🎯 Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL (Visual Studio 2022 / C++)

✅ Gesamtarchitektur

🔹 ① CLI-Wrapper-DLL (C++/CLI)

Stellt die Funktionalität zum Ausführen von PowerShell-Skripten bereit.

🔹 ② Nativer C++-Aufrufer

Ruft die CLI-DLL auf, um das PowerShell-Skript auszuführen.

🔧 Schritt 1: Erstellen des CLI-Wrapper-DLL-Projekts

1. Projekt erstellen

[Neues Projekt erstellen] → [C++] → CLR-Klassenbibliothek (.NET Framework)
Name: PowerShellWrapper

💡 Wenn diese Vorlage nicht angezeigt wird, installieren Sie die Workload “.NET-Desktopentwicklung”.

2. NuGet-Paket hinzufügen

Rechtsklick auf das Projekt → [NuGet-Pakete verwalten]
Suchen und installieren Sie System.Management.Automation
(Version 5.x oder 7.x)

3. Implementierung des CLI-Codes

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 Schritt 2: Aufruf aus nativem C++

1. Erstellen des C++-Konsolen-App-Projekts

Name: NativeApp

2. Referenzeinstellungen

Rechtsklick auf das Projekt → [Hinzufügen] → [Referenz] → Projekte → PowerShellWrapper hinzufügen
[Konfigurationseigenschaften] → [C/C++] → [Common Language Runtime-Unterstützung] → Ändern in /clr

3. Ausführungscode (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 Zusätzliche Informationen (IDL / TLB / COM-Registrierung)

Diese Konfiguration verweist direkt auf die .NET-DLL anstelle von COM, daher ist keine IDL-, TLB- oder COM-Registrierung erforderlich .

✅ Endgültige Architektur

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → DLL-Aufruf

Verfahren zur Software-Wiederherstellung (Initialisierung/Reparatur) für Android (Google Pixel)-Geräte

Fri, 28 Feb 2025 01:20:41 +0900

Verfahren zur Wiederherstellung von Android (Google Pixel)-Geräten

Wenn Ihr Google Pixel-Gerät schwerwiegende Systemprobleme aufweist, wie z. B. “ständige Neustarts (Bootloop)”, “Hängenbleiben beim Logo-Bildschirm” oder “extrem instabiles Verhalten”, können Sie die Software des Geräts sicher über Ihren Browser reparieren (wiederherstellen), indem Sie das offizielle “Pixel Update and Software Repair” Tool von Google verwenden.

In diesem Artikel erklären wir die spezifischen Verfahren und Vorsichtsmaßnahmen im Detail.

1. Auf das Wiederherstellungstool zugreifen

Greifen Sie zunächst über den Browser Ihres PCs (Windows oder Mac) (Google Chrome oder Microsoft Edge wird empfohlen) auf die folgende offizielle Reparaturtool-Seite zu:

🔗 Offizielle Website von Pixel Update and Software Repair

※ Achtung ※ Bei der Ausführung des Wiederherstellungsprozesses können die Daten auf dem Gerät (Fotos, Apps, Kontakte usw.) vollständig gelöscht (initialisiert) werden. Wenn das Gerät noch bedienbar ist, führen Sie unbedingt vorher ein Backup in Google Drive oder Ähnlichem durch.

2. Vorbereitung vor der Wiederherstellung

Um einen reibungslosen Ablauf zu gewährleisten, bereiten Sie Folgendes vor:

Akku aufladen Wenn während des Vorgangs der Strom ausfällt, besteht die Gefahr, dass das Gerät unbrauchbar wird (Brick). Stellen Sie sicher, dass der Akku zu mindestens 50 % oder im Idealfall vollständig aufgeladen ist.
Verwendung des Original-USB-Kabels Um eine stabile Datenübertragung zu gewährleisten, wird dringend empfohlen, das mit dem Gerät gelieferte Original-USB-C-Kabel zu verwenden.
Treiberinstallation (falls erforderlich) Bei Verwendung eines Windows-PCs wird das Gerät möglicherweise nicht richtig erkannt. Installieren Sie in diesem Fall bitte die Google USB-Treiber.

3. Spezifische Schritte zur Wiederherstellung

Wenn Sie bereit sind, befolgen Sie die Anweisungen auf dem Bildschirm, um mit der Wiederherstellung fortzufahren.

Schritt 1: Mobilfunkanbieter auswählen und Gerät anschließen

Beim Öffnen der Website wird zunächst ein Bildschirm zur Auswahl des Mobilfunkanbieters angezeigt. Wenn es sich um ein entsperrtes Gerät oder ein Gerät ohne Vertragsbindung handelt, wählen Sie “Andere (Other)” usw. Schließen Sie danach den PC und das Pixel-Gerät mit einem USB-Kabel an.

Schritt 2: Das Gerät in den “Rescue Mode (Fastboot-Modus)” versetzen

Befolgen Sie die Anweisungen auf dem Bildschirm. Halten Sie bei ausgeschaltetem Gerät gleichzeitig die Ein-/Aus-Taste und die Leiser-Taste gedrückt , um den Fastboot-Modus zu starten (ein schwarzer Bildschirm mit einem liegenden Android-Roboter).

Schritt 3: Das Gerät vom PC erkennen lassen

Wenn Sie im Browser auf die Schaltfläche “Gerät verbinden” klicken, öffnet sich ein Pop-up-Fenster mit der Liste der angeschlossenen Pixel-Geräte. Wählen Sie das Zielgerät aus und lassen Sie die Verbindung zu.

Schritt 4: Software herunterladen und installieren

Sobald das Gerät erkannt wurde, wird automatisch die optimale Version des Android-Betriebssystems (Firmware) ausgewählt. Durch Klicken auf “Installieren” wird die Software auf den PC heruntergeladen und das Schreiben (Flashen) auf das Gerät beginnt sofort.

⚠️ Warnung: Ziehen Sie während dieses Vorgangs niemals das USB-Kabel ab und schalten Sie den PC nicht aus.

Schritt 5: Abschluss und Ersteinrichtung

Wenn der Fortschrittsbalken 100 % erreicht und die Meldung “Abgeschlossen” angezeigt wird, war die Wiederherstellung erfolgreich. Das Gerät wird automatisch neu gestartet und derselbe Ersteinrichtungsbildschirm (“Hallo”-Bildschirm) wie beim Kauf wird angezeigt.

Zusammenfassung

Das offizielle Reparaturtool für Google Pixel ist ein hervorragendes Tool, mit dem Sie Firmwares durch einfache Klicks im Browser sicher flashen können, ohne spezielle Befehle (adb oder fastboot) direkt eingeben zu müssen.

Bevor Sie Ihr Gerät wegen einer Fehlfunktion in ein Geschäft bringen, kann das Ausprobieren dieses Verfahrens das Problem möglicherweise leicht lösen. Probieren Sie es gerne aus.

Python-Code-Schnipsel

Mon, 24 Feb 2025 18:21:14 +0900

Einführung in Beispielcode mit der Standardbibliothek.

Ein Bild herunterladen und anzeigen

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


import urllib.request
import tempfile
import os
import webbrowser
import time

url = "https://www.aomori-ringo.or.jp/kids/wp-content/uploads/2021/11/apple.png"

try:
 with urllib.request.urlopen(url) as response:
 img_data = response.read()

 # In einer temporären Datei speichern und anzeigen
 with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
 tmp.write(img_data)
 print(f"file://{tmp.name}")
 webbrowser.open(f"file://{tmp.name}")
 time.sleep(3)
except Exception as e:
 print(f"Ein Fehler ist aufgetreten: {e}")

finally:
 if 'tmp' in locals():
 os.unlink(tmp.name) # Temporäre Datei löschen

ChatGPT API über curl aufrufen

Sat, 01 Feb 2025 17:15:34 +0900

ChatGPT API über curl aufrufen

Es wird davon ausgegangen, dass der Aufruf über die Windows-Eingabeaufforderung erfolgt.

1
2

curl https://api.openai.com/v1/chat/completions -H "Content-Type: application/json" -H "Authorization: Bearer sk-proj-XXXXXXXXXXXXXXXXXXXX" -d "{""model"": ""gpt-3.5-turbo"",""messages"": [{""role"": ""system"", ""content"": ""Bitte im Kansai-Dialekt antworten.""}, {""role"": ""user"", ""content"": ""Fügen Sie hier die Nachricht ein, die Sie senden möchten""}]}"

LoadIcon muss DestroyIcon nicht aufrufen

Fri, 19 Apr 2024 01:55:17 +0900

Über die Notwendigkeit, DestroyIcon aufzurufen

In folgenden Fällen ist es notwendig, DestroyIcon aufzurufen:

CreateIconFromResourceEx (wenn ohne das Flag LR_SHARED aufgerufen)
CreateIconIndirect
CopyIcon

Wenn durch die obigen Funktionen erstellt.

LoadIcon
LoadImage (wenn das Flag LR_SHARED verwendet wird)
CopyImage (wenn das Flag LR_COPYRETURNORG verwendet wird und der Parameter hImage ein freigegebenes Symbol ist)
CreateIconFromResource
CreateIconFromResourceEx (wenn das Flag LR_SHARED verwendet wird)

Symbole, die in den obigen Fällen erstellt und geladen wurden, dürfen DestroyIcon nicht aufrufen.

Referenz

DestroyIcon-Funktion (winuser.h)

Schriftartensammlung für die Programmierung

Sat, 30 Mar 2024 02:21:31 +0900

JetBrains Mono

Dies ist eine Open-Source-Programmierschriftart, die von JetBrains bereitgestellt wird.

Download: https://www.jetbrains.com/ja-jp/lp/mono/

HackGen

Hakugen (HackGen) ist eine Programmierschriftart, die die englische Schriftart für die Programmierung Hack mit der Schriftart GenJyuu Gothic, einem Derivat von Source Han Sans, kombiniert.

Download: https://github.com/yuru7/HackGen/releases

Ricty Diminished

Ricty Diminished ist eine Schwester-Schriftart von Ricty, die erstellt wurde, indem Inconsolata und Circle M+ 1m mit dem Ricty-Generierungsskript kombiniert wurden, anstelle von Inconsolata und Migu 1M. Da sie die Glyphen der IPA Gothic-Schriftart nicht enthält, verfügt sie über weniger verwendbare Kanji-Glyphen, kann aber im Gegenzug unter der SIL Open Font License verbreitet werden.

Download: https://rictyfonts.github.io/diminished

Cica

Alphanumerische Zeichen und Symbole verwenden Hack + DejaVu Sans Mono. Für andere Zeichen ist es eine Programmierschriftart, die Rounded Mgen+ verwendet.

Download: https://github.com/miiton/Cica/releases

Referenz:

Migu

Dies ist eine kombinierte Schriftart aus M+ und IPA.

Download: https://itouhiro.github.io/mixfont-mplus-ipa/migu/

Osaka

Es handelt sich um eine Schriftart, die es ermöglicht, die Mac OS-Standardschriftart Osaka unter Windows zu verwenden.

Download: http://ifs.nog.cc/osakattf.hp.infoseek.co.jp/

PlemolJP

Dies ist eine Programmierschriftart, die die Open-Source-Japanisch-Schriftart IBM Plex Sans JP, die von IBM veröffentlicht wurde, mit IBM Plex Mono aus der IBM Plex-Serie kombiniert.

Download: https://github.com/yuru7/PlemolJP/releases

Beispiel mit wxWidgets

Tue, 18 Apr 2023 00:18:22 +0900

Was ist wxWidgets

wxWidgets ist eine C++-GUI-Bibliothek, die auf Plattformen wie Windows, Mac, Linux, Android, iOS usw. funktioniert.

Installation von wxWidgets

Öffnen Sie https://www.wxwidgets.org/downloads/ und laden Sie den Windows Installer herunter.
Führen Sie wxMSW-3.2.2.1-Setup.exe aus, um es zu installieren.
Öffnen Sie “C:\wxWidgets-3.2.2.1\build\msw\wx_vc17.sln” aus dem installierten Ordner.
Nachdem Sie wx_vc17.sln geöffnet haben, wählen Sie Erstellen > Stapelverarbeitung.
Drücken Sie die Schaltfläche Alle auswählen und dann die Schaltfläche Neu erstellen.
Schließen Sie Visual Studio vorübergehend, nachdem der Build abgeschlossen ist.

Erstellung des Beispielprojekts

Öffnen Sie Visual Studio.
Wählen Sie Datei > Neu > Projekt.
Wählen Sie Windows-Desktopanwendung (Registerkarten sind C++, Windows, Desktop).
Geben Sie wxWidgetsSample unter Projektname ein.
Klicken Sie auf Erstellen.
Klicken Sie mit der rechten Maustaste auf wxWidgetsSample und wählen Sie Eigenschaften.
Fügen Sie unter Konfigurationseigenschaften > C/C++ > Zusätzliche Includeverzeichnisse C:\wxWidgets-3.2.2.1\include und C:\wxWidgets-3.2.2.1\include\msvc hinzu.
Fügen Sie unter Konfigurationseigenschaften > Linker > Zusätzliche Bibliotheksverzeichnisse C:\wxWidgets-3.2.2.1\lib\vc_x64_lib hinzu.
Öffnen Sie wxWidgetsSample.cpp und ersetzen Sie den Code durch den folgenden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

#include <wx/wxprec.h>

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

class MyApp : public wxApp
{
public:
 virtual bool OnInit();
};

class MyFrame : public wxFrame
{
public:
 MyFrame();
private:
 void OnHello(wxCommandEvent& event);
 void OnExit(wxCommandEvent& event);
 void OnAbout(wxCommandEvent& event);
};

enum
{
 ID_Hello = 1
};

wxIMPLEMENT_APP(MyApp);

bool MyApp::OnInit()
{
 MyFrame* frame = new MyFrame();
 frame->Show(true);
 return true;
}

MyFrame::MyFrame()
 : wxFrame(NULL, wxID_ANY, "Hello World")
{
 wxMenu* menuFile = new wxMenu;
 menuFile->Append(ID_Hello, "&Hello...\tCtrl-H",
 "Help string shown in status bar for this menu item");
 menuFile->AppendSeparator();
 menuFile->Append(wxID_EXIT);
 wxMenu* menuHelp = new wxMenu;
 menuHelp->Append(wxID_ABOUT);
 wxMenuBar* menuBar = new wxMenuBar;
 menuBar->Append(menuFile, "&File");
 menuBar->Append(menuHelp, "&Help");
 SetMenuBar(menuBar);

 wxButton* button1 = new wxButton(this, ID_Hello, _("Hello"), wxPoint(20, 20), wxSize(100, 32));
 Connect(ID_Hello, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnHello));

 wxButton* button2 = new wxButton(this, wxID_ABOUT, _("About"), wxPoint(20, 60), wxSize(100, 32));
 Connect(wxID_ABOUT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnAbout));

 wxButton* button3 = new wxButton(this, wxID_EXIT, _("Exit"), wxPoint(20, 100), wxSize(100, 32));
 Connect(wxID_EXIT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnExit));

 CreateStatusBar();
 SetStatusText("Welcome to wxWidgets!");
 Bind(wxEVT_MENU, &MyFrame::OnHello, this, ID_Hello);
 Bind(wxEVT_MENU, &MyFrame::OnAbout, this, wxID_ABOUT);
 Bind(wxEVT_MENU, &MyFrame::OnExit, this, wxID_EXIT);
}

void MyFrame::OnExit(wxCommandEvent& event)
{
 Close(true);
}

void MyFrame::OnAbout(wxCommandEvent& event)
{
 wxMessageBox("This is a wxWidgets' Hello world sample",
 "About Hello World", wxOK | wxICON_INFORMATION);
}

void MyFrame::OnHello(wxCommandEvent& event)
{
 wxLogMessage("Hello world from wxWidgets!");
}

Beim Kompilieren und Ausführen wird ein Fenster wie das untenstehende geöffnet.

Referenzen

Das Beispielprojekt ist unten verfügbar. wxWidgetsSample

Das ist alles.

Wie man die aktuelle Zeit im ISO 8601 Format in C++ ausgibt

Sat, 15 Apr 2023 19:35:27 +0900

Voraussetzungen

ISO C++ 20 Standard (/std:c++20)

Code

1
2
3
4


#include <chrono>
#include <format>

std::string datetime = std::format("{:%FT%TZ}", system_clock::now());

So können Sie die aktuelle Zeit im ISO 8601 Format in C++ ausgeben.

Referenzen

std::format

[Nach Sprache] Zusammenfassung der Online-Code-Ausführungsumgebungen

Sun, 09 Apr 2023 14:01:00 +0900

Python

Google Colaboratory

Google Colaboratory ist eine online verfügbare Python-Ausführungsumgebung.

Die Nutzung von GPUs ist ebenfalls möglich.
Mit Colab-Notebooks können Sie ausführbaren Code und Rich-Text (Bilder, HTML, LaTeX usw.) in einem einzigen Dokument schreiben.

Es basiert auf Jupyter Notebook.

Rust

Rust Playground

JavaScript

Javascript Playground

Java

paiza.IO Online Java compiler

Haskell

Haskell Playground

Swift

Online Swift Playground

C++

C++ 14

Sonstiges

AWS Cloud9

Eine von Amazon AWS bereitgestellte integrierte Online-Entwicklungsumgebung. Werkzeuge für über 40 Programmiersprachen wie Node.js, JavaScript, Python, PHP, Ruby, Go, C++ usw. sind vorpaketiert.

Visual Studio Code for the Web

Eine von Microsoft bereitgestellte Online-Entwicklungsumgebung. Sprachen, die kompiliert werden müssen, können jedoch weder ausgeführt noch debuggt werden.

paiza.IO

Eine Online-Ausführungsumgebung, die 24 Hauptsprachen wie C, C++, Java, Ruby, Python, PHP, Perl usw. unterstützt.

CodePen

Eine Online-Ausführungsumgebung für HTML, CSS und JavaScript.

codeanywhere

Eine Online-IDE. Ermöglicht Codefreigabe und Chat.

Wie man mit der Twitter API und Google Colaboratory twittert

Sat, 08 Apr 2023 18:48:32 +0900

Was Sie benötigen

Twitter API
Twitter API SECRET
Twitter ACCESS TOKEN
Twitter ACCESS TOKEN SECRET
Google-Konto

Besuchen Sie die Referenzseite, um zu erfahren, wie Sie die Twitter API erhalten.

Schritte zum Twittern mit der API

Gehen Sie zu https://colab.research.google.com/
Wählen Sie “Datei” -> “Neues Notizbuch”
Fügen Sie den folgenden Code ein und führen Sie ihn aus (bitte verwenden Sie Ihre eigenen tatsächlichen Werte)

1
2
3
4


API_KEY = '9Smu2f2RoLqbVQHQq6n79Z2JW'
API_SECRET = 'uGVRIkLL2l8sRyPv2Lr4mXxXppnQF1isMoRnvktcXCtFgAK2R8'
ACCESS_TOKEN = '0367292979164670705-7hSErDoQbO6fkFtnn5UY0vqpvecy0O'
ACCESS_TOKEN_SECRET = 'pUv81U9GVzZirz5g4AxZPHAJ4GpSXnBo8GUcZ1egtjw9q'

Fügen Sie den folgenden Code ein und führen Sie ihn aus

1

import tweepy

Fügen Sie den folgenden Code ein und führen Sie ihn aus (API v1.1)

1
2
3
4


auth = tweepy.OAuthHandler(API_KEY, API_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = tweepy.API(auth)
api.update_status("hello")

→ Ein Tweet mit dem Text hello wird gepostet.

Fügen Sie den folgenden Code ein und führen Sie ihn aus (API v2.0)

1
2


client = tweepy.Client(consumer_key=API_KEY, consumer_secret=API_SECRET, access_token=ACCESS_TOKEN, access_token_secret=ACCESS_TOKEN_SECRET)
client.create_tweet(text='hello v2')

→ Ein Tweet mit dem Text hello v2 wird gepostet.

Das ist alles.

Referenz

Wie man OpenSSL unter Windows kompiliert

Fri, 07 Apr 2023 21:06:32 +0900

Was ist OpenSSL?

Es ist eine Open-Source-Bibliothek, die die notwendige Verarbeitung für verschlüsselte Kommunikation bereitstellt.

Um es in einem Programm verwenden zu können, müssen Sie es kompilieren, um eine Bibliothek zu erstellen, da der C-Quellcode veröffentlicht wird.

Nachfolgend stellen wir den Kompilierungsvorgang vor.

Vorbereitung der Build-Umgebung

Perl

Laden Sie strawberry-perl-5.32.1.1-64bit.msi von https://strawberryperl.com/ herunter. Die neueste Version sollte in Ordnung sein.
NASM

Laden Sie 2.16.01/nasm-2.16.01-win64.zip unter Download von https://www.nasm.us/ herunter. Die neueste Non-RC-Version sollte in Ordnung sein. Nach der Installation müssen Sie den Ordner, in dem NASM installiert ist, in der Umgebungsvariablen PATH registrieren.
Visual Studio 2022 oder Build Tools for Visual Studio 2022

Installieren Sie Visual Studio 2022 Community oder Build Tools for Visual Studio 2022 von https://visualstudio.microsoft.com/ja/downloads/.

OpenSSL-Build-Prozedur unter Windows

Laden Sie openssl-3.1.0.tar.gz von https://www.openssl.org/source/ herunter und entpacken Sie es. Wenn Sie es nicht entpacken können, führen Sie tar -xzf openssl-3.1.0.tar.gz in der Eingabeaufforderung aus.
Starten Sie die Eingabeaufforderung mit Administratorrechten.
Öffnen Sie den entpackten Ordner.
Führen Sie den folgenden Befehl aus. *Ändern Sie den Teil Community, damit er Ihrer installierten Version von Visual Studio entspricht.

1

"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64

Führen Sie den folgenden Befehl aus:

1

perl Configure VC-WIN64A

Führen Sie den folgenden Befehl aus (dauert ziemlich lange):

1

nmake

Führen Sie den folgenden Befehl aus (dauert ziemlich lange):

1

nmake test

Führen Sie den folgenden Befehl aus:

1

nmake install

Wenn es erfolgreich war, wird OpenSSL in C:\Program Files\OpenSSL installiert.

Das ist alles.

Referenzen

https://ja.wikipedia.org/wiki/OpenSSL

Wie man Präsentationen mit HTML erstellt (reveal.js)

Thu, 06 Apr 2023 23:23:46 +0900

Wie man Präsentationen mit HTML erstellt

reveal.js ist ein Tool zur Erstellung von Präsentationen mit HTML und Markdown, das die folgenden Funktionen bietet:

Verschiedene Präsentationsfunktionen wie mathematische Formeln, Animationen und Wischgesten
Anpassbare Themes und Layouts
Navigationsfunktionen, die von mehreren Geräten wie Maus, Tastatur und Touchpad unterstützt werden
Bietet erweiterte Funktionen wie automatische Wiedergabe von Folien und eingebettete Videos
Kann im PDF-Format exportiert werden

Mit diesen Funktionen können Benutzer ganz einfach interaktive und ansprechende Präsentationen erstellen.

Installation und Nutzung von reveal.js

Der einfachste Weg, es zu nutzen, besteht darin, die gesamte ZIP-Datei von der folgenden Seite herunterzuladen und zu entpacken.

Öffnen Sie https://revealjs.com/installation und laden Sie die Datei master.zip über den Link herunter
Öffnen Sie die Datei index.html im extrahierten Ordner in einem Browser
Schreiben Sie die index.html um, um Ihr eigenes Präsentationsmaterial zu erstellen

※ Da der Demo-HTML-Code in demo.html geschrieben ist, können Sie ihn als Referenz verwenden.

Verwendungsmöglichkeiten

Die von Ihnen erstellten Präsentationen können als Webseiten veröffentlicht oder als PDFs exportiert werden. Da die Quelle der Präsentation aus Text besteht, lässt sie sich außerdem problemlos mit einem Versionskontrollsystem verwalten.

Es scheint auch möglich zu sein, Präsentationsmaterialien im Markdown-Format zu erstellen.

Referenzen

Wie man Illustrationsbilder mit KI (Stable Diffusion) generiert

Thu, 06 Apr 2023 00:43:19 +0900

Was ist Stable diffusion

Stable diffusion ist eine KI, die von einem Forschungsteam der Universität München, Deutschland, entwickelt wurde und Bilder aus eingegebenen Textinformationen generiert. Indem sie mit verschiedenen Bildern trainiert wurde, kann sie eine Vielzahl von Bildern generieren, von Fotos bis hin zu Illustrationen.

Dieses Mal werde ich vorstellen, wie man Illustrationsbilder mit den vortrainierten Daten von Stable diffusion generiert.

Was Sie benötigen

Google-Konto

Nur das

Generierungsverfahren

Öffnen Sie https://colab.research.google.com
Wählen Sie Datei oben links und dann Neues Notebook
Wählen Sie Bearbeiten und dann Notebook-Einstellungen
Ändern Sie den Hardwarebeschleuniger auf GPU
Fügen Sie den folgenden Code ein und führen Sie ihn aus

1

!pip install diffusers==0.8.0 transformers

Fügen Sie den folgenden Code ein und führen Sie ihn aus

1

from diffusers import StableDiffusionPipeline

Fügen Sie den folgenden Code ein und führen Sie ihn aus

1
2


pipe = StableDiffusionPipeline.from_pretrained("gsdf/Counterfeit-V2.5")
pipe.to("cuda")

Fügen Sie den folgenden Code ein und führen Sie ihn aus

1
2
3
4
5


prompt = "((masterpiece,best quality)),1girl, solo, animal ears, rabbit, barefoot, knees up, dress, sitting, rabbit ears, short sleeves, looking at viewer, grass, short hair, smile, white hair, puffy sleeves, outdoors, puffy short sleeves, bangs, on ground, full body, animal, white dress, sunlight, brown eyes, dappled sunlight, day, depth of field"
n_prompt = "EasyNegative, extra fingers,fewer fingers"

image = pipe(prompt, negative_prompt = n_prompt).images[0]
image

Der hier verwendete Prompt basiert auf dem Prompt von https://huggingface.co/gsdf/Counterfeit-V2.5.

Generierte Ergebnisse (einige)

Referenzen

Wie man rustc aktualisiert

Sat, 18 Mar 2023 10:27:02 +0900

Wie man rustc aktualisiert

Führen Sie einfach die folgende Zeile in der Befehlszeile aus.

1

rustup update

Ausgabereferenz

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


rustup update
info: syncing channel updates for 'stable-x86_64-pc-windows-msvc'
warning: Signature verification failed for 'https://static.rust-lang.org/dist/channel-rust-stable.toml'
info: latest update on 2023-03-09, rust version 1.68.0 (2c8cc3432 2023-03-06)
info: downloading component 'rust-src'
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
info: downloading component 'rust-std'
info: downloading component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 37.5 MiB/s in 1s ETA: 0s
info: downloading component 'rustfmt'
info: removing previous version of component 'rust-src'
info: removing previous version of component 'cargo'
info: removing previous version of component 'clippy'
info: removing previous version of component 'rust-docs'
info: removing previous version of component 'rust-std'
info: removing previous version of component 'rustc'
info: removing previous version of component 'rustfmt'
info: installing component 'rust-src'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 19.4 MiB / 19.4 MiB (100 %) 2.4 MiB/s in 6s ETA: 0s
info: installing component 'rust-std'
 27.6 MiB / 27.6 MiB (100 %) 12.7 MiB/s in 2s ETA: 0s
info: installing component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 13.8 MiB/s in 4s ETA: 0s
info: installing component 'rustfmt'
info: checking for self-updates
info: downloading self-update

 stable-x86_64-pc-windows-msvc updated - rustc 1.68.0 (2c8cc3432 2023-03-06) (from rustc 1.64.0 (a55dd71d5 2022-09-19))

info: cleaning up downloads & tmp directories

Eigenschaften von Rust

Mon, 03 Oct 2022 22:47:20 +0900

Eigenschaften von Rust

Eine relativ neue Open-Source-Programmiersprache, die von Mozilla entwickelt wird
Eine schnelle Sprache ohne Garbage Collection, die auf Systemprogrammierung spezialisiert ist
Garantiert Speichersicherheit durch einzigartige Mechanismen für Besitz (ownership) und Ausleihen (borrowing) als Teil der Sprachspezifikation
Funktioniert plattformübergreifend
Besitzt standardmäßig den hervorragenden Paketmanager Cargo

Ein einfaches Fenster in Rust anzeigen

Sat, 01 Oct 2022 19:08:58 +0900

Ein einfaches Fenster in Rust anzeigen

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "win"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies.winapi]
version = "0.3"
features = ["winuser"]

Der Quellcode ist unten

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


#![windows_subsystem = "windows"]
use winapi::{
 um::{
 winuser::{RegisterClassW, WNDCLASSW, CS_HREDRAW, CS_VREDRAW,
 LoadIconW, IDI_APPLICATION, LoadCursorW, IDC_ARROW,
 CreateWindowExW, ShowWindow, SW_NORMAL, UpdateWindow,
 GetMessageW, TranslateMessage, DispatchMessageW, MSG,
 WM_DESTROY, PostQuitMessage, DefWindowProcW, WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT},
 wingdi::{GetStockObject, WHITE_BRUSH},
 },
 shared::{
 windef::{HWND, HBRUSH},
 minwindef::{UINT, WPARAM, LPARAM, LRESULT},
 },
};
use std::ptr;
use std::mem;

fn main() {
 unsafe {
 let class_name = encode("my_window_class_name");
 if !register_wndclass(&class_name) {
 return;
 }
 let hwnd = create_window(&class_name);
 if hwnd.is_null() {
 return;
 }
 ShowWindow(hwnd, SW_NORMAL);
 UpdateWindow(hwnd);
 let mut msg = mem::uninitialized::<MSG>();
 loop {
 if GetMessageW(&mut msg, ptr::null_mut(), 0, 0) == 0 {
 return;
 }
 TranslateMessage(&mut msg);
 DispatchMessageW(&mut msg);
 }
 }
}

fn encode(source: &str) -> Vec<u16> {
 source.encode_utf16().chain(Some(0)).collect()
}

unsafe fn register_wndclass(class_name: &[u16]) -> bool {
 let mut winc = mem::zeroed::<WNDCLASSW>();
 winc.style = CS_HREDRAW | CS_VREDRAW;
 winc.lpfnWndProc = Some(win_proc);
 winc.hIcon = LoadIconW(ptr::null_mut(), IDI_APPLICATION);
 winc.hCursor = LoadCursorW(ptr::null_mut(), IDC_ARROW);
 winc.hbrBackground = GetStockObject(WHITE_BRUSH as i32) as HBRUSH;
 winc.lpszClassName = class_name.as_ptr();
 RegisterClassW(&winc) > 0
}

unsafe fn create_window(class_name: &[u16]) -> HWND {
 CreateWindowExW(
 0,
 class_name.as_ptr(),
 encode("Hello, World!").as_ptr(),
 WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 )
}

unsafe extern "system" fn win_proc(hwnd: HWND, msg: UINT, w_param: WPARAM, l_param: LPARAM) -> LRESULT {
 match msg {
 WM_DESTROY => PostQuitMessage(0),
 _ => return DefWindowProcW(hwnd, msg, w_param, l_param),
 };
 0
}

Referenzen

Windows-Programmierung in Rust - CreateWindow

Tests in Rust schreiben

Sat, 01 Oct 2022 02:00:59 +0900

Um Tests in Rust zu schreiben, erstellen Sie eine Funktion, indem Sie das Attribut #[test] eine Zeile über der Definition der Testfunktion hinzufügen.

1
2
3
4
5
6
7
8


fn plus(a:i32,b:i32)->i32 {
 a+b
}

#[test]
fn plus_test() {
 assert_eq!(plus(1, 1), 2);
}

Der Testcode kann mit cargo test ausgeführt werden. Wenn der Test erfolgreich ist, wird ok ausgegeben. Wenn er fehlschlägt, wird FAILED ausgegeben.

Im Erfolgsfall

1
2
3
4
5
6
7
8
9


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.35s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Im Fehlerfall

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.33s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... FAILED

failures:

---- plus_test stdout ----
thread 'plus_test' panicked at 'assertion failed: `(left == right)`
 left: `2`,
 right: `3`', src\main.rs:7:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
 plus_test

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass '--bin test1'

Anzeigen einer MessageBox in Rust

Fri, 30 Sep 2022 23:54:31 +0900

Sie können eine MessageBox in Rust anzeigen, indem Sie die folgenden Schritte ausführen.

Installieren Sie Rust. Siehe Erste Schritte mit Rust
Führen Sie cargo new --bin MessageBox in der Eingabeaufforderung aus.
Wechseln Sie in das Verzeichnis MessageBox.
Öffnen Sie Cargo.toml und ändern Sie es wie folgt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
winapi = "0.2.7"
user32-sys = "0.2.0"

Öffnen Sie src\main.rs und ändern Sie es wie folgt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


extern crate user32;
extern crate winapi;

use std::ffi::CString;
use user32::MessageBoxA;
use winapi::winuser::{MB_OK, MB_ICONINFORMATION};

fn main() {
 let lp_text = CString::new("Hello, world!").unwrap();
 let lp_caption = CString::new("MessageBox Example").unwrap();

 unsafe {
 MessageBoxA(
 std::ptr::null_mut(),
 lp_text.as_ptr(),
 lp_caption.as_ptr(),
 MB_OK | MB_ICONINFORMATION
 );
 }
}

Führen Sie cargo run in der Eingabeaufforderung aus.
Um einen Release-Build zu erstellen, führen Sie cargo build --release aus.

Referenz

Hello World MesssageBox example in Rust

Fenstertitel auflisten

Tue, 20 Sep 2022 17:03:15 +0900

Fenstertitel auflisten

Hier erfahren Sie, wie Sie mit PowerShell die Titel der aktuell geöffneten Fenster auflisten können.

1

Get-Process|where{$_.mainWindowTItle}|Select-Object MainWindowTitle

Ausgabebeispiel

1
2
3
4
5
6
7
8
9


MainWindowTitle
---------------
Windows PowerShell
Internet Explorer
Unbenannt - Paint
Unbenannt - Editor
Task-Manager
Windows-Eingabeumgebung
Dokument - WordPad

.DS_Store stapelweise löschen mit PowerShell

Mon, 12 Sep 2022 10:11:42 +0900

Wechseln Sie in das Zielverzeichnis und führen Sie den folgenden Befehl aus, um .DS_Store-Dateien einschließlich der in Unterordnern stapelweise zu löschen.

1

Get-ChildItem . -include '.DS_Store' -Recurse -Force | Remove-Item -Force

Wie man Go installiert

Sat, 10 Sep 2022 00:48:17 +0900

Einführung

Go ist eine relativ neue Programmiersprache, die 2009 von Google veröffentlicht wurde. Der Compiler, die Werkzeuge und die Bibliotheken von Go sind Open Source. Darüber hinaus ist Go eine statisch typisierte Sprache wie C oder Java, aber sie verwendet keine Zeiger wie die C-Sprache.

Installationsmethode

Go installieren

Auf der obigen Website stehen Installationsprogramme für jede Plattform zur Verfügung.

Befolgen Sie die Anweisungen auf dem Bildschirm, um mit der Installation fortzufahren.

Die Installation ist abgeschlossen. Einfach, oder?

Erstes Programm

Speichern Sie das folgende Programm als hello.go.

1
2
3
4
5
6
7


package main

import "fmt"

func main() {
 fmt.Printf("Hello World\n")
}

Wenn Sie go run hello.go über die Eingabeaufforderung oder das Terminal ausführen, wird Hello, world! ausgegeben.

Beim Kompilieren wird durch Ausführen von go build hello.go die Datei hello.exe generiert. Wenn Sie hello.exe ausführen, wird Hello, world! ausgegeben.

Sie können Code auch auf einer Webseite ausführen

https://go.dev/play/

Japanische Dokumentation

http://go.shibu.jp/

Die Erklärungen, die zum Erlernen von Go erforderlich sind, sind im obigen Link (japanische übersetzte Version) zusammengefasst. Die mit Go verbundene Technologie ist so offen und umfassend, dass fast keine Notwendigkeit besteht, gedruckte Texte zu kaufen.

Dann, viel Spaß mit Go!

Aufzählung von Primzahlen in Rust

Fri, 09 Sep 2022 07:08:49 +0900

Ich habe ein Programm geschrieben, um Primzahlen in Rust aufzuzählen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}

Wie man mit Rust anfängt

Tue, 06 Sep 2022 00:12:36 +0900

Einführung

Rust ist eine relativ neue Programmiersprache, mit der Sie schnelle und speichereffiziente Module mit moderner Syntax schreiben können. Es ist plattformübergreifend und wird auch in der Welt von WebAssembly und eingebetteten Systemen verwendet. Bekanntermaßen wird es von Firefox, DropBox und Cloudflare eingesetzt.

Es zieht auch als Alternative zu C++ Aufmerksamkeit auf sich.

Wie man installiert

Rust installieren

Die obige Website bietet Installationsanweisungen für jede Plattform.

Erstes Programm

Speichern Sie das folgende Programm als main.rs.

1
2
3


fn main() {
 println!("Hello, world!");
}

Wenn Sie rustc main.rs über die Eingabeaufforderung oder das Terminal ausführen, wird es kompiliert. Die Ausführung von ./main (oder main.exe unter Windows) gibt Hello, world! aus.

Japanische Dokumentation

The Rust Programming Language Japanische Ausgabe

Die Erklärungen, die zum Erlernen von Rust notwendig sind, sind unter dem obigen Link (japanisch übersetzte Version) zusammengestellt. Sie ist so umfassend, dass Sie kein Buch über Rust kaufen müssen.

Wenn Sie es im Web ausprobieren möchten

Wenn Sie es im Web ausprobieren möchten, ohne den Compiler zu installieren, können Sie The Rust Playground verwenden. Nach der Eingabe des Codes und dem Klicken auf die Schaltfläche “Run” wird er im Web kompiliert und ausgeführt.

Programmierung on kenji.blog

So entfernen Sie Metadaten (persönliche Informationen) stapelweise aus Excel, Word usw. mit PowerShell

“So entfernen Sie Metadaten (persönliche Informationen) stapelweise aus Excel, Word usw. mit PowerShell”

1. Entfernen von Metadaten aus einer einzelnen Excel-Datei

2. Stapelverarbeitung aller Excel-Dateien in einem Ordner

3. Entfernen von Metadaten aus anderen Office-Dateien (Word / PowerPoint)

Für Word

Für PowerPoint

Fazit

Schritte, um TinyLLaMA aus C++ aufzurufen (unter Verwendung von llama.cpp)

✅ Einrichtung von TinyLLaMA × C++ (mit llama.cpp)

🔧 Schritt 1: llama.cpp vorbereiten

1-1. Erforderliche Umgebung (Minimum)

1-2. llama.cpp abrufen und kompilieren

📦 Schritt 2: TinyLLaMA-Modell herunterladen und konvertieren

2-1. Originalmodell von HuggingFace beziehen

2-2. In das GGUF-Format konvertieren (für llama.cpp)

2-3. Modellquantisierung (Größenreduzierung)

🧪 Schritt 3: Das Modell aus C++ aufrufen (Codebeispiel)

3-1. Einfacher C++-Code (Inferenz)

🧱 Schritt 4: Kompilierungsmethode (Beispiel)

✅ Beispiel für die Struktur der Artefakte (Organisation)

🧠 Zusätzliche Hinweise zur Anwendung auf Anwendungsfälle

📌 Zusammenfassung

Vor- und Nachteile der Programmerstellung mit Win32API + C++

Der Reiz und die Herausforderungen der Entwicklung mit Win32API + C++

Vorteile

Ultraschnelle Native Ausführung

Hohe Flexibilität und Freiheit

Einfach zu Verteilen Ohne Laufzeitbedarf

Kann Leichtgewichtige Apps Erstellen

Fortgeschrittene Steuerung auf Betriebssystemebene Möglich

Nachteile

Geringe Entwicklungseffizienz

Leicht Verringerte Wartbarkeit

Schwierige Unterstützung Moderner UI

Keine Plattformübergreifende Unterstützung

Extrem Hohe Lernkosten

Geeignete Anwendungen

Ungeeignete Anwendungen

Bewertungszusammenfassung

Fazit

FizzBuzz

Was genau ist eigentlich FizzBuzz?

Stimmt es, dass man „als Programmierer versagt hat, wenn man FizzBuzz nicht schreiben kann“?

Es geht nicht um das Können, sondern darum, ob man den „Zustand“ dafür hat

Die Falle des üblichen Ratschlags „Einfach üben, dann wird alles gut“

Abgesehen davon ist FizzBuzz immer noch eine gute Frage

Zusammenfassend

Türme von Hanoi

Türme von Hanoi

Was sind die Türme von Hanoi?

Lösen wir die Türme von Hanoi mit Python

Wie lange dauert es, 64 Scheiben zu bewegen?

Zusammenfassung

Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL

🎯 Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL (Visual Studio 2022 / C++)

✅ Gesamtarchitektur

🔹 ① CLI-Wrapper-DLL (C++/CLI)

🔹 ② Nativer C++-Aufrufer

🔧 Schritt 1: Erstellen des CLI-Wrapper-DLL-Projekts

1. Projekt erstellen

2. NuGet-Paket hinzufügen

3. Implementierung des CLI-Codes

PowerShellWrapper.h

PowerShellWrapper.cpp

🔧 Schritt 2: Aufruf aus nativem C++

1. Erstellen des C++-Konsolen-App-Projekts

2. Referenzeinstellungen

3. Ausführungscode (main.cpp)

💡 Zusätzliche Informationen (IDL / TLB / COM-Registrierung)

✅ Endgültige Architektur

Verfahren zur Software-Wiederherstellung (Initialisierung/Reparatur) für Android (Google Pixel)-Geräte

Verfahren zur Wiederherstellung von Android (Google Pixel)-Geräten

1. Auf das Wiederherstellungstool zugreifen

2. Vorbereitung vor der Wiederherstellung

3. Spezifische Schritte zur Wiederherstellung

Schritt 1: Mobilfunkanbieter auswählen und Gerät anschließen

Schritt 2: Das Gerät in den “Rescue Mode (Fastboot-Modus)” versetzen

Schritt 3: Das Gerät vom PC erkennen lassen

✅ Einrichtung von TinyLLaMA × C++ (mit `llama.cpp`)

2-2. In das GGUF-Format konvertieren (für `llama.cpp`)