Schleifen
parent
4c249a49e8
commit
ea7febbff4
|
|
@ -24,7 +24,7 @@
|
|||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"execution_count": 15,
|
||||
"id": "80a31a45-95ee-4375-8b26-ec8f2e0f87d3",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
|
|
@ -98,7 +98,7 @@
|
|||
}
|
||||
],
|
||||
"source": [
|
||||
"let betrag = Math.random(); // Zufallszah zwischen 0 und 1\n",
|
||||
"let betrag = Math.random(); // Zufallszahl zwischen 0 und 1\n",
|
||||
"console.log(betrag);\n",
|
||||
"\n",
|
||||
"if (betrag >= 0.5) {\n",
|
||||
|
|
|
|||
|
|
@ -246,7 +246,7 @@
|
|||
"Deno.test(\"01.03.7: istSchaltjahr(1900)\", () => {\n",
|
||||
" assertEquals(istSchaltjahr(1900), false)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.03.7: istSchaltjahr(0)\", () => {\n",
|
||||
"Deno.test(\"01.03.7: istSchaltjahr(2000)\", () => {\n",
|
||||
" assertEquals(istSchaltjahr(2000), true)\n",
|
||||
"})"
|
||||
]
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@
|
|||
}
|
||||
],
|
||||
"source": [
|
||||
"for(let i: number = 0 ; i < 10 ; i++) {\n",
|
||||
"for(let i = 0 ; i < 10 ; i++) {\n",
|
||||
" console.log(i);\n",
|
||||
"}"
|
||||
]
|
||||
|
|
@ -78,7 +78,9 @@
|
|||
"source": [
|
||||
"* `let i: number = 0` ist die Start-Anweisung. Sie wird einmalig ausgeführt vor dem ersten Schleifendurchlauf. Hier wird eine Variable `i` angelegt und mit 0 initialisiert.\n",
|
||||
"* `i < 10` ist die Bedingung, vor jedem Schleifendurchlauf wird überprüft, ob diese Bedingung zutrifft. Sobald die Bedingung nicht mehr zutrifft wird die Schleife komplett beendet\n",
|
||||
"* `i++` ist die Aktualisierung, dieser Befehl wird nach jedem Schleifendurchlauf ausgeführt. Hier wird `i` inkrementiert, d.h. der Wert wird um 1 erhöht."
|
||||
"* `i++` ist die Aktualisierung, dieser Befehl wird nach jedem Schleifendurchlauf ausgeführt. Hier wird `i` inkrementiert, d.h. der Wert wird um 1 erhöht.\n",
|
||||
"\n",
|
||||
"Da die `for`-Schleife eine bestimmte Anzahl an Durchläufen ausführt, wird diese auch *Zählschleife* genannt."
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
|
|||
|
|
@ -31,12 +31,16 @@
|
|||
"# Aufgabe 01.04.1\n",
|
||||
"\n",
|
||||
"Programmiere eine Methode `quadratzahlen` (ohne Parameter) und lasse darin mithilfe einer Schleife die Quadratzahlen von 1 bis 20 ausgeben. Das Ergebnis soll so aussehen:\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"Die Quadratzahl von 1 ist 1\n",
|
||||
"Die Quadratzahl von 2 ist 4\n",
|
||||
"...\n",
|
||||
"Die Quadratzahl von 20 ist 400\n",
|
||||
"```"
|
||||
"```\n",
|
||||
"\n",
|
||||
"#### Hinweis:\n",
|
||||
"du kannst bei den kommenden Aufgaben auch die Funktion zum Testen in deiner Programmierung selbst aufrufen!"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -81,7 +85,7 @@
|
|||
" assertEquals(quadratzahlen.length, 0)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.1: Ausgabe\", () => {\n",
|
||||
" console.start()\n",
|
||||
" console.start(true)\n",
|
||||
" quadratzahlen()\n",
|
||||
" assertEquals(console.end(), 'Die Quadratzahl von 1 ist 1\\nDie Quadratzahl von 2 ist 4\\nDie Quadratzahl von 3 ist 9\\nDie Quadratzahl von 4 ist 16\\nDie Quadratzahl von 5 ist 25\\nDie Quadratzahl von 6 ist 36\\nDie Quadratzahl von 7 ist 49\\nDie Quadratzahl von 8 ist 64\\nDie Quadratzahl von 9 ist 81\\nDie Quadratzahl von 10 ist 100\\nDie Quadratzahl von 11 ist 121\\nDie Quadratzahl von 12 ist 144\\nDie Quadratzahl von 13 ist 169\\nDie Quadratzahl von 14 ist 196\\nDie Quadratzahl von 15 ist 225\\nDie Quadratzahl von 16 ist 256\\nDie Quadratzahl von 17 ist 289\\nDie Quadratzahl von 18 ist 324\\nDie Quadratzahl von 19 ist 361\\nDie Quadratzahl von 20 ist 400')\n",
|
||||
"})"
|
||||
|
|
@ -124,6 +128,7 @@
|
|||
"execution_count": null,
|
||||
"id": "1cf5880f-25cc-43d2-aee1-697d29c7a773",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
|
|
@ -156,6 +161,81 @@
|
|||
" assertEquals(addiereBis(9), 45)\n",
|
||||
"})"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "596dbf4f-51cf-4f2b-abea-5e9b919c5113",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 01.04.3\n",
|
||||
"Die `for`-Schleife soll nochmal anhand der in der Mathematik verwendeten Fakultät geübt werden. Die Fakultät einer natürlichen Zahl `n` ist das Produkt aller natürlichen Zahlen (ohne Null) kleiner oder gleich `n`. Sie wird durch ein nachgestelltes Ausrufezeichen abgekürzt: `3! = 1*2*3 = 6`. Per Definition gilt `0! = 1`.\n",
|
||||
"\n",
|
||||
"Schreibe eine Funktion `fakultaet`, die die Fakultät einer natürlichen Zahl berechnet und zurückgibt.\n",
|
||||
"\n",
|
||||
"Beispiel: `fakultaet(3)` sollte `1*2*3 = 6` ergeben."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "341d72f8-6076-4c8f-9f0a-28e0afb0dfbb",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "8635d86d-2a2d-4228-82ed-eab5f39348ce",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Deno.test(\"01.04.3: function\", () => {\n",
|
||||
" assertEquals(typeof addiereBis, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.3: Parameter\", () => {\n",
|
||||
" assertEquals(fakultaet.length, 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.3: fakultaet(0)\", () => {\n",
|
||||
" assertEquals(fakultaet(0), 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.3: fakultaet(1)\", () => {\n",
|
||||
" assertEquals(fakultaet(1), 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.3: fakultaet(2)\", () => {\n",
|
||||
" assertEquals(fakultaet(2), 2)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.3: fakultaet(3)\", () => {\n",
|
||||
" assertEquals(fakultaet(3), 6)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.3: fakultaet(4)\", () => {\n",
|
||||
" assertEquals(fakultaet(4), 24)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.3: fakultaet(9)\", () => {\n",
|
||||
" assertEquals(fakultaet(9), 362880)\n",
|
||||
"})"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,130 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "802a389f-359a-42c8-8602-317bd18d5c96",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## `while`-Schleife\n",
|
||||
"\n",
|
||||
"Eine `while`-Schleife hat - anders als die `for`-Schleife - lediglich eine Bedingung und führt die Anweisungen in der Schleife so lange aus, so lange die Bedingung erfüllt ist."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"id": "5af36a9c-5be8-457d-863d-46d85918fcf9",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"17\n",
|
||||
"8.5\n",
|
||||
"4.25\n",
|
||||
"2.125\n",
|
||||
"1.0625\n",
|
||||
"Nach der Schleife ist x = 0.53125\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"let x = 17\n",
|
||||
"\n",
|
||||
"while ( x > 1 ) {\n",
|
||||
" console.log(x)\n",
|
||||
" x = x / 2\n",
|
||||
"}\n",
|
||||
"\n",
|
||||
"console.log(\"Nach der Schleife ist x = \" + x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "19d1ca71-6286-4ed6-bedd-c953c2b67906",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"Am Beispiel sehen wir, dass die Schleife läuft, solange die Bedingung `x > 1` erfüllt ist. Sobald `x` kleiner ist als 1 bricht die Schleife ab."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "9b887033-e9d7-4a98-aaf8-48e115f09093",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## `for` vs. `while`\n",
|
||||
"\n",
|
||||
"Eine `for`-Schleife kann man auch als `while`-Schleife (und umgekehrt) schreiben:\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"for ( let i = 0 ; i < 10 ; i++) {\n",
|
||||
" [...]\n",
|
||||
"}\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"entspricht in `while`-Schreibweise:\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"let i = 0 // Initialisierung vor dem ersten Schleifendurchlauf\n",
|
||||
"while ( i < 10 ) { // Bedingung\n",
|
||||
" [...]\n",
|
||||
" i++ // Aktualisierung nach jedem Schleifendurchlauf\n",
|
||||
"}\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## Wann nutzt man `for`, wann `while`?\n",
|
||||
"\n",
|
||||
"In der Regel nutzt man eine `for`-Schleife, wenn zum Start des ersten Schleifendurchlaufes bereits feststeht, wie oft die Schleife durchlaufen werden muss.\n",
|
||||
"\n",
|
||||
"**Beispiel:** Es sollen 10 Zahlen ausgegeben werden.\n",
|
||||
"\n",
|
||||
"Eine `while`-Schleife nutzt man hingegen normalerweise, wenn die genaue Anzahl noch nicht bekannt ist und die Schleifenbedingung durch die Schleife selbst verändert.\n",
|
||||
"\n",
|
||||
"**Beispiel:** Ein Kunde bezahlt (mit Bargeld), der Bezahlvorgang läuft so lange, bis der komplette Betrag beglichen ist."
|
||||
]
|
||||
}
|
||||
],
|
||||
"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
|
||||
}
|
||||
|
|
@ -0,0 +1,407 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "e77a8d37-be27-42fe-84a4-7b762e26f730",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"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": "b4399c83-ae7b-44dd-b786-d85bff292661",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 01.04.4 - größter gemeinsamer Teiler\n",
|
||||
"\n",
|
||||
"Programmiere eine Methode `ggT`, die 2 Zahlen `a` und `b` als Parameter annimmt und den größten gemeinsamen Teiler dieser Zahlen bestimmt und diesen als Ergebnis zurückgibt.\n",
|
||||
"\n",
|
||||
"#### Hinweis 1:\n",
|
||||
"der größte gemeinsame Teiler `ggT` ist die ganze Zahl ≥1, die sowohl ein Teiler von `a` ist, als auch ein Teiler von `b`. Gleichzeitig ist der `ggT` auch die größte Zahl, die diese Bedingungen erfüllt.\n",
|
||||
"\n",
|
||||
"#### Hinweis 2:\n",
|
||||
"die Teilbarkeit überprüft man, indem man Modulo rechnet. Gilt `a % t === 0` so ist `t` ein Teiler von `a`. (D.h. beim Teilen von `a` durch `t` gibt es den Rest `0`)\n",
|
||||
"\n",
|
||||
"#### Beispiel:\n",
|
||||
"`ggT(6,15)=3`\n",
|
||||
"\n",
|
||||
"#### Tipp zur Programmierung:\n",
|
||||
"beginne bei `t = a` und zähle dann `t` so lange runter, bis `t` ein Teiler von `a` und `b` ist."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "0a26736e-986c-4a54-bd6d-b41e8c48332f",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "6420fb99-b5db-41b4-b8ca-e9e8d57522da",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Deno.test(\"01.04.4: function\", () => {\n",
|
||||
" assertEquals(typeof ggT, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: Parameter\", () => {\n",
|
||||
" assertEquals(ggT.length, 2)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(1,1)=1\", () => {\n",
|
||||
" assertEquals(ggT(1,1), 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(1,2)=1\", () => {\n",
|
||||
" assertEquals(ggT(1,2), 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(2,3)=1\", () => {\n",
|
||||
" assertEquals(ggT(2,3), 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(2,4)=2\", () => {\n",
|
||||
" assertEquals(ggT(2,4), 2)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(15,6)=3\", () => {\n",
|
||||
" assertEquals(ggT(15,6), 3)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(12,18)=6\", () => {\n",
|
||||
" assertEquals(ggT(12,18), 6)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(18,12)=6\", () => {\n",
|
||||
" assertEquals(ggT(18,12), 6)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(15,45)=15\", () => {\n",
|
||||
" assertEquals(ggT(15,45), 15)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.4: ggT(45,15)=15\", () => {\n",
|
||||
" assertEquals(ggT(45,15), 15)\n",
|
||||
"})"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d6b3211a-cc44-404d-84c5-93aba9b53155",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 01.04.5 - Fibonacci-Folge\n",
|
||||
"\n",
|
||||
"Programmiere eine Methode `fibonacci` die einen Zahl als Parameter entgegennimmt und die Fibonacci-Folge auf der Konsole ausgibt bis zur angegebenen Zahl (oder kleiner).\n",
|
||||
"\n",
|
||||
"#### Hinweis:\n",
|
||||
"Die Fibonacci-Folge ist folgendermaßen definiert: man beginnt mit den Zahlen 0 und 1. Die jeweils folgende Zahl ist die Summe der beiden Vorgänger.\n",
|
||||
"\n",
|
||||
"#### Beispiel:\n",
|
||||
"0,1,1,2,3,5,8,13,21,34,55,89,144,...\n",
|
||||
"\n",
|
||||
"#### Hinweis zur Ausgabe:\n",
|
||||
"Wird als Parameter `10` angegeben, soll die Fibonacci nach der 8 abbrechen. Gib jede Zahl mit `console.log` ohne Komma aus.\n",
|
||||
"\n",
|
||||
"#### Tipp zur Programmierung:\n",
|
||||
"Speichere die beiden Zahlen in Variablen ab und überlege dir, was du wann addieren und zuweisen musst"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "7eb0df34-14be-4854-9a37-5bae80607753",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "8b02d832-1cc3-4d0d-a8fc-b377bf8b5e7e",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Deno.test(\"01.04.5: function\", () => {\n",
|
||||
" assertEquals(typeof fibonacci, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.5: Parameter\", () => {\n",
|
||||
" assertEquals(fibonacci.length, 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.5: fibonacci(0)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" fibonacci(0)\n",
|
||||
" assertEquals(console.end(), '0')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.5: fibonacci(1)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" fibonacci(1)\n",
|
||||
" assertEquals(console.end(), '0\\n1\\n1')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.5: fibonacci(6)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" fibonacci(6)\n",
|
||||
" assertEquals(console.end(), '0\\n1\\n1\\n2\\n3\\n5')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.5: fibonacci(10)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" fibonacci(10)\n",
|
||||
" assertEquals(console.end(), '0\\n1\\n1\\n2\\n3\\n5\\n8')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.5: fibonacci(100)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" fibonacci(100)\n",
|
||||
" assertEquals(console.end(), '0\\n1\\n1\\n2\\n3\\n5\\n8\\n13\\n21\\n34\\n55\\n89')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.5: fibonacci(500)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" fibonacci(500)\n",
|
||||
" assertEquals(console.end(), '0\\n1\\n1\\n2\\n3\\n5\\n8\\n13\\n21\\n34\\n55\\n89\\n144\\n233\\n377')\n",
|
||||
"})"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "fd3274ce-bd67-4d1e-9329-c386a4a461ec",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 01.04.6 - Collatz-Folge\n",
|
||||
"\n",
|
||||
"Die Collatz-Folge ist folgendermaßen definiert:\n",
|
||||
"* beginne bei einer Zahl `x`\n",
|
||||
"* ist die Zahl `x` gerade, so ist die nächste Zahl `x/2`\n",
|
||||
"* ist die Zahl `x` ungerade, so ist die nächste Zahl `3*x + 1`\n",
|
||||
"* die Folge endet, wenn man bei 1 angekommen ist.\n",
|
||||
"\n",
|
||||
"Programmiere eine Methode `collatz`, die einen Startwert als Parameter bekommt und ausgehend davon die Collatz-Folge ausgibt.\n",
|
||||
"\n",
|
||||
"#### Beispiele:\n",
|
||||
"* 3,10,5,16,8,4,2,1\n",
|
||||
"* 7,22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1\n",
|
||||
"\n",
|
||||
"#### Hinweis zur Ausgabe:\n",
|
||||
"Gib jede Zahl mit `console.log` ohne Komma aus."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "238eece7-d51b-4776-acaa-27c4a1ccbb98",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "f65373b5-e2de-4b58-9966-2c6883607cc3",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Deno.test(\"01.04.6: function\", () => {\n",
|
||||
" assertEquals(typeof collatz, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.6: Parameter\", () => {\n",
|
||||
" assertEquals(collatz.length, 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.6: collatz(0)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" collatz(0)\n",
|
||||
" assertEquals(console.end(), '0')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.6: collatz(1)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" collatz(1)\n",
|
||||
" assertEquals(console.end(), '1')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.6: collatz(2)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" collatz(2)\n",
|
||||
" assertEquals(console.end(), '2\\n1')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.6: collatz(5)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" collatz(5)\n",
|
||||
" assertEquals(console.end(), '5\\n16\\n8\\n4\\n2\\n1')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.6: collatz(7)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" collatz(7)\n",
|
||||
" assertEquals(console.end(), '7\\n22\\n11\\n34\\n17\\n52\\n26\\n13\\n40\\n20\\n10\\n5\\n16\\n8\\n4\\n2\\n1')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.6: collatz(97)\", () => {\n",
|
||||
" console.start(false)\n",
|
||||
" collatz(97)\n",
|
||||
" assertEquals(console.end(), '97\\n292\\n146\\n73\\n220\\n110\\n55\\n166\\n83\\n250\\n125\\n376\\n188\\n94\\n47\\n142\\n71\\n214\\n107\\n322\\n161\\n484\\n242\\n121\\n364\\n182\\n91\\n274\\n137\\n412\\n206\\n103\\n310\\n155\\n466\\n233\\n700\\n350\\n175\\n526\\n263\\n790\\n395\\n1186\\n593\\n1780\\n890\\n445\\n1336\\n668\\n334\\n167\\n502\\n251\\n754\\n377\\n1132\\n566\\n283\\n850\\n425\\n1276\\n638\\n319\\n958\\n479\\n1438\\n719\\n2158\\n1079\\n3238\\n1619\\n4858\\n2429\\n7288\\n3644\\n1822\\n911\\n2734\\n1367\\n4102\\n2051\\n6154\\n3077\\n9232\\n4616\\n2308\\n1154\\n577\\n1732\\n866\\n433\\n1300\\n650\\n325\\n976\\n488\\n244\\n122\\n61\\n184\\n92\\n46\\n23\\n70\\n35\\n106\\n53\\n160\\n80\\n40\\n20\\n10\\n5\\n16\\n8\\n4\\n2\\n1')\n",
|
||||
"})"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "6ab68dbf-26c0-4e28-b75d-17fd9afaaf23",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 01.04.6 - Länge der Collatz-Folge\n",
|
||||
"\n",
|
||||
"Modifiziere deine Programmierung von oben so und programmiere diese als Funktion `collatzlaenge`, dass die Funktion als Rückgabewert (mit `return`) die Anzahl der Zahlen zurückgibt. Die Ausgabe auf der Konsole kannst du dabei weglassen.\n",
|
||||
"\n",
|
||||
"#### Beispiel:\n",
|
||||
"* `collatzlaenge(3)=8` (da 3,10,5,16,8,4,2,1 -> 8 Zahlen)\n",
|
||||
"* `collatzlaenge(7)=17` (da 7,22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1 -> 17 Zahlen)\n",
|
||||
"\n",
|
||||
"#### Zusatzaufgabe:\n",
|
||||
"Finde mit dieser Hilfe die Startzahl ≤100, die die längste Collatzfolge erzeugt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "031e69cd-e7ce-4495-89ce-a265425cf809",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "11bc9be9-218f-4677-b08e-3ad1386e2aec",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Deno.test(\"01.04.7: function\", () => {\n",
|
||||
" assertEquals(typeof collatzlaenge, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: Parameter\", () => {\n",
|
||||
" assertEquals(collatzlaenge.length, 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: collatzlaenge(1)=1\", () => {\n",
|
||||
" assertEquals(collatzlaenge(1), 1)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: collatzlaenge(7)=17\", () => {\n",
|
||||
" assertEquals(collatzlaenge(7), 17)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: collatzlaenge(13)=10\", () => {\n",
|
||||
" assertEquals(collatzlaenge(13), 10)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: collatzlaenge(32)=6\", () => {\n",
|
||||
" assertEquals(collatzlaenge(32), 6)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: collatzlaenge(51)=25\", () => {\n",
|
||||
" assertEquals(collatzlaenge(51), 25)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: collatzlaenge(82)=111\", () => {\n",
|
||||
" assertEquals(collatzlaenge(82), 111)\n",
|
||||
"})\n",
|
||||
"Deno.test(\"01.04.7: collatzlaenge(100)=26\", () => {\n",
|
||||
" assertEquals(collatzlaenge(100), 26)\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
|
||||
}
|
||||
Loading…
Reference in New Issue