{ "cells": [ { "cell_type": "code", "execution_count": null, "id": "c9079895-47dc-4d88-b630-57c1923a0eb5", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "import { assertEquals } from \"jsr:@std/assert\"\n", "import \"https://git.amgdhg.de/kg/tslib/raw/branch/main/logger.ts?5\"" ] }, { "cell_type": "markdown", "id": "d4b638e5-98c7-4c03-a496-cb4e0316808b", "metadata": { "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# Aufgabe 01.05.1 - Summe\n", "\n", "Programmiere eine Funktion `summe`, die zwei Zahlen als Parameter annimmt, deren Summe berechnet und anschließend zurückgibt.\n", "\n", "#### Hinweis:\n", "\n", "zurückgeben heißt: `return`" ] }, { "cell_type": "code", "execution_count": null, "id": "b05082a3-b2fc-46d1-9f91-d418f1861b69", "metadata": { "editable": false, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "6b14aef1-7dc0-406a-8a7a-6d4ec4727792", "metadata": { "editable": false, "jupyter": { "source_hidden": true }, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "Deno.test(\"01.05.1: function\", () => {\n", " assertEquals(typeof summe, 'function')\n", "})\n", "Deno.test(\"01.05.1: Parameter\", () => {\n", " assertEquals(summe.length, 2)\n", "})\n", "Deno.test(\"01.05.1: summe() mit verschiedenen Zufallszahlen\", () => {\n", " console.log(\"\")\n", " for (let i = 0; i < 10; i++) {\n", " let a = Math.random()\n", " let b = Math.random()\n", " console.log(\" Teste summe(\"+a+\",\"+b+\")\")\n", " assertEquals(summe(a,b), a+b)\n", " }\n", "})" ] }, { "cell_type": "markdown", "id": "272cc82a-2c1b-456d-86e4-5d2b7ebefc68", "metadata": { "editable": false, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# Aufgabe 01.05.2 - Primzahlen\n", "\n", "Programmiere eine Funktion `istPrim`, die eine Zahl als Parameter bekommt. Die Methode soll überprüfen, ob der Parameter eine Primzahl ist und dementsprechend `true` oder `false` zurückgeben.\n", "\n", "#### 1. Hinweis:\n", "1 ist per Definition *keine* Primzahl!\n", "\n", "#### 2. Hinweis:\n", "da TypeScript nur allgemeine Zahltypen versteht, müssen wir hier auch überprüfen, ob es eine ganze Zahl ist! (Tipp: überprüfe, ob der übergebene Parameter durch 1 teilbar ist.)" ] }, { "cell_type": "code", "execution_count": null, "id": "50ebf235-210d-439f-8906-4d56f3e70b0a", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "58073f15-9ba6-4d50-a26e-c83a5002b739", "metadata": { "editable": false, "jupyter": { "source_hidden": true }, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "let _nr = \"01.05.3\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof istPrim, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(istPrim.length, 1)\n", "})\n", "Deno.test(`${_nr}: istPrim(2.052)=false`, () => {\n", " assertEquals(istPrim(2.052), false)\n", "})\n", "Deno.test(`${_nr}: istPrim(1)=false`, () => {\n", " assertEquals(istPrim(1), false)\n", "})\n", "Deno.test(`${_nr}: istPrim(2)=true`, () => {\n", " assertEquals(istPrim(2), true)\n", "})\n", "Deno.test(`${_nr}: istPrim(3)=true`, () => {\n", " assertEquals(istPrim(3), true)\n", "})\n", "Deno.test(`${_nr}: istPrim(4)=false`, () => {\n", " assertEquals(istPrim(4), false)\n", "})\n", "Deno.test(`${_nr}: istPrim(5)=true`, () => {\n", " assertEquals(istPrim(5), true)\n", "})\n", "Deno.test(`${_nr}: istPrim(72)=false`, () => {\n", " assertEquals(istPrim(72), false)\n", "})\n", "Deno.test(`${_nr}: istPrim(97)=true`, () => {\n", " assertEquals(istPrim(97), true)\n", "})" ] }, { "cell_type": "markdown", "id": "1bf8c3e7-2fef-46e2-a92a-8d345b4bee5f", "metadata": { "editable": false, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# Aufgabe 01.05.3 - Primzahl-Doubletten\n", "\n", "Eine Primzahl-Doublette besteht aus zwei Primzahlen, deren Differenz gleich 2 ist (z.B. 3 und 5 oder 11 und 13 oder 1019 und 1021)\n", "\n", "Programmiere eine Funktion `primDoublette`, die eine Zahl `min` als Parameter annimmt. Von diesem Wert `min` soll aufsteigend nach der nächsten Primzahl-Doublette gesucht werden.\n", "\n", "Zurückgegeben werden soll die kleinere der beiden Zahlen (also in den obigen Beispielen 3 bzw. 11 bzw. 1019)\n", "\n", "#### Beispiel:\n", "\n", "Wird die Funktion mit dem Paramter `20` aufgerufen, soll als Ergebnis `29` zurückgegeben werden, da 29 und 31 die kleinsten Primzahl-Doubletten sind, die größer sind als `20`\n", "\n", "#### Hinweis:\n", "\n", "es soll dabei die Methode `istPrim` aus Aufgabe 01.05.2 weiterverwendet werden!*" ] }, { "cell_type": "code", "execution_count": null, "id": "9501c38b-8336-4c06-a09c-917e4d13bce2", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "6ff22110-d320-4bf6-9241-2d87b2891e30", "metadata": { "editable": false, "jupyter": { "source_hidden": true }, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "let _nr = \"01.05.3\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof primDoublette, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(primDoublette.length, 1)\n", "})\n", "Deno.test(`${_nr}: primDoublette(1)=3`, () => {\n", " assertEquals(primDoublette(1), 3)\n", "})\n", "Deno.test(`${_nr}: primDoublette(10)=11`, () => {\n", " assertEquals(primDoublette(10), 11)\n", "})\n", "Deno.test(`${_nr}: primDoublette(50)=59`, () => {\n", " assertEquals(primDoublette(50), 59)\n", "})\n", "Deno.test(`${_nr}: primDoublette(100)=101`, () => {\n", " assertEquals(primDoublette(100), 101)\n", "})\n", "Deno.test(`${_nr}: primDoublette(1000)=1019`, () => {\n", " assertEquals(primDoublette(1000), 1019)\n", "})\n", "Deno.test(`${_nr}: primDoublette(59108)=59207`, () => {\n", " assertEquals(primDoublette(59108), 59207)\n", "})" ] }, { "cell_type": "markdown", "id": "f10e6386-bec1-43b9-8a45-15dc6bd9a4a4", "metadata": { "editable": false, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# Aufgabe 01.05.4 - Pythagoräische Tripel\n", "\n", "Ein pythagoräisches Tripel besteht aus drei ganzen Zahlen `a`, `b` und `c`, die zusammen die Bedingung $a^2+b^2=c^2$ erfüllen, wie z.B. (3,4,5)\n", "\n", "Programmiere eine Funktion `pytTripel` ohne Parameter, die sämtliche Pythagoräischen Tripel auf der Konsole ausgibt für $a,b,c \\leq 100$\n", "\n", "Außerdem soll gelten: $a\\leq b$. Die Ausgabe soll leerzeichengetrennt erfolgen, also\n", "```\n", "3 4 5\n", "5 12 13\n", "6 8 10\n", "[...]\n", "```" ] }, { "cell_type": "code", "execution_count": null, "id": "eb8318be-02b9-44d5-aa1e-15455ea74b9f", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "8473f71c-3e33-4321-8ed4-d5fdd85b946b", "metadata": { "editable": false, "jupyter": { "source_hidden": true }, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "let _nr = \"01.05.4\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof pytTripel, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(pytTripel.length, 0)\n", "})\n", "Deno.test(`${_nr}: pytTripel()`, () => {\n", " console.start(false)\n", " pytTripel()\n", " let result = console.end().split(\"\\n\")\n", " \n", " assertEquals(result.length, 52, \"nicht korrekte Anzahl ausgegeben\")\n", " for(let i = 0; i < result.length; i++) {\n", " const row = result[i].split(\" \").map(x => parseInt(x))\n", " assertEquals(row[0]*row[0] + row[1]*row[1], row[2]*row[2], \"ungültiges Tripel ausgegeben\")\n", "\n", " if (i < result.length - 1) {\n", " const next = result[i + 1].split(\" \").map(x => parseInt(x))\n", " assertEquals(row[0] === next[0] && row[1] === next[1], false, \"zwei gleiche Tripel ausgegeben\")\n", " }\n", " }\n", "})" ] }, { "cell_type": "markdown", "id": "1489f365-a169-46d0-9349-b482db1d5d75", "metadata": { "editable": false, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# Aufgabe 01.05.5 - lineare Nullstelle\n", "\n", "Schreibe eine Funktion `linNst`, die die Nullstelle einer linearen Funktion $f(x) = m\\cdot x + c$ berechnet.\n", "\n", "Als Parameter sollen `m` und `c` eingegeben werden, zurückgegeben werden soll der `x`-Wert der Nullstelle.\n", "\n", "#### mathematischer Hinweis:\n", "Eine lineare Funktion hat immer eine Nullstelle, außer mit $a=0$ und $b\\neq0$. Bei $a=0$ und $b=0$ gibt es unendlich viele Nullstellen. Diese Sonderfälle müssen hier nicht beachtet werden!\n", "\n", "#### Tipp:\n", "Für eine Nullstelle gilt $y=0$. Anschließend kann nach $x$ umgeformt werden." ] }, { "cell_type": "code", "execution_count": null, "id": "1faf34b0-553d-49ae-87c2-92c335b97aab", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "7a6012f7-8be8-4b6b-aa28-06d9dc9d4bdb", "metadata": { "editable": false, "jupyter": { "source_hidden": true }, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "let _nr = \"01.05.5\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof linNst, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(linNst.length, 2)\n", "})\n", "Deno.test(`${_nr}: linNst(1,0)=0`, () => {\n", " assertEquals(linNst(1,0), 0)\n", "})\n", "Deno.test(`${_nr}: linNst(5,0)=0`, () => {\n", " assertEquals(linNst(5,0), 0)\n", "})\n", "Deno.test(`${_nr}: linNst(2,4)=-2`, () => {\n", " assertEquals(linNst(2,4), -2)\n", "})\n", "Deno.test(`${_nr}: linNst(4,2)=-0.5`, () => {\n", " assertEquals(linNst(4,2), -0.5)\n", "})\n", "Deno.test(`${_nr}: linNst(-0.6,9)=15`, () => {\n", " assertEquals(linNst(-0.6,9), 15)\n", "})" ] }, { "cell_type": "markdown", "id": "e420032b-ed4d-4e4e-80f8-0b14d5f0cc2b", "metadata": { "editable": false, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# Aufgabe 01.05.6 - quadratische Nullstellen\n", "\n", "Äquivalent zur Aufgabe 01.05.5 soll nun die Funktion `quadNst` programmiert werden, die die Nullstellen einer quadratischen Funktion $f(x)=a\\cdot x^2+b\\cdot x + c$ berechnet.\n", "\n", "Als Parameter sollen die Werte für $a$, $b$ und $c$ eingegeben werden.\n", "\n", "Zurückgegeben werden sollen *alle* möglichen Nullstellen.\n", "\n", "#### Hinweis:\n", "\n", "Um mehrere Werte zurückgeben zu können, kann folgende Schreibweise genutzt werden:\n", "* `return []` gibt ein leeres Ergebnis zurück (= keine Nullstelle)\n", "* `return [x1]` gibt ein Ergebnis mit einer Nullstelle $x_1$ zurück\n", "* `return [x1, x2]` gibt ein Ergebnis mit zwei Nullstellen $x_1$ und $x_2$ zurück.\n", "\n", "#### 2. Hinweis:\n", "\n", "Die Wurzel eines Wertes $D$ lässt sich mit `Math.sqrt(D)` berechnen.\n", "\n", "#### mathematischer Hinweis:\n", "\n", "Die Nullstellen einer quadratischen Funktion berechnet man mit der Mitternachtsformel. Die Diskriminante (= Radikand = Wert unter der Wurzel) entscheidet darüber, wie viele Nullstellen es gibt." ] }, { "cell_type": "code", "execution_count": null, "id": "a49e6ce5-ba34-406c-ab1a-99745a09e468", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "09b15d57-2e91-45d4-ae06-e4872bbfc777", "metadata": { "editable": false, "jupyter": { "source_hidden": true }, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "let _nr = \"01.05.6\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof quadNst, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(quadNst.length, 3)\n", "})\n", "Deno.test(`${_nr}: quadNst(1,-5,6)=[2,3]`, () => {\n", " const res = quadNst(1,-5,6)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 2)\n", " assertEquals(res.sort(), [2,3])\n", "})\n", "Deno.test(`${_nr}: quadNst(1,-3,2)=[1,2]`, () => {\n", " const res = quadNst(1,-3,2)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 2)\n", " assertEquals(res.sort(), [1,2])\n", "})\n", "Deno.test(`${_nr}: quadNst(2,-8,6)=[1,3]`, () => {\n", " const res = quadNst(2,-8,6)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 2)\n", " assertEquals(res.sort(), [1,3])\n", "})\n", "Deno.test(`${_nr}: quadNst(3,-12,9)=[1,3]`, () => {\n", " const res = quadNst(3,-12,9)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 2)\n", " assertEquals(res.sort(), [1,3])\n", "})\n", "Deno.test(`${_nr}: quadNst(-1,7,-12)=[3,4]`, () => {\n", " const res = quadNst(-1,7,-12)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 2)\n", " assertEquals(res.sort(), [3,4])\n", "})\n", "Deno.test(`${_nr}: quadNst(1,-4,4)=[2]`, () => {\n", " const res = quadNst(1,-4,4)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 1)\n", " assertEquals(res.sort(), [2])\n", "})\n", "Deno.test(`${_nr}: quadNst(-2,8,-8)=[2]`, () => {\n", " const res = quadNst(-2,8,-8)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 1)\n", " assertEquals(res.sort(), [2])\n", "})\n", "Deno.test(`${_nr}: quadNst(3,6,3)=[-1]`, () => {\n", " const res = quadNst(3,6,3)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 1)\n", " assertEquals(res.sort(), [-1])\n", "})\n", "Deno.test(`${_nr}: quadNst(1,2,5)=[]`, () => {\n", " const res = quadNst(1,2,5)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 0)\n", "})\n", "Deno.test(`${_nr}: quadNst(2,4,6)=[]`, () => {\n", " const res = quadNst(2,4,6)\n", " assertEquals(Array.isArray(res), true)\n", " assertEquals(res.length, 0)\n", "})" ] }, { "cell_type": "markdown", "id": "a213d25b-b301-4cd9-9ada-9ad914bfff0f", "metadata": { "editable": false, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# Aufgabe 01.05.7 - Sonntage zählen\n", "Die folgenden Informationen sind gegeben:\n", "* der 1. Januar 1900 war ein Montag\n", "* 30 Tage haben folgende Monate: April, Juni, September und November\n", "* der Februar hat 28 Tage, in Schaltjahren 29 Tage\n", "* alle anderen Monate haben 31 Tage\n", "\n", "## Teilaufgabe 1:\n", "Programmiere eine Funktion `istSchaltjahr`, die als Parameter eine Jahreszahl bekommt und `true` oder `false` zurückgibt.\n", "\n", "## Teilaufgabe 2:\n", "Programmiere eine Funktion `tageImMonat`, die als Parameter Monat und Jahr übergeben bekommt und die Anzahl der Tage in diesem Monat zurückgibt\n", "\n", "## Teilaufgabe 3:\n", "* Programmiere eine Methode `ausgabe`, die mithilfe von Schleifen zunächst alle Datumsangaben vom 1.1.1900 bis zum 31.12.2000 ausgibt, z.B.\n", "```\n", "1.1.1900\n", "2.1.1900\n", "3.1.1900\n", "[...]\n", "30.12.1900\n", "31.12.1900\n", "```\n", "\n", "Ergänze die Ausgabe anschließend um den Wochentag, z.B.\n", "```\n", "1.1.1900 Montag\n", "2.1.1900 Dienstag\n", "[...]\n", "```\n", "\n", "#### Hinweis:\n", "Das Ergebnis dieser Methode wird nicht überprüft!\n", "\n", "## Teilaufgabe 4:\n", "Programmiere eine Funktion `sonntage`, die als Parameter eine Jahreszahl übergeben bekommt und die Sonntage vom 1.1.1900 bis zum 31.12. des als Parameter angegebenen Jahres **zählt** und die Anzahl zurückgibt.\n", "\n", "#### Beispiel:\n", "* `sonntage(1900)` zählt die Sonntage zwischen dem 1.1.1900 und 31.12.1900 und gibt als Ergebnis `52` zurück\n", "* `sonntage(2000)` gibt als Ergebnis `5270` zurück" ] }, { "cell_type": "code", "execution_count": null, "id": "19f1f81e-fb48-4fee-a2a3-e047a254e521", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "bb3c5d55-fe18-4445-8cb7-734a9e19768b", "metadata": { "editable": false, "jupyter": { "source_hidden": true }, "scrolled": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "let _nr = \"01.05.6.1\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof istSchaltjahr, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(istSchaltjahr.length, 1)\n", "})\n", "Deno.test(`${_nr}: istSchaltjahr`, () => {\n", " assertEquals(istSchaltjahr(0), true)\n", " assertEquals(istSchaltjahr(2024), true)\n", " assertEquals(istSchaltjahr(2025), false)\n", " assertEquals(istSchaltjahr(1900), false)\n", " assertEquals(istSchaltjahr(2000), true)\n", "})\n", "_nr = \"01.05.6.2\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof tageImMonat, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(tageImMonat.length, 2)\n", "})\n", "Deno.test(`${_nr}: tageImMonat`, () => {\n", " assertEquals(tageImMonat(1,1900), 31)\n", " assertEquals(tageImMonat(2,1900), 28)\n", " assertEquals(tageImMonat(2,2000), 29)\n", " assertEquals(tageImMonat(3,1964), 31)\n", " assertEquals(tageImMonat(4,1786), 30)\n", "})\n", "_nr = \"01.05.6.4\"\n", "Deno.test(`${_nr}: function`, () => {\n", " assertEquals(typeof sonntage, 'function')\n", "})\n", "Deno.test(`${_nr}: Parameter`, () => {\n", " assertEquals(sonntage.length, 1)\n", "})\n", "Deno.test(`${_nr}: sonntage`, () => {\n", " assertEquals(sonntage(1900), 52)\n", " \n", " const a = (new Date(\"1900-01-01\")).getTime()\n", " for (let i = 0; i < 100; i++) {\n", " const y = Math.round(1900 + Math.random()*125)\n", " const b = (new Date(`${y+1}-01-01`)).getTime()\n", " const c = b-a\n", " const s = Math.floor(c/3600000/24/7)\n", "\n", " assertEquals(sonntage(y), s)\n", " }\n", "})" ] } ], "metadata": { "kernelspec": { "display_name": "Deno", "language": "typescript", "name": "deno" }, "language_info": { "codemirror_mode": "typescript", "file_extension": ".ts", "mimetype": "text/x.typescript", "name": "typescript", "nbconvert_exporter": "script", "pygments_lexer": "typescript", "version": "5.8.3" } }, "nbformat": 4, "nbformat_minor": 5 }