Get-ADUser -Filter {(Enabled -eq "true") -and (Department -like "Personal")}

Um einem Button einen Code zuzuordnen, machst du einfach einen Rechtsklick auf den Button und dann auf Ereignis... dann geht ein Fenster auf, wo du auf "Code-Generator" klickst.

Alternativ kannst du das Eigenschaftenfenster vom Button öffnen und da in die Registerkarte "Eigenschaften" gehen und einen Doppelklick bei "Beim Klicken" machen. Dann steht "[Ereignisprozedur]" drin und wenn du auf die drei Punkte klickst, wird auch der VBA-Editor geöffnet.

Zum eigentlichen Problem: Würde es auch gehen, wenn du den Key und die Anzahl in einem Formular eingibst und dann einfach entsprechend viele Einträge in eine Tabelle geschrieben werden, anstatt dass du einen Eintrag per Hand in die Tabelle schreibst und ihn dann mit der Prozedur mehrmals kopierst?

Wenn du schon ein Formular mit einem Button hast, kannst du da einfach zwei Textfelder anlegen (ich nenne sie mal txtKey und txtCount) und kannst dann für den Button (ich hab ihn hier mal btnInsert genannt) diese Prozedur rein machen:

Option Compare Database
Option Explicit

Private Sub btnInsert_Click()
    Dim count As Integer, i As Integer
    
    ' Textinhalt in Zahl umwandeln, um sicherzugehen, dass eine Zahl eingegeben wurde
    count = Me.txtCount.Value
    
    ' Sicherstellen, dass etwas eingegeben wurde
    If Me.txtKey = "" Then
        MsgBox "Bitte einen Key eingeben"
        Exit Sub
    End If
    
    If count = 0 Then
        MsgBox "Bitte eine Anzahl eingeben"
        Exit Sub
    End If
    
    ' Daten einfügen
    Dim RS As DAO.Recordset
    Set RS = CurrentDb.OpenRecordset("KeyAssignments")
    For i = 1 To count
        ' Man könnte auch currentDB.execute(SQL-Befehl) nehmen, aber das ist anfällig für SQL-Injection Attacken
        RS.AddNew
        RS!Key = Me.txtKey
        RS.Update
    Next i
    
    MsgBox "Es wurden " & count & " Einträge mit dem Key """ + Me.txtKey + """ eingetragen."
End Sub

Die Formel muss auch nicht in das Dropdown-Feld, sondern dahin, wo das x erscheinen soll.

=WENN(A1="x";"x";"")

Statt A1 muss halt die Zelle rein, wo das Dropdown-Feld ist.

127.0.0.1 ist der localhost, also dein eigener PC. Wenn du auf deinem PC also keinen Webserver laufen hast, ist es logisch, dass Chrome dir anzeigt, dass die Webseite nicht geladen werden kann.

Wahrscheinlich reicht es, wenn du eine andere Startseite einstellst. Das geht in Chrome unter der Adresse chrome://settings/onStartup

Du kannst dir das grid-Layout so vorstellen, als wenn du eine Tabelle hättest, wo in jede Zelle ein Steuerelement reinkommt. Die Spaltenbreiten werden also immer an das größte Element angepasst. Da du für den div_btn und den square_btn eine andere Breite, als für alle anderen angegeben hast, wird die Spalte an die beiden Buttons angepasst und es entsteht die Lücke. Wenn du die beiden auch auf Breite 10 setzt, sieht es gut aus.

Ich denke mal, du willst die beiden Buttons unter den Zahlen haben und so breit, wie zwei Zahlenbuttons. Dafür nimmst du am besten bei der Erstellung die width raus, damit die Breite automatisch berechnet wird und fügst dann beim grid die parameter 'columnspan=2' und 'sticky="we" ' hinzu.

div_btn = Button(root, text='/', command=div_btn_press, activebackground='#3a3b3c', background='#2a2b2c', fg='#7a7b7c', height='3')
square_btn = Button(root, text='^', command=square_btn_press, activebackground='#3a3b3c', background='#2a2b2c', fg='#7a7b7c', height='3')

...

div_btn.grid(row=3, column=0, pady=0, padx=0, columnspan = 2, sticky = "we")
square_btn.grid(row=3, column=2, pady=0, padx=0, columnspan = 2, sticky = "we")

Ich denke mal, ein Hintergrundbild zu malen und einen Ball aus der Sprite-Bibliothek rauszusuchen dürfte kein großes Problem sein, oder?

Dann erstellst du einfach ein kleines Programm, was den Ball in eine zufällige Richtung zeigen lässt und was dann eine Endlosschleife startet, in der der Ball bewegt wird und geprüft wird, ob eine Farbe berührt wird:

Und was du in die beiden Abprallen-Blöcke schreiben musst, steht über der Aufgabe. Zumindest den links/rechts-Teil kann man auf dem Bild noch lesen. Ich bin mir ziemlich sicher, dass der oben/unten Teil da auch steht.

Ich hab ein paar Anläufe gebraucht, bis ich kapiert hab, was überhaupt zu tun ist. Wie Mathmaninoff schon sagt, wäre eine kontinuierliche Bewegung schöner. Und was ich bei der Steuerung besser fände: Mach es so, dass man auch zweimal schnell hintereinander links oder rechts drücken kann. Bis jetzt muss man immer warten, bis der Sound für die links/rechts Bewegung abgespielt ist, bevor man nochmal links/rechts drücken kann. Benutze da lieber "start sound" anstatt "play sound until done"

Das kurze duschen nach der Sauna kann man ja kaum duschen nennen. Da hältst du kurz die Luft an und lässt ein paar Sekunden lang das eiskalte Wasser auf dich raufprasseln, um dich direkt danach ins Handtuch einzukuscheln. Also die Dusche ist vorbei, bevor du überhaupt richtig drüber nachdenken kannst.

Ich denke aber, selbst wenn die normale Dusche bei den Umkleiden auch gemischt wäre, würde es mich nicht stören. Man sieht oder zeigt da ja auch nicht mehr, als in der Sauna selbst.

Ein paar Probleme:

1. Dein Ergebnisarray "ia" erstellst du mit der gleichen Länge, wie das Wort, in dem du suchst. In deinem Beispiel ist das Array also 6 Stellen lang, auch wenn du nur zwei Ergebnisse findest.
2. Du prüfst in jedem Schleifendurchlauf, ob find irgendwo in s auftaucht. Also wenn der Suchbegriff nur einmal enthalten ist, wird das if bei jedem Schleifendurchlauf ausgeführt.

Den Rest hat dir regex9 schon erklärt.

Ich würde den String am ehesten mit regulären Ausdrücken durchsuchen. Da wird dir für jeden Fund ein Objekt ausgespuckt, was allerlei Infos hat (wo fängt es an, wo hört es auf, welche Gruppen sind drin, wo fangen die jeweils an oder hören auf...) und du kannst die einfach in ein int[] packen.

Ausführlich mit Kommentaren (man könnte das auch in einer Zeile machen):

public static int[] getIndicies(String s, String find) {
    // Wir benutzen ein Regex-Pattern
    return Pattern
            // und suchen nach find
            // Das "Pattern.quote" ist dafür da, dass man auch nach Zeichen
            // suchen kann, die eigentlich Regex-Steuerzeichen sind
            // Mit Pattern.CASE_INSENSITIVE ist Groß-/Kleinschreibung egal
            .compile(Pattern.quote(find), Pattern.CASE_INSENSITIVE)
            // im String s
            .matcher(s)
            // Dann nehmen wir uns alle Ergebnisse
            .results()
            // Und nehmen uns daraus die start-indizes
            .mapToInt(result -> result.start()) // oder MatchResult::start
            // und wandeln das in ein int[] um, damit wir es zurückgeben können
            .toArray();
}

Falls das eine Schulaufgabe ist und du keine regulären Ausdrücke benutzen darfst und auch keine Objekte, wie z.B. eine List benutzen darfst, kannst du die Funktion so bauen, dass sie immer ab dem letzten Vorkommen des Suchbegriffs weitersucht. Und du musst mitzählen, wie viele Ergebnisse du gefunden hast, damit du am Ende nur die gefundenen Ergebnisse zurückgibst:

public static int[] getIndicies(String s, String find) {
    // beide Parameter in lowerCase umwandeln, damit die Suche ohne
    // Beachtung der Groß-/Kleinschreibung geschieht
    s = s.toLowerCase();
    find = find.toLowerCase();
    // Ergebnisarray erstellen. Die maximale Anzahl an Ergebnissen
    // kann nur so viel sein, wie der String s lang ist.
    int[] indices = new int[s.length()];
    // in count zählen wir einfach, wie oft was gefunden wurde
    int count = 0;
    
    // Suchstring suchen
    int previousIndex = s.indexOf(find);
    // So lange der Suchstring gefunden wird
    while (previousIndex >= 0) {
        // letzten Fund zum Array hinzufügen
        // und Zähler erhöhen
        indices[count++] = previousIndex;
        // und ab dem letzten Fund nochmal suchen
        previousIndex = s.indexOf(find, previousIndex + 1);
    }
    
    // Nur die gefundenen Stellen zurückgeben 
    return Arrays.copyOf(indices, count);
}

Naja, du hast fest in deinem Code stehen, dass er "0.1+ BTC" anzeigen soll. Die URL, die du dir da rausgesucht hast, gibt leider eine komplette Webseite zurück. Wenn du Daten automatisch verarbeiten willst, geht das einfacher mit einer Web-Api (z.B. die von Blockchain.info. Die Dokumentation kannst du dir hier ansehen: https://www.blockchain.com/api/blockchain_api)

Ich weiß nicht, ob du mit deinem Programm am Ende nur deine Freunde verarschen willst, oder ob du wirklich denkst, dass du so an Bitcoins kommst, aber mit der Bitcoin-Adresse kannst du nur den Kontostand der jeweiligen Adresse anschauen. Um an die Bitcoins zu kommen, bräuchtest du den privaten Schlüssel zu der Adresse.

So kannst du z.B. den neuesten Block auslesen und kriegst damit gleich mehrere Adressen mit Bitcoins (ohne dass du dich durch haufenweise leere Konten kämpfen musst)

import requests

def get_block_outputs(block_hash):
    block_data = requests.get("https://blockchain.info/rawblock/" + block_hash).json()
    transactions = block_data["tx"]
    out_data = [tx["out"] for tx in transactions]
    # Die Scripts von Transaktionen ohne Adresse können leider nicht berücksichtigt werden
    out_addresses = [record["addr"] for output in out_data for record in output if "addr" in record.keys()]
    return out_addresses

# Neuesten Block ermitteln und alle Ausgangsadressen extrahieren
latest_block_hash = requests.get("https://blockchain.info/latestblock").json()["hash"]
addresses = get_block_outputs(latest_block_hash)

# Immer nur 100 Adressen auf einmal einlesen
balance_data = dict()
while len(addresses) > 0:
    balance_data.update(requests.get("https://blockchain.info/balance?active=" + "|".join(addresses[:100])).json())
    addresses = addresses[100:]

# Ergebnisse ausgeben    
for key, value in balance_data.items():
    print(f"{key}: {value['final_balance']} sats ({value['final_balance']/100000000} BTC)")

print("======================================================")
total = sum([address["final_balance"] for address in balance_data.values()])
print(f"Total: {total/100000000} BTC")

Leere Datei erstellen:

type nul > C:\temp\text.txt

Datei mit Text erstellen:

echo Ich bin ein Text>C:\temp\text.txt

Zeilen an Datei anfügen:

echo Ich bin die zweite Zeile>>C:\temp\text.txt

Input in eine Variable schreiben (Achtung, keine Leerzeichen um das Gleich-Zeichen machen):

set /p x=Gib mal was nettes ein: 

Ich würde dir aber allgemein empfehlen, dich nicht zu sehr mit Batch zu beschäftigen. Zumindest nicht, um etwas zu programmieren. Um einfach ein paar Programme nacheinander auszuführen, ist es gut, aber nicht wirklich für mehr. Für komplexere Sachen schau dir lieber Powershell an.

Kann sein, dass man das irgendwie über Reflect hinkriegt, aber es wäre sinnvoller, das Vorhaben an sich zu ändern.

Du könntest z.B. ein Array erstellen und damit sozusagen deine Variablen nummerieren:

int[] item = new int[10]; // int-Array mit 10 Elementen erstellen

// den Elementen Werte zuweisen
item[5] = 5;
item[3] = 9;
item[8] = 4;

Oder du benutzt eine HashMap, wo du quasi Variablen benennen kannst:

Map<String, Integer> variablen = new HashMap<>();
variablen.put("item_number_5", 5);

System.out.println(variablen.get("item_number_5"));

Allerdings kann man von einem String nicht mit Minus irgendwas entfernen (also dein Beispiel mit "item_number_5_abc" - "_abc" würde nicht gehen. Ich kann mir auch nicht vorstellen, dass das in JavaScript geht)

Erzähl mal, was du allgemein machen willst, vielleicht kann man dir dann besser helfen.

Ist jetzt ein bisschen die Frage, was du tatsächlich machen sollst. Sollst du die Klasse "Paar" bauen? Wenn ja, soll die Klasse Paar nur numerische Datentypen aufnehmen können? Oder sollst du einfach unabhängig von der Klasse Paar die Methode bauen?

Wenn die Methode unabhängig von der Klasse sein soll, brauchst du keine Generics. Da kannst du einfach als Datentyp das Interface Number angeben:

public double sumGenerisch(Number item1, Number item2) {
	return item1.doubleValue() + item2.doubleValue();
}

Wenn du die Klasse "Paar" bauen sollst und sie nur numerische Typen aufnehmen darf, musst du das im Kopf der Klasse angeben und brauchst der Methode "sumGenerisch" natürlich nichts mitgeben, weil die einfach die vorhandenen Daten der Klassenvariablen benutzen kann:

public class Paar<T extends Number, U extends Number> {
	protected T item1;
	protected U item2;
	
	public Paar(T item1, U item2) {
		this.item1 = item1;
		this.item2 = item2;
	}
	
	public double sumGenerisch() {
		return item1.doubleValue() + item2.doubleValue();
	}
}

Wenn die Klasse Paar alle Objekttypen, also auch nicht-numerische aufnehmen können soll, musst du in sumGenerisch prüfen, ob es Zahlen sind:

public class Paar<T, U> {
	protected T item1;
	protected U item2;
	
	public Paar(T item1, U item2) {
		this.item1 = item1;
		this.item2 = item2;
	}
	
	public double sumGenerisch() {
		if (item1 instanceof Number && item2 instanceof Number) {
			Number value1 = (Number) item1;
			Number value2 = (Number) item2;
			return value1.doubleValue() + value2.doubleValue();
		} else {
			throw new java.lang.IllegalArgumentException("item1 und item2 müssen das Interface \"Number\" implementieren.");
		}
	}
}

Ganz am Anfang hatten die Computer so wenig Speicherplatz, dass ein "Programmierprogramm" gar nicht drauf gepasst hätte. Z.B. der ENIAC hatte eine Speicherkapazität von etwa 100 Bytes. Es würde also nicht mal der erste Satz dieser Antwort in den Speicher passen.

Die ersten Computer wurden noch für jede Aufgabe fest verdrahtet. Später hatten die Computer eine einfache Maschinensprache, so dass man das Programm als Assemblercode mit Stift und Papier aufschreiben konnte und dann relativ einfach in Maschinensprache übersetzen konnte. Die Programme wurden dann oft "gefädelt". Also man hat sich sein Programm per Hand in Maschinensprache übersetzt und dann jede Menge sehr dünne Kabel genommen und sie für jede 1 durch einen Ferritring gefädelt und für jede 0 am Ferritring vorbei geführt. Der Computer konnte dann erkennen, welche Kabel wie gefädelt waren und brauchte nur wenige Byte Ram-Speicher, um das Programm ausführen zu können.

Soweit ich weiß, ist Fortran die erste Hochsprache, die damals auf den großen IBM Computern gelaufen ist. Der Compiler wurde vermutlich gefädelt, der Quellcode im Fortran-Code wurde mit Lochkarten eingelesen und das Ergebnis wieder direkt auf Lochkarten gestanzt.

Die Computer damals hatten aber auch die Möglichkeit, mit Schaltern direkt in den RAM zu schreiben und einzelne Takte per Hand auszuführen. Das wurde recht lange beibehalten und ging auch noch mit den ersten Heimcomputern (z.B. Altair 8800).

Dieses geschlossene System, wie wir es heute kennen, kam erst später. Also dass man einen Computer mit einem laufenden Programm braucht, um selbst ein Programm schreiben zu können.

Noch ein paar zusätzliche Gedanken:

Studenten haben keine natürliche Ordnung. Wenn man dir z.B. 10 Studenten hinstellt und sagt "sortier die mal", dann ist nicht automatisch klar, nach welchem Kriterium sie sortiert werden (es könnte z.B. nach Name (erst Nachname, dann Vorname oder vielleicht auch andersrum), nach Alter, nach Punktzahl, nach Größe, nach Farbe des Pullovers etc. sein). Von daher ist es untypisch, eine Klasse "Student" das Interface Comparable<Student> implementieren zu lassen.

In der Java-Dokumentation steht auch, dass dringend empfohlen wird, dass die compareTo-Funktion konsistent zu der equals-Funktion ist. Also anders gesagt: Wenn die compareTo-Funktion zurückgibt, dass zwei Objekte gleich sind (Rückgabewert 0), dass dann auch die equals-Funktion zurückgeben sollte, dass zwei Objekte gleich sind. Das ist aber nicht der Fall, wenn du zwei Studenten mit der gleichen Punktzahl hast.

Normalerweise würdest du also der Sortierfunktion direkt ein Kriterium mitgeben, nach dem sortiert werden soll. Z.B absteigend nach Punktzahl:

studentenListe.sort(Comparator.comparing(Student::getPunktzahl).reversed());

Nur falls es jetzt für besondere Anlässe eine bestimmte Sortierung gibt (z.B. bei der Zeugnisaugabe am Ende des Studiums sollen alle zuerst absteigend nach Punktzahl, dann nach Nachname und dann nach Vorname sortiert sein), könntest du einen Comparator als öffentliche Konstante in deine Klasse aufnehmen:

public static final Comparator<Student> COMP_ZEUGNISAUSGABE = Comparator.comparing(Student::getPunktzahl).reversed().thenComparing(Student::getNachname).thenComparing(Student::getVorname);

Und noch ein Tipp:

Mal angenommen, Studenten hätten eine natürliche Sortierung nach Punktzahl, würde ich dir empfehlen, die vorhandene compare-Funktion für den jeweiligen Variablentyp zu nehmen. Dadurch vermeidest du Flüchtigkeitsfehler. Z.B. bei int-Werten:

@Override
public int compareTo(Student other) {
	return Integer.compare(this.punktzahl, other.punktzahl);
}

Bei Objekt-Arrays kopiert die Methode "copyOf" nicht die Werte, sondern die Referenzen auf die Objekte des Original-Arrays. Das ist bei Arrays, die scheinbar aus primitiven Typen bestehen (in deinem Fall das double[][]) eine Stolperfalle. Das ist nämlich nicht einfach ein mehrdimensionales Array aus doubles, sondern ein Array aus double-Arrays und die double-Arrays sind Objekte, die per Referenz gespeichert werden. Das heißt, aClone hat Referenzen auf die double-Arrays, die auch in a liegen. Mit dieser Zeile veränderst du also auch die Werte in den Unterarrays von a:

aClone[i][j] -= alpha * aClone[p][j];

Um das zu umgehen, darfst du nicht mit copyOf das ganze Array kopieren, sondern musst jedes Unterarray einzeln kopieren:

double aClone[][] = Arrays.stream(a).map(subArray->Arrays.copyOf(subArray,subArray.length)).toArray(double[][]::new);

Die anderen Antworten hier fand ich bis jetzt noch nicht so aufschlussreich. Ich versuche es mal mit meinen Worten zu erklären:

In Java gibt es nicht wirklich mehrdimensionale Arrays. Zumindest nicht so, wie in anderen Programmiersprachen. In Java werden dafür Arrays aus Arrays benutzt, daher können die Unterarrays auch verschieden lang sein.

Du hast also die Variable "ausgabe", die ein Array aus int-Arrays ist und die Länge 3 hat (weil 3 Unterarrays enthalten sind). Die Unterarrays haben aber verschiedene Längen:

{ 
  {2, 3}, // Unterarray 0 mit Länge 2
  {7, 9, 1}, // Unterarray 1 mit Länge 3
  {4} // Unterarray 2 mit Länge 1
}

Um jetzt zu deiner eigentlichen Frage zurückzukommen, warum in der zweiten Schleife b < ausgabe[a].length steht: In der Variable a steht der Index, der grade behandelt wird (also welches Unterarray grade dran ist). Mit ausgabe[a].length wird also die Länge des aktuellen Unterarrays bestimmt. Wenn du das [a] weglassen würdest, also ausgabe.length würdest du stattdessen ermitteln, wieviele Elemente ausgabe hat. In diesem Fall also 3, weil drei Unterarrays in ausgabe stehen.

In einem anderen Kommentar hast du geschrieben "Wenn alle Unterarrays gleich lang sind, würde ja auch (b<ausgabe.length) reichen". Das stimmt so nicht. Wenn beispielsweise jedes Unterarray drei Zahlen hätte, aber insgesamt 10 Unterarrays in ausgabe stehen würden, würdest du eine ArrayIndexOutOfBoundsException kriegen, weil das Programm dann versuchen würde, in jedem Unterarray bis Index 9 zu zählen. Du müsstest also trotzdem ausgabe[a].length oder zumindest ausgabe[0].length benutzen.

Wenn du im Browser nochmal auf die Adresszeile klickst, siehst du, dass aus dem http ein https geworden ist. Die meisten Webseiten werden automatisch von http auf https weitergeroutet, ohne dass man das als Benutzer mitkriegt.

Http ist auch nicht per se unsicher. Wenn das eine Webseite ist, auf der du keine persönlichen Daten eingibst, sondern nur liest, kann das auch problemlos eine http-Seite sein. Es geht nur darum, dass die Verbindung halt nicht verschlüsselt ist und jemand mitlesen könnte, was du auf der Seite eingibst.

Das Tabellenblatt bezieht die Daten aus dem Blatt "Calculations", was so um die 100 Formeln hat, die sich wiederum auf die ganzen ausgeblendeten Tabellenblätter mit jeweils mehreren 1000 Datensätzen bezieht, daher kann ich da nicht alles durchgucken und schauen, ob ich irgendwelche Bezüge vergessen hab.

Das höchste, was ich finden konnte, war "Hand Ballista" mit Upgrade Level 25

Der Sinn von Klassen ist es, dass du damit Objekte erzeugen kannst und auf die Objekte kannst du dann mithilfe von self zugreifen.

Also um dein Beispiel zu vervollständigen müsstest du ein Objekt vom Typ CIRT anlegen und kannst dann davon die Methode Ram() aufrufen:

if __name__ == '__main__':
    cirt_object = CIRT()
    print(cirt_object.Ram())

Wenn deine Methode keinen Zugriff auf die Parameter eines bestimmten Objektes braucht, kannst du sie auch als Klassenmethode oder als statische Methode anlegen:

class CIRT:
    @staticmethod
    def Ram():
        return 'test'

if __name__ == '__main__':
    print(CIRT.Ram())