Programmieren lernen

def hoechste(liste):
        if len(liste)==1: return liste[0]
        if liste[0]>=liste[-1]:
                return hoechste(liste[:-1])
        else:
                return hoechste(liste[1:])

liste = [1,2,3,4,5,6,5,84,2,10029,2,2,3]
print(hoechste(liste))

                

Lösung von: rob ert (tub)

def max_recursion(l):
  if len(l) == 1:
    return l[0]
  elif len(l) == 2:
    return max(l[0], l[1])
  return max(max_recursion(l[:1]), max_recursion(l[1:]))
print(max_recursion([1,2,3,4,5,6,5,84,2,10029,2,2,3]))
                

Lösung von: Name nicht veröffentlicht

function maxRec(arr, max = arr.shift()) {
  if (arr.length == 0) return max;
  return maxRec(arr, Math.max(max, arr.shift()));
}

let a = [1,2,3,4,5,6,5,84,2,10029,2,2,3];
console.log(maxRec(a));
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET 6.x | C# 10.x | VS-2022
static int MaxValueRec(int[] arr, int n) => n == 1 ? arr[0] : Math.Max(arr[n - 1], MaxValueRec(arr, n - 1));

var arr = new int[] {1, 2, 3, 4, 5, 6, 5, 84, 2, 10029, 2, 2, 3};
Console.WriteLine(MaxValueRec(arr, arr.Length));
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17
#include <iostream>
#include <optional>
#include <vector>

size_t get_maxValue_rec(const std::vector<size_t>& v, std::optional<size_t> n = std::nullopt) {
    const size_t r{ !n ? v.size() : *n};
    return r == 1 ? v[0] : std::max(v[r - 1], get_maxValue_rec(v, r - 1));
}

int main() {
    const std::vector<size_t> v{1, 2, 3, 4, 5, 6, 5, 84, 2, 10029, 2, 2, 3};
    std::cout << get_maxValue_rec(v) << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// NET 6.x | C# 10.x | VS-2022
static int MaxValueRec(List<int> lst, int? n = null) {
    int r = n?? lst.Count;
    return r == 1 ? lst.First() : Math.Max(lst[r - 1], MaxValueRec(lst, r - 1));
}

var lst = new List<int>{ 1, 2, 3, 4, 5, 6, 5, 84, 2, 10029, 2, 2, 3 };
Console.WriteLine(MaxValueRec(lst));
                

Lösung von: Jens Kelm (@JKooP)

// C++ 20 | VS-2022

#include <iostream>

const auto maximum(auto&& comp_, auto&& left_, auto&& right_) {
    return comp_(left_, right_) ? left_ : right_;
}

const auto maximum(auto&& comp_, auto&& first_, auto&& ... args_) {
    return maximum(comp_, first_, maximum(comp_, (args_)...));
}

int main() {
    std::cout << maximum(std::greater<>(), 1, 2, 3, 4, 5, 6, 5, 84, 2, 10029, 2, 2, 3) << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)