கூகுள் ஷீட்ஸில் உள்ள ஒரு வார்த்தையிலிருந்து தனித்துவமான எழுத்துக்களைப் பிரித்தெடுக்கவும்

கூகுள் தாள்களில் தனித்த எழுத்துப் பிரித்தெடுத்தல் தேர்ச்சி

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

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

இதைப் படியுங்கள்: "பனானா" என்ற வார்த்தையை நீங்கள் புதுப்பித்து, அசல் வரிசையை இழக்காமல், "BAN" என்பதை உடனடியாகப் பிரதிபலிக்க வேண்டும். 🕵️‍♀️ இது உங்கள் விரிதாள் மாறும் மற்றும் பல்வேறு புதிர்களுக்கு ஏற்றவாறு இருப்பதை உறுதி செய்கிறது. கைமுறை வேலை இல்லை, சுத்தமான ஆட்டோமேஷன்.

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

தனித்துவமான எழுத்துக்களைப் பிரித்தெடுப்பதற்கான தீர்வுகளைத் திறக்கவும்

முதல் தீர்வு, செயல்படுத்தப்பட்டது Google Apps ஸ்கிரிப்ட், அசல் வரிசையை பராமரிக்கும் போது தனிப்பட்ட எழுத்துக்களை பிரித்தெடுக்கும் செயல்முறையை தானியங்குபடுத்துகிறது. உள்ளீட்டு வார்த்தையின் (எ.கா., "TRILLION") ஒவ்வொரு எழுத்தையும் சுழற்றி, எழுத்து ஏற்கனவே முடிவு சரத்தில் உள்ளதா எனச் சரிபார்ப்பதன் மூலம் இது செயல்படுகிறது. அது இல்லையென்றால், கடிதம் சேர்க்கப்படும், நகல்கள் தவிர்க்கப்படுவதை உறுதிசெய்கின்றன. இந்த ஸ்கிரிப்ட் விரிதாள் வெளியீட்டை மாறும் வகையில் புதுப்பிக்கிறது, ஒவ்வொரு தனிப்பட்ட எழுத்தையும் கிடைமட்டமாக தனித்தனி கலங்களில் வைக்கிறது. எடுத்துக்காட்டாக, செல் A1 இல் உள்ள வார்த்தையை "பனானா" க்கு புதுப்பித்தால், வெளியீட்டை உடனடியாக "BAN" ஆக மாற்றுகிறது. இந்த ஆட்டோமேஷன், வார்த்தை புதிர்கள் போன்ற, மீண்டும் மீண்டும் செய்யும் பணிகளுக்கு ஏற்றதாக அமைகிறது. 🧩

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

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

இறுதியாக, அலகு சோதனைகள் ஒவ்வொரு தீர்வும் சரியாக வேலை செய்வதை உறுதி செய்கின்றன. Mocha/Chai போன்ற கட்டமைப்புகளைக் கொண்ட சோதனையானது விளிம்பு நிலைகள் மற்றும் வழக்கமான உள்ளீடுகள் இரண்டையும் சரிபார்க்கிறது, அதாவது வெற்று சரங்களை அல்லது ஒரே மாதிரியான எழுத்துக்களைக் கொண்ட சொற்களைக் கையாளுதல். எடுத்துக்காட்டாக, "AAAAA" உடன் சோதனை செய்யும் போது, ​​"A" வெளியீடு நகல்களை திறம்பட கையாளுவதை உறுதிப்படுத்துகிறது. சேர்த்தல் பிழை கையாளுதல் தவறான உள்ளீடுகளுக்கு எதிரான பாதுகாப்பு, நம்பகத்தன்மையை உறுதிப்படுத்துகிறது. இந்த தீர்வுகளை சோதனைகளுடன் இணைப்பதன் மூலம், பயனர்கள் மற்றும் டெவலப்பர்கள் தங்கள் துல்லியம் மற்றும் தகவமைப்புத் தன்மையில் நம்பிக்கையைப் பெறுகின்றனர். ஒன்றாக, இந்த அணுகுமுறைகள் தொழில்நுட்ப கருவிகள் மற்றும் படைப்பாற்றல் சிந்தனை இரண்டும் தனிப்பட்ட எழுத்துக்களைப் பிரித்தெடுப்பது போன்ற நிஜ உலக சவால்களை எவ்வாறு எதிர்கொள்ள முடியும் என்பதை நிரூபிக்கிறது. 🚀

// Function to extract unique letters from a string in order of appearancefunction extractUniqueLetters() {  var sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet(); // Access the active sheet
  var inputCell = sheet.getRange("A1").getValue(); // Get the word from cell A1
  var uniqueLetters = "";
  for (var i = 0; i < inputCell.length; i++) {
    if (!uniqueLetters.includes(inputCell[i])) {
      uniqueLetters += inputCell[i];
    }
  }
  var outputRange = sheet.getRange(1, 2, 1, uniqueLetters.length);
  var outputArray = uniqueLetters.split("");
  outputRange.setValues([outputArray]); // Write unique letters horizontally
}

=ARRAYFORMULA(TEXTJOIN("", TRUE,
IFERROR(IF(MATCH(SPLIT(A1, ""), SPLIT(A1, ""), 0) = ROW(SPLIT(A1, "")),
SPLIT(A1, ""),
""),
""
)))

// Function to get unique letters in the order they appearfunction getUniqueLetters(word) {  let unique = [];
  for (let char of word) {
    if (!unique.includes(char)) {
      unique.push(char);
    }
  }
  return unique.join("");
}
// Example Usage:
console.log(getUniqueLetters("TRILLION")); // Output: TRILON

const { expect } = require("chai");
describe("getUniqueLetters", function () {
  it("should return TRILON for TRILLION", function () {
    expect(getUniqueLetters("TRILLION")).to.equal("TRILON");
  });
  it("should return BAN for BANANA", function () {
    expect(getUniqueLetters("BANANA")).to.equal("BAN");
  });
});

தனித்த எழுத்துக்களை வரிசையில் பிரித்தெடுக்கும் திறமையான முறைகள்

தனிப்பட்ட எழுத்துக்களை வரிசையாக பிரித்தெடுப்பதில் அடிக்கடி கவனிக்கப்படாத அம்சம் உங்கள் தீர்வின் அளவிடுதல் ஆகும். விரிதாள் அல்லது பயன்பாட்டில் பயனர் உருவாக்கிய சொற்கள் போன்ற டைனமிக் உள்ளீடுகளுடன் பணிபுரியும் போது, ​​நீண்ட சொற்கள் அல்லது வழக்கத்திற்கு மாறான எழுத்துக்கள் போன்ற பலதரப்பட்ட நிகழ்வுகளை இந்த முறை கையாள்வதை உறுதி செய்வது அவசியம். உதாரணமாக, "MISP" ஐப் பெறுவதற்கு, "MISSIPPI"யை திறமையாகச் செயலாக்குவது ஒரு முக்கிய சவாலாகும், குறிப்பாக இது பல தாள்கள் அல்லது தரவுத்தொகுப்புகளில் அளவிட வேண்டியிருக்கும் போது. 📝

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

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