2^8 Zahlen können dargestellt werden... also 2^7+2^6+usw.
Ein byte ist in Java immer vorzeichenbehaftet, d. h., nach 127 beginnen die negativen Zahlen...
Btw.: Die 0 zählt zu den positiven Zahlen.
Das kommt, weil mit "left(6)" die Drehung zu klein ist, und du oft fast an dieselbe Stelle schreibst. Probier mal das:
from gturtle import *
makeTurtle()
hideTurtle()
def dreieck():
repeat 3:
forward(50)
right(120)
def sechseck():
repeat 6:
right(60)
dreieck()
#sechseck()
#forward(100)
#sechseck()
def animation():
sechseck()
delay(100)
sechseck()
delay(100)
left(30)
forward(100)
setPenColor("green")
repeat 12:
animation()
Hallo, das ginge so:
//-------CONFIGURATION
name: Schiebe erste 1 nach rechts
init: q0
accept: q5
q0,0
q0,0,>
q0,1
q1,1,>
// End state
q0,_
q5,_,-
q1,1
q1,1,>
q1,0
q2,0,<
// End state
q1,_
q5,_,-
q2,1
q2,1,<
q2,0
q3,0,>
q2,_
q3,_,>
q3,0
q3,0,>
q3,1
q4,0,>
q4,1
q4,1,>
// End state
q4,0
q5,1,-
Du kannst es zum Beispiel hier ausprobieren: https://turingmachinesimulator.com/ und solltest noch weitere Kommentare hinzufügen...
Hallo, das sollte so funktionieren (die "decrypt"-Funktionen sind dann so ähnlich... also genau umgekehrt):
function encryptChar(s, offset) {
let a = "a".charCodeAt(0);
let z = "z".charCodeAt(0);
let c = s.toLowerCase().charCodeAt(0);
c = c + offset;
while (c > z) {
c = c - z - 1 + a;
}
return String.fromCharCode(c);
}
function encryptString(str, offset) {
let s = "";
for (let i = 0; i < str.length; i++) {
s = s.concat(encryptChar(str.substr(i, 1), offset));
}
return s;
}
console.log(encryptString("Hallo", 15));
2) Wenn Anastasia den Most holt wird es bald etwas zu trinken geben und das Abendessen wird beginnen vorausgesetzt dass Bartholm¨aus das Brot schon gebacken hat.
a = Anastasia holt den Most
b = Es gibt bald zu trinken
c = Abendessen beginnt
d = Bartholm hat das Brot gebacken
(a -> b) ^ ((a ^ d) -> c)
Das steht da und es lässt sich etwas vereinfachen:
(!b v a) ^ (!c v (a ^ d))
= (!b v a) ^ (!c v a) ^ (!c v d)
= !b^!c v a^!c v a^d (DNF)
(Regeln, siehe hier)
... Und dann steht dort: Entweder, es gibt nichts zu trinken und kein Abendessen, oder Anastasia hat den Most geholt und es gibt kein Abendessen, oder Anastasia hat den Most geholt und Bartholm hat das Brot gebacken.
Wenn die Frage ist, wann kann es etwas zu trinken geben, dann ist die Antwort, zum Beispiel, wenn Anastasia den Most geholt hat (es kann ja auch jemand anderes den Most geholte haben) Und wann kann es Abendessen geben, dann ist die Antwort, zum Beispiel, wenn Anastasia den Most geholt hat und Bartholm das Brot gebacken hat (natürlich kann auch jemand anderes den Most und das Brot beschafft haben)
Der erste Teil der Implikation ist ein Indiz für den zweiten Teil, aber der zweite Teil kann auch ohne den ersten erfüllt sein...
Tabelle:
A B C D │ (¬B ∨ A) ∧ (¬C ∨ (A ∧ D))
─────────┼───────────────────────────
1 1 1 1 │ 1
1 1 1 0 │ 0
1 1 0 1 │ 1
1 1 0 0 │ 1
1 0 1 1 │ 1
1 0 1 0 │ 0
1 0 0 1 │ 1
1 0 0 0 │ 1
0 1 1 1 │ 0
0 1 1 0 │ 0
0 1 0 1 │ 0
0 1 0 0 │ 0
0 0 1 1 │ 0
0 0 1 0 │ 0
0 0 0 1 │ 1
0 0 0 0 │ 1
Na ja, an der Uni gibt es lineare Algebra 1 und 2, Analysis 1 und 2 und Stochastik. Wenn du in jedem wenigstens Grundkenntnisse hast, dann bist du vom Mathematikbedarf schon gut abgedeckt fürs Programmieren.
Schreib es am besten untereinander auf, dann ist es wie normales Addieren:
ABCD
+70FB
...18
..1C
..C
11
Ergebnis: 11CC8
Vermutlich kommt da "KZU" raus (auch, wenn es keinen Sinn ergibt):
https://www.rapidtables.com/convert/number/hex-to-ascii.html
Die erste Hexadezimal-Stelle wird immer mit 16 multipliziert.
00 = 0
10 = 16
20 = 32
usw.
0x33 wäre zum Beispiel dezimal 51, oktal 63 und binär 0011 0011.
Hallo, das Format ist eigentlich ganz gut beschrieben ... Ich habe dir hier mal einen De-/Encoder in JS geschrieben, den du zum Beispiel mit https://jsfiddle.net/ (in das JavaScript-Feld eintragen) ausführen kannst ...
Das Ergebnis sieht dann so aus, wie im Beispiel:
Code:
function getImage(binaryData) {
const width = 150;
const height = 150;
const cellSize = 30;
// create canvas
let canvas = document.createElement("canvas"),
context = canvas.getContext("2d"),
imgData = context.createImageData(width, height);
canvas.height = height;
canvas.width = width;
let width2, height2, blockSize, colorDepth;
let colors = [];
let pixels = [];
for (let i = 0; i < binaryData.length; ) {
if (i == 0) {
width2 = parseInt(binaryData.substring(i, i + 8), 2);
height2 = parseInt(binaryData.substring(i + 8, i + 16), 2);
blockSize = parseInt(binaryData.substring(i + 16, i + 24), 2);
colorDepth = parseInt(binaryData.substring(i + 24, i + 32), 2);
i += 32;
}
if (i >= 32 && i < Math.pow(2, colorDepth) * 24 + 32) {
let r = parseInt(binaryData.substring(i, i + 8), 2);
let g = parseInt(binaryData.substring(i + 8, i + 16), 2);
let b = parseInt(binaryData.substring(i + 16, i + 24), 2);
colors.push([r, g, b]);
i += 24;
}
if (i >= Math.pow(2, colorDepth) * 24 + 32) {
let color = colors[parseInt(binaryData.substring(i, i + colorDepth), 2)];
let size = parseInt(binaryData.substring(i + colorDepth, i + colorDepth + blockSize), 2);
for (let j = 0; j < size; j++) {
pixels.push(color);
}
i += colorDepth + blockSize;
}
}
for (let i = 0; i < width * height; i++) {
let x = Math.floor((i % width) / cellSize);
let y = Math.floor(i / height / cellSize);
let i2 = y * width2 + x;
let i3 = i * 4;
if (x < width2 && y < height2) {
let color = pixels[i2];
imgData.data[i3] = color[0];
imgData.data[i3 + 1] = color[1];
imgData.data[i3 + 2] = color[2];
imgData.data[i3 + 3] = 255; // Alpha channel
} else {
imgData.data[i3] = 255;
imgData.data[i3 + 1] = 255;
imgData.data[i3 + 2] = 255;
imgData.data[i3 + 3] = 255; // Alpha channel
}
}
// put data to context at (0, 0)
context.putImageData(imgData, 0, 0);
// output image
var img = new Image();
img.src = canvas.toDataURL("image/png");
return img;
}
document.body.appendChild(
getImage(
"00000100 00000101 00000010 00000010 00000000 00000000 00000000 01010101 01010101 01010101 01010101 01010101 01010101 11111111 11111111 11111111 01110001 01011110 10010110 11010001 01011110 00010111 0001"
.split(" ")
.join("")
)
);
Naja, LLMs sind nicht wirklich kreativ.
Doch, sind sie.
Large Language Modelle verstehen, verarbeiten und generieren natürliche Sprache und sind eine Form von generativer künstlicher Intelligenz.
Sie generieren grammatikalisch und orthografisch schlüssige Texte. (Das würde man sich von manchen Studis auch manchmal wünschen ...)
Ich denke, der entscheidende Nachteil ist (noch), dass sie mit riesigen Textmengen über längere Zeiträume trainiert werden müssen.
Aber wäre dieser Nachteil nicht gegeben, hätte ja jeder sein eigenes ChatGPT. ;)
Man könnte auch andersherum rechnen und die Dualzahl in eine Dezimalzahl umwandeln:
MSB Bit 1? Ja, also ist die Zahl negativ. Dann:
101 0110 = 86
(2^7) - 86 = 42
(Anmerkung: (2^7)-1 ist der höchste Wert, der mit 7 Bit darstellbar ist.)
Der Link-Tag sollte so aussehen:
<head>
<link rel="stylesheet" href="styles.css">
</head>
siehe auch hier: https://www.w3schools.com/tags/tag_link.asp
Die Logik oder der logische Teil eines Programms. Wird manchmal auch Programmablauflogik genannt. Andere Teile einer Anwendung können zum Beispiel die Oberfläche/Darstellung oder die Datenhaltung/-modell sein.
Ist nicht so kompliziert. Du hast eine Datenstruktur mit Tupel, wobei die erste Komponente die Anzahl und die zweite Komponente den Preis angibt. Das könnte zum Beispiel ein Array sein. Die Berechnung für jede Aktie ist dann einfach:
menge * preisUsd * umrechnungskurs ...
In JavaScript sähe das so aus:
function umrechnen(menge, preisUsd, umrechnungskursUsdEur) {
return menge * preisUsd * umrechnungskursUsdEur;
}
function gesamtwert(mengePreisArray, umrechnungskursUsdEur) {
let sum = 0;
for (let index = 0; index < mengePreisArray.length; index++) {
sum += umrechnen(mengePreisArray[index][0], mengePreisArray[index][1], umrechnungskursUsdEur);
}
return sum;
}
function demo() {
mengePreisArray = [
[10, 1.2],
[20, 4.2],
[30, 3.0],
];
umrechnungskursUsdEur = 0.95;
console.log(gesamtwert(mengePreisArray, umrechnungskursUsdEur)); // 176.7 EUR
}
demo();
Probiere es aus:
function f(a, b, c, d) {
return (!b && c && d) || (a && !b && c) || (a && !b && !d);
}
function table() {
for (let index = 0; index < 16; index++) {
let x0 = (index & 1) == 1;
let x1 = ((index >> 1) & 1) == 1;
let x2 = ((index >> 2) & 1) == 1;
let x3 = ((index >> 3) & 1) == 1;
let result = f(x3, x2, x1, x0);
if (result) {
console.log(x3 + " " + x2 + " " + x1 + " " + x0 + " (" + index + ")");
}
}
}
table();
Zum Beispiel hier: https://jsfiddle.net/
Das Kreuzchen bei "n." dürfte falsch sein.
Der Trick ist, dass du jeweils nur drei relevante Variablen betrachten musst, da der Term schon als DNF gegeben wurde. Der Wert der vierten Variable ist dann nicht von Belang.
Rein subjektives Empfinden nach: Ja
Nicht alle, aber zum Beispiel ein paar Beweise kann auch eine KI wie zum Beispiel ChatGPT. Probier's mal aus. ;)
Woher kommen die zwei weiteren Bits?
Die zwei weiteren Bits sind einfach führende Nullen, damit der String insgesamt 4 Zeichen lang ist, um so gedanklich einfacher subtrahieren zu können.
Du kannst es auch mit einem Tool testen:
https://ivanzuzak.info/noam/webapps/fsm_simulator/
Der reguläre Ausdruck des DFA sieht so aus:
(a+b)*aabab
Der DFA sieht so aus:
Die zu testende Eingabe ist:
aaababaabaababaab
Bei dieser Eingabe kommt es nicht vor, dass von Zustand 1 auf 0 gewechselt wird, obwohl dies durchaus möglich wäre.
Mit der Eingabe: abaabab würde zum Beispiel am Anfang von Zustand 1 nach 0 gewechselt werden. :)
Das Array funk hat 23 Plätze (von 0 bis 22).
x hat am Anfang den Wert 0 und z den Wert 1.
x entwickelt sich so:
0,2,4,6,8,usw.
Gleichzeitig entwickelt sich z so:
1,3,5,7,9,usw.
Das heißt, in dem Moment, wo x=22 gilt, gilt auch z=23. Und der Zugriff auf das Element mit dem Index 23 ist nicht gestattet, eine AIOOB-Exception wird deshalb ausgelöst.
Um das zu verhindern, könntest du beispielsweise x UND z im Schleifenkopf überprüfen.