Top 30 Dart Coding Challenges for Exprienced Developers

The traditional first program to verify a working setup.

void main() {
  print('Hello, World!');
}

A basic test of loops and list manipulation.

int sumOfList(List numbers) {
  int sum = 0;
  for (int number in numbers) {
    sum += number;
  }
  return sum;
}

A simple test of string manipulation.

String reverseString(String text) {
  return text.split('').reversed.join('');
}

A fundamental algorithm using a simple loop.

int findLargest(List numbers) {
  int largest = numbers[0];
  for (int number in numbers) {
    if (number > largest) {
      largest = number;
    }
  }
  return largest;
}

Tests string manipulation and comparison logic.

bool isPalindrome(String text) {
  String reversedText = text.split('').reversed.join('');
  return text == reversedText;
}

The classic test of basic conditional logic and loops.

void fizzBuzz(int n) {
  for (int i = 1; i 

Introduces custom types and data organization.

class Person {
  String name;
  int age;

  Person(this.name, this.age);
}

A simple function to demonstrate map creation.

Map createPerson(String name, int age) {
  return {
    'name': name,
    'age': age,
  };
}

A basic loop to demonstrate syntax.

void printNumbers() {
  for (int i = 1; i 

Tests basic conditional logic.

String checkNumber(int number) {
  if (number > 0) {
    return 'Positive';
  } else if (number 

A simple asynchronous function to demonstrate `Future`, `async`, and `await`.

Future fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  return 'Data fetched';
}

Use a map to count the frequency of words in a text.

Map wordCount(String text) {
  Map counts = {};
  List words = text.split(' ');
  for (String word in words) {
    counts[word] = (counts[word] ?? 0) + 1;
  }
  return counts;
}

A simple implementation of a stack using a list.

class Stack {
  List _items = [];

  void push(T item) => _items.add(item);
  T pop() => _items.removeLast();
}

Convert Dart objects to and from JSON.

import 'dart:convert';

class User {
  String name;
  int age;

  User(this.name, this.age);

  Map toJson() => {'name': name, 'age': age};
  factory User.fromJson(Map json) => User(json['name'], json['age']);
}

A common interview question that can be solved with a map.

String firstNonRepeatingCharacter(String text) {
  Map counts = {};
  for (int i = 0; i 

A simple example of class inheritance.

abstract class Shape {
  double get area;
}

class Circle extends Shape {
  double radius;
  Circle(this.radius);

  @override
  double get area => 3.14 * radius * radius;
}

A function that takes another function as an argument.

List transform(List numbers, int Function(int) transformer) {
  return numbers.map(transformer).toList();
}

A simple example of error handling with `try-catch`.

void main() {
  try {
    throw Exception('An error occurred');
  } catch (e) {
    print(e);
  }
}

A simple example of the cascade operator.

class Person {
  String name;
  int age;
}

void main() {
  Person person = Person()
    ..name = 'John Doe'
    ..age = 30;
}

A simple implementation of a stream.

Stream countStream(int max) async* {
  for (int i = 1; i 

A generic repository pattern for data access.

abstract class Repository {
  Future getById(int id);
  Future> getAll();
  Future save(T entity);
  Future delete(T entity);
}

A simple BLoC for managing state.

import 'dart:async';

abstract class CounterEvent {}
class IncrementEvent extends CounterEvent {}

class CounterBloc {
  int _counter = 0;
  final _counterStateController = StreamController();
  StreamSink get _inCounter => _counterStateController.sink;
  Stream get counter => _counterStateController.stream;

  final _counterEventController = StreamController();
  Sink get counterEventSink => _counterEventController.sink;

  CounterBloc() {
    _counterEventController.stream.listen(_mapEventToState);
  }

  void _mapEventToState(CounterEvent event) {
    if (event is IncrementEvent) {
      _counter++;
    }
    _inCounter.add(_counter);
  }

  void dispose() {
    _counterStateController.close();
    _counterEventController.close();
  }
}

A simple example of using isolates for parallel processing.

import 'dart:isolate';

void main() async {
  final receivePort = ReceivePort();
  await Isolate.spawn(heavyComputation, receivePort.sendPort);
  receivePort.listen((message) {
    print(message);
  });
}

void heavyComputation(SendPort sendPort) {
  int sum = 0;
  for (int i = 0; i 

A custom extension method for a string.

extension StringExtensions on String {
  String capitalize() {
    return this[0].toUpperCase() + this.substring(1);
  }
}

A debounce function to limit the rate of execution.

import 'dart:async';

Function debounce(Function fn, Duration duration) {
  Timer _timer;
  return () {
    _timer?.cancel();
    _timer = Timer(duration, fn);
  };
}

A custom exception class for advanced error handling.

class CustomException implements Exception {
  final String message;
  CustomException(this.message);
}

void main() {
  try {
    throw CustomException('An error occurred');
  } on CustomException catch (e) {
    print(e.message);
  }
}

A simple example of using mixins to add functionality to a class.

mixin Flyable {
  void fly() => print('Flying');
}

class Bird with Flyable {}

A complex data model with immutability.

class User {
  final String name;
  final int age;

  User(this.name, this.age);

  User copyWith({String name, int age}) {
    return User(
      name ?? this.name,
      age ?? this.age,
    );
  }
}

A simple implementation of a singleton pattern.

class Singleton {
  static final Singleton _instance = Singleton._internal();
  factory Singleton() => _instance;
  Singleton._internal();
}

A simple example of using `compute` for heavy computations in Flutter.

import 'package:flutter/foundation.dart';

Future heavyComputation(int value) async {
  int sum = 0;
  for (int i = 0; i