diff --git a/build/test/cache/defines_dependency.yml b/build/test/cache/defines_dependency.yml
index a81d8fc..d7ae090 100644
--- a/build/test/cache/defines_dependency.yml
+++ b/build/test/cache/defines_dependency.yml
@@ -7,3 +7,5 @@ src/zahlenraten.c:
 - TEST
 src/SchereSteinPapier.c:
 - TEST
+src/WortSpiel.c:
+- TEST
diff --git a/build/test/cache/test_WortSpiel.c b/build/test/cache/test_WortSpiel.c
new file mode 100644
index 0000000..5389a8d
--- /dev/null
+++ b/build/test/cache/test_WortSpiel.c
@@ -0,0 +1,223 @@
+#include "src/WortSpiel.h"
+#include "C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h"
+
+
+
+
+
+
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testLoescheBuchstaben_Buchstabeexistiert(void) {
+
+
+
+    char wort1[] = "Beispiel";
+
+    loescheBuchstaben(wort1, 'i');
+
+    UnityAssertEqualString((const char*)(("Bespel")), (const char*)((wort1)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(19));
+
+}
+
+
+
+void testLoescheBuchstaben_Buchstabeexistiertnicht(void) {
+
+    char wort2[] = "Test";
+
+    loescheBuchstaben(wort2, 'z');
+
+    UnityAssertEqualString((const char*)(("Test")), (const char*)((wort2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(25));
+
+}
+
+
+
+void testLoescheBuchstaben_Leereswort(void) {
+
+  char wort3[] = "";
+
+    loescheBuchstaben(wort3, 'a');
+
+    UnityAssertEqualString((const char*)(("")), (const char*)((wort3)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(31));
+
+}
+
+
+
+void testZaehleBuchstaben_Buchstabenexistiert(void) {
+
+
+
+    char wort1[] = "Beispiel";
+
+    int anzahl1 = zaehleBuchstaben(wort1, 'i');
+
+    UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((anzahl1)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(38), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testZaehleBuchstaben_Buchstabenexistiertnicht(void) {
+
+    char wort2[] = "Test";
+
+    int anzahl2 = zaehleBuchstaben(wort2, 'z');
+
+    UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((anzahl2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(44), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testZaehleBuchstaben_Leereswort(void) {
+
+    char wort2[] = "Test";
+
+    int anzahl2 = zaehleBuchstaben(wort2, 'z');
+
+    UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((anzahl2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(50), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testUmdrehenWort_normalesWort(void) {
+
+
+
+    char wort1[] = "Hello";
+
+    umdrehenWort(wort1);
+
+    UnityAssertEqualString((const char*)(("olleH")), (const char*)((wort1)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(57));
+
+}
+
+
+
+void testUmdrehenWort_leeresWort(void) {
+
+    char wort2[] = "";
+
+    umdrehenWort(wort2);
+
+    UnityAssertEqualString((const char*)(("")), (const char*)((wort2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(63));
+
+}
+
+
+
+void testUmdrehenWort_einBuchstabe(void) {
+
+    char wort3[] = "A";
+
+    umdrehenWort(wort3);
+
+    UnityAssertEqualString((const char*)(("A")), (const char*)((wort3)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(69));
+
+}
+
+
+
+void testSucheBuchstabe_existiert(void) {
+
+    char wort1[] = "Programming";
+
+    int position = sucheBuchstabe(wort1, 'g');
+
+    UnityAssertEqualNumber((UNITY_INT)((3)), (UNITY_INT)((position)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(75), UNITY_DISPLAY_STYLE_INT);
+
+
+
+}
+
+
+
+void testSucheBuchstabe_existiertnicht(void) {
+
+    char wort2[] = "Testing";
+
+    int position = sucheBuchstabe(wort2, 'z');
+
+    UnityAssertEqualNumber((UNITY_INT)((-1)), (UNITY_INT)((position)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(82), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testSucheBuchstabe_leeresWort(void) {
+
+    char wort3[] = "";
+
+    int position = sucheBuchstabe(wort3, 'a');
+
+    UnityAssertEqualNumber((UNITY_INT)((-1)), (UNITY_INT)((position)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(88), UNITY_DISPLAY_STYLE_INT);
+
+}
diff --git a/build/test/dependencies/WortSpiel.d b/build/test/dependencies/WortSpiel.d
new file mode 100644
index 0000000..08b6a08
--- /dev/null
+++ b/build/test/dependencies/WortSpiel.d
@@ -0,0 +1 @@
+build/test/out/c/WortSpiel.o: src/WortSpiel.c src/WortSpiel.h
diff --git a/build/test/dependencies/test_WortSpiel.d b/build/test/dependencies/test_WortSpiel.d
new file mode 100644
index 0000000..2db99e5
--- /dev/null
+++ b/build/test/dependencies/test_WortSpiel.d
@@ -0,0 +1,4 @@
+build/test/out/c/test_WortSpiel.o: test/test_WortSpiel.c \
+ C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h \
+ C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity_internals.h \
+ src/WortSpiel.h
diff --git a/build/test/dependencies/test_WortSpiel_runner.d b/build/test/dependencies/test_WortSpiel_runner.d
new file mode 100644
index 0000000..b41d36c
--- /dev/null
+++ b/build/test/dependencies/test_WortSpiel_runner.d
@@ -0,0 +1,4 @@
+build/test/out/c/test_WortSpiel_runner.o: \
+ build/test/runners/test_WortSpiel_runner.c \
+ C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h \
+ C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity_internals.h
diff --git a/build/test/out/c/WortSpiel.o b/build/test/out/c/WortSpiel.o
new file mode 100644
index 0000000..77fbdcf
Binary files /dev/null and b/build/test/out/c/WortSpiel.o differ
diff --git a/build/test/out/c/test_WortSpiel.o b/build/test/out/c/test_WortSpiel.o
new file mode 100644
index 0000000..a88a13f
Binary files /dev/null and b/build/test/out/c/test_WortSpiel.o differ
diff --git a/build/test/out/c/test_WortSpiel_runner.o b/build/test/out/c/test_WortSpiel_runner.o
new file mode 100644
index 0000000..7f06cfe
Binary files /dev/null and b/build/test/out/c/test_WortSpiel_runner.o differ
diff --git a/build/test/out/test_SchereSteinPapier.out b/build/test/out/test_SchereSteinPapier.out
index f080fdc..c34d366 100644
Binary files a/build/test/out/test_SchereSteinPapier.out and b/build/test/out/test_SchereSteinPapier.out differ
diff --git a/build/test/out/test_WortSpiel.out b/build/test/out/test_WortSpiel.out
new file mode 100644
index 0000000..9975f14
Binary files /dev/null and b/build/test/out/test_WortSpiel.out differ
diff --git a/build/test/out/test_ageinseconds.out b/build/test/out/test_ageinseconds.out
index 56606b6..e2d675c 100644
Binary files a/build/test/out/test_ageinseconds.out and b/build/test/out/test_ageinseconds.out differ
diff --git a/build/test/out/test_minirechner.out b/build/test/out/test_minirechner.out
index e3a27d6..ae5ee8b 100644
Binary files a/build/test/out/test_minirechner.out and b/build/test/out/test_minirechner.out differ
diff --git a/build/test/out/test_zahlenraten.out b/build/test/out/test_zahlenraten.out
index 0417dd4..0649942 100644
Binary files a/build/test/out/test_zahlenraten.out and b/build/test/out/test_zahlenraten.out differ
diff --git a/build/test/preprocess/files/test_WortSpiel.c b/build/test/preprocess/files/test_WortSpiel.c
new file mode 100644
index 0000000..5389a8d
--- /dev/null
+++ b/build/test/preprocess/files/test_WortSpiel.c
@@ -0,0 +1,223 @@
+#include "src/WortSpiel.h"
+#include "C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h"
+
+
+
+
+
+
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testLoescheBuchstaben_Buchstabeexistiert(void) {
+
+
+
+    char wort1[] = "Beispiel";
+
+    loescheBuchstaben(wort1, 'i');
+
+    UnityAssertEqualString((const char*)(("Bespel")), (const char*)((wort1)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(19));
+
+}
+
+
+
+void testLoescheBuchstaben_Buchstabeexistiertnicht(void) {
+
+    char wort2[] = "Test";
+
+    loescheBuchstaben(wort2, 'z');
+
+    UnityAssertEqualString((const char*)(("Test")), (const char*)((wort2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(25));
+
+}
+
+
+
+void testLoescheBuchstaben_Leereswort(void) {
+
+  char wort3[] = "";
+
+    loescheBuchstaben(wort3, 'a');
+
+    UnityAssertEqualString((const char*)(("")), (const char*)((wort3)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(31));
+
+}
+
+
+
+void testZaehleBuchstaben_Buchstabenexistiert(void) {
+
+
+
+    char wort1[] = "Beispiel";
+
+    int anzahl1 = zaehleBuchstaben(wort1, 'i');
+
+    UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((anzahl1)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(38), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testZaehleBuchstaben_Buchstabenexistiertnicht(void) {
+
+    char wort2[] = "Test";
+
+    int anzahl2 = zaehleBuchstaben(wort2, 'z');
+
+    UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((anzahl2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(44), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testZaehleBuchstaben_Leereswort(void) {
+
+    char wort2[] = "Test";
+
+    int anzahl2 = zaehleBuchstaben(wort2, 'z');
+
+    UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((anzahl2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(50), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testUmdrehenWort_normalesWort(void) {
+
+
+
+    char wort1[] = "Hello";
+
+    umdrehenWort(wort1);
+
+    UnityAssertEqualString((const char*)(("olleH")), (const char*)((wort1)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(57));
+
+}
+
+
+
+void testUmdrehenWort_leeresWort(void) {
+
+    char wort2[] = "";
+
+    umdrehenWort(wort2);
+
+    UnityAssertEqualString((const char*)(("")), (const char*)((wort2)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(63));
+
+}
+
+
+
+void testUmdrehenWort_einBuchstabe(void) {
+
+    char wort3[] = "A";
+
+    umdrehenWort(wort3);
+
+    UnityAssertEqualString((const char*)(("A")), (const char*)((wort3)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(69));
+
+}
+
+
+
+void testSucheBuchstabe_existiert(void) {
+
+    char wort1[] = "Programming";
+
+    int position = sucheBuchstabe(wort1, 'g');
+
+    UnityAssertEqualNumber((UNITY_INT)((3)), (UNITY_INT)((position)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(75), UNITY_DISPLAY_STYLE_INT);
+
+
+
+}
+
+
+
+void testSucheBuchstabe_existiertnicht(void) {
+
+    char wort2[] = "Testing";
+
+    int position = sucheBuchstabe(wort2, 'z');
+
+    UnityAssertEqualNumber((UNITY_INT)((-1)), (UNITY_INT)((position)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(82), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void testSucheBuchstabe_leeresWort(void) {
+
+    char wort3[] = "";
+
+    int position = sucheBuchstabe(wort3, 'a');
+
+    UnityAssertEqualNumber((UNITY_INT)((-1)), (UNITY_INT)((position)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(88), UNITY_DISPLAY_STYLE_INT);
+
+}
diff --git a/build/test/preprocess/includes/test_WortSpiel.c b/build/test/preprocess/includes/test_WortSpiel.c
new file mode 100644
index 0000000..eeb7242
--- /dev/null
+++ b/build/test/preprocess/includes/test_WortSpiel.c
@@ -0,0 +1,3 @@
+---
+- C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h
+- src/WortSpiel.h
diff --git a/build/test/results/test_SchereSteinPapier.pass b/build/test/results/test_SchereSteinPapier.pass
index 258ffd9..2e37765 100644
--- a/build/test/results/test_SchereSteinPapier.pass
+++ b/build/test/results/test_SchereSteinPapier.pass
@@ -19,4 +19,4 @@
   :failed: 0
   :ignored: 0
 :stdout: []
-:time: 0.8575828000011825
+:time: 0.04579279999961727
diff --git a/build/test/results/test_WortSpiel.pass b/build/test/results/test_WortSpiel.pass
new file mode 100644
index 0000000..8af2c88
--- /dev/null
+++ b/build/test/results/test_WortSpiel.pass
@@ -0,0 +1,62 @@
+---
+:source:
+  :path: test
+  :file: test_WortSpiel.c
+:successes:
+- :test: testLoescheBuchstaben_Buchstabeexistiert
+  :line: 15
+  :message: ''
+  :unity_test_time: 0
+- :test: testLoescheBuchstaben_Buchstabeexistiertnicht
+  :line: 22
+  :message: ''
+  :unity_test_time: 0
+- :test: testLoescheBuchstaben_Leereswort
+  :line: 28
+  :message: ''
+  :unity_test_time: 0
+- :test: testZaehleBuchstaben_Buchstabenexistiert
+  :line: 34
+  :message: ''
+  :unity_test_time: 0
+- :test: testZaehleBuchstaben_Buchstabenexistiertnicht
+  :line: 41
+  :message: ''
+  :unity_test_time: 0
+- :test: testZaehleBuchstaben_Leereswort
+  :line: 47
+  :message: ''
+  :unity_test_time: 0
+- :test: testUmdrehenWort_normalesWort
+  :line: 53
+  :message: ''
+  :unity_test_time: 0
+- :test: testUmdrehenWort_leeresWort
+  :line: 60
+  :message: ''
+  :unity_test_time: 0
+- :test: testUmdrehenWort_einBuchstabe
+  :line: 66
+  :message: ''
+  :unity_test_time: 0
+- :test: testSucheBuchstabe_existiert
+  :line: 72
+  :message: ''
+  :unity_test_time: 0
+- :test: testSucheBuchstabe_existiertnicht
+  :line: 79
+  :message: ''
+  :unity_test_time: 0
+- :test: testSucheBuchstabe_leeresWort
+  :line: 85
+  :message: ''
+  :unity_test_time: 0
+:failures: []
+:ignores: []
+:counts:
+  :total: 12
+  :passed: 12
+  :failed: 0
+  :ignored: 0
+:stdout: []
+:time: 0.8378995999992185
diff --git a/build/test/results/test_ageinseconds.pass b/build/test/results/test_ageinseconds.pass
index 0eeae5e..601e23f 100644
--- a/build/test/results/test_ageinseconds.pass
+++ b/build/test/results/test_ageinseconds.pass
@@ -23,4 +23,4 @@
   :failed: 0
   :ignored: 0
 :stdout: []
-:time: 0.04093739999916579
+:time: 0.04312009999921429
diff --git a/build/test/results/test_minirechner.pass b/build/test/results/test_minirechner.pass
index 138bb1e..dc1f5bc 100644
--- a/build/test/results/test_minirechner.pass
+++ b/build/test/results/test_minirechner.pass
@@ -83,4 +83,4 @@
   :failed: 0
   :ignored: 0
 :stdout: []
-:time: 0.04128909999963071
+:time: 0.04265739999937068
diff --git a/build/test/results/test_zahlenraten.pass b/build/test/results/test_zahlenraten.pass
index d0e87e9..bd03a75 100644
--- a/build/test/results/test_zahlenraten.pass
+++ b/build/test/results/test_zahlenraten.pass
@@ -15,4 +15,4 @@
   :failed: 0
   :ignored: 0
 :stdout: []
-:time: 0.04106339999998454
+:time: 0.0429972000001726
diff --git a/build/test/runners/test_WortSpiel_runner.c b/build/test/runners/test_WortSpiel_runner.c
new file mode 100644
index 0000000..fe9dca7
--- /dev/null
+++ b/build/test/runners/test_WortSpiel_runner.c
@@ -0,0 +1,103 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+
+/*=======Automagically Detected Files To Include=====*/
+#include "unity.h"
+
+int GlobalExpectCount;
+int GlobalVerifyOrder;
+char* GlobalOrderError;
+
+/*=======External Functions This Runner Calls=====*/
+extern void setUp(void);
+extern void tearDown(void);
+extern void testLoescheBuchstaben_Buchstabeexistiert(void);
+extern void testLoescheBuchstaben_Buchstabeexistiertnicht(void);
+extern void testLoescheBuchstaben_Leereswort(void);
+extern void testZaehleBuchstaben_Buchstabenexistiert(void);
+extern void testZaehleBuchstaben_Buchstabenexistiertnicht(void);
+extern void testZaehleBuchstaben_Leereswort(void);
+extern void testUmdrehenWort_normalesWort(void);
+extern void testUmdrehenWort_leeresWort(void);
+extern void testUmdrehenWort_einBuchstabe(void);
+extern void testSucheBuchstabe_existiert(void);
+extern void testSucheBuchstabe_existiertnicht(void);
+extern void testSucheBuchstabe_leeresWort(void);
+
+
+/*=======Mock Management=====*/
+static void CMock_Init(void)
+{
+  GlobalExpectCount = 0;
+  GlobalVerifyOrder = 0;
+  GlobalOrderError = NULL;
+}
+static void CMock_Verify(void)
+{
+}
+static void CMock_Destroy(void)
+{
+}
+
+/*=======Test Reset Options=====*/
+void resetTest(void);
+void resetTest(void)
+{
+  tearDown();
+  CMock_Verify();
+  CMock_Destroy();
+  CMock_Init();
+  setUp();
+}
+void verifyTest(void);
+void verifyTest(void)
+{
+  CMock_Verify();
+}
+
+/*=======Test Runner Used To Run Each Test=====*/
+static void run_test(UnityTestFunction func, const char* name, UNITY_LINE_TYPE line_num)
+{
+    Unity.CurrentTestName = name;
+    Unity.CurrentTestLineNumber = line_num;
+#ifdef UNITY_USE_COMMAND_LINE_ARGS
+    if (!UnityTestMatches())
+        return;
+#endif
+    Unity.NumberOfTests++;
+    UNITY_CLR_DETAILS();
+    UNITY_EXEC_TIME_START();
+    CMock_Init();
+    if (TEST_PROTECT())
+    {
+        setUp();
+        func();
+    }
+    if (TEST_PROTECT())
+    {
+        tearDown();
+        CMock_Verify();
+    }
+    CMock_Destroy();
+    UNITY_EXEC_TIME_STOP();
+    UnityConcludeTest();
+}
+
+/*=======MAIN=====*/
+int main(void)
+{
+  UnityBegin("test_WortSpiel.c");
+  run_test(testLoescheBuchstaben_Buchstabeexistiert, "testLoescheBuchstaben_Buchstabeexistiert", 15);
+  run_test(testLoescheBuchstaben_Buchstabeexistiertnicht, "testLoescheBuchstaben_Buchstabeexistiertnicht", 22);
+  run_test(testLoescheBuchstaben_Leereswort, "testLoescheBuchstaben_Leereswort", 28);
+  run_test(testZaehleBuchstaben_Buchstabenexistiert, "testZaehleBuchstaben_Buchstabenexistiert", 34);
+  run_test(testZaehleBuchstaben_Buchstabenexistiertnicht, "testZaehleBuchstaben_Buchstabenexistiertnicht", 41);
+  run_test(testZaehleBuchstaben_Leereswort, "testZaehleBuchstaben_Leereswort", 47);
+  run_test(testUmdrehenWort_normalesWort, "testUmdrehenWort_normalesWort", 53);
+  run_test(testUmdrehenWort_leeresWort, "testUmdrehenWort_leeresWort", 60);
+  run_test(testUmdrehenWort_einBuchstabe, "testUmdrehenWort_einBuchstabe", 66);
+  run_test(testSucheBuchstabe_existiert, "testSucheBuchstabe_existiert", 72);
+  run_test(testSucheBuchstabe_existiertnicht, "testSucheBuchstabe_existiertnicht", 79);
+  run_test(testSucheBuchstabe_leeresWort, "testSucheBuchstabe_leeresWort", 85);
+
+  return UnityEnd();
+}
diff --git a/src/WortSpiel.c b/src/WortSpiel.c
new file mode 100644
index 0000000..3f9394f
--- /dev/null
+++ b/src/WortSpiel.c
@@ -0,0 +1,86 @@
+#include "WortSpiel.h"
+#include <stdio.h>
+#include <string.h>
+
+//Funktion zum loeschen von einem Buchstaben
+void loescheBuchstaben(char *wort, char buchstabe) {
+    int laenge = strlen(wort);
+    int i, j = 0;
+
+    for (i = 0; i < laenge; i++) {
+        if (wort[i] != buchstabe) {
+            wort[j++] = wort[i];
+        }
+    }
+
+    wort[j] = '\0';
+}
+
+//Funktion zum zaehlen wie oft ein Buchstabe vorkommt
+int zaehleBuchstaben(const char *wort, char buchstabe) {
+    int zaehler = 0;
+    int laenge = strlen(wort);
+
+    while (*wort) {
+        if (*wort == buchstabe) {
+            zaehler++;
+        }
+        wort++;
+    }
+
+    return zaehler;
+}
+//Funktion zum Umdrehen der Wörter
+void umdrehenWort(char *wort) {
+    int laenge = strlen(wort);
+
+    for (int i = 0, j = laenge - 1; i < j; i++, j--) {
+        char temp = wort[i];
+        wort[i] = wort[j];
+        wort[j] = temp;
+    }
+}
+//Funktion zum suchen von einem Buchstaben
+int sucheBuchstabe(const char *wort, char buchstabe) {
+    int laenge = strlen(wort);
+
+    for (int i = 0; i < laenge; i++) {
+        if (wort[i] == buchstabe) {
+            return i;
+        }
+    }
+
+    return -1; // Buchstabe nicht gefunden
+}
+
+int run_wortspiel() {
+    char wort[50];
+    char buchstabe;
+
+    printf("Gib ein Wort ein: ");
+    scanf("%s", wort);
+
+    printf("Gib den zu löschenden Buchstaben ein: ");
+    scanf(" %c", &buchstabe);  
+
+    loescheBuchstaben(wort, buchstabe);
+
+    printf("Wort nach dem Löschen des Buchstabens: %s\n", wort);
+
+    int anzahl = zaehleBuchstaben(wort, buchstabe);
+    printf("Der Buchstabe '%c' kommt %d Mal vor.\n", buchstabe, anzahl);
+
+    umdrehenWort(wort);
+    printf("Wort nach dem Umdrehen: %s\n", wort);
+
+    int index = sucheBuchstabe(wort, buchstabe);
+    if (index != -1) {
+        printf("Der Buchstabe '%c' wurde an der Position %d gefunden.\n", buchstabe, index);
+    } else {
+        printf("Der Buchstabe '%c' wurde nicht gefunden.\n", buchstabe);
+    }
+
+
+    
+    return 0;
+}
\ No newline at end of file
diff --git a/src/WortSpiel.h b/src/WortSpiel.h
new file mode 100644
index 0000000..1828867
--- /dev/null
+++ b/src/WortSpiel.h
@@ -0,0 +1,9 @@
+#ifndef WORTSPIEL_H
+#define WORTSPIEL_H
+
+void loescheBuchstaben(char* wort, char buchstabe);
+int zaehleBuchstaben(const char* wort, char buchstabe);
+void umdrehenWort(char* wort);
+void testSucheBuchstabe_existiert(void);
+
+#endif // WORTSPIEL_H
diff --git a/test/test_WortSpiel.c b/test/test_WortSpiel.c
new file mode 100644
index 0000000..234a8e5
--- /dev/null
+++ b/test/test_WortSpiel.c
@@ -0,0 +1,93 @@
+#ifdef TEST
+
+#include "unity.h"
+
+#include "WortSpiel.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testLoescheBuchstaben_Buchstabeexistiert(void) {
+    // Testfall 1: Buchstabe existiert im Wort
+    char wort1[] = "Beispiel";
+    loescheBuchstaben(wort1, 'i');
+    TEST_ASSERT_EQUAL_STRING("Bespel", wort1);
+}
+
+void testLoescheBuchstaben_Buchstabeexistiertnicht(void) {
+    char wort2[] = "Test";
+    loescheBuchstaben(wort2, 'z');
+    TEST_ASSERT_EQUAL_STRING("Test", wort2);
+}
+
+void testLoescheBuchstaben_Leereswort(void) {
+  char wort3[] = "";
+    loescheBuchstaben(wort3, 'a');
+    TEST_ASSERT_EQUAL_STRING("", wort3);
+}  
+
+void testZaehleBuchstaben_Buchstabenexistiert(void) {
+    // Testfall 1: Buchstabe existiert im Wort
+    char wort1[] = "Beispiel";
+    int anzahl1 = zaehleBuchstaben(wort1, 'i');
+    TEST_ASSERT_EQUAL_INT(2, anzahl1);
+}
+
+void testZaehleBuchstaben_Buchstabenexistiertnicht(void) {
+    char wort2[] = "Test";
+    int anzahl2 = zaehleBuchstaben(wort2, 'z');
+    TEST_ASSERT_EQUAL_INT(0, anzahl2);
+}
+
+void testZaehleBuchstaben_Leereswort(void) {
+    char wort2[] = "Test";
+    int anzahl2 = zaehleBuchstaben(wort2, 'z');
+    TEST_ASSERT_EQUAL_INT(0, anzahl2);
+}
+
+void testUmdrehenWort_normalesWort(void) {
+    // Testfall 1: Umdrehen eines normalen Wortes
+    char wort1[] = "Hello";
+    umdrehenWort(wort1);
+    TEST_ASSERT_EQUAL_STRING("olleH", wort1);
+}
+
+void testUmdrehenWort_leeresWort(void) {
+    char wort2[] = "";
+    umdrehenWort(wort2);
+    TEST_ASSERT_EQUAL_STRING("", wort2);
+}
+
+void testUmdrehenWort_einBuchstabe(void) {
+    char wort3[] = "A";
+    umdrehenWort(wort3);
+    TEST_ASSERT_EQUAL_STRING("A", wort3);
+}
+
+void testSucheBuchstabe_existiert(void) {
+    char wort1[] = "Programming";
+    int position = sucheBuchstabe(wort1, 'g');
+    TEST_ASSERT_EQUAL_INT(3, position);
+
+}
+
+void testSucheBuchstabe_existiertnicht(void) {
+    char wort2[] = "Testing";
+    int position = sucheBuchstabe(wort2, 'z');
+    TEST_ASSERT_EQUAL_INT(-1, position);
+}
+
+void testSucheBuchstabe_leeresWort(void) {
+    char wort3[] = "";
+    int position = sucheBuchstabe(wort3, 'a');
+    TEST_ASSERT_EQUAL_INT(-1, position);
+}
+
+
+
+#endif // TEST