இயற்கை வரிசைப்படுத்தல் வரிசையில் குழப்பம்10
25

பெரும்பாலான வரைகலை கோப்பு மேலாளர்கள் கண்டிப்பாக அகராதியியல் ரீதியாக வரிசைப்படுத்துவதில்லை, மாறாக "இயற்கை" வரிசைப்படுத்தலைப் பயன்படுத்துகிறார்கள். பெயர்களில் உள்ள எண்களின் தொகுதிகள் எண்களாக விளக்கப்படுகின்றன - எதிர் அகரவரிசைப்படி உண்மையாக இருந்தாலும் கூட, எண்களின் பெரிய தொகுதி வெற்றி பெறுகிறது. இயற்கை வரிசைப்படுத்தலுக்குப் பின்னால் உள்ள யோசனை: மக்கள் வழக்கமாக விரும்புவது "10 க்கு முன் 9," "அத்தியாயம் 10 க்கு முன் அத்தியாயம் 2" - முன்னணி பூஜ்ஜியங்களைச் சேர்க்காமல்.

பின்வரும் கோப்பு ஜோடிகள் இயற்கையாகவே ஏறுவரிசையில் பின்வருமாறு வரிசைப்படுத்தப்படுகின்றன::

  • build-9e2.log
  • build-950.log

ஆச்சரியமாக இருக்கிறது, ஆனால் விளக்கக்கூடியது: முதல் இலக்கம் \(9\) முதல் இலக்கத் தொகுதியை விடச் சிறியது \(950\) .

  • IMG_12113419_90.jpg
  • IMG_0554363070_90.jpg

\(12113419\) என்ற எண் \(554363070\) விடக் குறைவு (முன்னணி \(0\) நீக்கப்பட்டது).

  • temp_0C.txt
  • temp_2C.txt
  • temp_-3C.txt
  • temp_10C.txt
  • temp_-12C.txt

ஒப்பிடப்பட்ட எண்கள் \(0\) , \(2\) , \(3\) , \(10\) , \(12\) - “-” எண்ணின் ஒரு பகுதியாகக் கருதப்படவில்லை.

"அகரவரிசை" கூட உலகளவில் தெளிவற்றது அல்ல: பெரிய எழுத்து, ä (ஜெர்மன்) போன்ற umlauts அல்லது ch (செக்) போன்ற பல எழுத்து எழுத்துக்கள் முறையான மாறுபாடுகளுக்கு வழிவகுக்கும். எனவே "முற்றிலும் அகரவரிசை" என்பது சூழல் சார்ந்தது. விண்டோஸ் எக்ஸ்ப்ளோரர் இதை StrCmpLogicalW செயல்பாட்டில் செயல்படுத்துகிறது. அதன் மூலக் குறியீடு (shlwapi.dll) தனியுரிமமானது மற்றும் பொதுவில் இல்லை என்றாலும், எடுத்துக்காட்டாக, ReactOS இலிருந்து மறு செயல்படுத்தல்கள் உள்ளன.:

{
    TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(comp));
 
    if (!str || !comp)
        return 0;
 
    while (*str)
    {
        if (!*comp)
            return 1;
        else if (*str >= '0' && *str <= '9')
        {
            int str_value, comp_value;
 
            if (*comp < '0' || *comp > '9')
                return -1;
 
            /* Compare the numbers */
            StrToIntExW(str, 0, &str_value);
            StrToIntExW(comp, 0, &comp_value);
 
            if (str_value < comp_value)
                return -1;
            else if (str_value > comp_value)
                return 1;
 
            /* Skip */
            while (*str >= '0' && *str <= '9') str++;
            while (*comp >= '0' && *comp <= '9') comp++;
        }
        else if (*comp >= '0' && *comp <= '9')
            return 1;
        else
        {
            int diff = ChrCmpIW(*str, *comp);
            if (diff > 0)
                return 1;
            else if (diff < 0)
                return -1;
 
            str++;
            comp++;
        }
    }
 
    if (*comp)
      return -1;
 
    return 0;
}

கூகிள் டிரைவ், ஒன் டிரைவ், கேடிஇ மற்றும் பிறவும் இதேபோன்ற வரிசைப்படுத்தும் நடத்தையைக் காட்டுகின்றன. CLI கருவிகள் போன்றவை ls மற்றும் find இருப்பினும், அவை GUI கோப்பு மேலாளர்களை விட வித்தியாசமாக வரிசைப்படுத்துகின்றன. சொற்பொருள்கள் கோப்பு பெயர்களில் உள்ளன, API இல் இல்லை. ஆச்சரியங்கள் இல்லாமல் முடிவுகளை நீங்கள் விரும்பினால், மரபுகளை வரையறுக்கவும்: நிலையான பிரிப்பான்கள், திணிக்கப்பட்ட எண்கள் மற்றும் அலகுகளின் தெளிவான கையாளுதல். பின்னர் "அகரவரிசை" மீண்டும் கணிக்கக்கூடியதாக மாறும்.

மீண்டும்