Programmier-Übungen für jeden Tag

def count_words(text):
    counts = {}
    for word in text.lower().split():
        counts[word] = counts.get(word, 0) + 1
    return counts

Kürzer geht es mit collections.Counter: Counter(text.lower().split()).

def is_palindrome(text):
    letters = [c for c in text.lower() if c.isalnum()]
    return letters == letters[::-1]

def check_password(password):
    problems = []
    if len(password) < 8:
        problems.append("zu kurz")
    if not any(c.isdigit() for c in password):
        problems.append("keine Ziffer")
    if not any(c.isupper() for c in password):
        problems.append("kein Großbuchstabe")
    return problems

def summarize(purchases):
    totals = {}
    for product, price in purchases:
        totals[product] = totals.get(product, 0) + price
    return sorted(totals.items(), key=lambda pair: pair[1], reverse=True)

def binary_search(items, target):
    low, high = 0, len(items) - 1
    while low <= high:
        mid = (low + high) // 2
        if items[mid] == target:
            return mid
        if items[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

function binarySearch(items, target) {
  let low = 0;
  let high = items.length - 1;
  while (low <= high) {
    const mid = Math.floor((low + high) / 2);
    if (items[mid] === target) return mid;
    if (items[mid] < target) low = mid + 1;
    else high = mid - 1;
  }
  return -1;
}

Bei einer Million Einträgen reichen so etwa 20 Vergleiche.

def two_sum(numbers, target):
    seen = {}
    for i, n in enumerate(numbers):
        if target - n in seen:
            return [seen[target - n], i]
        seen[n] = i
    return None

function twoSum(numbers, target) {
  const seen = new Map();
  for (let i = 0; i < numbers.length; i++) {
    const rest = target - numbers[i];
    if (seen.has(rest)) return [seen.get(rest), i];
    seen.set(numbers[i], i);
  }
  return null;
}

Zwei verschachtelte Schleifen gehen auch, brauchen bei langen Listen aber viel länger.

def is_balanced(text):
    pairs = {")": "(", "]": "[", "}": "{"}
    stack = []
    for c in text:
        if c in "([{":
            stack.append(c)
        elif c in pairs:
            if not stack or stack.pop() != pairs[c]:
                return False
    return not stack

function isBalanced(text) {
  const pairs = { ')': '(', ']': '[', '}': '{' };
  const stack = [];
  for (const c of text) {
    if ('([{'.includes(c)) stack.push(c);
    else if (c in pairs && stack.pop() !== pairs[c]) return false;
  }
  return stack.length === 0;
}

def group_anagrams(words):
    groups = {}
    for word in words:
        key = "".join(sorted(word))
        groups.setdefault(key, []).append(word)
    return list(groups.values())

function groupAnagrams(words) {
  const groups = new Map();
  for (const word of words) {
    const key = [...word].sort().join('');
    if (!groups.has(key)) groups.set(key, []);
    groups.get(key).push(word);
  }
  return [...groups.values()];
}