क्या कोई रास्ता है दे घुमा के एक स्ट्रिंग को कम केस स्ट्रिंग में बदलने के लिए?
उदाहरण के लिए, अगर मेरे पास:
a="Hi all"मैं इसे रूपांतरित करना चाहता हूं:
"hi all"जवाबों:
विभिन्न तरीके हैं:
$ echo "$a" | tr '[:upper:]' '[:lower:]'
hi all$ echo "$a" | awk '{print tolower($0)}'
hi allआप निम्न उदाहरणों के साथ पोर्टेबिलिटी मुद्दों में भाग सकते हैं:
$ echo "${a,,}"
hi all$ echo "$a" | sed -e 's/\(.*\)/\L\1/'
hi all
# this also works:
$ sed -e 's/\(.*\)/\L\1/' <<< "$a"
hi all$ echo "$a" | perl -ne 'print lc'
hi alllc(){
case "$1" in
[A-Z])
n=$(printf "%d" "'$1")
n=$((n+32))
printf \\$(printf "%o" "$n")
;;
*)
printf "%s" "$1"
;;
esac
}
word="I Love Bash"
for((i=0;i<${#word};i++))
do
ch="${word:$i:1}"
lc "$ch"
doneनोट: इस पर YMMV। उपयोग करने के साथ भी मेरे लिए (GNU बैश संस्करण 4.2.46 और 4.0.33 (और समान व्यवहार 2.05b.0 लेकिन nocasematch लागू नहीं है) के लिए काम नहीं करता है shopt -u nocasematch;। उस nocasematch को रोकने के कारण [["fooBaR" == "FOObar"]] को अजीब तरह से [bz] गलत तरीके से मिलान किया जाता है [AZ]। बैश दोहरे नकारात्मक ("परेशान nocasematch") द्वारा भ्रमित है! :-)
word="Hi All"अन्य उदाहरणों की तरह बनाते हैं, तो यह वापस आ जाता है ha, नहीं hi all। यह केवल बड़े अक्षरों के लिए काम करता है और पहले से ही निचली अक्षरों को छोड़ देता है।
trऔर awkउदाहरण POSIX मानक में निर्दिष्ट हैं।
tr '[:upper:]' '[:lower:]'अपरकेस / लोअरकेस समतुल्य का निर्धारण करने के लिए वर्तमान लोकेल का उपयोग करेगा, इसलिए यह उन स्थानों के साथ काम करेगा जो वर्णनात्मक अंक वाले अक्षरों का उपयोग करते हैं।
b="$(echo $a | tr '[A-Z]' '[a-z]')"
बैश 4 में:
नीचे करना
$ string="A FEW WORDS"
$ echo "${string,}"
a FEW WORDS
$ echo "${string,,}"
a few words
$ echo "${string,,[AEIUO]}"
a FeW WoRDS
$ string="A Few Words"
$ declare -l string
$ string=$string; echo "$string"
a few wordsअपरकेस करने के लिए
$ string="a few words"
$ echo "${string^}"
A few words
$ echo "${string^^}"
A FEW WORDS
$ echo "${string^^[aeiou]}"
A fEw wOrds
$ string="A Few Words"
$ declare -u string
$ string=$string; echo "$string"
A FEW WORDSटॉगल करें (संकलित समय पर वैकल्पिक रूप से कॉन्फ़िगर किया गया)
$ string="A Few Words"
$ echo "${string~~}"
a fEW wORDS
$ string="A FEW WORDS"
$ echo "${string~}"
a FEW WORDS
$ string="a few words"
$ echo "${string~}"
A few wordsकैपिटलाइज़ करें (संकलित समय पर वैकल्पिक रूप से कॉन्फ़िगर किया गया)
$ string="a few words"
$ declare -c string
$ string=$string
$ echo "$string"
A few wordsशीर्षक खाना:
$ string="a few words"
$ string=($string)
$ string="${string[@]^}"
$ echo "$string"
A Few Words
$ declare -c string
$ string=(a few words)
$ echo "${string[@]}"
A Few Words
$ string="a FeW WOrdS"
$ string=${string,,}
$ string=${string~}
$ echo "$string"
A few wordsएक declareविशेषता को बंद करने के लिए , का उपयोग करें +। उदाहरण के लिए, declare +c string। यह बाद के असाइनमेंट को प्रभावित करता है न कि वर्तमान मूल्य को।
declareविकल्प चर की विशेषता है, लेकिन नहीं सामग्री बदल जाते हैं। मेरे उदाहरणों में दिए गए पुन: असाइनमेंट सामग्री को परिवर्तन दिखाने के लिए अद्यतन करते हैं।
संपादित करें:
जोड़ा गया "शब्द द्वारा पहला पात्र टॉगल करें" ( ${var~}) जैसा कि ghostdog74 द्वारा सुझाया गया है ।
संपादित करें: बैश 4.3 से मिलान करने के लिए सही टिल्ड व्यवहार।
string="łódź"; echo ${string~~}"ŹDŹ" लौटाएगा, लेकिन echo ${string^^}"łóDź" लौटाएगा। में भी LC_ALL=pl_PL.utf-8। वह बैश 4.2.24 का उपयोग कर रहा है।
en_US.UTF-8। यह एक बग है और मैंने इसे रिपोर्ट किया है।
echo "$string" | tr '[:lower:]' '[:upper:]'। यह संभवतः उसी विफलता को प्रदर्शित करेगा। तो समस्या कम से कम आंशिक रूप से बैश की नहीं है।
echo "Hi All" | tr "[:upper:]" "[:lower:]"trमेरे लिए गैर-एसीआईआई पात्रों के लिए काम नहीं करता है। मेरे पास सही लोकल सेट और लोकेल फाइलें उत्पन्न होती हैं। क्या मुझे पता है कि मैं गलत कर सकता हूं?
[:upper:]जरूरी है?
a="$(tr [A-Z] [a-z] <<< "$a")"{ print tolower($0) }y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/a="$(tr [A-Z] [a-z] <<< "$a")"मुझे सबसे आसान लगता है। मैं अभी भी एक शुरुआत कर रहा हूँ ...
sedसमाधान की सिफारिश करता हूं ; मैं एक ऐसे माहौल में काम कर रहा हूं, जो किसी कारण से नहीं है, trलेकिन मुझे अभी तक बिना किसी सिस्टम के ढूंढना है sed, इसके अलावा बहुत से समय मैं ऐसा करना चाहता हूं, मैंने अभी कुछ और किया sedहै, इसलिए चेन कर सकता हूं एक एकल (लंबे) बयान में एक साथ आदेश।
tr [A-Z] [a-z] Aअगर कोई एक भी पत्र या से मिलकर फ़ाइल नाम हैं, खोल फ़ाइल नाम विस्तार प्रदर्शन कर सकते हैं nullgob निर्धारित है। tr "[A-Z]" "[a-z]" Aठीक से व्यवहार करेगा।
sed
tr [A-Z] [a-z]लगभग सभी स्थानों में गलत है। उदाहरण के लिए, en-USलोकेल में, A-Zवास्तव में अंतराल है AaBbCcDdEeFfGgHh...XxYyZ।
मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन मैंने इसका जवाब दूसरी साइट के लिए बनाया है, तो मुझे लगा कि मैं इसे यहाँ पोस्ट करूँगा:
UPPER -> निचला : अजगर का उपयोग करें:
b=`echo "print '$a'.lower()" | python`या रूबी:
b=`echo "print '$a'.downcase" | ruby`या पर्ल (शायद मेरा पसंदीदा):
b=`perl -e "print lc('$a');"`या PHP:
b=`php -r "print strtolower('$a');"`या अवाक्:
b=`echo "$a" | awk '{ print tolower($1) }'`या पाल:
b=`echo "$a" | sed 's/./\L&/g'`या बैश 4:
b=${a,,}या अगर आपके पास NodeJS है (और थोड़े पागल हैं ...):
b=`echo "console.log('$a'.toLowerCase());" | node`आप भी इस्तेमाल कर सकते हैं dd(लेकिन मैं नहीं!):
b=`echo "$a" | dd conv=lcase 2> /dev/null`निचला -> उत्तर प्रदेश :
अजगर का उपयोग करें:
b=`echo "print '$a'.upper()" | python`या रूबी:
b=`echo "print '$a'.upcase" | ruby`या पर्ल (शायद मेरा पसंदीदा):
b=`perl -e "print uc('$a');"`या PHP:
b=`php -r "print strtoupper('$a');"`या अवाक्:
b=`echo "$a" | awk '{ print toupper($1) }'`या पाल:
b=`echo "$a" | sed 's/./\U&/g'`या बैश 4:
b=${a^^}या अगर आपके पास NodeJS है (और थोड़े पागल हैं ...):
b=`echo "console.log('$a'.toUpperCase());" | node`आप भी इस्तेमाल कर सकते हैं dd(लेकिन मैं नहीं!):
b=`echo "$a" | dd conv=ucase 2> /dev/null`इसके अलावा जब आप कहते हैं कि 'शेल' मैं आपको मतलब मान रहा हूं, bashलेकिन अगर आप इसका उपयोग कर सकते हैं तो zshयह उतना आसान है
b=$a:lनिचले मामले के लिए और
b=$a:uऊपरी मामले के लिए।
aकिसी एकल उद्धरण में मान शामिल है, तो आपके पास न केवल व्यवहार टूट गया है, बल्कि एक गंभीर सुरक्षा समस्या है।
Zsh में:
echo $a:uहोगा प्यार zsh!
echo ${(C)a} #Upcase the first char only
प्री बैश 4.0
एक स्ट्रिंग के मामले को कम करें और चर को असाइन करें
VARIABLE=$(echo "$VARIABLE" | tr '[:upper:]' '[:lower:]')
echo "$VARIABLE"echoऔर पाइप की आवश्यकता नहीं : उपयोग$(tr '[:upper:]' '[:lower:]' <<<"$VARIABLE")
केवल शेलिंस का उपयोग करके एक मानक शेल (बिना बशीश) के लिए:
uppers=ABCDEFGHIJKLMNOPQRSTUVWXYZ
lowers=abcdefghijklmnopqrstuvwxyz
lc(){ #usage: lc "SOME STRING" -> "some string"
i=0
while ([ $i -lt ${#1} ]) do
CUR=${1:$i:1}
case $uppers in
*$CUR*)CUR=${uppers%$CUR*};OUTPUT="${OUTPUT}${lowers:${#CUR}:1}";;
*)OUTPUT="${OUTPUT}$CUR";;
esac
i=$((i+1))
done
echo "${OUTPUT}"
}और ऊपरी मामले के लिए:
uc(){ #usage: uc "some string" -> "SOME STRING"
i=0
while ([ $i -lt ${#1} ]) do
CUR=${1:$i:1}
case $lowers in
*$CUR*)CUR=${lowers%$CUR*};OUTPUT="${OUTPUT}${uppers:${#CUR}:1}";;
*)OUTPUT="${OUTPUT}$CUR";;
esac
i=$((i+1))
done
echo "${OUTPUT}"
}${var:1:1}एक Bashism के साथ substrings हैं।
आप यह कोशिश कर सकते हैं
s="Hello World!"
echo $s # Hello World!
a=${s,,}
echo $a # hello world!
b=${s^^}
echo $b # HELLO WORLD!
रेफरी: http://wiki.workassis.com/shell-script-convert-text-to-lowercase-and-upportsase/
मैं जिस आज्ञा को साझा करना चाहता हूं, उसका श्रेय लेना चाहता हूं, लेकिन सच्चाई यह है कि मुझे http://commandlinefu.com से अपने स्वयं के उपयोग के लिए प्राप्त किया गया है । इसका यह फायदा है कि यदि आप cdअपने खुद के होम फोल्डर में किसी भी डायरेक्टरी में हैं, तो यह है कि सभी फाइल और फोल्डर को लोअर केस में बदल दें, कृपया सावधानी से उपयोग करें। यह एक शानदार कमांड लाइन फिक्स है और विशेष रूप से उन एल्बमों के लिए उपयोगी है जिन्हें आपने अपने ड्राइव पर संग्रहीत किया है।
find . -depth -exec rename 's/(.*)\/([^\/]*)/$1\/\L$2/' {} \;आप वर्तमान निर्देशिका या पूर्ण पथ को दर्शाने वाले खोज के बाद डॉट (।) के स्थान पर एक निर्देशिका निर्दिष्ट कर सकते हैं।
मुझे उम्मीद है कि यह समाधान एक चीज को उपयोगी साबित करता है जो यह आदेश नहीं करता है अंडरस्कोर के साथ रिक्त स्थान को बदलें - ओह अच्छी तरह से एक और समय।
prenameसे perl: dpkg -S "$(readlink -e /usr/bin/rename)"देता हैperl: /usr/bin/prename
बाहरी कार्यक्रमों का उपयोग करते हुए कई उत्तर, जो वास्तव में उपयोग नहीं कर रहा है Bash।
यदि आप जानते हैं कि आपके पास बैश 4 उपलब्ध होगा तो आपको वास्तव में केवल ${VAR,,}अंकन का उपयोग करना चाहिए (यह आसान और अच्छा है)। 4 से पहले बैश के लिए (मेरा मैक अभी भी उदाहरण के लिए बैश 3.2 का उपयोग करता है)। मैंने अधिक पोर्टेबल संस्करण बनाने के लिए @ ghostdog74 के उत्तर के सही संस्करण का उपयोग किया।
एक आप कॉल कर सकते हैं lowercase 'my STRING'और एक लोअरकेस संस्करण प्राप्त कर सकते हैं । मैंने परिणाम को var पर सेट करने के बारे में टिप्पणियां पढ़ीं, लेकिन यह वास्तव में पोर्टेबल नहीं है Bash, क्योंकि हम स्ट्रिंग्स को वापस नहीं कर सकते हैं। इसे प्रिंट करना सबसे अच्छा उपाय है। कुछ के साथ कब्जा करने के लिए आसान है var="$(lowercase $str)"।
यह कैसे काम करता है
जिस तरह से यह काम करता है वह ASCII पूर्णांक प्रतिनिधित्व के साथ प्रत्येक चार का प्रतिनिधित्व करता है printfऔर फिर adding 32अगरupper-to->lower , या subtracting 32यदि lower-to->upper। फिर printfनंबर को वापस चार में बदलने के लिए फिर से उपयोग करें। से 'A' -to-> 'a'हम 32 वर्ण का अंतर है।
printfसमझाने के लिए उपयोग करना :
$ printf "%d\n" "'a"
97
$ printf "%d\n" "'A"
6597 - 65 = 32
और यह उदाहरण के साथ काम करने वाला संस्करण है।
कृपया कोड में टिप्पणियों को नोट करें, क्योंकि वे बहुत सारे सामान समझाते हैं:
#!/bin/bash
# lowerupper.sh
# Prints the lowercase version of a char
lowercaseChar(){
case "$1" in
[A-Z])
n=$(printf "%d" "'$1")
n=$((n+32))
printf \\$(printf "%o" "$n")
;;
*)
printf "%s" "$1"
;;
esac
}
# Prints the lowercase version of a sequence of strings
lowercase() {
word="$@"
for((i=0;i<${#word};i++)); do
ch="${word:$i:1}"
lowercaseChar "$ch"
done
}
# Prints the uppercase version of a char
uppercaseChar(){
case "$1" in
[a-z])
n=$(printf "%d" "'$1")
n=$((n-32))
printf \\$(printf "%o" "$n")
;;
*)
printf "%s" "$1"
;;
esac
}
# Prints the uppercase version of a sequence of strings
uppercase() {
word="$@"
for((i=0;i<${#word};i++)); do
ch="${word:$i:1}"
uppercaseChar "$ch"
done
}
# The functions will not add a new line, so use echo or
# append it if you want a new line after printing
# Printing stuff directly
lowercase "I AM the Walrus!"$'\n'
uppercase "I AM the Walrus!"$'\n'
echo "----------"
# Printing a var
str="A StRing WITH mixed sTUFF!"
lowercase "$str"$'\n'
uppercase "$str"$'\n'
echo "----------"
# Not quoting the var should also work,
# since we use "$@" inside the functions
lowercase $str$'\n'
uppercase $str$'\n'
echo "----------"
# Assigning to a var
myLowerVar="$(lowercase $str)"
myUpperVar="$(uppercase $str)"
echo "myLowerVar: $myLowerVar"
echo "myUpperVar: $myUpperVar"
echo "----------"
# You can even do stuff like
if [[ 'option 2' = "$(lowercase 'OPTION 2')" ]]; then
echo "Fine! All the same!"
else
echo "Ops! Not the same!"
fi
exit 0और इसे चलाने के बाद परिणाम:
$ ./lowerupper.sh
i am the walrus!
I AM THE WALRUS!
----------
a string with mixed stuff!
A STRING WITH MIXED STUFF!
----------
a string with mixed stuff!
A STRING WITH MIXED STUFF!
----------
myLowerVar: a string with mixed stuff!
myUpperVar: A STRING WITH MIXED STUFF!
----------
Fine! All the same!यह केवल ASCII वर्णों के लिए काम करना चाहिए ।
मेरे लिए यह ठीक है, क्योंकि मुझे पता है कि मैं केवल एएससीआईआई को इसके लिए पास करूंगा।
मैं उदाहरण के लिए कुछ केस-असंवेदनशील सीएलआई विकल्पों के लिए इसका उपयोग कर रहा हूं।
परिवर्तित मामला केवल वर्णमाला के लिए किया जाता है। तो, यह बड़े करीने से काम करना चाहिए।
मैं ऊपरी मामले से निचले मामले में az के बीच अक्षर बदलने पर ध्यान केंद्रित कर रहा हूं। किसी भी अन्य पात्रों को बस स्टडआउट में मुद्रित किया जाना चाहिए जैसा कि यह है ...
AZ को az रेंज के भीतर पथ / में / फ़ाइल / फ़ाइल नाम के सभी पाठ को रूपांतरित करता है
निचले मामले को ऊपरी मामले में परिवर्तित करने के लिए
cat path/to/file/filename | tr 'a-z' 'A-Z'ऊपरी मामले से निचले मामले में परिवर्तित करने के लिए
cat path/to/file/filename | tr 'A-Z' 'a-z'उदाहरण के लिए,
फ़ाइल का नाम:
my name is xyzमें परिवर्तित हो जाता है:
MY NAME IS XYZउदाहरण 2:
echo "my name is 123 karthik" | tr 'a-z' 'A-Z'
# Output:
# MY NAME IS 123 KARTHIKउदाहरण 3:
echo "my name is 123 &&^&& #@$#@%%& kAR2~thik" | tr 'a-z' 'A-Z'
# Output:
# MY NAME IS 123 &&^&& #@0@%%& KAR2~THIKयदि v4 का उपयोग किया जाता है, तो यह बेक किया हुआ है । यदि नहीं, तो यहां एक सरल, व्यापक रूप से लागू समाधान है। इस धागे पर अन्य उत्तर (और टिप्पणियाँ) नीचे दिए गए कोड को बनाने में काफी मददगार थे।
# Like echo, but converts to lowercase
echolcase () {
tr [:upper:] [:lower:] <<< "${*}"
}
# Takes one arg by reference (var name) and makes it lowercase
lcase () {
eval "${1}"=\'$(echo ${!1//\'/"'\''"} | tr [:upper:] [:lower:] )\'
}टिप्पणियाँ:
a="Hi All"और फिर: के lcase aरूप में एक ही काम करेंगे:a=$( echolcase "Hi All" )${!1//\'/"'\''"}की ${!1}अनुमति देता है।4.0 से पहले के बैश संस्करणों के लिए, यह संस्करण सबसे तेज़ होना चाहिए (क्योंकि यह किसी आदेश को कांटा / निष्पादित नहीं करता है ):
function string.monolithic.tolower
{
local __word=$1
local __len=${#__word}
local __char
local __octal
local __decimal
local __result
for (( i=0; i<__len; i++ ))
do
__char=${__word:$i:1}
case "$__char" in
[A-Z] )
printf -v __decimal '%d' "'$__char"
printf -v __octal '%03o' $(( $__decimal ^ 0x20 ))
printf -v __char \\$__octal
;;
esac
__result+="$__char"
done
REPLY="$__result"
}टेक्नोसॉरस के उत्तर में क्षमता भी थी, हालांकि यह ठीक से चल रहा था।
इसके बावजूद यह प्रश्न कितना पुराना है और टेक्नोसॉरस के इस जवाब से मिलता-जुलता है । मेरे पास एक मुश्किल समय था जो एक समाधान ढूंढता था जो अधिकांश प्लेटफार्मों (जो मैं उपयोग करता हूं) के साथ-साथ बैश के पुराने संस्करणों में भी पोर्टेबल था। मैं तुच्छ चर को पुनः प्राप्त करने के लिए सरणियों, कार्यों और प्रिंटों, इकोस और अस्थायी फ़ाइलों के उपयोग से भी निराश हो गया हूं। यह मेरे लिए बहुत अच्छा काम करता है अब तक मैंने सोचा था कि मैं साझा करूंगा। मेरे मुख्य परीक्षण वातावरण हैं:
- GNU बैश, संस्करण 4.1.2 (1) -release (x86_64-redhat-linux-gnu)
- GNU बैश, संस्करण 3.2.57 (1) -release (स्पार्क-सन-सोलारिस 2.10)
lcs="abcdefghijklmnopqrstuvwxyz"
ucs="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
input="Change Me To All Capitals"
for (( i=0; i<"${#input}"; i++ )) ; do :
for (( j=0; j<"${#lcs}"; j++ )) ; do :
if [[ "${input:$i:1}" == "${lcs:$j:1}" ]] ; then
input="${input/${input:$i:1}/${ucs:$j:1}}"
fi
done
doneलूप के लिए सरल सी-शैली स्ट्रिंग्स के माध्यम से पुनरावृति करने के लिए । नीचे की पंक्ति के लिए यदि आपने इससे पहले ऐसा कुछ नहीं देखा है, जहां मैंने यह सीखा है । इस मामले में लाइन चेक करती है कि क्या char $ {इनपुट: $ i: 1} (निचला मामला) इनपुट में मौजूद है और यदि ऐसा है तो दिए गए char $ {ucs: $ j: 1} (ऊपरी मामले) के साथ बदल देता है और इसे संग्रहीत करता है इनपुट में वापस
input="${input/${input:$i:1}/${ucs:$j:1}}"यह JaredTS486 के दृष्टिकोण का कहीं अधिक तेज़ बदलाव है जो अपने दृष्टिकोण को अनुकूलित करने के लिए देशी बैश क्षमताओं (बाश संस्करणों सहित <4.0) का उपयोग करता है।
मैंने एक छोटे स्ट्रिंग (25 अक्षर) और एक बड़े स्ट्रिंग (445 वर्ण) के लिए इस दृष्टिकोण के 1,000 पुनरावृत्तियों को लोअरकेस और अपरकेस रूपांतरणों के लिए समयबद्ध किया है। चूंकि परीक्षण के तार मुख्य रूप से निचले होते हैं, इसलिए निचले हिस्से के रूपांतरण आमतौर पर अपरकेस की तुलना में अधिक तेज़ होते हैं।
मैंने इस पृष्ठ पर कई अन्य उत्तरों के साथ अपने दृष्टिकोण की तुलना की है जो बैश 3.2 के साथ संगत हैं। मेरा दृष्टिकोण यहां प्रलेखित अधिकांश दृष्टिकोणों की तुलना में कहीं अधिक बेहतर है, और trकई मामलों में इससे भी तेज है ।
यहां 25 वर्णों के 1,000 पुनरावृत्तियों के लिए समय परिणाम दिए गए हैं:
trलोअरकेस के लिए 3.67 ; अपरकेस के लिए 3.81445 पात्रों के 1,000 पुनरावृत्तियों के लिए समय परिणाम (विटर बर्नर द्वारा कविता "द रॉबिन"):
trलोअरकेस के लिए 4 एस ; अपरकेस के लिए 4समाधान:
#!/bin/bash
set -e
set -u
declare LCS="abcdefghijklmnopqrstuvwxyz"
declare UCS="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
function lcase()
{
local TARGET="${1-}"
local UCHAR=''
local UOFFSET=''
while [[ "${TARGET}" =~ ([A-Z]) ]]
do
UCHAR="${BASH_REMATCH[1]}"
UOFFSET="${UCS%%${UCHAR}*}"
TARGET="${TARGET//${UCHAR}/${LCS:${#UOFFSET}:1}}"
done
echo -n "${TARGET}"
}
function ucase()
{
local TARGET="${1-}"
local LCHAR=''
local LOFFSET=''
while [[ "${TARGET}" =~ ([a-z]) ]]
do
LCHAR="${BASH_REMATCH[1]}"
LOFFSET="${LCS%%${LCHAR}*}"
TARGET="${TARGET//${LCHAR}/${UCS:${#LOFFSET}:1}}"
done
echo -n "${TARGET}"
}दृष्टिकोण सरल है: जबकि इनपुट स्ट्रिंग में कोई शेष अपरकेस अक्षर मौजूद है, अगले एक को ढूंढें, और उस पत्र के सभी उदाहरणों को उसके निचले संस्करण के साथ बदलें। सभी अपरकेस अक्षरों को बदलने तक दोहराएं।
मेरे समाधान की कुछ प्रदर्शन विशेषताएँ:
UCSऔर LCSअतिरिक्त पात्रों के साथ संवर्धित किया जा सकता है