Go-Python-Java-C-LeetCode High Decomposition Method – Sammlung der zweiten Woche

Vorwort

Der Go-Sprachteil dieser Problemlösung basiert auf LeetCode-Go.
Der andere Teil basiert auf meinem praktischen Lernen.
Persönliche Problemlösung GitHub-Link: LeetCode-Go-Python-Java-C
Go-Python-Java-C-LeetCode High Auflösungsmethode – Sammlung der ersten Woche Ein Teil
des Inhalts dieses Artikels stammt aus der Online-Sammlung und der persönlichen Praxis. Sollten Informationen Fehler enthalten, können Leser diese gerne kritisieren und korrigieren. Dieser Artikel dient nur zum Lernen und zur Kommunikation, nicht für kommerzielle Zwecke.

8. String zu Integer (atoi)

Thema

Implementieren Sie die myAtoi(string s)Funktion, die eine Zeichenfolge in eine 32-Bit-Ganzzahl mit Vorzeichen konvertiert (ähnlich der atoiFunktion von C/C++).

Der Algorithmus dafür myAtoi(string s)lautet wie folgt:

1. Lesen Sie alle führenden Leerzeichen ein und ignorieren Sie sie.
2. Überprüfen Sie, ob das nächste Zeichen (sofern es nicht bereits am Ende der Zeichenfolge steht) '-'oder ist '+'. Lesen Sie dieses Zeichen ein, wenn dies der Fall ist. Dies bestimmt, ob das Endergebnis negativ oder positiv ist. Gehen Sie davon aus, dass das Ergebnis positiv ist, wenn keines von beiden vorhanden ist.
3. Lesen Sie als nächstes die Zeichen ein, bis das nächste nichtstellige Zeichen oder das Ende der Eingabe erreicht ist. Der Rest der Zeichenfolge wird ignoriert.
4. Wandeln Sie diese Ziffern in eine ganze Zahl um (z "123" -> 123. B. "0032" -> 32). Wenn keine Ziffern gelesen wurden, ist die ganze Zahl 0. Ändern Sie das Vorzeichen nach Bedarf (ab Schritt 2).
5. Wenn die Ganzzahl außerhalb des 32-Bit-Ganzzahlbereichs mit Vorzeichen liegt [-231, 231 - 1], klemmen Sie die Ganzzahl so fest, dass sie im Bereich bleibt. Insbesondere sollten ganze Zahlen, die kleiner als sind , 231auf geklemmt werden 231, und ganze Zahlen, die größer als sind, 231 - 1sollten auf geklemmt werden 231 - 1.
6. Gibt die Ganzzahl als Endergebnis zurück.

Notiz:

• Nur das Leerzeichen ' 'wird als Leerzeichen betrachtet.
• Ignorieren Sie keine anderen Zeichen als das führende Leerzeichen oder den Rest der Zeichenfolge nach den Ziffern.

Beispiel 1:

Input: s = "42"
Output: 42
Explanation: The underlined characters are what is read in, the caret is the current reader position.
Step 1: "42" (no characters read because there is no leading whitespace)
         ^
Step 2: "42" (no characters read because there is neither a '-' nor '+')
         ^
Step 3: "42" ("42" is read in)
           ^
The parsed integer is 42.
Since 42 is in the range [-231, 231 - 1], the final result is 42.

Beispiel 2:

Input: s = "   -42"
Output: -42
Explanation:
Step 1: "   -42" (leading whitespace is read and ignored)
            ^
Step 2: "   -42" ('-' is read, so the result should be negative)
             ^
Step 3: "   -42" ("42" is read in)
               ^
The parsed integer is -42.
Since -42 is in the range [-231, 231 - 1], the final result is -42.

Beispiel 3:

Input: s = "4193 with words"
Output: 4193
Explanation:
Step 1: "4193 with words" (no characters read because there is no leading whitespace)
         ^
Step 2: "4193 with words" (no characters read because there is neither a '-' nor '+')
         ^
Step 3: "4193 with words" ("4193" is read in; reading stops because the next character is a non-digit)
             ^
The parsed integer is 4193.
Since 4193 is in the range [-231, 231 - 1], the final result is 4193.

Beispiel 4:

Input: s = "words and 987"
Output: 0
Explanation:
Step 1: "words and 987" (no characters read because there is no leading whitespace)
         ^
Step 2: "words and 987" (no characters read because there is neither a '-' nor '+')
         ^
Step 3: "words and 987" (reading stops immediately because there is a non-digit 'w')
         ^
The parsed integer is 0 because no digits were read.
Since 0 is in the range [-231, 231 - 1], the final result is 0.

Beispiel 5:

Input: s = "-91283472332"
Output: -2147483648
Explanation:
Step 1: "-91283472332" (no characters read because there is no leading whitespace)
         ^
Step 2: "-91283472332" ('-' is read, so the result should be negative)
          ^
Step 3: "-91283472332" ("91283472332" is read in)
                     ^
The parsed integer is -91283472332.
Since -91283472332 is less than the lower bound of the range [-231, 231 - 1], the final result is clamped to -231 = -2147483648.

Einschränkungen:

• 0 <= s.length <= 200
• sbesteht aus englischen Buchstaben (Klein- und Großbuchstaben), Ziffern ( 0-9), ' ','+'

Die allgemeine Idee des Themas

Bitte implementieren Sie eine myAtoi(string s)-Funktion, damit sie einen String in eine 32-Bit-Ganzzahl mit Vorzeichen konvertieren kann (ähnlich der atoi-Funktion in C/C++).

Der Algorithmus der Funktion myAtoi(string s) ist wie folgt:

• Lesen Sie einen String ein und verwerfen Sie unnötige führende Leerzeichen
• Überprüfen Sie, ob das nächste Zeichen (vorausgesetzt, das Ende des Zeichens ist noch nicht erreicht) positiv oder negativ ist, und lesen Sie dieses Zeichen (falls vorhanden). Bestimmen Sie, ob das Endergebnis eine negative oder positive Zahl ist. Wenn beides nicht vorhanden ist, wird das Ergebnis als positiv angenommen.
• Lesen Sie das nächste Zeichen ein, bis das nächste nicht numerische Zeichen erreicht ist oder das Ende der Eingabe erreicht ist. Der Rest der Zeichenfolge wird ignoriert.
• Konvertieren Sie die in den vorherigen Schritten gelesenen Zahlen in ganze Zahlen (z. B. „123“ -> 123, „0032“ -> 32). Wird keine Zahl eingelesen, ist die Ganzzahl 0. Ändern Sie ggf. die Symbole (beginnen Sie mit Schritt 2).
• Wenn die Ganzzahl den 32-Bit-Ganzzahlbereich mit Vorzeichen [−231, 231 − 1] überschreitet, muss die Ganzzahl gekürzt werden, um sie innerhalb dieses Bereichs zu halten. Insbesondere sollten ganze Zahlen kleiner als −231 auf −231 und ganze Zahlen größer als 231 − 1 auf 231 − 1 festgelegt werden.
• Gibt als Endergebnis eine Ganzzahl zurück.

Beachten:

• Die Leerzeichen in dieser Frage umfassen nur das Leerzeichen „“.
• Ignorieren Sie keine Zeichen außer führenden Leerzeichen oder dem Rest der Zeichenfolge nach Zahlen.

Ideen zur Problemlösung

• Diese Frage ist eine einfache Frage. Die Frage erfordert die Implementierung von Funktionen ähnlich der Funktion C++in . atoiDie Funktion dieser Funktion besteht darin, Zeichenfolgentypnummern in intTypnummern umzuwandeln. Entfernen Sie zunächst die führenden Leerzeichen in der Zeichenfolge und bestimmen Sie das Vorzeichen der aufgezeichneten Zahl. Die führenden Zahlen müssen entfernt werden 0. Konvertieren Sie abschließend die Zahl in einen numerischen Typ, um festzustellen, ob sie intdie Obergrenze des Typs überschreitet [-2^31, 2^31 - 1]. Wenn die Obergrenze überschritten wird, muss die Grenze ausgegeben werden, d. h. -2^31, oder 2^31 - 1.

Lösungsideen für jede Sprachversion:

Geh zur Sprache

1. strings.TrimSpace() entfernt führende Leerzeichen
2. strings.Split() teilt eine Zeichenfolge in ein Array numerischer Zeichen
3. for range iteriert über das Zeichenarray
4. strconv.Atoi() wandelt Zeichen Zeichen für Zeichen in Ganzzahlen um
5. Hängen Sie eine Ganzzahl an ein Array an
6. Bei der Slicing-Operation wird die Summe der Quadrate der ersten 100 Zahlen ermittelt

Python

1. isspace() ermittelt Leerzeichen, isdigit() ermittelt numerische Zeichen
2. int() erzwingt die Konvertierung von Zeichen in Ganzzahlen, Try-Exception fängt Überlauf ab
3. append() fügt Zahlen zu einem Array hinzu
4. itertools.islice() übernimmt die ersten 100 Elemente
5. sum() findet die Summe, pow() findet das Quadrat

Java

1. replaceAll() ersetzt Leerzeichen, split() teilt Strings
2. Character.isDigit() ermittelt numerische Zeichen
3. Integer.parseInt() analysiert eine Ganzzahl
4. ArrayList speichert Ganzzahlen, subList() übernimmt die ersten 100
5. Stream-Streaming-Verarbeitung, MapToInt().sum()-Summierung

C++

1. isspace() ermittelt Leerzeichen, isdigit() ermittelt Zahlen
2. stoi() wandelt Zeichen in Ganzzahlen um
3. vector speichert Zahlen, resize() passt die Größe an
4. akkumulieren und summieren, transformieren und quadrieren
5. Nehmen Sie die ersten 100 Elemente des Vektors zur Verarbeitung

Code

Gehen

func myAtoi(s string) int {
    // 定义最大整数值,是否允许符号,是否允许空白,符号,数字数组
    maxInt, signAllowed, whitespaceAllowed, sign, digits := int64(2<<30), true, true, 1, []int{}
    for _, c := range s {
      // 如果是空格且允许空白,继续
      if c == ' ' && whitespaceAllowed {
         continue
      }
      // 如果允许符号
      if signAllowed {
         // 如果是加号,不再允许符号和空白
         if c == '+' {
            signAllowed = false
            whitespaceAllowed = false
            continue
         } else if c == '-' { // 如果是减号,置符号为-1
            sign = -1
            signAllowed = false
            whitespaceAllowed = false
            continue
         }
      }
      // 如果不是数字,跳出循环
      if c < '0' || c > '9' {
         break
      }
      // 不再允许符号和空白
      whitespaceAllowed, signAllowed = false, false
      // 将字符转换为整数并加入数字数组 
      digits = append(digits, int(c-48))
    }
    // 定义返回值相关变量
    var num, place int64
    place, num = 1, 0
    // 记录最后一个前导0的索引
    lastLeading0Index := -1
    // 找到最后一个前导0
    for i, d := range digits {
       if d == 0 {
          lastLeading0Index = i
       } else {
          break
       }
    }
    // 如果有前导0,去掉前导0
    if lastLeading0Index > -1 {
       digits = digits[lastLeading0Index+1:]
    }
    // 定义正负数最大返回值
    var rtnMax int64
    if sign > 0 {
       rtnMax = maxInt - 1
    } else {
       rtnMax = maxInt
    }
    // 计算数字总位数
    digitsCount := len(digits)
    // 从低位到高位计算数值
    for i := digitsCount - 1; i >= 0; i-- {
       num += int64(digits[i]) * place
       place *= 10
       // 如果超出范围,返回最大值
       if digitsCount-i > 10 || num > rtnMax {
          return int(int64(sign) * rtnMax)
       }
    }
    // 加上符号
    num *= int64(sign)
    return int(num)
}

Python

class Solution:
    def myAtoi(self, s: str) -> int:
        max_int = 2**31 - 1
        min_int = -2**31
        sign = 1 # 符号默认为正
        result = 0 # 结果初始化为0
        index = 0
        n = len(s)
        # 去掉前导空格
        while index < n and s[index] == ' ':
            index += 1
        # 判断符号   
        if index < n and s[index] == '+':
            sign = 1
            index += 1
        elif index < n and s[index] == '-':
            sign = -1
            index += 1
        # 将后续数字字符转换为整数累加
        while index < n and s[index].isdigit():
            digit = int(s[index])
            result = result * 10 + digit
            index += 1
            # 每次处理一个数字后检查是否越界
            if result * sign <= min_int:
                return min_int
            if result * sign >= max_int:
                return max_int
        return sign * result

Java

class Solution {
    public int myAtoi(String s) {
        // 定义变量
        long maxInt = Integer.MAX_VALUE; 
        long minInt = Integer.MIN_VALUE;
        boolean signAllowed = true;
        boolean whitespaceAllowed = true;
        int sign = 1;
        List<Integer> digits = new ArrayList<>();

        for(char c : s.toCharArray()) {
            // 处理空格
            if(c == ' ' && whitespaceAllowed) continue;

            // 处理正负号
            if(signAllowed) {
                if(c == '+') {
                    signAllowed = false;
                    whitespaceAllowed = false;
                    continue;
                } else if(c == '-') {
                    sign = -1;
                    signAllowed = false;
                    whitespaceAllowed = false;
                    continue;
                }
            }

            // 非数字则跳出
            if(c < '0' || c > '9') break;

            // 记录数字
            signAllowed = false;
            whitespaceAllowed = false;
            digits.add(c - '0');
        }

        // 处理前导0
        int lastLeading0 = -1;
        for(int i = 0; i < digits.size(); i++) {
            if(digits.get(i) == 0) lastLeading0 = i;
            else break;
        }
        if(lastLeading0 > -1) {
            digits = digits.subList(lastLeading0+1, digits.size());
        }

        // 计算数值
        long num = 0;
        for(int i = digits.size()-1; i >= 0; i--) {
            num += digits.get(i) * Math.pow(10, digits.size()-1-i);
            
            // 处理越界
            if(sign == 1 && num > maxInt) return (int)maxInt;
            if(sign == -1 && -num < minInt) return (int)minInt;
        }
        
        return (int)(sign * num);
    }
}

Cpp

#include <iostream>
#include <string>
#include <limits>

class Solution {
public:
    int myAtoi(std::string s) {
        int i = 0;
        int sign = 1;
        int result = 0;

        if (s.empty()) {
            return 0;
        }

        // 跳过空格
        while (i < s.size() && s[i] == ' ') {
            i++;
        }

        // 处理正负号
        if (i < s.size() && (s[i] == '+' || s[i] == '-')) {
            sign = (s[i] == '-') ? -1 : 1;
            i++;
        }

        // 转换数字并检查溢出
        while (i < s.size() && isdigit(s[i])) {
            int digit = s[i] - '0';
            if (result > (std::numeric_limits<int>::max() - digit) / 10) {
                return (sign == 1) ? std::numeric_limits<int>::max() : std::numeric_limits<int>::min();
            }
            result = result * 10 + digit;
            i++;
        }

        return result * sign;
    }
};

Grundlegende Wissenspunkte für jede Sprachversion:

Geh zur Sprache

• Strings-Paket: strings.TrimSpace() kann führende Leerzeichen aus einem String entfernen, strings.Contains() bestimmt Teilstrings
• strconv-Paket: strconv.Atoi() String zu Ganzzahl, strconv.Itoa() Ganzzahl zu String
• Arrays und Slicing: Zahlen werden in Arrays gespeichert und können mit append() hinzugefügt werden. Slicing-Operationen benötigen Teilzeichenfolgen.
• für Bereichsdurchquerung: Sie können die Zeichenfolge direkt durchlaufen und über Indizes oder Runentypen auf Zeichen zugreifen.
• Typkonvertierung: Es ist eine Typkonvertierung in Int und Int64 erforderlich, die durch Typumwandlung erreicht wird.

Python

• str-Methode: isspace() ermittelt Leerzeichen, isdigit() ermittelt Zahlen usw.
• Int erzwungene Konvertierung: Direct int() kann eine Zeichenfolge in eine Ganzzahl konvertieren
• try-exclusive: Sie können try-exclusive verwenden, um Überlaufausnahmen bei der Ganzzahlkonvertierung abzufangen
• Mathematikmodul: Stellt die idempotente Hilfsmethode pow() bereit

Java

• Verpackungsklassen: Integer, Long und andere Boxed-Klassen stellen numerische Bereichskonstanten bereit
• ArrayList: Sie können Zahlen dynamisch hinzufügen, subList() akzeptiert Teilzeichenfolgen
• Mathematikklasse: Bietet idempotente mathematische Funktionen
• Typzwang: Konvertierung zwischen int und long muss durchgeführt werden

C++

• Header-Datei: Imits usw. werden benötigt, um numerische Grenzen zu definieren.
• isdigit() ermittelt numerische Zeichen
• String-Verarbeitung: substr() akzeptiert Teilstrings usw.
• Ausnahmen: Ausnahmen können anstelle manueller Grenzbeurteilungen verwendet werden
• Typkonvertierung: statische erzwungene Konvertierung oder stoi, to_string und andere Funktionen

9. Palindromzahl

Thema

Bestimmen Sie, ob eine ganze Zahl ein Palindrom ist. Eine Ganzzahl ist ein Palindrom, wenn sie rückwärts wie vorwärts dasselbe liest.

Beispiel 1 :

Input: 121
Output: true

Beispiel 2 :

Input: -121
Output: false
Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.

Beispiel 3 :

Input: 10
Output: false
Explanation: Reads 01 from right to left. Therefore it is not a palindrome.

Follow-up :

Könnten Sie es lösen, ohne die Ganzzahl in eine Zeichenfolge umzuwandeln?

Die allgemeine Idee des Themas

Bestimmen Sie, ob eine ganze Zahl ein Palindrom ist. Eine Palindromzahl ist eine Ganzzahl, die in Vorwärtsreihenfolge (von links nach rechts) und Rückwärtsreihenfolge (von rechts nach links) dasselbe liest.

Ideen zur Problemlösung

• Bestimmen Sie, ob eine ganze Zahl ein Palindrom ist.
• Einfache Frage. Beachten Sie, dass es negative Zahlen geben wird. Negative Zahlen, einzelne Ziffern und 10 sind keine Palindrome. Andere ganze Zahlen werden nach den Regeln von Palindromen beurteilt.
  Go-Sprachversion:

1. Verwenden Sie if, um den Fall negativer Zahlen und 0 am Ende zu bestimmen, und geben Sie direkt false zurück.
2. Verwenden Sie eine for-Schleife, um kontinuierlich den Rest von x zu nehmen, jede Zahl abzurufen und sie im Slice-Arr zu speichern
3. Bestimmen Sie die Länge des Schnitts, durchlaufen Sie ihn von beiden Enden zur Mitte und stellen Sie fest, ob er gleich ist.
4. Wenn sie nicht gleich sind, geben Sie direkt false und am Ende des Durchlaufs true zurück.

Python-Sprachversion:

1. Verwenden Sie if, um negative Zahlen zu ermitteln und direkt false zurückzugeben.
2. Konvertieren Sie die Ganzzahl in eine Zeichenfolge s, um die anschließende Durchquerung zu erleichtern
3. Ermitteln Sie die Länge einer Saite und durchlaufen Sie die Saite von beiden Enden bis zur Mitte
4. Bestimmen Sie, ob die Zeichen gleich sind, geben Sie false zurück, wenn sie nicht gleich sind, und geben Sie true zurück, wenn der Durchlauf abgeschlossen ist

Java-Sprachversion:

1. Methode 1: Konvertieren Sie ähnlich wie bei Python Ganzzahlen in Zeichenfolgen
2. Bestimmen Sie die Länge der Zeichenfolge, durchlaufen Sie sie von beiden Enden zur Mitte und stellen Sie fest, ob die Zeichen gleich sind
3. Methode 2: Ganzzahlen direkt durch ganzzahlige Division und Rest verarbeiten
4. Verwenden Sie eine While-Schleife, um Stück für Stück zu vergleichen und festzustellen, ob es sich um ein Palindrom handelt.

C++-Sprachversion:

1. Verwenden Sie if, um negative Zahlen zu ermitteln und direkt false zurückzugeben.
2. Verwenden Sie eine While-Schleife, um den Rest von x zu nehmen und jede Ziffer im Vektor zu speichern.
3. Bestimmen Sie die Länge des Vektors, durchlaufen Sie ihn von beiden Enden zur Mitte und stellen Sie fest, ob er gleich ist.
4. Für den Betrieb kann es auch in eine Zeichenfolge umgewandelt werden. Die Idee ist dieselbe wie oben
5. Wenn sie nicht gleich sind, geben Sie direkt false und am Ende des Durchlaufs true zurück.

Code

Gehen

// 解法一
func isPalindrome(x int) bool {
    if x < 0 { // 如果x是负数,返回false
       return false
    }
    if x == 0 { // 如果x是0,返回true
       return true
    }
    if x%10 == 0 { // 如果x能被10整除,返回false
       return false
    }
    arr := make([]int, 0, 32) // 创建一个空切片arr
    for x > 0 { // 当x大于0时循环
       arr = append(arr, x%10) // 将x对10取余作为个位数存入arr
       x = x / 10 // x整除10
    }
    sz := len(arr) // 获得arr的长度
    for i, j := 0, sz-1; i <= j; i, j = i+1, j-1 { // 从头尾两边向中间遍历arr
       if arr[i] != arr[j] { // 如果两边的数字不相等
          return false // 返回false
       }
    }
    return true // 遍历完成,说明是回文,返回true
}
// 解法二 数字转字符串
func isPalindrome(x int) bool {
    if x < 0 { // 如果x是负数,返回false
       return false
    }
    if x < 10 { // 单位数都是回文,返回true
       return true
    }
    s := strconv.Itoa(x) // 将x转为字符串
    length := len(s) // 获得字符串长度
    for i := 0; i <= length/2; i++ { // 从两头向中间遍历字符串
       if s[i] != s[length-1-i] { // 如果两边的字符不相等
          return false // 返回false
       }
    }
    return true // 遍历完成,说明是回文,返回true
} 

Python

class Solution:
    def isPalindrome(self, x: int) -> bool:
        # 方法一
        if x < 0:
            return False
        if x == 0:
            return True
        if x % 10 == 0:
            return False
        arr = []
        while x > 0:
            arr.append(x % 10)
            x //= 10
        n = len(arr)
        for i in range(n // 2):
            if arr[i] != arr[n - 1 - i]:
                return False
        return True
class Solution:
    def isPalindrome(self, x: int) -> bool:
        # 方法二
        if x < 0:
            return False
        if x < 10:
            return True
        s = str(x)
        n = len(s)
        for i in range(n // 2):
            if s[i] != s[n - 1 - i]:
                return False
        return True 

Java

class Solution {    
  // 解法一:整数转换为字符串
  public boolean isPalindrome(int x) {
    if (x < 0) {
      return false;
    }
    if (x < 10) {
      return true;
    }
    String s = String.valueOf(x);
    int length = s.length();
    for (int i = 0; i <= length / 2; i++) {
      if (s.charAt(i) != s.charAt(length - 1 - i)) {
        return false;
      }
    }
    return true;
  }

}

class Solution {
  // 解法二:直接对整数操作
  public boolean isPalindrome(int x) {
    if (x < 0) {
      return false;
    }
    if (x == 0) {
      return true;
    }
    int div = 1;
    while (x / div >= 10) {
      div *= 10;
    }
    while (x != 0) {
      int left = x / div;
      int right = x % 10;
      if (left != right) {
        return false;
      }
      x = (x % div) / 10;
      div /= 100;
    }
    return true;
  }
}

Cpp

class Solution {
public:
    bool isPalindrome(int x) {
        // 方法一
        if(x < 0) return false;
        if(x == 0) return true;
        if(x % 10 == 0) return false;
        vector<int> arr;
        while(x > 0) {
            arr.push_back(x % 10);
            x /= 10;
        }
        int n = arr.size();
        for(int i = 0; i < n / 2; i++) {
            if(arr[i] != arr[n - 1 - i])
                return false;
        }
        return true;

    }
}; 
class Solution {
public:
    bool isPalindrome(int x) {
        // 方法二
        if(x < 0) return false;
        if(x < 10) return true;
        string s = to_string(x);
        int n = s.size();
        for(int i = 0; i < n / 2; i++) {
            if(s[i] != s[n - 1 - i])
                return false;
        }
        return true;

    }
}; 

Erforderliche Grundkenntnisse für jede Sprachversion:

Go-Sprachversion:

1. Wenn eine bedingte Beurteilung vorliegt, beurteilen Sie die Situation der negativen Zahlen und 0 gemäß den Anforderungen der Frage
2. Definition von Slice und Anhängen zum Hinzufügen von Elementen
3. für Schleife durchquert Slices
4. len() ermittelt die Slice-Länge
5. Der %-Restoperator erhält jede Ziffer
6. /=-Operator dividiert und weist Werte zu

Python-Sprachversion:

1. wenn die Bedingung eine negative Zahl und 0 bestimmt
2. Konvertieren Sie eine Ganzzahl in einen String str()
3. len() ermittelt die Länge einer Zeichenfolge
4. String-Traversal und Indexzugriff s[i]
5. //Operator ganzzahlige Division

Java-Sprachversion:

1. wenn die Bedingung eine negative Zahl und 0 bestimmt
2. String-Klasse und ihre Methode charAt()
3. Stringdurchquerung und Länge len
4. Ganzzahliger Divisionsoperator / und Restoperator %
5. while-Schleife

C++-Sprachversion:

1. wenn die Bedingung eine negative Zahl und 0 bestimmt
2. Der Vektorcontainer fügt Push_back und Traversal hinzu
3. size() ermittelt die Länge des Vektors
4. String-Konvertierung in_string und Traversierung
5. Der %-Restoperator erhält jede Ziffer
6. /=-Operator dividiert und weist Werte zu

10. Vergleich regulärer Ausdrücke

Thema

Implementieren Sie bei gegebener Eingabezeichenfolge s und einem Muster p den regulären Ausdrucksabgleich mit Unterstützung für „.“ und wo:

'.' Entspricht einem beliebigen einzelnen Zeichen.
​​​​ ' *' Entspricht null oder mehr des vorhergehenden Elements.
Der Abgleich sollte die gesamte Eingabezeichenfolge abdecken (nicht teilweise).

Beispiel 1:

Eingabe: s = „aa“, p = „a“
Ausgabe: false
Erläuterung: „a“ stimmt nicht mit der gesamten Zeichenfolge „aa“ überein.
Beispiel 2:

Eingabe: s = „aa“, p = „a*“
Ausgabe: wahr
Erläuterung: „*“ bedeutet null oder mehr des vorhergehenden Elements „a“. Wenn man also „a“ einmal wiederholt, wird es zu „aa“.
Beispiel 3:

Eingabe: s = „ab“, p = „. "
Ausgabe: true
Erläuterung: ". „bedeutet „null oder mehr (*) eines beliebigen Zeichens (.)“.

Die allgemeine Idee des Themas

Implementieren Sie bei gegebener Zeichenfolge s und einem Zeichenmuster p einen regulären Ausdrucksabgleich, der „.“ und „*“ unterstützt.

„.“ stimmt mit jedem einzelnen Zeichen überein.
„*“ stimmt mit null oder mehr des vorherigen Elements überein
. Der sogenannte Match soll die gesamte Zeichenfolge abdecken, nicht einen Teil der Zeichenfolge.

Ideen zur Problemlösung

Go-Sprache:

1. Verwenden Sie dynamische Programmierung, um ein zweidimensionales Array f[i][j] zu lösen und zu definieren, um darzustellen, ob die ersten i Zeichen von s und die ersten j Zeichen von p übereinstimmen.
2. Initialisieren Sie f[0][0] auf true, um anzuzeigen, dass die beiden Zeichenfolgen übereinstimmen, wenn sie leer sind.
3. Verwenden Sie eine doppelschichtige for-Schleife für die Statusübertragung. Berücksichtigen Sie die beiden Situationen , in denen das aktuelle Zeichen „ “ und nicht „ “ ist.
4. Wenn p[j-1]='*' ist, wird die Diskussion in zwei Fälle unterteilt: Verwenden und Nicht-Verwenden.
5. Verwenden Sie nicht '*', erben Sie direkt das Ergebnis von f[i][j-2]
6. Mit '*' müssen Sie prüfen, ob s[i-1] und p[j-2] übereinstimmen. Wenn sie übereinstimmen, erben Sie f[i-1][j]
7. Wenn es nicht „*“ ist, bestimmen Sie, ob s[i-1] und p[j-1] übereinstimmen. Wenn sie übereinstimmen, wird f[i-1][j-1] geerbt.
8. Geben Sie f[m][n] als Endergebnis zurück

Python-Sprache:

1. Verwenden Sie auch dynamische Programmierung + zweidimensionales Array f
2. Initialisieren Sie f[0][0] auf true
3. Doppelschichtige for-Schleife zur Lösung des Zustandsübergangs
4. Wenn p[j-1] „*“ ist, gibt es zwei Situationen: nicht verwenden und verwenden.
5. Wenn Sie die Vererbung f[i][j-2] nicht verwenden, müssen Sie überprüfen, ob s[i-1] und p[j-2] übereinstimmen.
6. Wenn es nicht „*“ ist, wird davon ausgegangen, dass s[i-1] und p[j-1] übereinstimmen, und f[i-1][j-1] wird vererbt.
7. Geben Sie f[m][n] als Ergebnis zurück

Java-Sprache:
Die Idee ist die gleiche wie oben:

1. Dynamische Programmierung, definieren Sie das boolesche Array f[i][j]
2. Initialisieren Sie f[0][0] auf true
3. Zweischichtige for-Schleife zur Zustandsübertragung
4. Besprechen Sie die „ “- und „Nicht “-Situationen
5. „*“ berücksichtigt zwei Situationen: Nichtnutzung und Nutzung.
6. Nicht-'*' bestimmt, ob das vorherige Zeichen übereinstimmt
7. Geben Sie f[m][n] als endgültige Lösung zurück

C++-Sprache:

1. Initialisieren Sie f mithilfe eines zweidimensionalen Vektors und dynamischer Programmierung
2. f[0][0] ist wahr
3. Doppelschichtige for-Schleife für die Zustandsübertragung
4. Wenn p[j-1] „*“ ist, wird es in nicht verwendete und verwendete Situationen unterteilt.
5. Verwenden Sie nicht die Vererbung f[i][j-2], sondern verwenden Sie sie, um die Übereinstimmung zu überprüfen
6. Andernfalls stellen Sie fest, ob das vorherige Zeichen übereinstimmt
7. Geben Sie f[m][n] als Ergebnis zurück

Code

Gehen

func isMatch(s string, p string) bool {
    // 定义s和p的长度
    m, n := len(s), len(p)
    // 判断s和p的子串从i和j位置开始是否匹配
    matches := func(i, j int) bool {
        // 如果i为0,说明s为空,返回false
        if i == 0 {
            return false
        }
        // 如果p[j-1]为'.',代表通配符,返回true
        if p[j-1] == '.' {
            return true
        }
        // 否则判断s[i-1]和p[j-1]是否相等
        return s[i-1] == p[j-1]
    }
    // 初始化二维数组f为m+1行n+1列
    f := make([][]bool, m + 1)
    for i := 0; i < len(f); i++ {
        f[i] = make([]bool, n + 1)
    }
    // 边界条件,如果s和p均为空,返回true
    f[0][0] = true
    // 动态规划状态转移
    for i := 0; i <= m; i++ {
        for j := 1; j <= n; j++ {
            // 如果p[j-1]为'*',有两种情况
            if p[j-1] == '*' {
                // 1. 不使用'*',直接继承f[i][j-2]的结果
                f[i][j] = f[i][j] || f[i][j-2]
                // 2. 使用'*',当s[i-1]和p[j-2]匹配时,继承f[i-1][j]的结果
                if matches(i, j - 1) {
                    f[i][j] = f[i][j] || f[i-1][j]
                }
            // 如果s[i-1]和p[j-1]匹配,继承f[i-1][j-1]的结果
            } else if matches(i, j) {
                f[i][j] = f[i][j] || f[i-1][j-1]
            }
        }
    }
    // 返回最终结果f[m][n]
    return f[m][n]
} 

Python

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        m, n = len(s), len(p)
        f = [[False] * (n+1) for _ in range(m+1)]
        f[0][0] = True
        for i in range(m+1):
            for j in range(1, n+1):
                if p[j-1] == '*':
                    f[i][j] |= f[i][j-2]
                    if self.matches(s, p, i, j-1):
                        f[i][j] |= f[i-1][j]
                else:
                    if self.matches(s, p, i, j):
                        f[i][j] |= f[i-1][j-1]
        return f[m][n]
    def matches(self, s, p, i, j):
        if i == 0:
            return False
        if p[j-1] == '.':
            return True
        return s[i-1] == p[j-1]

Java

class Solution {
    public boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();
        boolean[][] f = new boolean[m + 1][n + 1];
        f[0][0] = true;
        for (int i = 0; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (p.charAt(j-1) == '*') {
                    f[i][j] = f[i][j-2];
                    if (matches(s, p, i, j-1)) {
                        f[i][j] = f[i][j] || f[i-1][j];
                    }
                } else {
                    if (matches(s, p, i, j)) {
                        f[i][j] = f[i-1][j-1];
                    }
                }
            }
        }
        return f[m][n];
    }
    public boolean matches(String s, String p, int i, int j) {
        if (i == 0) {
            return false;
        }
        if (p.charAt(j-1) == '.') {
            return true;
        }
        return s.charAt(i-1) == p.charAt(j-1);
    }
}

Cpp

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size();
        int n = p.size();
        vector<vector<bool>> f(m + 1, vector<bool>(n + 1, false));
        f[0][0] = true;
        for (int i = 0; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (p[j-1] == '*') {
                    f[i][j] = f[i][j-2];
                    if (matches(s, p, i, j-1)) {
                        f[i][j] = f[i][j] || f[i-1][j];
                    }
                } else {
                    if (matches(s, p, i, j)) {
                        f[i][j] = f[i-1][j-1];
                    }
                }
            }
        }
        return f[m][n];
    }
    bool matches(string s, string p, int i, int j) {
        if (i == 0) {
            return false;
        }
        if (p[j-1] == '.') {
            return true;
        }
        return s[i-1] == p[j-1];
    }
};

Go-Sprache:

1. Definition von Array/Slice: var arr [n]type, initialisieren, len, um die Länge zu erhalten
2. String-Zugriff: s[i] ruft Zeichen nach Index ab
3. Funktionsdefinition: func xxx (Parameter) Rückgabewerttyp {}
4. if-Bedingungsbeurteilung: if-Bedingung {} else {}
5. for-Schleife: zur Initialisierung; Bedingung; Follow-up {}
6. Logisches ODER: ||
7. Rückgabewert: Direkte Rückgabe, mehrere Werte können zurückgegeben werden

Python:

1. Listengenerierung:[[0]* n für _ im Bereich(m)]
2. String-Zugriff: s[i], Index beginnt bei 0
3. Funktionsdefinition: Def. Funktionsname (Parameter):
4. Bedingtes Urteil: if Bedingung: elif: else:
5. for-Schleife: für Variable in Sammlung:
6. Logisches ODER: |
7. Rückgabewert: Direkt zurückgeben

Java:

1. Array-Definition: Typ [] Array-Name = neuer Typ [Länge]
2. String-Zugriff: string.charAt(index)
3. Funktionsdefinition: Funktionsname des Rückgabewerttyps (Parameter) {}
4. Bedingtes Urteil: if() {} else {}
5. for-Schleife: for (Initialisierung; Bedingung; Inkrement) {}
6. Logisches ODER: ||
7. Rückgabewert: Ergebnis zurückgeben;

C++:

1. Vektordefinition: Vektor<Typ> Name (Größe)
2. String-Zugriff: string[index]
3. Funktionsdefinition: Funktionsname des Rückgabewerttyps (Parameter) {}
4. Bedingtes Urteil: if() {} else {}
5. for-Schleife: for (Initialisierung; Bedingung; Inkrement) {}
6. Logisches ODER: ||
7. Rückgabewert: Ergebnis zurückgeben;

11. Behälter mit dem meisten Wasser

Thema

Gegeben sind n nichtnegative ganze Zahlen a1, a2, …, an, wobei jede einen Punkt an der Koordinate (i, ai) darstellt. Es werden n vertikale Linien so gezeichnet, dass die beiden Endpunkte der Linie i bei (i, ai) und (i, 0) liegen. Finden Sie zwei Linien, die zusammen mit der x-Achse einen Behälter bilden, sodass der Behälter das meiste Wasser enthält.

Hinweis: Der Behälter darf nicht geneigt sein und n ist mindestens 2.

[Externer Link Bildübertragung fehlgeschlagen. Die Quellseite verfügt möglicherweise über einen Anti-Leeching-Mechanismus. Es wird empfohlen, das Bild zu speichern und direkt hochzuladen (img-P3DovAkA-1692502410923)(https://s3-lc-upload.s3.amazonaws .com/uploads/2018 /07/17/question_11.jpg)]

Die obigen vertikalen Linien werden durch das Array [1,8,6,2,5,4,8,3,7] dargestellt. In diesem Fall beträgt die maximale Wasserfläche (blauer Bereich), die der Behälter aufnehmen kann, 49.

Beispiel 1:

Input: [1,8,6,2,5,4,8,3,7]
Output: 49

Die allgemeine Idee des Themas

Bei einem Array nicht negativer Ganzzahlen a1, a2, a3, ... an identifiziert jede Ganzzahl eine Wand mit einer Höhe ai, die an der x-Position der Koordinatenachse errichtet wird. Wählen Sie zwei Wände und den durch die x-Achse gebildeten Behälter aus kann das meiste Wasser aufnehmen.

Ideen zur Problemlösung

Diese Frage ist auch die Idee kollidierender Zeiger. Am Anfang und am Ende gibt es zwei Zeiger. Nach jeder Bewegung wird beurteilt, ob das Produkt aus Länge und Breite das größte ist.

Go-Version

• Definieren Sie den maximalen Bereich max, den Anfang und das Ende des linken und rechten Zeigers
• Beginn der Schleifenbeurteilung<Ende
• Berechnen Sie die Breite als End-Anfang
• Höhe hoch auf 0 initialisieren
• Bestimmen Sie die Größe von height[start] und height[end]
• Nehmen Sie den kleineren Wert für Höhe hoch
• Bewegen Sie den Zeiger mit kleinerer Höhe
• Berechnen Sie die Flächentemperatur als Breite*Höhe
• Temperatur und Maximum vergleichen, Maximum aktualisieren

Python-Version

• Definieren Sie die maximale Fläche max und die linken und rechten Zeiger beginnen und enden auf beide Enden der Liste
• Beginn der Schleifenbeurteilung<Ende
• Berechnen Sie die Breite als End-Anfang
• Höhe hoch auf 0 initialisieren
• Bestimmen Sie die Größe von height[start] und height[end]
• Nehmen Sie den kleineren Wert für Höhe hoch
• Bewegen Sie den Zeiger mit kleinerer Höhe
• Berechnen Sie die Fläche als Breite * Höhe
• Fläche und Max vergleichen, Max aktualisieren

Java-Version

• Definieren Sie die maximale Fläche max und die linken und rechten Zeiger beginnen und enden auf beiden Enden des Arrays
• Beginn der Schleifenbeurteilung<Ende
• Berechnen Sie die Breite als End-Anfang
• Höhe hoch auf 0 initialisieren
• Bestimmen Sie die Größe von height[start] und height[end]
• Nehmen Sie den kleineren Wert für Höhe hoch
• Bewegen Sie den Zeiger mit kleinerer Höhe
• Berechnen Sie die Flächentemperatur als Breite*Höhe
• Temperatur und Maximum vergleichen, Maximum aktualisieren

C++-Version

• Definieren Sie die maximale Fläche max und die linken und rechten Zeiger beginnen und enden auf beiden Enden des Vektors
• Beginn der Schleifenbeurteilung<Ende
• Berechnen Sie die Breite als End-Anfang
• Höhe hoch auf 0 initialisieren
• Bestimmen Sie die Größe von height[start] und height[end]
• Nehmen Sie den kleineren Wert für Höhe hoch
• Bewegen Sie den Zeiger mit kleinerer Höhe
• Berechnen Sie die Flächentemperatur als Breite*Höhe
• Temperatur und Maximum vergleichen, Maximum aktualisieren

Code

Gehen

func maxArea(height []int) int {
    // 初始化最大面积max为0,start为0,end为数组长度-1
    max, start, end := 0, 0, len(height)-1 
    // 当start小于end时循环
    for start < end {
       // 宽度为end-start
       width := end - start 
       // 高初始化为0 
       high := 0
       // 如果start位置的高度小于end位置 
       if height[start] < height[end] {
          // 高为start位置的高度
          high = height[start]
          // start加1
          start++
       } else {
          // 否则高为end位置的高度
          high = height[end]
          // end减1
          end--
       }
       // 临时面积为宽乘高
       temp := width * high
       // 如果临时面积大于最大面积
       if temp > max {
          // 更新最大面积
          max = temp
       }
    }
    // 返回最大面积
    return max
}

Python

class Solution:
    def maxArea(self, height: List[int]) -> int:
        # 初始化最大面积为0,左右指针start和end分别指向列表两端
        max_area = 0
        start = 0
        end = len(height) - 1
        while start < end:
            # 计算当前宽度
            width = end - start
            # 初始化高度为0
            high = 0
            if height[start] < height[end]:
                # 如果左指针对应的高度更小,则取左指针高度
                high = height[start]
                # 左指针右移
                start += 1
            else:
                # 否则取右指针高度
                high = height[end]
                # 右指针左移
                end -= 1
            # 计算当前面积   
            area = width * high
            # 如果当前面积大于最大面积,则更新最大面积
            if area > max_area:
                max_area = area
        return max_area

Java

class Solution {
    public int maxArea(int[] height) {
        // 初始化最大面积为0,左右指针start和end分别指向数组两端
        int max = 0, start = 0, end = height.length - 1;
        while(start < end) {
            // 计算当前宽度
            int width = end - start;
            // 初始化高度为0
            int high = 0;
            if(height[start] < height[end]) {
                // 如果左指针对应的高度更小,则取左指针高度
                high = height[start];
                // 左指针右移
                start++;
            } else {
                // 否则取右指针高度
                high = height[end];
                // 右指针左移
                end--;
            }
            // 计算当前面积
            int temp = width * high;
            // 如果当前面积大于最大面积,则更新最大面积
            if(temp > max) {
                max = temp;
            }
        }
        return max;
    }
}

Cpp

class Solution {
public:
    int maxArea(vector<int>& height) {
        // 初始化最大面积为0,左右指针start和end分别指向向量两端
        int max = 0, start = 0, end = height.size() - 1;
        while(start < end) {
            // 计算当前宽度
            int width = end - start;
            // 初始化高度为0
            int high = 0;
            if(height[start] < height[end]) {
                // 如果左指针对应的高度更小,则取左指针高度
                high = height[start];
                // 左指针右移
                start++;
            } else {
                // 否则取右指针高度
                high = height[end];
                // 右指针左移
                end--;
            }
            // 计算当前面积
            int temp = width * high;
            // 如果当前面积大于最大面积,则更新最大面积
            if(temp > max) {
                max = temp;
            }
        }
        return max;
    }
};

Erforderliche Grundkenntnisse für jede Sprachversion:

Go-Version

Die Go-Sprachversion erfordert folgende Kenntnisse:

• Variablendeklaration – :=Deklaration verwenden und Variablen initialisieren
• Array – Verwenden Sie []int„declare array“, len(), um die Länge des Arrays zu ermitteln
• for-Schleife – für Startbedingung; Endbedingung; Schritt
• if-Bedingungsbeurteilung – if-Bedingung {} else {}
• Addition und Subtraktion - +, -
• Multiplikation - *
• Größer als kleiner als - >,<
• Rückgabewert – Verwendungreturn

Python-Version

Die Python-Version erfordert folgende Kenntnisse:

• Variable – Der Typ muss nicht deklariert werden, sondern weist den Wert einfach direkt zu.
• Liste – Verwenden Sie []die deklarierte Liste len(), um die Länge zu erhalten
• while-Schleife - while-Bedingung:
• wenn Bedingungsurteil - wenn Bedingung: ,else:
• Addition und Subtraktion - +, -
• Multiplikation - *
• Größer als kleiner als - >,<
• Rückgabewert - Rückkehr

Java-Version

Die Java-Version erfordert folgende Kenntnisse:

• Variablendeklaration – Deklarieren Sie den Variablentyp, z.B.int
• Array – Verwenden Sie int[]„declare array,.length“, um die Länge zu erhalten
• for-Schleife oder while-Schleife
• if bedingtes Urteil - if() {} else {}
• Addition und Subtraktion - +, -
• Multiplikation - *
• Größer als kleiner als - >,<
• Rückgabewert - Rückkehr

C++-Version

Die C++-Version erfordert folgende Kenntnisse:

• Variablendeklaration – Deklarieren Sie den Variablentyp, z.B.int
• Vektorcontainer – Vektordeklaration, .size() ruft die Länge ab
• while-Schleife
• if bedingtes Urteil - if() {} else {}
• Addition und Subtraktion - +, -
• Multiplikation - *
• Größer als kleiner als - >,<
• Rückgabewert - Rückkehr

12. Ganzzahl in römisch

Thema

Römische Ziffern werden durch sieben verschiedene Symbole dargestellt: I, V, X, L, und .CDM

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

Beispielsweise 2wird wie in römischen Ziffern geschrieben II, nur zwei Einsen werden addiert. 12wird als geschrieben XII, was
einfach ist X + II. Die Zahl wird als 27geschrieben .XXVIIXX + V + II

Römische Ziffern werden normalerweise von links nach rechts vom größten zum kleinsten geschrieben. Die Ziffer für vier ist jedoch nicht IIII.
Stattdessen wird die Zahl vier als geschrieben IV. Da die Eins vor der Fünf liegt, subtrahieren wir sie, was vier ergibt. Das gleiche
Prinzip gilt für die Zahl Neun, die als geschrieben wird IX. Es gibt sechs Fälle, in denen Subtraktion verwendet wird:

• IVkann vor (5) und X(10) platziert werden , um 4 und 9 zu ergeben.
• XLkann vor (50) und C(100) platziert werden , um 40 und 90 zu ergeben.
• CDkann vor (500) und M(1000) platziert werden , um 400 und 900 zu ergeben.

Wandeln Sie eine gegebene ganze Zahl in eine römische Zahl um.

Beispiel 1:

Input: num = 3
Output: "III"

Beispiel 2:

Input: num = 4
Output: "IV"

Beispiel 3:

Input: num = 9
Output: "IX"

Beispiel 4:

Input: num = 58
Output: "LVIII"
Explanation: L = 50, V = 5, III = 3.

Beispiel 5:

Input: num = 1994
Output: "MCMXCIV"
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Einschränkungen:

• 1 <= num <= 3999

Die allgemeine Idee des Themas

Normalerweise stehen kleinere Zahlen in römischen Ziffern rechts von größeren Zahlen. Aber es gibt Sonderfälle. Beispielsweise wird 4 nicht als IIII, sondern als IV geschrieben. Die Zahl 1 steht links von der Zahl 5 und stellt eine Zahl dar, die der großen Zahl
5 minus der Zahl 1 entspricht, was dem Wert 4 entspricht. Ebenso wird die Zahl 9 als IX dargestellt. Diese Sonderregel gilt nur für die folgenden sechs Situationen:

• I kann links von V(5) und X(10) platziert werden, um 4 und 9 darzustellen.
• X kann links von L(50) und C(100) platziert werden, um 40 und 90 darzustellen.
• C kann links von D(500) und M(1000) platziert werden, um 400 und 900 darzustellen.

Wandeln Sie eine gegebene ganze Zahl in römische Ziffern um. Stellen Sie sicher, dass die Eingabe im Bereich von 1 bis 3999 liegt.

Ideen zur Problemlösung

• Geben Sie entsprechend der Bedeutung der Frage großen Zahlen Vorrang und verwenden Sie den Greedy-Algorithmus, um das Problem zu lösen. Fügen Sie die römischen Ziffern im Bereich von 1 bis 3999 in das Array von groß nach klein ein und wählen Sie vom Anfang bis zum Ende aus, um die Ganzzahlen in römische Ziffern umzuwandeln.

Go-Sprachversion:

1. Definieren Sie ganzzahlige Array-Werte und String-Array-Symbole, die alle Kombinationen römischer Ziffern enthalten
2. Die Initialisierungsergebniszeichenfolge res ist leer und der Index i ist 0
3. Verwenden Sie eine for-Schleife, um eine Schleife durchzuführen, wenn num nicht 0 ist
4. Verwenden Sie die if-Beurteilung innerhalb der Schleife. Wenn der Wert in den aktuellen Werten größer als num ist, wird i inkrementiert und übersprungen.
5. Subtrahieren Sie den Wert in aktuellen Werten von num
6. Verbinden Sie die Zeichenfolgen in den entsprechenden Symbolen mit res
7. Geben Sie abschließend den res-String als Ergebnis zurück

Python-Sprachversion:

1. Definieren Sie die Wertelistenwerte und die Symbollistensymbole, einschließlich aller Kombinationen römischer Ziffern
2. Die Initialisierungsergebniszeichenfolge res ist leer und der Index i ist 0
3. Verwenden Sie eine while-Schleife, um eine Schleife durchzuführen, wenn num größer als 0 ist
4. Verwenden Sie die if-Beurteilung innerhalb der Schleife. Wenn der Wert in den aktuellen Werten größer als num ist, wird i inkrementiert und übersprungen.
5. Subtrahieren Sie den Wert in aktuellen Werten von num
6. Verbinden Sie die Zeichenfolgen in den entsprechenden Symbolen mit res
7. Geben Sie abschließend den res-String als Ergebnis zurück

Java-Sprachversion:

1. Definieren Sie ganzzahlige Array-Werte und String-Array-Symbole, die alle Kombinationen römischer Ziffern enthalten
2. Die Initialisierungsergebniszeichenfolge res ist leer und der Index i ist 0
3. Verwenden Sie eine while-Schleife, um eine Schleife durchzuführen, wenn num größer als 0 ist
4. Verwenden Sie die if-Beurteilung innerhalb der Schleife. Wenn der Wert in den aktuellen Werten größer als num ist, wird i inkrementiert und übersprungen.
5. Subtrahieren Sie den Wert in aktuellen Werten von num
6. Verbinden Sie die Zeichenfolgen in den entsprechenden Symbolen mit res
7. Geben Sie abschließend den res-String als Ergebnis zurück

C++-Sprachversion:

1. Definieren Sie ganzzahlige Array-Werte und String-Array-Symbole, die alle Kombinationen römischer Ziffern enthalten
2. Die Initialisierungsergebniszeichenfolge res ist leer und der Index i ist 0
3. Verwenden Sie eine while-Schleife, um eine Schleife durchzuführen, wenn num größer als 0 ist
4. Verwenden Sie die if-Beurteilung innerhalb der Schleife. Wenn der Wert in den aktuellen Werten größer als num ist, wird i inkrementiert und übersprungen.
5. Subtrahieren Sie den Wert in aktuellen Werten von num
6. Verbinden Sie die Zeichenfolgen in den entsprechenden Symbolen mit res
7. Geben Sie abschließend den res-String als Ergebnis zurück

Code

Gehen

func intToRoman(num int) string {
    values := []int{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1} // 定义一个整数数组,包含罗马数字的基本值
    symbols := []string{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"} // 定义一个字符串数组,包含对应的罗马符号
    res, i := "", 0 // res为返回的罗马数字字符串,i为values和symbols的索引
    for num != 0 { // 当num不为0时循环
        for values[i] > num { // 如果当前values中的值大于num
            i++ // i增加1
        }
        num -= values[i] // 从num中减去当前values中的值
        res += symbols[i] // 在res中加上对应的罗马符号
    }
    return res // 返回组成的罗马数字字符串
}

Python

class Solution:
    def intToRoman(self, num: int) -> str:
        values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1] # 定义值列表
        symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"] # 符号列表
        res = ""
        i = 0 # 结果字符串和索引
        while num > 0: # 当num大于0时循环
            while values[i] > num: # 如果当前值大于num
                i += 1 # 索引加1
            num -= values[i] # 从num中减去当前值
            res += symbols[i] # 在结果中添加对应的符号
        return res # 返回组成的罗马数字字符串

Java

class Solution {
    public String intToRoman(int num) {
        int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; // 定义整数数组,包含罗马数字的基本值
        String[] symbols = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}; // 定义字符串数组,包含罗马符号
        String res = "";
        int i = 0; // 结果字符串res,以及values和symbols的索引i
        while(num > 0) { // 当num大于0时循环
            while(values[i] > num) { // 如果当前values中的值大于num
                i++; // i增加1
            }
            num -= values[i]; // 从num中减去当前values中的值
            res += symbols[i]; // 在res中添加对应的罗马符号
        }
        return res; // 返回组成的罗马数字字符串
    }
}

Cpp

class Solution {
public:
    string intToRoman(int num) {
        int values[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; // 定义整数数组,包含罗马数字的基本值
        string symbols[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}; // 定义字符串数组,包含罗马符号
        string res;
        int i = 0; // 结果字符串res,以及values和symbols的索引i
        while(num > 0) { // 当num大于0时循环
            while(values[i] > num) { // 如果当前values中的值大于num
                i++; // i增加1
            }
            num -= values[i]; // 从num中减去当前values中的值
            res += symbols[i]; // 在res中添加对应的罗马符号
        }
        return res; // 返回组成的罗马数字字符串
    }
};

Go-Sprachversion:

• int-Typ: Der Ganzzahltyp in der Go-Sprache, der zur Darstellung von Ganzzahlen verwendet wird.
• String-Typ: String-Typ in der Go-Sprache.
• []int und []string: Definieren Sie Integer-Arrays und String-Arrays.
• for-Schleife: die grundlegende Schleifenstruktur der Go-Sprache.
• wenn bedingtes Urteil: die bedingte Urteilsstruktur der Go-Sprache.
• += Operator: Verkettungszuweisungsoperator für Zeichenfolgen oder Ganzzahlen.
• Funktionsdefinition und Rückgabewert: Die Format- und Rückgabewertmethode zum Definieren von Funktionen in der Go-Sprache.

Python-Sprachversion:

• int-Typ: Ganzzahltyp in Python.
• str-Typ: String-Typ in Python.
• Liste: Eine Liste in Python, äquivalent zu einem Array.
• while-Schleife: Pythons grundlegende Schleifenstruktur.
• wenn bedingtes Urteil: Pythons bedingte Urteilsstruktur.
• += Operator: Zuweisungsoperator für die Zeichenfolgenverkettung.
• def definiert Funktion und Rückgabewert: Die Methode zum Definieren von Funktionen und Rückgabewerten in Python.

Java-Sprachversion:

• int-Typ: Integer-Typ in Java.
• String-Typ: String-Klasse in Java.
• int[] und String[]: Definieren Sie Integer-Arrays und String-Arrays.
• while-Schleife: Java-Schleifenstruktur.
• wenn bedingtes Urteil: Javas bedingte Urteilsstruktur.
• += Operator: Zuweisungsoperator für die Zeichenfolgenverkettung.
• Methodendefinition, Rückgabewert zurückgeben: Die Methode zum Definieren von Methoden und Rückgabewerten in Java.

C++-Sprachversion:

• int-Typ: Integer-Typ in C++.
• String-Typ: String-Klasse in C++.
• int[] und string[]: Definieren Sie Integer-Arrays und String-Arrays.
• while-Schleife: C++-Schleifenstruktur.
• wenn bedingte Beurteilung: C++-bedingte Beurteilungsstruktur.
• += Operator: Zuweisungsoperator für die Zeichenfolgenverkettung.
• Funktionsdefinition, Rückgabewert zurückgeben: Die Möglichkeit, Funktionen und Rückgabewerte in C++ zu definieren.

13. Roman zu Ganzzahl

Thema

Römische Ziffern werden durch sieben verschiedene Symbole dargestellt: I, V, X, L, und .CDM

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

Zum Beispiel wird zwei wie in römischen Ziffern geschrieben II, nur dass zwei Einsen addiert werden. Zwölf wird als geschrieben, XIIwas
einfach X+ ist II. Die Zahl siebenundzwanzig wird geschrieben als XXVII, also XX+ V+ II.

Römische Ziffern werden normalerweise von links nach rechts vom größten zum kleinsten geschrieben. Die Ziffer für vier ist jedoch nicht IIII.
Stattdessen wird die Zahl vier als geschrieben IV. Da die Eins vor der Fünf liegt, subtrahieren wir sie, was vier ergibt. Das gleiche
Prinzip gilt für die Zahl Neun, die als geschrieben wird IX. Es gibt sechs Fälle, in denen Subtraktion verwendet wird:

• IVkann vor (5) und X(10) platziert werden , um 4 und 9 zu ergeben.
• XLkann vor (50) und C(100) platziert werden , um 40 und 90 zu ergeben.
• CDkann vor (500) und M(1000) platziert werden , um 400 und 900 zu ergeben.

Wandeln Sie eine gegebene römische Zahl in eine ganze Zahl um. Die Eingabe liegt garantiert im Bereich von 1 bis 3999.

Beispiel 1 :

Input: "III"
Output: 3

Beispiel 2 :

Input: "IV"
Output: 4

Beispiel 3 :

Input: "IX"
Output: 9

Beispiel 4 :

Input: "LVIII"
Output: 58
Explanation: L = 50, V= 5, III = 3.

Beispiel 5 :

Input: "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Die allgemeine Idee des Themas

Römische Ziffern enthalten die folgenden sieben Zeichen: I, V, X, L, C, D und M.

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

Beispielsweise wird die römische Zahl 2 als II geschrieben, also aus zwei Einsen nebeneinander. 12 wird als XII geschrieben, also X + II. 27 wird als XXVII geschrieben, also XX + V + II.

Normalerweise stehen kleinere Zahlen in römischen Ziffern rechts von größeren Zahlen. Aber es gibt Sonderfälle. Beispielsweise wird 4 nicht als IIII, sondern als IV geschrieben. Die Zahl 1 steht links von der Zahl 5 und stellt eine Zahl dar, die der großen Zahl
5 minus der Zahl 1 entspricht, was dem Wert 4 entspricht. Ebenso wird die Zahl 9 als IX dargestellt. Diese Sonderregel gilt nur für die folgenden sechs Situationen:

• I kann links von V(5) und X(10) platziert werden, um 4 und 9 darzustellen.
• X kann links von L(50) und C(100) platziert werden, um 40 und 90 darzustellen. - C kann links von D(500) und M(1000) platziert werden, um 400 und 900 darzustellen.

Wandeln Sie eine gegebene römische Zahl in eine ganze Zahl um. Stellen Sie sicher, dass die Eingabe im Bereich von 1 bis 3999 liegt.

Ideen zur Problemlösung

• Wandeln Sie eine gegebene römische Zahl in eine ganze Zahl um. Stellen Sie sicher, dass die Eingabe im Bereich von 1 bis 3999 liegt.
• Einfache Frage. Berechnen Sie einfach die Dezimalzahl, die den römischen Ziffern entspricht, anhand der Zeichenwerte der römischen Ziffern in der Frage.

Go-Sprachversion:

1. Erstellen Sie eine Kartenzuordnung von Zeichen zu ganzen Zahlen
2. Bestimmen Sie, ob die Zeichenfolge leer ist, und geben Sie 0 zurück, wenn sie leer ist
3. Definieren Sie die Variablen „num“, „lastNum“ und „total“, die auf 0 initialisiert werden sollen
4. Durchlaufen Sie die Saite von hinten nach vorne
5. Holen Sie sich das aktuelle Zeichen und suchen Sie den entsprechenden Wert in der Karte
6. Bestimmen Sie die Beziehung zwischen dem aktuellen Wert und dem vorherigen Wert: Wenn er kleiner als der vorherige Wert ist, subtrahieren Sie den aktuellen Wert; andernfalls addieren Sie den aktuellen Wert
7. Aktualisieren Sie lastNum auf den aktuellen Wert
8. Das Gesamtergebnis wird am Ende der Durchquerung zurückgegeben

Python-Sprachversion:

1. Erstellen Sie ein Diktatwörterbuch von Zeichen in ganze Zahlen
2. Bestimmen Sie, ob die Zeichenfolge leer ist, und geben Sie 0 zurück, wenn sie leer ist
3. Definieren Sie die Variablen „num“, „last_num“ und „total“, die auf 0 initialisiert werden sollen
4. Durchlaufen Sie die Zeichenfolge in umgekehrter Reihenfolge im Bereich von len-1 bis 0
5. Rufen Sie das aktuelle Zeichen ab und suchen Sie den entsprechenden Wert im Diktat
6. Bestimmen Sie die Beziehung zwischen dem aktuellen Wert und dem vorherigen Wert: Wenn er kleiner als der vorherige Wert ist, subtrahieren Sie den aktuellen Wert; andernfalls addieren Sie den aktuellen Wert
7. Aktualisieren Sie last_num auf den aktuellen Wert
8. Das Gesamtergebnis wird am Ende der Durchquerung zurückgegeben

Java-Sprachversion:

1. Erstellen Sie eine Map-Zuordnung von Zeichen zu ganzen Zahlen
2. Bestimmen Sie, ob die Zeichenfolge leer ist, und geben Sie 0 zurück, wenn sie leer ist
3. Definieren Sie die Variablen „num“, „lastNum“ und „total“, die auf 0 initialisiert werden sollen
4. Durchlaufen Sie einen String in umgekehrter Reihenfolge, i–Implementierung
5. Holen Sie sich das aktuelle Zeichen und suchen Sie den entsprechenden Wert in der Karte
6. Bestimmen Sie die Beziehung zwischen dem aktuellen Wert und dem vorherigen Wert: Wenn er kleiner als der vorherige Wert ist, subtrahieren Sie den aktuellen Wert; andernfalls addieren Sie den aktuellen Wert
7. Aktualisieren Sie lastNum auf den aktuellen Wert
8. Das Gesamtergebnis wird am Ende der Durchquerung zurückgegeben

C++-Sprachversion:

1. Erstellen Sie eine Kartenzuordnung von Zeichen zu ganzen Zahlen
2. Bestimmen Sie, ob die Zeichenfolge leer ist, und geben Sie 0 zurück, wenn sie leer ist
3. Definieren Sie die Variablen „num“, „lastNum“ und „total“, die auf 0 initialisiert werden sollen
4. Durchlaufen Sie einen String in umgekehrter Reihenfolge, i–Implementierung
5. Holen Sie sich das aktuelle Zeichen und suchen Sie den entsprechenden Wert in der Karte
6. Bestimmen Sie die Beziehung zwischen dem aktuellen Wert und dem vorherigen Wert: Wenn er kleiner als der vorherige Wert ist, subtrahieren Sie den aktuellen Wert; andernfalls addieren Sie den aktuellen Wert
7. Aktualisieren Sie lastNum auf den aktuellen Wert
8. Das Gesamtergebnis wird am Ende der Durchquerung zurückgegeben

Code

Gehen

// 定义一个map,映射罗马数字字符到整数值
var roman = map[string]int{ 
    "I": 1,
    "V": 5, 
    "X": 10,
    "L": 50,
    "C": 100,
    "D": 500,
    "M": 1000,
}
// 将罗马数字字符串转换为整数的函数
func romanToInt(s string) int {
    // 如果传入空字符串,直接返回0
    if s == "" { 
       return 0
    }
    // 定义num为当前数字值,lastint为上一个数字值,total为结果
    num, lastint, total := 0, 0, 0
    // 从字符串末尾向前遍历
    for i := 0; i < len(s); i++ {
       // 获取当前字符 
       char := s[len(s)-(i+1) : len(s)-i]
       // 在map中找当前字符对应的数字值 
       num = roman[char]
       // 如果当前数字小于上一个数字,则减去当前数字
       if num < lastint {
          total = total - num
       } else {
           // 否则加上当前数字
          total = total + num
       }
       // 更新lastint为当前数字值
       lastint = num
    }
    // 返回最终结果
    return total
}

Python

class Solution:
    def romanToInt(self, s: str) -> int:
        
        # 定义一个字典,映射罗马数字字符到整数值
        roman = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
        
        # 如果传入空字符串,直接返回0
        if not s:
            return 0
        
        # 定义当前数字、上一个数字和结果变量        
        num, last_num, total = 0, 0, 0
        
        # 从字符串末尾向前遍历
        for i in range(len(s)-1, -1, -1):
            
            # 获取当前字符
            char = s[i]
            
            # 在字典中找当前字符对应的数字
            num = roman[char]
            
            # 如果当前数字小于上一个数字,则减去当前数字
            if num < last_num:
                total -= num
            else:
                # 否则加上当前数字
                total += num
                
            # 更新last_num为当前数字
            last_num = num
        
        return total
        

Java

class Solution {
    public int romanToInt(String s) {
        // 定义一个Map,映射罗马数字字符到整数值
        Map<Character, Integer> roman = new HashMap<>();
        roman.put('I', 1);
        roman.put('V', 5);
        roman.put('X', 10);
        roman.put('L', 50);
        roman.put('C', 100);
        roman.put('D', 500);
        roman.put('M', 1000);

        // 如果传入空字符串,直接返回0
        if (s.isEmpty()) {
            return 0;
        }
        
        // 初始化lastNum为0
        int num, lastNum = 0, total = 0;

        // 从字符串末尾向前遍历
        for (int i = s.length() - 1; i >= 0; i--) {

            // 获取当前字符
            char c = s.charAt(i);

            // 在map中找当前字符对应的数字
            num = roman.get(c);

            // 如果当前数字小于上一个数字,则减去当前数字
            if (num < lastNum) {
                total -= num; 
            } else {
                // 否则加上当前数字
                total += num;
            }

            // 更新lastNum为当前数字
            lastNum = num;
        }
        
        // 返回最终结果
        return total;
    }
}

Cpp

class Solution {
public:
    int romanToInt(string s) {
        
        // 定义一个map,映射罗马数字字符到整数值
        unordered_map<char, int> roman = {
   
   {'I', 1}, {'V', 5}, {'X', 10}, {'L', 50}, 
                                         {'C', 100}, {'D', 500}, {'M', 1000}}; 
        
        // 如果传入空字符串,直接返回0
        if (s.empty()) {
            return 0; 
        }
        
        // 定义当前数字、上一个数字和结果变量
        int num, lastNum = 0, total = 0;
        
        // 从字符串末尾向前遍历
        for (int i = s.length() - 1; i >= 0; i--) {
            
            // 获取当前字符
            char c = s[i];
            
            // 在map中找当前字符对应的数字值
            num = roman[c];
            
            // 如果当前数字小于上一个数字,则减去当前数字
            if (num < lastNum) {
                total -= num;
            } else {
                // 否则加上当前数字
                total += num;
            }
            
            // 更新lastNum为当前数字
            lastNum = num;
        }
        
        return total;
    }
};

Go-Sprachversion:

• Karte: In der Go-Sprache ist Karte eine Sammlung von Schlüssel-Wert-Paaren, mit denen eine Zuordnungsbeziehung zwischen Zeichen und ganzen Zahlen hergestellt werden kann.
• len-Funktion: Sie können die Länge einer Zeichenfolge ermitteln.
• Slice:s[start:end] kann einen Teilstring eines Strings extrahieren.
• wenn bedingtes Urteil und sonst Zweig.
• Definieren Sie mehrere Variablen: num, lastint, total := 0, 0, 0.
• Die for-Schleife durchläuft die Zeichenfolge.
  -String-Verkettung: char := s[len(s)-(i+1) : len(s)-i].

Python-Sprachversion:

• Wörterbuch-Dikt: Ein Wörterbuch in Python kann eine Zuordnungsbeziehung zwischen Zeichen und ganzen Zahlen herstellen.
• len-Funktion: Sie können die Länge einer Zeichenfolge ermitteln.
  -Subscript index:s[i] ruft die Zeichen in der Zeichenfolge ab.
• wenn bedingtes Urteil und sonst Zweig.
• Definieren Sie mehrere Variablen: num, last_num, total = 0, 0, 0.
• Die for-Schleife durchläuft die Zeichenfolge und die Range-Funktion generiert den Index.
• Subtraktionsoperation: range(len(s)-1, -1, -1).

Java-Sprachversion:

• Kartensammlung: Kann eine Schlüssel-Wert-Paar-Zuordnungsbeziehung herstellen.
• isEmpty bestimmt, ob die Zeichenfolge leer ist.
• charAt übernimmt das Zeichen an der angegebenen Position in der Zeichenfolge.
• HashMap erstellt eine Kartensammlung.
• wenn bedingtes Urteil und sonst Zweig.
• Die for-Schleife durchläuft die Zeichenfolge i – implementiert die umgekehrte Reihenfolge.
• length ermittelt die Stringlänge.

C++-Sprachversion:

• unordered_map-Zuordnungssammlung, die eine Zuordnung von Zeichen und ganzen Zahlen erstellen kann.
• empty bestimmt, ob die Zeichenfolge leer ist.
• []Zugriff auf Vektorelemente.
• wenn bedingtes Urteil und sonst Zweig.
• Definieren Sie mehrere Variablen: int num, lastNum = 0, total = 0.
• Die for-Schleife durchläuft die Zeichenfolge i – implementiert die umgekehrte Reihenfolge.
• Die Längenfunktion ermittelt die Stringlänge.

14. Längstes gemeinsames Präfix

Thema

Schreiben Sie eine Funktion, um die längste gemeinsame Präfixzeichenfolge in einem Array von Zeichenfolgen zu finden.

Wenn es kein gemeinsames Präfix gibt, geben Sie eine leere Zeichenfolge „“ zurück.

Beispiel 1 :

Input: strs = ["flower","flow","flight"]
Output: "fl"

Beispiel 2 :

Input: strs = ["dog","racecar","car"]
Output: ""
Explanation: There is no common prefix among the input strings.

Einschränkungen:

• 1 <= strs.length <= 200
• 0 <= strs[i].length <= 200
• strs[i] besteht nur aus englischen Kleinbuchstaben.

Die allgemeine Idee des Themas

Schreiben Sie eine Funktion, um das längste gemeinsame Präfix in einem Array von Zeichenfolgen zu finden.

Wenn kein gemeinsames Präfix vorhanden ist, wird die leere Zeichenfolge „“ zurückgegeben.

Ideen zur Problemlösung

• Sortieren Sie die Zeichenfolgen in aufsteigender Reihenfolge nach der Zeichenfolgenlänge und ermitteln Sie die Länge der kleinsten Zeichenfolge in Zeichenfolgen, minLen.
• Vergleichen Sie die Zeichen in der Zeichenfolge nacheinander mit der Mindestlänge und anderen Zeichenfolgen. Wenn sie nicht gleich sind, geben Sie commonPrefix zurück, andernfalls fügen Sie das Zeichen zu commonPrefix hinzu.

Go-Version

1. Legen Sie die erste Zeichenfolge als Präfix fest
2. Durchlaufen Sie die verbleibende Zeichenfolge
3. Vergleichen Sie das Präfix Zeichen für Zeichen und reduzieren Sie die Präfixlänge, wenn sie nicht gleich sind.
4. Wiederholen Sie Schritt 3, bis das Präfix leer ist oder mit allen Zeichenfolgen übereinstimmt
5. Das zurückgegebene Präfix
   verwendet hauptsächlich String-Traversal- und Slicing-Operationen, um das Präfix schrittweise zu kürzen.

Python-Version

1. Die erste Zeichenfolge ist ein Präfix
2. Durchlaufen Sie die restlichen Saiten
3. Verwenden Sie die Suchmethode, um festzustellen, ob es mit einem Präfix beginnt
4. Wenn es nicht übereinstimmt, reduzieren Sie die Präfixlänge
5. Wiederholen Sie die Schritte 3 und 4, bis das Präfix leer ist oder mit allen Zeichenfolgen übereinstimmt
6. Das zurückgegebene Präfix
   verwendet die Suchmethode und den Slicing-Vorgang, um das Präfix zu ermitteln und zu ändern.

Java-Version

1. Die erste Zeichenfolge ist ein Präfix
2. Durchlaufen Sie die restlichen Saiten
3. Verwenden Sie indexOf, um zu bestimmen, ob es mit einem Präfix beginnt
4. Wenn es nicht übereinstimmt, reduzieren Sie die Präfixlänge
5. Wiederholen Sie die Schritte 3 und 4, bis das Präfix leer ist oder mit allen Zeichenfolgen übereinstimmt
6. Das zurückgegebene Präfix
   verwendet auch die Methoden indexOf und substring, um den Teilstring zu ermitteln und abzurufen.

C++-Version

1. Die erste Zeichenfolge ist ein Präfix
2. Durchlaufen Sie die restlichen Saiten
3. Verwenden Sie die Suchmethode, um festzustellen, ob es mit einem Präfix beginnt
4. Wenn es nicht übereinstimmt, reduzieren Sie die Präfixlänge
5. Wiederholen Sie die Schritte 3 und 4, bis das Präfix leer ist oder mit allen Zeichenfolgen übereinstimmt
6. Das zurückgegebene Präfix
   basiert auf den Methoden „find“ und „substr“, um die Teilzeichenfolge zu ermitteln und abzurufen.

Code

Gehen

func longestCommonPrefix(strs []string) string {
    prefix := strs[0]

    for i := 1; i < len(strs); i++ {
        for j := 0; j < len(prefix); j++ {
            if len(strs[i]) <= j || strs[i][j] != prefix[j] {
                prefix = prefix[0:j]
                break
            }
        }
    }

    return prefix
}

Python

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs: return ""
        prefix = strs[0]
        for i in range(1, len(strs)):
            while strs[i].find(prefix) != 0:
                prefix = prefix[:len(prefix)-1]
                if not prefix: return ""
        return prefix

Java

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) return "";
        String prefix = strs[0];
        for (int i = 1; i < strs.length; i++) {
            while (strs[i].indexOf(prefix) != 0) {
                prefix = prefix.substring(0, prefix.length() - 1);
                if (prefix.isEmpty()) return "";
            }       
        }
        return prefix;
    }
}

Cpp

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if (strs.empty()) return "";
        string prefix = strs[0];
        for (int i = 1; i < strs.size(); i++) {
            while (strs[i].find(prefix) != 0) {
                prefix = prefix.substr(0, prefix.size()-1);
                if (prefix.empty()) return "";
            }
        }
        return prefix;
    }
};

Für jede Version erforderliche Grundkenntnisse:

Go-Version

• Strings-Paket: Das Strings-Paket stellt Funktionen für String-Operationen bereit, z. B. Enthält, Index usw.
• String-Traversal: Sie können die Bytes eines Strings durch eine for-Schleife durchlaufen
• String-Slicing: Teilstrings können durch Angabe der Start- und Endpositionen [i:j] erhalten werden.

Python-Version

• str-Typ: Pythons integrierter String-Typ
• Suchmethode: Suchen Sie die Position, an der die Teilzeichenfolge in der Zeichenfolge vorkommt, und geben Sie den Index der ersten übereinstimmenden Position zurück. Wenn er nicht vorhanden ist, geben Sie -1 zurück
• Slicing-Operation: Teilzeichenfolgen können durch Angabe der Start- und Endpositionen [i:j] erhalten werden.

Java-Version

• String-Klasse: String stellt einen unveränderlichen String dar und verfügt über Methoden wie Indexzugriffszeichen und Teilstring-Erfassung.
• indexOf-Methode: Suchen Sie die Position, an der die Teilzeichenfolge in der Zeichenfolge erscheint, und geben Sie den ersten übereinstimmenden Positionsindex zurück. Wenn dieser nicht vorhanden ist, geben Sie -1 zurück
• Teilzeichenfolgenmethode: Rufen Sie die Teilzeichenfolge des angegebenen Bereichs der Zeichenfolge ab

C++-Version

• String-Klasse: String stellt ein String-Objekt dar und unterstützt Vorgänge wie das Durchlaufen, den Zugriff auf einzelne Zeichen und das Abrufen von Teilstrings.
• find-Methode: Suchen Sie die Position, an der die Teilzeichenfolge zum ersten Mal in der Zeichenfolge erscheint. Wenn sie nicht vorhanden ist, geben Sie string::npos zurück
• substr-Methode: Ruft den angegebenen Zeichenbereich in der Teilzeichenfolge ab