படபடப்பு மூலம் தரவு கட்டமைப்புகளை வேடிக்கையான முறையில் கற்றுக்கொள்வது எப்படி என்பது இங்கே.

விளையாட்டுகளை உருவாக்கி கணினி அறிவியலைக் கற்றுக்கொள்ளுங்கள்.

தரவு கட்டமைப்புகள் திறமையான மென்பொருள் மேம்பாட்டின் அடித்தளமாக அமைகின்றன, இருப்பினும் பாரம்பரிய கற்றல் முறைகள் பெரும்பாலும் அவற்றை சுருக்கமாகவும் நிஜ உலக பயன்பாடுகளிலிருந்து துண்டிக்கப்பட்டதாகவும் உணர வைக்கின்றன. இந்தக் கட்டுரை வேறுபட்ட அணுகுமுறையை எடுக்கிறது - Flutter இல் கோட்பாட்டை நடைமுறைப்படுத்தலுடன் இணைத்து கற்றலை ஈடுபாட்டுடனும் நடைமுறை ரீதியாகவும் ஆக்குகிறது.

கூகிளின் ஆண்ட்ராய்டுடன் கூடிய அப்ளைடு சிஎஸ் மூலம் ஈர்க்கப்பட்டு, ஃப்ளட்டருக்கான இந்தத் தழுவல் , வரிசைகள், ஹாஷ்செட்கள் மற்றும் ஹாஷ்மேப்களைப் புரிந்துகொள்ள ஒரு ஊடாடும் வழியை வழங்குகிறது. வெறும் 3–4 மணி நேரத்தில், இந்த அடிப்படை தரவு கட்டமைப்புகளை அர்த்தமுள்ள சூழலில் பயன்படுத்தும்போது அவற்றைப் பற்றிய ஆழமான புரிதலைப் பெறுவீர்கள்.

நீங்கள் உங்கள் CS அடிப்படைகளை வலுப்படுத்த விரும்பும் ஒரு தொடக்கநிலையாளராக இருந்தாலும் சரி அல்லது உங்கள் திறன்களை மேம்படுத்த விரும்பும் அனுபவம் வாய்ந்த டெவலப்பராக இருந்தாலும் சரி, இந்த வழிகாட்டி அத்தியாவசிய தரவு கட்டமைப்புகளில் தேர்ச்சி பெறுவதற்கான திறமையான மற்றும் சுவாரஸ்யமான வழியை வழங்குகிறது. தொடங்குவோம்.

இந்தக் கட்டுரையின் நோக்கங்கள்:

1. தரவைச் சேமிக்க அகராதிகள் எவ்வாறு பயன்படுத்தப்படலாம் என்பதை நீங்களே அறிந்து கொள்ளுங்கள் (இந்த விஷயத்தில் சொற்கள்).
2. சொற்களின் குழுக்களைச் சேமிக்க ஹாஷ் வரைபடங்களைப் பயன்படுத்தவும், அவை அனகிராம்கள்.
3. பெரிய தரவுத் தொகுப்புகளுடன் பணிபுரியும் போது சில தரவு கட்டமைப்புகள் எதிர்கொள்ளும் வரம்புகளை விளக்க முடியும்.

தயாரிப்பு:

பட்டறை செயல்பாட்டில் சில தரவு கட்டமைப்புகளைப் பயன்படுத்துவோம், எனவே தயவுசெய்து பட்டியல்கள் , ஹாஷ்செட்கள் மற்றும் ஹாஷ்மேப்களை மதிப்பாய்வு செய்யவும். டார்ட்டில் இந்த தரவு கட்டமைப்புகளைப் பயன்படுத்தி நீங்கள் நம்பிக்கையுடன் கூறுகளைச் செருக, நீக்க, அணுக மற்றும் சரிபார்க்க முடியும்.

இது தரவு கட்டமைப்புகள், ஹாஷ்செட்கள் மற்றும் ஹாஷ்மேப் பற்றிய ஒரு சிறிய அறிமுகம்.

ஒரு சிறிய தொடக்க பயிற்சி வார்ம்-அப்:

HashMaps ஐப் பயன்படுத்தி ஒரு செயல்பாட்டிற்கு ஒரு எடுத்துக்காட்டு, ஒரு நிரலை உருவாக்கவும் (Flutter செயலி அவசியமில்லை - கட்டளை வரி நல்லது) அது மூன்றெழுத்து நாட்டுக் குறியீட்டை ( ISO-3166 ஐப் பார்க்கவும்) எடுத்து, அது எந்த நாட்டைச் சேர்ந்ததோ அதன் முழுப் பெயரையும் வழங்கும்.

உதாரணத்திற்கு:

 Input | Output ----- | ---------------------------------------------------- GBR | United Kingdom of Great Britain and Northern Ireland IDN | Indonesia IND | India

நீட்டிப்பாக, உள்ளீடு 3 எழுத்துக்களுக்கு மேல் இருந்தால், அதை ஒரு நாட்டின் பெயராகக் கருதி, அதற்கான மூன்றெழுத்து குறியீட்டைத் திருப்பி அனுப்பவும். உள்ளீடு செல்லுபடியாகும் குறியீடாகவோ அல்லது நாட்டின் பெயராகவோ இல்லாவிட்டால், ஒரு பயனுள்ள பிழைச் செய்தியை எழுதவும்.

ஆரம்பிக்கலாம்.

அனகிராம்கள்

ஒரு அனகிராம் என்பது மற்றொரு வார்த்தையின் எழுத்துக்களை மறுசீரமைப்பதன் மூலம் உருவாகும் ஒரு சொல். உதாரணமாக, சினிமா என்பது ஐஸ்மேன் என்பதன் அனகிராம் ஆகும்.

விளையாட்டின் இயக்கவியல் பின்வருமாறு:

1. விளையாட்டு அகராதியிலிருந்து ஒரு வார்த்தையை பயனருக்கு வழங்குகிறது.

   
   

2. கொடுக்கப்பட்ட வார்த்தையின் அனைத்து எழுத்துக்களையும் சேர்த்து ஒரு கூடுதல் எழுத்தையும் கொண்ட முடிந்தவரை பல சொற்களை உருவாக்க பயனர் முயற்சிக்கிறார். மற்ற எழுத்துக்களை மறுவரிசைப்படுத்தாமல் தொடக்கத்திலோ அல்லது முடிவிலோ கூடுதல் எழுத்தைச் சேர்ப்பது செல்லாது என்பதை நினைவில் கொள்ளவும். எடுத்துக்காட்டாக, விளையாட்டு 'தாது' என்ற வார்த்தையை தொடக்கமாகத் தேர்ந்தெடுத்தால், பயனர் 'ரோஸ்' அல்லது 'பூஜ்ஜியம்' என்று யூகிக்கலாம், ஆனால் 'புண்' என்று யூகிக்கக்கூடாது.

   
   

3. பயனர் விட்டுக்கொடுத்து, அவர்கள் யூகிக்காத வார்த்தைகளைப் பார்க்கலாம்.

இந்த விளையாட்டின் UI பகுதிகளைக் கையாளும் 10,000-வார்த்தை அகராதியைக் கொண்ட சில தொடக்கக் குறியீட்டை நாங்கள் உங்களுக்கு வழங்கியுள்ளோம், மேலும் அனைத்து சொல் கையாளுதல்களையும் கையாளும் AnagramBlocclass ஐ எழுதுவதற்கு நீங்கள் பொறுப்பாவீர்கள்.

குறியீட்டின் சுற்றுப்பயணம்

தொடக்க குறியீடு மூன்று முக்கிய டார்ட் வகுப்புகளைக் கொண்டுள்ளது:

anagrams_page.dart

இது மேலே நாம் காணும் திரையைக் குறிக்கும் எளிய குறியீடு. திரைக்கான நிலை மேலாண்மைக்கு ஒரு தொகுதியைப் பயன்படுத்துவோம். தொகுதிக்கு ஒரு நிகழ்வைச் சுட்டு, வெவ்வேறு விளையாட்டு நிலைகளுக்குத் திரை பதிலளிக்கும்போது என்ன நடக்கும் என்பதை வரையறுப்பதன் மூலம் விளையாட்டை அமைப்பதன் மூலம் தொடங்குவோம்.

 import 'package:anagrams/anagrams/bloc/anagram_bloc.dart'; import 'package:anagrams/anagrams/domain/word.dart'; import 'package:anagrams/l10n/l10n.dart'; import 'package:bloc_presentation/bloc_presentation.dart'; import 'package:flutter/material.dart'; import 'package:flutter_bloc/flutter_bloc.dart'; class AnagramsPage extends StatelessWidget { const AnagramsPage({super.key}); @override Widget build(BuildContext context) { return BlocProvider( create: (_) => AnagramBloc() ..add( SetupAnagrams( DefaultAssetBundle.of(context), ), ), child: const AnagramsView(), ); } } class AnagramsView extends StatelessWidget { const AnagramsView({super.key}); @override Widget build(BuildContext context) { final l10n = context.l10n; return Scaffold( appBar: AppBar(title: Text(l10n.anagramAppBarTitle)), body: BlocBuilder<AnagramBloc, AnagramState>( builder: (context, state) { switch (state.status) { case AnagramGameStatus.gameError: return const Center( child: Text('An error occurred'), ); case AnagramGameStatus.loaded: return Padding( padding: const EdgeInsets.all(20), child: ListView( children: const [ _SelectedWord(), SizedBox(height: 20), _AnagramsTextField(), SizedBox(height: 10), _GuessListView(), ], ), ); case AnagramGameStatus.initial: return const Center( child: CircularProgressIndicator(), ); } }, ), floatingActionButton: const _NextWordButton(), ); } } class _SelectedWord extends StatelessWidget { const _SelectedWord(); @override Widget build(BuildContext context) { return BlocSelector<AnagramBloc, AnagramState, String>( selector: (state) => state.currentWord, builder: (context, currentWord) { return Text.rich( TextSpan( text: 'Find as many words as possible that can be ' 'formed by adding one letter to ', children: [ TextSpan( text: currentWord.toUpperCase(), style: const TextStyle(fontWeight: FontWeight.bold), ), TextSpan( text: ' (but that do not contain the substring' ' ${currentWord.toUpperCase()}).', ), ], ), ); }, ); } } class _AnagramsTextField extends StatelessWidget { const _AnagramsTextField(); @override Widget build(BuildContext context) { final controller = TextEditingController(); return TextField( controller: controller, decoration: const InputDecoration( hintText: 'Enter an anagram', border: OutlineInputBorder(), ), keyboardType: TextInputType.text, textInputAction: TextInputAction.done, onSubmitted: (value) { controller.clear(); context.read<AnagramBloc>().add(ProcessWord(value)); }, ); } } class _GuessListView extends StatelessWidget { const _GuessListView(); @override Widget build(BuildContext context) { return BlocSelector<AnagramBloc, AnagramState, List<Word>>( selector: (state) => state.guesses, builder: (context, guesses) { return Column( children: guesses.map((word) { return ListTile( minTileHeight: 0, contentPadding: EdgeInsets.zero, visualDensity: VisualDensity.compact, title: Text(word.value), leading: Icon( word.isAnagram ? Icons.check : Icons.close, color: word.isAnagram ? Colors.green : Colors.red, ), ); }).toList(), ); }, ); } } class _GameResult extends StatelessWidget { const _GameResult(this.currentWord, this.result); final List<Word> result; final String currentWord; @override Widget build(BuildContext context) { return ListView( shrinkWrap: true, children: [ const SizedBox(height: 20), Padding( padding: const EdgeInsets.symmetric( horizontal: 20, ), child: Text( 'Game Result for $currentWord', style: const TextStyle(fontSize: 20), ), ), Padding( padding: const EdgeInsets.all(20), child: SizedBox( width: double.infinity, child: DataTable( decoration: BoxDecoration( border: Border.all( color: Colors.grey.shade400, ), borderRadius: BorderRadius.circular(10), ), columns: const [ DataColumn(label: Text('Possible Anagrams')), DataColumn(label: Text('Your Guesses')), ], rows: result.map((word) { return DataRow( cells: [ DataCell(Text(word.value)), DataCell( Center( child: Icon( word.isAnagram ? Icons.check : Icons.close, color: word.isAnagram ? Colors.green : Colors.red, ), ), ), ], ); }).toList(), ), ), ), ], ); } } class _NextWordButton extends StatelessWidget { const _NextWordButton(); @override Widget build(BuildContext context) { final l10n = context.l10n; return BlocPresentationListener<AnagramBloc, AnagramPresenterEvent>( listener: (context, event) { if (event is FinishGuess) { // show a bottom sheet with the anagrams that were not guessed showModalBottomSheet<void>( context: context, useSafeArea: true, builder: (context) { return _GameResult(event.currentWord, event.result); }, ); } }, child: FloatingActionButton.extended( onPressed: () async { context.read<AnagramBloc>().add(ResetGame()); }, label: Text(l10n.nextWordButton), ), ); } }

• _SelectWord : விளையாட்டு அனகிராம்களை உருவாக்குவதற்கான தேர்ந்தெடுக்கப்பட்ட வார்த்தையைக் காட்டுகிறது.

• _AnagramsTextField : பயனர் தட்டச்சு செய்த வார்த்தையை செயலாக்க வார்த்தையை எடுத்து ஒரு நிகழ்வை இயக்குகிறது.

• _GuessListView : பயனர் உள்ளிட்ட யூகங்களையும் அவை சரியானதா இல்லையா என்பதையும் காட்டுகிறது.

• _NextWordButton : விளையாட்டை மீட்டமைத்து, தற்போதைய வார்த்தையின் அனைத்து அனகிராம்களையும், பயனர் எந்த வார்த்தையை யூகித்துள்ளார் என்பதையும் பயனருக்கு வழங்குகிறது.

anagram_states.dart

 enum AnagramGameStatus { initial, loaded, gameError } const minNumAnagrams = 5; const defaultWordLength = 3; const maxDefaultWordLength = 7; @immutable final class AnagramState extends Equatable { factory AnagramState({ AnagramGameStatus status = AnagramGameStatus.initial, List<String> words = const [], String currentWord = '', List<String> anagrams = const [], List<Word> guesses = const [], HashSet<String>? wordSet, HashMap<String, List<String>>? anagramMap, HashMap<int, List<String>>? sizeToWords, int wordLength = defaultWordLength, }) { return AnagramState._( status: status, words: words, currentWord: currentWord, anagrams: anagrams, guesses: guesses, wordSet: wordSet ?? HashSet<String>(), anagramMap: anagramMap ?? HashMap<String, List<String>>(), sizeToWords: sizeToWords ?? HashMap<int, List<String>>(), wordLength: wordLength, ); } const AnagramState._({ required this.status, required this.words, required this.currentWord, required this.anagrams, required this.guesses, required this.wordSet, required this.anagramMap, required this.sizeToWords, this.wordLength = defaultWordLength, }); // The current status of the game final AnagramGameStatus status; // All the words in the game final List<String> words; // Currently chosen word of the game to form anagrams final String currentWord; // All the anagrams for the current word final List<String> anagrams; // All the guesses user has made final List<Word> guesses; // A set of all the words in the game final HashSet<String> wordSet; // A map of anagrams for each word final HashMap<String, List<String>> anagramMap; // Stores the words in increasing order of their length final HashMap<int, List<String>> sizeToWords; final int wordLength; AnagramState copyWith({ AnagramGameStatus? status, List<String>? words, String? currentWord, List<String>? anagrams, List<Word>? guesses, HashSet<String>? wordSet, HashMap<String, List<String>>? anagramMap, HashMap<int, List<String>>? sizeToWords, int? wordLength, }) { return AnagramState( status: status ?? this.status, words: words ?? this.words, currentWord: currentWord ?? this.currentWord, anagrams: anagrams ?? this.anagrams, guesses: guesses ?? this.guesses, wordSet: wordSet ?? this.wordSet, anagramMap: anagramMap ?? this.anagramMap, sizeToWords: sizeToWords ?? this.sizeToWords, wordLength: wordLength ?? this.wordLength, ); } @override List<Object?> get props => [ status, words, currentWord, anagrams, guesses, wordSet, anagramMap, sizeToWords, wordLength, ]; }

விளையாட்டை இயக்கத் தேவையான அனைத்து நிலை மாறிகளையும் அனகிராம்ஸ்டேட் வைத்திருக்கிறது.

• status : விளையாட்டு ஏற்றப்படுகிறதா (ஆரம்ப), ஏற்றப்படுகிறதா அல்லது ஏதேனும் பிழை ஏற்பட்டதா என்பதை வைத்திருக்கிறது.
• words : word.txt கோப்பிலிருந்து ஏற்றப்பட்ட அனைத்து சொற்களையும் பட்டியலிடுகிறது.
• anagrams : தேர்ந்தெடுக்கப்பட்ட வார்த்தைக்கான அனைத்து அனகிராம்களையும் வைத்திருக்கும்.
• currentword : ஒரு சொல் பட்டியலிலிருந்து தேர்ந்தெடுக்கப்பட்ட சொல் மற்றும் அனகிராம்களை உருவாக்குவதற்கான சொல்.
• guesses : பயனர் உள்ளிடும் அனைத்து தேர்வுகளும், அவை சரியா தவறா என்பதும்.

மீதமுள்ள விவரங்களை பின்னர் கட்டுரையில் பார்ப்போம்.

anagram_bloc.dart

 import 'dart:async'; import 'dart:collection'; import 'dart:convert'; import 'package:anagrams/anagrams/domain/word.dart'; import 'package:bloc_presentation/bloc_presentation.dart'; import 'package:equatable/equatable.dart'; import 'package:flutter/widgets.dart'; import 'package:flutter_bloc/flutter_bloc.dart'; part 'anagram_events.dart'; part 'anagram_states.dart'; class AnagramBloc extends Bloc<AnagramEvent, AnagramState> with BlocPresentationMixin<AnagramState, AnagramPresenterEvent> { AnagramBloc() : super(AnagramState()) { on<SetupAnagrams>(_onSetupAnagrams); on<ProcessWord>(_onProcessWord); on<ResetGame>(_onResetGame); } Future<void> _onSetupAnagrams( SetupAnagrams event, Emitter<AnagramState> emit, ) async { try { // this should not be done here, // but for the sake of simplicity, we will do it here final wordsFile = await event.defaultAssetBundle.loadString('assets/words.txt'); // read each line in the file final words = const LineSplitter().convert(wordsFile); // change the state of the game emit( state.copyWith( status: AnagramGameStatus.loaded, words: words, ), ); // reset the game _onRestartGame(emit); } catch (e) { emit( state.copyWith( status: AnagramGameStatus.gameError, ), ); } } Future<void> _onProcessWord( ProcessWord event, Emitter<AnagramState> emit, ) async { try { final word = event.word.trim().toLowerCase(); if (word.isEmpty) { return; } if (_isGoodWord(word) && state.anagrams.contains(word)) { // remove the word from the list of anagrams // add the word to the list of guesses emit( state.copyWith( anagrams: state.anagrams..remove(word), guesses: [...state.guesses, Word(word, isAnagram: true)], ), ); // if there are no more anagrams, the game is over // call _onResetGame to reset the game if (state.anagrams.isEmpty) { add(ResetGame()); } } else { emit( state.copyWith( guesses: [...state.guesses, Word(word)], ), ); } } catch (e) { // show an error message } } FutureOr<void> _onResetGame(ResetGame event, Emitter<AnagramState> emit) { _onGameFinished(); _onRestartGame(emit); } void _onRestartGame(Emitter<AnagramState> emit) { final starterWord = _pickGoodStarterWord(emit); emit( state.copyWith( status: AnagramGameStatus.loaded, currentWord: starterWord, anagrams: _getAnagrams(starterWord), guesses: [], ), ); } void _onGameFinished() { emitPresentation(FinishGuess(_result, state.currentWord)); } List<Word> get _result { // All the anagrams that were not guessed final notGuessedAnagrams = state.anagrams.map(Word.new).toList(); // All the guesses that were made final guesses = state.guesses.where((word) => word.isAnagram).toList(); // return the list of anagrams that were not guessed return [...guesses, ...notGuessedAnagrams]; } /// create a function to find all the anagrams of the target word List<String> _getAnagrams(String targetWord) { // find all the anagrams of the target word final anagrams = <String>[]; // return the list of anagrams return anagrams; } // ignore: unused_element List<String> _getAnagramsWithOneMoreLetter(String targetWord) { final anagrams = HashSet<String>(); // return the list of anagrams return anagrams.toList(); } /// Picks a good starter word for the game. String _pickGoodStarterWord(Emitter<AnagramState> emit) { const word = 'skate'; return word; } /// Checks if the word is a good word. bool _isGoodWord(String word) { return true; } }

• onSetupAnagrams : கோப்பைப் படித்து, சொற்களைப் பிரித்து, பட்டியலில் சேர்க்கிறது. இது தற்போதைய வார்த்தையையும் கண்டறிந்து, அந்தத் தேர்ந்தெடுக்கப்பட்ட வார்த்தைக்கான அனகிராம்களைக் கண்டறிந்து, நிலையைப் புதுப்பிக்கிறது.

• onProcessWord : பயனர் ஒரு யூகத்தை உள்ளிட்டு நிலையைப் புதுப்பிக்கும்போது இது கையாளுபவர் என்று அழைக்கப்படுகிறது.
• onReset : அடுத்த வார்த்தை பொத்தானைக் கிளிக் செய்யும்போது விளையாட்டை மீட்டமைக்கும்.
• isGoodWord : கொடுக்கப்பட்ட சொல் அகராதியில் உள்ளது என்றும், அடிப்படை வார்த்தையின் தொடக்கத்திலோ அல்லது முடிவிலோ ஒரு எழுத்தைச் சேர்ப்பதன் மூலம் உருவாக்கப்படவில்லை என்றும் வலியுறுத்துகிறது.
• getAnagrams : கொடுக்கப்பட்ட வார்த்தையின் சாத்தியமான அனைத்து அனகிராம்களின் பட்டியலையும் உருவாக்குகிறது.
• getAnagramsWithOneMoreLetter : கொடுக்கப்பட்ட வார்த்தையுடன் ஒரு எழுத்தைச் சேர்ப்பதன் மூலம் உருவாக்கக்கூடிய அனைத்து சாத்தியமான சொற்களின் பட்டியலையும் உருவாக்குகிறது.
• pickGoodStarterWord : குறைந்தபட்சம் விரும்பிய எண்ணிக்கையிலான அனகிராம்களைக் கொண்ட ஒரு வார்த்தையை சீரற்ற முறையில் தேர்ந்தெடுக்கவும்.

மைல்கல் 1: அத்தியாவசியங்கள்

முதல் மைல்கல் மிகவும் எளிமையான வேலைத் திட்டத்தை உருவாக்குவதில் கவனம் செலுத்துகிறது. மைல்கற்கள் 2 மற்றும் 3 இல் கட்டமைக்கப்படும் அடித்தளங்களை நீங்கள் செயல்படுத்துவீர்கள்.

நாங்கள் anagram_bloc.dart இல் பணியாற்றுவோம்.

அனகிராம்களைப் பெறுங்கள்

ஒரு சரத்தை எடுத்து, அந்த சரத்தின் அனைத்து அனகிராம்களையும் நமது உள்ளீட்டில் கண்டுபிடிக்கும் getAnagrams செயல்படுத்தவும். இப்போதைக்கு நமது உத்தி நேரடியானது: words பட்டியலில் உள்ள ஒவ்வொரு சரத்தையும் உள்ளீட்டு வார்த்தையுடன் ஒப்பிட்டு, அவை அனகிராம்களா என்பதைத் தீர்மானிக்கவும். ஆனால் அதை எப்படி செய்வது?

இரண்டு சரங்கள் ஒன்றுக்கொன்று அனகிராம்களா என்பதைத் தீர்மானிக்க நீங்கள் பயன்படுத்தக்கூடிய பல்வேறு உத்திகள் உள்ளன (ஒவ்வொரு எழுத்தின் நிகழ்வுகளின் எண்ணிக்கையை எண்ணுவது போல), ஆனால் எங்கள் நோக்கத்திற்காக நீங்கள் ஒரு உதவி செயல்பாட்டை உருவாக்குவீர்கள் (அதை sortLetters என்று அழைக்கவும்), அது ஒரு String எடுத்து மற்றொரு String அதே எழுத்துக்களுடன் அகர வரிசைப்படி திருப்பி அனுப்பும் (எ.கா. "post" -> "post").

இரண்டு சரங்கள் அனகிராம்களா என்பதைத் தீர்மானிப்பது, அவை ஒரே நீளமா என்பதைச் சரிபார்ப்பது (வேகத்திற்காக) மற்றும் அவற்றின் எழுத்துக்களின் வரிசைப்படுத்தப்பட்ட பதிப்புகள் சமமாக உள்ளதா என்பதைச் சரிபார்ப்பது ஒரு எளிய விஷயம்.

wordSet மற்றும் anagramMap

துரதிர்ஷ்டவசமாக, இந்த நேரடியான உத்தி இந்த விளையாட்டின் மீதமுள்ள பகுதியை செயல்படுத்த மிகவும் மெதுவாக இருக்கும். எனவே, நாம் நமது onSetupAnagrams மீண்டும் பார்வையிட வேண்டும் மற்றும் நமது நோக்கங்களுக்கு வசதியான வழிகளில் வார்த்தைகளைச் சேமிக்கும் சில தரவு கட்டமைப்புகளைக் கண்டறிய வேண்டும். ( words கூடுதலாக) இரண்டு புதிய தரவு கட்டமைப்புகளை உருவாக்குவோம்:

• ஒரு வார்த்தை செல்லுபடியாகும்தா என்பதை விரைவாக (O(1) இல்) சரிபார்க்க அனுமதிக்கும் ஒரு HashSet ( wordSet என அழைக்கப்படுகிறது).

• ஒரு HashMap ( anagramMap என்று அழைக்கப்படுகிறது), இது அனகிராம்களை தொகுக்க நம்மை அனுமதிக்கும். ஒரு சரத்தின் sortLetters பதிப்பை விசையாகப் பயன்படுத்தி, அந்த விசையுடன் தொடர்புடைய சொற்களின் பட்டியலை எங்கள் மதிப்பாக சேமிப்பதன் மூலம் இதைச் செய்வோம். எடுத்துக்காட்டாக, எங்களிடம் படிவத்தின் உள்ளீடு இருக்கலாம்: key: "opst" மதிப்பு: ["post", "spot", "pots", "tops", ...].

உள்ளீட்டு சொற்களை நீங்கள் செயலாக்கும்போது, அவை ஒவ்வொன்றிலும் sortLetters அழைக்கவும், பின்னர் anagramMap ஏற்கனவே அந்த விசைக்கான உள்ளீட்டைக் கொண்டிருக்கிறதா என்று சரிபார்க்கவும். அவ்வாறு இருந்தால், தற்போதைய வார்த்தையை அந்த விசையில் உள்ள List சேர்க்கவும். இல்லையெனில், புதிய ஒன்றை உருவாக்கி, அதில் வார்த்தையைச் சேர்த்து, தொடர்புடைய விசையுடன் HashMap இல் சேமிக்கவும்.

இதை நீங்கள் முடித்தவுடன், நீங்கள் மைல்ஸ்டோன் 1 இன் முடிவை அடைந்துவிட்டீர்கள்! இப்போது நீங்கள் இரண்டாவது மைல்கல்லுக்குச் செல்லத் தயாராக உள்ளீர்கள், அங்கு உங்கள் நிரலில் மேலும் சிக்கலைச் சேர்ப்பீர்கள்.

மைல்கல் 1க்கான தீர்வு

மைல்கல் 2: தரத்தைச் சேர்த்தல்

மைல்ஸ்டோன் 2 என்பது தேர்ந்தெடுக்கப்பட்ட சொற்கள் அனகிராம் விளையாட்டுக்கு ஏற்றதாக இருப்பதை உறுதி செய்வதாகும். முந்தைய மைல்ஸ்டோனைப் போலல்லாமல், இது மூன்று பிரிவுகளாகப் பிரிக்கப்பட்டுள்ளது.

isGoodWord

உங்கள் அடுத்த பணி isGoodWord செயல்படுத்துவதாகும், இது பின்வருவனவற்றை சரிபார்க்கிறது:

• வழங்கப்பட்ட சொல் ஒரு செல்லுபடியாகும் அகராதி வார்த்தை (அதாவது, wordSet இல்), மற்றும்
• இந்த வார்த்தையில் அடிப்படை வார்த்தை துணை சரமாக இல்லை.

ஒரு சொல் செல்லுபடியாகும் அகராதிச் சொல்லா என்பதைச் சரிபார்ப்பது, அந்தச் சொல் உள்ளதா என்று wordSet ஐப் பார்ப்பதன் மூலம் நிறைவேற்றப்படலாம். அந்தச் சொல் அடிப்படைச் சொல்லை துணைச் சரமாகச் சேர்க்கவில்லையா என்று சரிபார்ப்பது ஒரு சவாலாகவே உள்ளது!

getAnagramsWithOneMoreLetter

இறுதியாக, getAnagramsWithOneMoreLetter செயல்படுத்தவும், இது ஒரு சரத்தை எடுத்து, அந்த வார்த்தையுடன் ஒரு எழுத்தைச் சேர்ப்பதன் மூலம் உருவாக்கக்கூடிய அனைத்து அனகிராம்களையும் கண்டுபிடிக்கும்.

உங்கள் வருவாய் மதிப்பாக ஒரு புதிய List உருவாக்குவதை உறுதிசெய்து கொள்ளுங்கள், பின்னர் கொடுக்கப்பட்ட சொல் + அகரவரிசையின் ஒவ்வொரு எழுத்தையும் anagramMap உள்ள உள்ளீடுகளுக்கு எதிராக ஒவ்வொன்றாகச் சரிபார்க்கவும்.

மேலும், getAnagrams க்குப் பதிலாக getAnagramsWithOneMoreLetter ஐ செயல்படுத்த onRestartGame புதுப்பிக்கவும்.

pickGoodStarterWord

உங்கள் விளையாட்டு வேலை செய்தால், விளையாட்டை மேலும் சுவாரஸ்யமாக்க pickGoodStarterWord செயல்படுத்த தொடரவும். வார்த்தை பட்டியலில் ஒரு சீரற்ற தொடக்கப் புள்ளியைத் தேர்ந்தெடுத்து, குறைந்தபட்சம் minNumAnagrams உள்ள ஒன்றைக் கண்டுபிடிக்கும் வரை வரிசையில் உள்ள ஒவ்வொரு வார்த்தையையும் சரிபார்க்கவும். தேவைப்பட்டால், வரிசையின் தொடக்கத்திற்குச் சுற்றிச் செல்வதைக் கையாள மறக்காதீர்கள்.

மூன்றில் இரண்டு பங்கு முடிந்தது! ஒரே ஒரு மைல்கல், இன்னும் ஒரு நீட்டிப்பு மட்டும் தான்.

மைல்கல் 2க்கான தீர்வு

மைல்கல் 3: மறுசீரமைப்பு

இந்த கட்டத்தில், விளையாட்டு செயல்பாட்டுக்குரியது, ஆனால் நீங்கள் ஒரு நீண்ட அடிப்படை வார்த்தையுடன் தொடங்கினால் விளையாடுவது மிகவும் கடினமாக இருக்கும். இதைத் தவிர்க்க, அதிகரிக்கும் நீளமுள்ள வார்த்தைகளைக் கொடுக்க onSetupGame மறுசீரமைப்போம்.

இந்த மறுசீரமைப்பு onSetupGame இல் தொடங்குகிறது, அங்கு word பட்டியலை நிரப்புவதோடு கூடுதலாக, நீங்கள் ஒவ்வொரு வார்த்தையையும் ஒரு HashMap இல் சேமிக்க வேண்டும் (அதை sizeToWords என்று அழைப்போம்), இது வார்த்தை நீளத்தை அந்த நீளத்தின் அனைத்து சொற்களின் List வரைபடமாக்குகிறது. இதன் பொருள், எடுத்துக்காட்டாக, sizeToWords.get(4) ஐ அழைப்பதன் மூலம் அகராதியில் உள்ள அனைத்து நான்கு எழுத்து வார்த்தைகளையும் நீங்கள் பெற முடியும்.

pickGoodStarterWord இல், உங்கள் தேடலை wordLength நீளமுள்ள சொற்களுக்கு மட்டுப்படுத்தவும், நீங்கள் முடித்ததும், wordLength அதிகரிக்கவும் (அது ஏற்கனவே axWordLength இல் இல்லாவிட்டால்) இதனால் அடுத்த அழைப்பு ஒரு பெரிய வார்த்தையைத் தரும்.

மைல்கல் 3க்கான தீர்வு

நீட்டிப்புகள்

இந்தச் செயல்பாடு (எதிர்கால செயல்பாடுகளைப் போலவே) சில விருப்ப நீட்டிப்புகளைக் கொண்டுள்ளது. நேரம் அனுமதித்தால், கீழே உள்ள பட்டியலிலிருந்து குறைந்தபட்சம் ஒரு நீட்டிப்பையோ அல்லது நீங்களே கண்டுபிடித்த ஒன்றையோ முயற்சிக்கவும்.

• இரண்டெழுத்து முறை: அனகிராம்களை உருவாக்க இரண்டு எழுத்துக்களைச் சேர்க்க பயனரை அனுமதிக்கும் நிலைக்கு மாறவும்.

• போதுமான அனகிராம்கள் இல்லாத சொற்களை சாத்தியமான தொடக்க சொற்களின் தொகுப்பிலிருந்து நீக்குவதன் மூலம் சொல் தேர்வை மேம்படுத்தவும். அந்த வார்த்தைகள் wordSet இல் இருக்க வேண்டும் என்பதை நினைவில் கொள்ளவும், ஏனெனில் அவை வேறு வார்த்தைகளில் அனகிராம்களாகப் பயன்படுத்தப்படலாம்.

• இரண்டு-வார்த்தை முறை: இரண்டு புதிய செல்லுபடியாகும் சொற்களை உருவாக்க, ஒரு ஜோடி சொற்களில் ஒரு எழுத்தைச் சேர்க்க பயனரை அனுமதிக்கவும்.

இறுதிவரை சாதித்ததற்கு வாழ்த்துகள்! எந்தவொரு நன்கு மேம்படுத்தப்பட்ட பயன்பாட்டிலும் செய்வது போலவே, Flutter இல் Lists, HashSets மற்றும் HashMaps எவ்வாறு திறமையான தரவு கையாளுதலை இயக்குகின்றன என்பதை நீங்கள் ஆராய்ந்துள்ளீர்கள். இந்த கட்டமைப்புகளைப் புரிந்துகொள்வது அளவிடக்கூடிய மற்றும் செயல்திறன் மிக்க குறியீட்டை எழுதுவதில் உங்களுக்கு ஒரு நன்மையைத் தரும். எனவே மேலே சென்று, உங்கள் முதுகில் ஒரு தகுதியான கைதட்டலைக் கொடுங்கள்! இப்போது, இந்த அறிவை செயல்பாட்டில் கொண்டு வந்து அற்புதமான விஷயங்களை உருவாக்கத் தொடருங்கள்!