Array – die besten Beiträge

Ich habe mehrere Arrays mit Texten, von denen ich in einer Funtkion eins auswählen und zurückgeben möchte.

String inputLower[5][6] = {
    { "a", "b", "c", "d", "e", "f" },
    { "g", "h", "i", "j", "k", "l" },
    { "m", "n", "o", "p", "q", "r" },
    { "s", "t", "u", "v", "w", "x" },
    { "y", "z", "", "", "", "" }
};
...

Folgendes brauche ich:

???? getArray() {
    if (...) return inputLower;
    if (...) return inputUpper;
    ...
}

Wie mache ich das am besten?

Ich möchte in C++ einen int16 in einem char[] buffer speichern und das ganze dann auch wieder als int16 ausgeben. Ich nutze LoRa und bin deshalb genötigt einen 8 bit buffer zu benutzen. Wie kann ich das am besten umsetzen?

Ich als CS Studentin habe große Probleme meine wöchentlichen Abgaben zu machen. Wir haben die Sprache "Java" angefangen und jetzt auch noch mit "Racket". Ich würde einfach mal alle meine Fragen zu diesem Thema erwähnen, weil ich keine Aufnahmestelle in der Uni habe.

Was genau ist Racket? Was sollen diese if und for Schleifen bedeuten,was ist dessen Zweck? Was ist ein "Identifyer"? Was ist der Unterschied zwischen einer public class und einer private class? Wozu werden Arrays verwendet, was bezwecken sie? was bedeutet public void? Was sind Interfaces? Welche Vererbungen, Klassen und Methoden gibt es?

Kennt einer von euch sehr gute und empfehlenswerte Videos, Foren, Seiten für Ersti Informatiker ohne Vorkenntnisse aber mit großem Lerninteresse?

Hat einer von euch vielleicht Lernzettel oder Material was mir helfen könnte?

Für alles mögliche wäre ich euch sehr dankbar!

L.G

Ich programmiere das Game of Live, und habe ein "Anfangs" Array, anhand von dem ich dann schaue ob eine Stelle in der nächsten Runde lebt oder nicht. Daher kann ich dieses Array anfangs nicht verändern, und habe ein neues Array erstellt indem ich die Werte für die nächste Runde vorerst speichere. Damit ich für dieses Array aber keine extra print Methode schreiben muss, dachte ich mir ich könnte einfach das Anfangsarray mit dem zweiten Array überschreiben. Geht das, und wenn ja wie?

(Ich hoffe die Erklärung ist halbwegs verständlich...)

Huhu ich hab's endlich geschafft meinen eigenen Code zu schreiben so dass er funktioniert und ich diesen auch verstehe. Jetzt ist meine nächstes "Problem" die optimierung kann man diesen in kürzerer Form schreiben?

```js

const array = ["3","4","5","6","7"];

for (let i= 0; i<=15; i++){

 console.log(array[0].repeat(20-i)+array[1].repeat(i));

}

for (let i= 16; i<=20; i++){

 console.log(array[0].repeat(20-i)+array[1].repeat(i));

 console.log(array[0].repeat(20-i)+array[1].repeat(i));

}

for (let i= 21; i<=35; i++){

 console.log(array[1].repeat(40-i)+array[2].repeat(i-20));

}

for (let i= 36; i<=40; i++){

 console.log(array[1].repeat(40-i)+array[2].repeat(i-20));

 console.log(array[1].repeat(40-i)+array[2].repeat(i-20));

}

for (let i= 41; i<=55; i++){

 console.log(array[2].repeat(60-i)+array[3].repeat(i-40));

}

for (let i= 56; i<=60; i++){

 console.log(array[2].repeat(60-i)+array[3].repeat(i-40));

 console.log(array[2].repeat(60-i)+array[3].repeat(i-40));

}

for (let i= 61; i<=75; i++){

 console.log(array[3].repeat(80-i)+array[4].repeat(i-60));

}

for (let i= 76; i<=80; i++){

 console.log(array[3].repeat(80-i)+array[4].repeat(i-60));

 console.log(array[3].repeat(80-i)+array[4].repeat(i-60));

}

```

sry hab kein plan wie man hier code formatiert rein haut^^ und danke für die geduld und fürs erklären. PS ich hoffe das kürzere ergebnis wird nicht zu kryptisch weil ich es dann wenn ich das in 6 wochen nochmal anschaue nicht mehr lesen kann. Dankö und habt einen schönen Start in die Woche🌞✌🏼

Hallo,

ich weiß, ich bin nicht so gut. Allerdings verstehe ich nicht, wie das richtig gehen würde. Was mache ich falsch?

Bitte ohne alles zu ändern, sprich Stack und Co.

public class Solution {
  public bool IsValid(string s) {
    if (s.Length % 2 != 0) {
      return false;
    }

    char[] marks = new char[] { '(', ')', '[', ']', '{', '}' };

    for (int i = 0; i < s.Length / 2; i++) {
      for (int j = 0; j < marks.Length; j++) {
        if (s[i] == marks[j] && s[s.Length - 1 - i] != marks[j + 1]) {
          return false;
        }
      }
    }

    return true;
  }
}

Es geht um einen Algorithmus, der schaut, ob Klammern richtig gesetzt worden sind:

()[) -> false,
()[]([]) -> true

Ich soll ein Programm schreiben das 5 Zahlen als Input nimmt, diese in einem Array speichert und dann die kleinste Zahl des Arrays mit der größten Zahl addiert und outputted.

Mein Code sieht folgendermaßen aus:

```
static void Main(string[] args)
{
    int x = 0;
    int[] arr = new int[5]

    while (x < arr.Length)
    {
        int inputs = int.Parse(Console.ReadLine());
        arr[x] = inputs;
        x++;
    }

    int min_Max_Sum = arr.Min() + arr.Max();
    Console.WriteLine(min_Max_Sum);
}
```

def add_vocabulary(key_word, value_word, form='infinitiv'):
dater = datetime.datetime.now().strftime("%d-%m-%Y")
    try:
        with (open('wordlist.json', 'r', encoding="utf-8-sig") as f):
            data = json.load(f)
            if dater not in data:
                data[dater] = {}
            if "0" not in data[dater]:
                data[dater]["0"] = {}
            if key_word not in data[dater]["0"]:
                data[dater]["0"] = [key_word]
            # KeyError 'h'
            if form not in data[dater]["0"][map(lambda y: y['Tags'], data[key_word])]:
                data[dater]["0"][key_word][form] = {}
                data[str(dater)]["0"][key_word][form] = value_word
                print("added as " + form + ": " + "english: " + key_word + "   german: " + value_word)

            while value_word != data[dater]["0"][key_word][form]:
                twogerman = data[dater]["0"][key_word][form]
                overwrite = input(f'do you want overwrite "%s" to "%s" (y-n): ' % (twogerman, value_word))
                if "y" == overwrite or "yes" == overwrite:
                    old_german = data[str(dater)]["0"][key_word][form]
                    data[str(dater)]["0"][key_word][form] = value_word
                    print("overwrite: " + "   form: " + form + ",   english: " + key_word + ",   german: " + old_german)
                    print("white: " + "   english: " + key_word + ",   german: " + value_word)
                    break
                elif "n" == overwrite or "no" == overwrite:
                    break

        with open('wordlist.json', 'w', encoding="utf-8-sig") as f:
            json.dump(data, f)

Schlüsselwort = h; value_word=j;

Ich möchte über das Schlüsselwort = ['h']-Werte auf die Werte zugreifen

Ich habe es mit mappen versucht, aber es erscheint der gleiche KeyError „h“.

ich finde den namen so toll, geht das so im 3er pack oder eher nicht oder in welches land müsste ich gehen damit das geht, ich kann ja einfach ausreisen baby bennenne und dann wieder einreisen, dann kann ja DE nichts gegen machen

sagen wir ich habe ein array a[ ] = {9,1,5,6,5,9};

jetzt will ich ne funktion schreiben die schaut ob und wenn ja wie oft eine zahl mehrfach vorhanden ist. also hier die 9 2mal und die 5 zweil mal

dafür müsste ich ja das array durchgehen und die i-te zahl mit jeder andere vergleichen, also ab dieser zahl und nicht von vorne.

also bei der 1. 9 mit 1,5,6,5,9 vergleichen

bei der 1 mit 5 6 5 9

bei der 5 mit 6 5 9

und bei der 6 5 9

usw.

wie würde ich da ne funktion schreiben?

Ich habe bereits ein Programm geschrieben, das in das Binärsystem konvertiert. Für das Oktalsystem habe ich einfach eine Acht anstelle einer 2 verwendet. Ich wollte dasselbe mit dem Hexadezimalsystem machen, aber ich habe gemerkt, dass es nicht so einfach ist. Allerdings hatte ich die Idee, das Problem mit einem Array zu lösen, aber ich weiß nicht, wie ich das machen kann...

Guten Tag,

ich muss ein eindimensionales Array erstellen, welches 3 Namen aus dem ersten Tabellenblatt von A1-A3 speichert. Diese sollen dann auf dem zweiten Tabellenblatt von A1-C1 wieder ausgegeben werden. Dabei müssen die Namen in die Tabelle eingetragen werden und daraus entnommen werden. Ich soll dabei "ReDim Preserve" benutzen, doch ich habe keine Ahnung wie ich das machen soll.

Guten Abend,

ich bräuchte mal kurz Hilfe bei folgenden Aufgaben, bitte. Es geht mir darum, dass ich einfach nicht versteh', was zu tun ist. Wir hatten in der Vorlesung den Quicksort-Algorithmus. Ich weiß, dass bei Quicksort das zu sortierende Array in immer kleiner Teilarrays eingeteilt wird, wobei das größere Array zuerst auf den Stack gelegt wird. Das Pivotelement ist entweder das linke oder das rechte und man setzt dann links und rechts einen Pointer am entsprechenden Teilarray. Ist das erste Element des zu sortierenden Teilarrays, welches größer als das Pivotelement ist, gefunden, und es findet sich vom rechten Pointer aus das erste Element, welches kleiner als das Pivotelement ist, so werden diese vertauscht. Bei Überkreuzungen tausche jenes Element auf dass der linke Pointer zeigt mit dem Pivotelement. So hatten wir's zumindest in der Vorlesung (Partitionswahl). Zu den Aufgaben

Aufgabe 1

Ein wichtiger Faktor für die Laufzeit von Quicksort und Quickselect (das Auswahlverfahren des k-kleinsten Elements analog zu Quicksort) ist die Wahl des Pivotelements. Das Pivotelement sollte die zu sortierende Folge in zwei möglichst gleich große Teilfolgen aufspalten.Gegeben sei eine unsortierte Folge mit n paarweise verschiedenen Elementen. Weiterhin sei r(x) die Position des Elements x in der sortierten Folge. Eine mögliche Strategie für die Pivotwahl ist:Wähle uniform zufällig 7 Elemente aus der Eingabefolge und gib das viertkleinste als Pivotelement aus. Dabei können Elemente in der Auswahl mehrmals vorkommen (Ziehen mit Zurücklegen)

.a) Berechne die Wahrscheinlichkeit für das Ereignis: n/4 < r(Pivot) ≤ 3n/4.

b) Nach wie vielen unabhängigen Wiederholungen der Pivotwahl ist zu erwarten, dass der Rang des Pivotelements das erste Mal außerhalb des Intervalls aus Aufgabenteil a) liegt? Hinweis: Du darfst annehmen, dass n= 4·kfür ein k∈N.

Aufgabe 2

Konstruiere eine Folge der Länge7, so dass Quickselect bei Verwendung der Pivotfunktionpivot(links, rechts) =⌈(links+rechts)/2⌉ auf der Suche nach dem viertgrößten Schlüssel die Problemgröße stets nur um 1verringert. Der Algorithmus soll insgesamt also sieben Schritte benötigen, bis er terminiert. Wende Quickselect auf Ihre Folge an, um die Korrektheit zu zeigen

Ansatz Ich verstehe hier nicht, wie n/4 gemeint ist. Wir hatten in der Vorlesung immer das Pivotelement ganz links oder ganz rechts. Jetzt steht hier "Pivot(links,rechts) = [(links+rechts)/2]. Greift man sich also da Element in der Mitte? Das ist bei einer Folge der Länge 7 doch nicht möglich, oder? WIe gehe ich allgemein vor um eine solche Folge zu finden.

LG

Jensek81

Hey, ich möchte feld1 bis feld7 so zusammenfassen, sodass ich das nicht alles einzeln eingeben muss. Dazu finde ich nur leider nichts im Internet.

import tkinter as tk from tkinter import *

modul = tk.Tk()
modul.geometry("900x900")
modul.title("Bunt3x3")
modul.resizable(width=False, height=False)

r = "red"
y = "yellow"
g = "green"
b = "blue"

def change():
  if feld1["bg"] == r:
    feld1.config(bg=g)
    feld3.config(bg=g)
    feld5.config(bg=g)
    feld7.config(bg=g)
    feld2.config(bg=b)
    feld4.config(bg=b)
    feld6.config(bg=b)
    feld8.config(bg=b)

    feldlabel.config(text="Rot & gelb")

  elif feld1["bg"] == g:
    feld1.config(bg=r)
    feld3.config(bg=r)
    feld5.config(bg=r)
    feld7.config(bg=r)
    feld2.config(bg=y)
    feld4.config(bg=y)
    feld6.config(bg=y)
    feld8.config(bg=y)

    feldlabel.config(text="Gruen & blau")

feld1 = tk.Frame(bg=r, width=300, height=300)
feld1.grid(column=1, row=1)
feld3 = tk.Frame(bg=r, width=300, height=300)
feld3.grid(column=3, row=1)
feld5 = tk.Frame(bg=r, width=300, height=300)
feld5.grid(column=1, row=3)
feld7 = tk.Frame(bg=r, width=300, height=300)
feld7.grid(column=3, row=3)
feld2 = tk.Frame(bg=y, width=300, height=300)
feld2.grid(column=2, row=1)
feld4 = tk.Frame(bg=y, width=300, height=300)
feld4.grid(column=1, row=2)
feld6 = tk.Frame(bg=y, width=300, height=300)
feld6.grid(column=3, row=2)
feld8 = tk.Frame(bg=y, width=300, height=300)
feld8.grid(column=2, row=3)

feld = tk.Frame(bg="white", width=300, height=300).grid(column=2, row=2)
feldlabel = tk.Label(text="Gruen & blau", bg="white", fg="black", font=("Arial", 15, "bold"))
feldlabel.grid(column=2, row=2)
feldbutton = tk.Button(text="Farbe aendern!", font=("Arial", 15, "bold"), bg="white", fg="black", command=change).place(x=370, y=470)
modul.mainloop()

Hab gerade eine Frage über verkettete Listen gesehen, und jetzt denke ich mir: Was genau kann denn so eine verkettete Liste mehr als ein Array/Pointer?

Mit realloc kann ich die größe des arrays ja auch während das Programm läuft verändern.. mehr vorteile einer linked list finde ich nicht. also: Warum sollte man eine Linked List hernehmen?

Hallo, ich steige langsam in die Programmierung ein und habe eine Frage zum aktualisieren von Datenreihen. zuerst mal den Code dann die Frage:

int array[50] = { 0 };
for(x=49; x>=1; x = x-1)
{
array[x]=array[x-1]
}
array[0]= NewValue;

Ok also es gibt ein Array mit 50 Werten. Wenn ein neuer Wert (NewValue) kommt dann wird obige Schleife ausgeführt und der neue Wert rückt in [0] und alle folgenden werden um eine Position nach hinten geschoben. Das war bisher meine Methode eine Datenreihe aktuell zu halten wenn neue Werte kommen. 50 Werte zu schreiben um 1 Wert zu aktualisieren ist wohl nicht so effektiv. Ich habe von Ringpuffern gelesen, dass diese eine bessere Alternative darstellen. Auch verstehe ich den Sinn von Pointern aber verstehe nicht wie das anhand meines Beispiels aussehen müsste??? Hat jemand eine Idee wie man die Datenreihe aktualisiert ohne alle 50 Werte einzelnd verschieben zu müssen?

Ist das folgende Struktogramm, welches ich erstellt habe, passend zu meinem Java Merge-Sort Code oder muss ich noch was nachbessern?

Code:

import java.util.Arrays;
import java.util.Random;

public class MergeSortWithMetrics {
  // Zähler für Sortierschritte
  static long comparisons = 0;
  static long assignments = 0;

  public static void main(String[] args) {
    // Konfiguration: Array-Größe und Zahlbereich
    int arraySize = 10000; // Größe des Arrays
    int numberRange = 214748647; // Bereich der Zufallszahlen (0 bis numberRange)
    boolean ArrayAusgebenAn = false;
    boolean StatistikenAn = true;
    
    // Zufälliges Array erstellen
    int[] array = generateRandomArray(arraySize, numberRange);
    if (ArrayAusgebenAn){
      System.out.println("Unsortiertes Array:");
      System.out.println(Arrays.toString(array));
    }
    
    // Zeitmessung starten
    long startTime = System.currentTimeMillis();
    // MergeSort aufrufen
    int[] sortedArray = mergeSort(array);
    // Zeitmessung beenden
    long endTime = System.currentTimeMillis();
    // Sortiertes Array ausgeben
    if (ArrayAusgebenAn){
    System.out.println("Sortiertes Array:");
    System.out.println(Arrays.toString(sortedArray));
    }
    
    // Statistiken ausgeben
    if (StatistikenAn){
    System.out.println("Sortierschritte:");
    System.out.println("Vergleiche: " + comparisons);
    System.out.println("Zuweisungen: " + assignments);
    System.out.println("Zeitmessung: " + (endTime - startTime) + " ms");
    }
    
  }

  // Funktion, um ein zufälliges Array zu generieren
  public static int[] generateRandomArray(int size, int range) {
    Random random = new Random();
    int[] array = new int[size];
    for (int i = 0; i < size; i++) {
      array[i] = random.nextInt(range);
    }
    return array;
  }

  // MergeSort-Algorithmus
  public static int[] mergeSort(int[] array) {
    if (array.length <= 1) {
      return array;
    }

    // Array in zwei Hälften teilen
    int mid = array.length / 2;
    int[] left = Arrays.copyOfRange(array, 0, mid);
    int[] right = Arrays.copyOfRange(array, mid, array.length);

    // Rekursive Sortierung der Hälften
    left = mergeSort(left);
    right = mergeSort(right);
    // Zusammenfügen der sortierten Hälften
    return merge(left, right);
  }

  // Merge-Funktion: Zwei sortierte Arrays zusammenfügen
  public static int[] merge(int[] left, int[] right) {
    int[] merged = new int[left.length + right.length];
    int i = 0, j = 0, k = 0;

    // Elemente vergleichen und in das neue Array einfügen
    while (i < left.length && j < right.length) {
      comparisons++;
      if (left[i] <= right[j]) {
        merged[k++] = left[i++];
      } else {
        merged[k++] = right[j++];
      }
      assignments++;
    }

    // Restliche Elemente hinzufügen
    while (i < left.length) {
      merged[k++] = left[i++];
      assignments++;
    }
    while (j < right.length) {
      merged[k++] = right[j++];
      assignments++;
    }
    return merged;
  }
}

Habe einen sehr tollen Lehrer gefragt ob er mir mit meinen Hausaufgaben helfen könnte, dies tat er auch.

Hatte alles verstanden, ging recht schnell und hat spaß gemacht.

Folgendes Problem: Ich habe vergessen wofür die einzelnen dinge nochmal stehen, außer das x und die 400, das weiß ich... bei i bin ich mir nicht sicher und dieses mit 120 voll vergessen.

Sollte so Reihenhäuser erstellen.

Leider ist das Bild schief. Jedenfalls wollte ich das gerne morgen vorstellen, aber ich glaube nicht dass ich vor dem Unterricht auf ihn treffen werde :(.

Könnte mir das jemand nochmal erklären?

Hey, ich bin grad am kämpfen, ich möchte eine randomzahl aus dem Array bekommen, weiß aber nicht wie!

const int ledPinsS[18] = { 2, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 14, 16 };

ich möchte, dass aus dem Array "ledPinsS" eine random zahl genommen wird, damit ich mit diese eine Random Led einschalten kann!
Ist ein Arduino Mega

Die Built-in-Funktion mapfile (bzw. readarray) ist eine praktische Sache, z. B. lassen sich so über eine while-read-Schleife gut gleichförmige Werte in einer csv-Datei nutzen. Bei der Erkundung der verschiedenen Möglichkeiten bin ich jedoch bei der Option -C hängen geblieben.

Soweit ich das anhand von manpage und diversen Anleitungen herausfinden konnte, kann man mit der Option -c (Kleinbuchstabe) eine bestimmte Anzahl von Indizes einlesen, nach denen mit Hilfe der Option -C (Großbuchstabe) etwas eingefügt werden kann, das sich »Callback« nennt. Leider wurde mir jedoch nicht klar, was genau man mit diesem Callback bewirken kann. Anschauliche Beispiele dazu gibt es im Internet leider keine.

Kann mir jemand ein paar praktische Anwendungsfälle zeigen?