12 28.11

// ignore_for_file: unused_element

extension on int {
  List<int> getDivs(final bool Function(int) predicate) {
    final divs = List<int>.empty(growable: true);

    for (int i = 1; i * i <= this; i++) {
      if (this % i == 0) {
        if (predicate(i)) {
          divs.add(i);
        }

        if (i * i < this && predicate(this ~/ i)) {
          divs.add(this ~/ i);
        }
      }
    }

    return divs;
  }

  bool get isSimple {
    for (int i = 2; i * i <= this; i++) {
      if (this % i == 0) {
        return false;
      }
    }

    return true;
  }

  bool get isUnique {
    final s = toString();

    if (s.length < 5) {
      return false;
    }

    final nums = s.codeUnits.map((e) => e - '0'.codeUnitAt(0)).toList();

    if (nums[2] % 2 != 0 || nums[4] % 2 != 0) {
      return false;
    }

    return nums
        .filterIndexed((ind, x) => ind != 2 && ind != 4)
        .every((element) => element % 2 == 1);
  }
}

extension on List<int> {
  List<int> sortAndGet([int Function(int, int)? compare]) {
    sort(compare);
    return this;
  }
}

extension IntIterableExt on Iterable<int> {
  static Iterable<int> createRange(final int startInclusive, final int endExclusive) =>
      Iterable.generate(endExclusive - startInclusive + 1, (x) => x + startInclusive);

  int get sum => fold(0, (previousValue, element) => previousValue + element);
}

extension IterableExt<T> on Iterable<T> {
  Iterable<T> withStep(final int step) {
    final list = List<T>.empty(growable: true);
    final thisList = toList();

    for (int i = 0; i < length; i += step) {
      list.add(thisList[i]);
    }

    return list;
  }

  void forEachIndexed(void Function(int, T) action) {
    final iter = iterator;

    for (int i = 0; i < length; i++) {
      iter.moveNext();
      action(i, iter.current);
    }
  }

  Iterable<T> filterIndexed(bool Function(int, T) predicate) {
    final list = List<T>.empty(growable: true);
    final thisList = toList();

    for (int i = 0; i < length; i++) {
      final elem = thisList[i];
      if (predicate(i, elem)) {
        list.add(elem);
      }
    }

    return list;
  }
}

class Pair<F, S> {
  F first;
  S second;
  Pair(this.first, this.second);
}

void main(final List<String> arguments) {
  final divsNotMatch = List.generate(3, (index) => index + 6);

  final filter = IntIterableExt
      .createRange(33333, 55555)
      .where((element) => divsNotMatch.every((e) => element % e != 0) && element.isUnique)
      .toList();

  print(filter.length);
  filter.sort();
  print(filter.last - filter.first);
}