701 lines
21 KiB
Plaintext
701 lines
21 KiB
Plaintext
{
|
|
"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. <u>3 und 5</u> oder <u>11 und 13</u> oder <u>1019 und 1021</u>)\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 <u>29 und 31</u> 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
|
|
}
|