Parse a Quaternion

Question

यदि आप पहले से ही नहीं जानते हैं, तो एक विचित्रता मूल रूप से एक 4-भाग संख्या है। इस चुनौती के प्रयोजनों के लिए, इसमें एक वास्तविक घटक और तीन काल्पनिक घटक हैं। काल्पनिक घटक प्रत्यय का प्रतिनिधित्व कर रहे i, j, k। उदाहरण के लिए, 1-2i+3j-4kके साथ एक चार का समुदाय है 1असली घटक जा रहा है और -2, 3, और -4काल्पनिक घटक जा रहा है।

इस चुनौती में आपको एक quaternion (उदा। "1+2i-3j-4k") के स्ट्रिंग रूप को गुणांक (उदा। [1 2 -3 -4]) की सूची / सरणी में पार्स करना है । हालाँकि, कई अलग-अलग तरीकों से क्वाटर्नियन स्ट्रिंग को स्वरूपित किया जा सकता है ...

• यह सामान्य हो सकता है: 1+2i-3j-4k
• यह लापता शर्तें हो सकती हैं: 1-3k, 2i-4k(तुम्हारी याद आ रही संदर्भ है, तो उत्पादन 0उन शब्दों के लिए)
• यह गुणांक लापता हो सकता है: i+j-k(इस मामले में, इस के बराबर है 1i+1j-1kदूसरे शब्दों में, एक। i, j, या kसामने एक संख्या एक मानी जाती है बिना 1डिफ़ॉल्ट रूप से सामने)
• यह सही क्रम में नहीं हो सकता है: 2i-1+3k-4j
• गुणांक केवल पूर्णांक या दशमलव हो सकते हैं: 7-2.4i+3.75j-4.0k

पार्स करते समय ध्यान देने योग्य कुछ बातें हैं:

• हमेशा एक +या -शर्तों के बीच होगा
• आपको हमेशा कम से कम 1 शब्द के साथ वैध इनपुट दिया जाएगा, और बिना दोहराए पत्रों (बिना j-jएस) के
• सभी नंबरों को वैध माना जा सकता है
• आप को पार्स अगर आप चाहते हैं के बाद एक और रूप में संख्या बदल सकते हैं (उदा। 3.0 => 3, 0.4 => .4, 7 => 7.0)

पार्सिंग / क्वाटर्नियन बिलिन और मानक खामियों को रोक दिया जाता है। इसमें evalकीवर्ड और फ़ंक्शंस शामिल हैं। इनपुट एक एकल स्ट्रिंग होगा और आउटपुट एक सूची, एक सरणी, व्हाट्सएप द्वारा अलग किए गए मान आदि होंगे।

चूंकि यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड।

टॉन्स ओ 'परीक्षण के मामले

1+2i+3j+4k             => [1 2 3 4]
-1+3i-3j+7k            => [-1 3 -3 7]
-1-4i-9j-2k            => [-1 -4 -9 -2]
17-16i-15j-14k         => [17 -16 -15 -14]

7+2i                   => [7 2 0 0]
2i-6k                  => [0 2 0 -6]
1-5j+2k                => [1 0 -5 2]
3+4i-9k                => [3 4 0 -9]

42i+j-k                => [0 42 1 -1]
6-2i+j-3k              => [6 -2 1 -3]
1+i+j+k                => [1 1 1 1]
-1-i-j-k               => [-1 -1 -1 -1]

16k-20j+2i-7           => [-7 2 -20 16]
i+4k-3j+2              => [2 1 -3 4]
5k-2i+9+3j             => [9 -2 3 5]
5k-2j+3                => [3 0 -2 5]

1.75-1.75i-1.75j-1.75k => [1.75 -1.75 -1.75 -1.75]
2.0j-3k+0.47i-13       => [-13 0.47 2.0 -3] or [-13 .47 2 -3]
5.6-3i                 => [5.6 -3 0 0]
k-7.6i                 => [0 -7.6 0 1]

0                      => [0 0 0 0]
0j+0k                  => [0 0 0 0]
-0j                    => [0 0 0 0] or [0 0 -0 0]
1-0k                   => [1 0 0 0] or [1 0 0 -0]

Comments

क्या +इनपुट में कभी अनावश्यक संकेत मिलेंगे ? जैसे +1k:?

— FryAmTheEggman

@FryAmTheEggman नंबर इनपुट कभी नहीं के साथ शुरू होगा +।

— GamrCorps

है -0पिछले दो उदाहरण के लिए कानूनी उत्पादन का एक हिस्सा?

— isaacg

@ आइसाकग हाँ जो ठीक है

— GamrCorps

@LlAMnYP आप एक अच्छा बिंदु लाते हैं। evalएक स्ट्रिंग में ले जाने के प्रतिबंध को परिभाषित करता है , कोड और / या इनपुट के रूप में व्याख्या करता है। कोई भी रूपांतरण इस बात के अंतर्गत नहीं आता है क्योंकि आप "test"एक पूर्णांक प्राप्त करने के लिए एक पूर्णांक रूपांतरण फ़ंक्शन को स्ट्रिंग , लेकिन उदाहरण के लिए, testएक सामान्य evalफ़ंक्शन में कोड के रूप में व्याख्या की जाएगी । TLDR: eval: no, टाइप रूपांतरण: हाँ।

— गामक्रॉप्स

Answer 1

पायथ, 48 बाइट्स

jm+Wg\-K--e|d0G\+K1+]-I#GJczfT.e*k<b\.zm/#dJ"ijk

प्रदर्शन सूट

आउटपुट स्वरूप नईलाइन अलग है। परीक्षण सूट कोड पढ़ने में आसानी के लिए, अंतरिक्ष पृथक्करण का उपयोग करता है, लेकिन अन्यथा समान है।

-0पिछले 2 मामलों में आउटपुट , जो मुझे आशा है कि ठीक है।

अनुसरण करने की व्याख्या।

Answer 2

रेटिना, 115

\b[ijk]
1$&
^(?!.*\d([+-]|$))
0+
^(?!.*i)
+0i+
^(?!.*j)
0j+
^(?!.*k)
0k+
O$`[+-]*[\d.]*(\w?)
$1
-
+-
^\+

S`[ijk+]+

इसे ऑनलाइन आज़माएं!

1 बाइट ने @ क्रिस जस्टर-यंग को धन्यवाद दिया ।

एक बग को ठीक किया गया और 6 बाइट्स ने @Martin Büttner को धन्यवाद दिया

कुछ बढ़त के मामलों से जुड़े एक जोड़े बग पाया, बाइट गिनती बहुत थोड़ा है।

अलग किए गए नंबरों को वापस करता है। वैसे भी, इसका एक बहुत ही सुंदर समाधान है जो किनारे के मामलों से बर्बाद हो जाता है, लेकिन हे मुझे सॉर्ट मोड का उपयोग करने के लिए मिला, इसका मतलब है कि मैंने नौकरी के लिए सही उपकरण का उपयोग किया है, है ना?

स्पष्टीकरण:

हमेशा की तरह स्टेज से स्टेज।

\b[ijk]
1$&

इनपुट में केवल अक्षर जो शब्द सीमाएँ बना सकते हैं, हैं -+.। इसका मतलब यह है कि अगर हम एक पत्र के बाद एक सीमा पाते हैं, तो हमारे पास एक निहित है 1जो हम प्रतिस्थापन के साथ जोड़ते हैं। $&के लिए एक पर्याय है $0।

^(?!.*\d([+-]|$))
0+

इस एक के लिए मार्टिन का बड़ा धन्यवाद, यह एक 0वास्तविक भाग के लिए निहितार्थ में जोड़ता है अगर यह इनपुट में गायब था। हम यह सुनिश्चित करते हैं कि हमें एक संख्या नहीं मिल सकती है जो कि प्लस या माइनस साइन या स्ट्रिंग के अंत के बाद है। सभी जटिल संख्याओं में उनके बाद एक पत्र होगा।

^(?!.*i)
+0i+

अगले 3 चरण सभी बहुत समान हैं, जो कि पत्र को प्रभावित करते हैं। वे सभी यह देखने के लिए कि क्या हम पत्र से मेल नहीं खा सकते हैं, और यदि हम 0इसके लिए कोई शब्द नहीं जोड़ सकते हैं । एकमात्र कारण iएक अतिरिक्त है +इससे पहले कि वास्तविक मूल्य को iएस गुणांक के साथ अपठनीय होने से रोकने के लिए , अन्य संख्याओं को उनके जटिल चर द्वारा अलग किया जाता है।

O$`[+-]*[\d.]*(\w?)
$1

आह, मज़ा हिस्सा। यह Oविकल्प विभाजक backtick से पहले द्वारा निरूपित newish सॉर्ट चरण का उपयोग करता है । यहाँ चाल एक शब्द चरित्र द्वारा वैकल्पिक रूप से अनुसरण की गई पूरी संख्या को हथियाने के लिए है, जो इस मामले में केवल एक से मेल खाएगी ijk। दूसरे विकल्प का उपयोग किया जाता है, $जो इन मैचों को बदलने के लिए उपयोग किए जाने वाले मान को बदलने का कारण बनता है। यहां हम केवल हमारे सॉर्ट वैल्यू के रूप में बचे वैकल्पिक अक्षर का उपयोग करते हैं। चूंकि रेटिना डिफ़ॉल्ट रूप से शाब्दिक रूप से भिन्न होता है, इसलिए मानों को क्रमबद्ध किया जाता है जैसे वे एक शब्दकोश में होंगे, जिसका अर्थ है कि हम "", "i", "j", "k"क्रम में मैच प्राप्त करते हैं ।

-
+-

यह चरण +सभी माइनस चिह्नों के सामने एक संकेत रखता है , इसकी जरूरत है अगर हम iविभाजन के चरण के लिए नकारात्मक मान रखते हैं , बाद में।

^ \ +

हम +यह सुनिश्चित करने के लिए अग्रणी को हटा देते हैं कि हमारे पास कोई अतिरिक्त अग्रणी नई रेखा नहीं है।

S`[ijk+]+

कॉम्प्लेक्स वैरिएबल या प्लस साइन के रन पर शेष लाइनों को विभाजित करें। यह अच्छी तरह से हमें प्रति पंक्ति एक मूल्य देता है।

Answer 3

पर्ल 5, 125 बाइट्स

#!perl -p
%n=(h,0,i,0,j,0,k,0);$n{$4//h}=0+"$1@{[$3//$5//1]}"while/([+-]?)(([\d.]+)?([ijk])|([\d.]+))/g;s/.*/@n{qw(h i j k)}/

Comments

@ केनीलाऊ दुख की बात है कि आपका प्रस्तावित परिवर्तन वह नहीं करता जो आप उम्मीद करते हैं। मैंने कोशिश की है कि इससे पहले कि मैं अपना जवाब पोस्ट करूं। ;-)

— क्रिस जस्टर-यंग

@ केनीलाऊ इस प्रस्तावित बदलाव के बारे में , पर्ल के \a"अलार्म" पर मेल खाते हैं, अल्फाबेटिक नहीं। नहीं है \wशब्द-चरित्र (अक्षरांकीय और अंडरस्कोर) के लिए, लेकिन वह यहाँ काम नहीं करेगा; हमें एक नंबर पर मैच नहीं करना चाहिए।

— क्रिस जस्टर-यंग

@ केनीलाऊ बीटीडब्ल्यू, आपके पास चैट में बात करने के लिए पर्याप्त प्रतिनिधि है । लगातार अपने संपादित सुझावों को अस्वीकार करने के बजाय, वहां विचारों पर चर्चा करने के लिए स्वतंत्र महसूस करें। ;-)

— क्रिस जेस्टर-यंग

मेरे पास अब टिप्पणी करने के लिए पर्याप्त प्रतिनिधि है। क्या पर्ल के पास [az] के लिए एक पैटर्न नहीं है?

— लीक नून

@ केनीलाऊ मेरी जानकारी के लिए नहीं।

— क्रिस जस्टर-यंग

Answer 4

लूआ , 185 187 195 183 166 बाइट्स ( इसे ऑनलाइन आज़माएं ) [प्रयुक्त रेगेक्स]

बेहतर सुधार के लिए @ क्रिस जस्टर-यंग को धन्यवाद ।

इसे 166 बाइट्स तक लाने के लिए @Katenkyo को धन्यवाद ।

golfed:

r={0,0,0,0}for u in(...):gsub("([+-])(%a)","%11%2"):gmatch("-?[%d.]+%a?")do n,i=u:match("(.+)(%a)")r[i and(" ijk"):find(i)or 1]=(n or u)end print(table.concat(r," "))

Ungolfed:

n = "42i+j-k+0.7"

result = {0,0,0,0}

for unit in n:gsub("([+-])(%a)","%11%2"):gmatch("-?[%d.]+%a?") do
  num, index = unit:match("(.+)(%a)")
  if index == "i" then
    result[2] = num
  elseif index == "j" then
    result[3] = num
  elseif index == "k" then
    result[4] = num
  else
    result[1] = unit
  end
end

print(table.concat(result," "))

Comments

हाय केनी, समाधान के लिए धन्यवाद। आमतौर पर हम इनपुट को एक चर में शुरू करने की अनुमति नहीं देते हैं (जैसे nकि इस मामले में), इसलिए आपको इनपुट पढ़ने के लिए कोड जोड़ना चाहिए।

— इसहाक

io.read()उपयोग के बजाय, अपने इनपुट को STDIN से तर्क में बदलकर कुछ बाइट को बचाने में सक्षम होना चाहिए (...)। यह पहली कमांड-लाइन तर्क को इंगित करेगा और आपको 4 और बाइट्स बचाने की अनुमति देगा :)

— कैटेनको

साथ ही, पूछा गया आउटपुट कुछ भी हो सकता है, जब तक कि इसे मनुष्यों द्वारा एक सूची के रूप में रखा जा सकता है, इसलिए आप अतिरिक्त स्वरूपण को हटा सकते हैं। कुछ और r={0,0,0,0}for u in(...):gsub("([+-])(%a)","%11%2"):gmatch("-?[%d.]+%a?")do n,i=u:match("(.+)(%a)")r[i and(" ijk"):find(i)or 1]=(n or u)end print(table.concat(r," "))

— व्हाट्सएप

Answer 5

सी, 236 बाइट्स

char j,n[9][9],s[9],y[9],i=8,k,*p=n[8];main(c){for(**n=48;c=getchar(),c+1;)c-32&&(c<46&&(k&&(y[1]=i),k=0,s[--i]=c-43,p=n[i])||c>57&&(k||(*p=49),k=0,y[c-103]=i)||(*p++=c,k=1));for(k&&(y[1]=i);++j<5;)printf("%c%s ",s[y[j]]?45:0,n[y[j]]);}

(-0 या -0.0 जैसे मानों के लिए, आउटपुट में माइनस साइन भी छपा होता है, लेकिन चूंकि चुनौती बताती है कि "यदि आप चाहें तो पार्स करने के बाद आप दूसरे रूप में नंबर बदल सकते हैं", और यदि -0 इनपुट में दिखाई दे, तो यह इस प्रकार है कि यह आउटपुट में भी स्वीकार्य है। @GamrCorps ने अब स्पष्ट किया है कि यह ठीक है। "

Answer 6

जावास्क्रिप्ट (ईएस 6), 103 100 बाइट्स

f=s=>s.replace(/(?=.)(\+|-|)([\d.]*)(\w?)/g,(_,s,x,c)=>a[c.charCodeAt()&3]=+(s+(x||1)),a=[0,0,0,0])&&a

संपादित करें: से स्विच करके 3 बाइट्स सहेजे parseIntगए हैं charCodeAt, जो आसानी &3से मुझे सही सरणी इंडेक्स प्राप्त करने की आवश्यकता है।

Comments

अच्छा विचार parseInt + mod। आधार और उपसर्ग के बारे में सोचना

— edc65

Answer 7

जावास्क्रिप्ट (ईएस 6) 106

s=>(s.replace(/([+-]?)([\d.]*)(\w?)/g,(a,b,c,d)=>a&&(s[d||9]=b+(c||1)),s={}),[...'9ijk'].map(i=>+s[i]||0))

परीक्षा

f=s=>(s.replace(/([+-]?)([\d.]*)(\w?)/g,(a,b,c,d)=>a&&(s[d||9]=b+(c||1)),s={}),[...'9ijk'].map(i=>+s[i]||0))

function Test()
{
  var t,k,r,ts=TS.value.split('\n')
  
  O.textContent=ts.map(x=>x.trim()&&(
    [t,k]=x.split('=>').map(x=>x.trim()),
    console.log(t,'*',k),
    k=k.match(/[\d+-.]+/g).map(x=>+x),
    r=f(t),
    t+' => '+r+(r+''==k+''?' OK':' KO (check: '+k+')')
  )).join('\n')
}    

Test()

#TS { width:90%; height:10em}

<pre id=O></pre>

Test data (modify if you like)<button onclick='Test()'>repeat test</button>
<textarea id=TS>
1+2i+3j+4k             => [1 2 3 4]
-1+3i-3j+7k            => [-1 3 -3 7]
-1-4i-9j-2k            => [-1 -4 -9 -2]
17-16i-15j-14k         => [17 -16 -15 -14]
  
7+2i                   => [7 2 0 0]
2i-6k                  => [0 2 0 -6]
1-5j+2k                => [1 0 -5 2]
3+4i-9k                => [3 4 0 -9]
  
42i+j-k                => [0 42 1 -1]
6-2i+j-3k              => [6 -2 1 -3]
1+i+j+k                => [1 1 1 1]
-1-i-j-k               => [-1 -1 -1 -1]
  
16k-20j+2i-7           => [-7 2 -20 16]
i+4k-3j+2              => [2 1 -3 4]
5k-2i+9+3j             => [9 -2 3 5]
5k-2j+3                => [3 0 -2 5]
  
1.75-1.75i-1.75j-1.75k => [1.75 -1.75 -1.75 -1.75]
2.0j-3k+0.47i-13       => [-13 0.47 2.0 -3]
5.6-3i                 => [5.6 -3 0 0]
k-7.6i                 => [0 -7.6 0 1]
  
0                      => [0 0 0 0]
0j+0k                  => [0 0 0 0]
-0j                    => [0 0 0 0]
1-0k                   => [1 0 0 0]
</textarea>

Answer 8

पॉवरशेल, 178 बाइट्स

param($a);$p="(-?)([\d.]+)?";$g={param($s)if($a-match"$p$s"){if(($r=$matches)[2]){$r[1]+$r[2]}else{$r[1]+1}}else{0}};$a-match"$p(\+|-|$)">$null;+$matches[2];"i","j","k"|%{&$g $_}

---

स्पष्टीकरण के साथ अधूरा

# Get the whole string into a variable
param($a)
# Pattern shared getting both imaginary and real numbers. 
$p="(-?)([\d.]+)?"
# Anonymous function that will locate a imaginary number using a letter sent as a parameter. 
# If no value is assigned a signed 1 is returned. If no value is matched 0 is returned
$g={param($s)if($a-match"$p$s"){if(($r=$matches)[2]){$r[1]+$r[2]}else{$r[1]+1}}else{0}}
# Locate the real component if any. Null is converted to 0
$a-match"$p(\+|-|$)">$null;+$matches[2]
# Call the anonymous function using each of the imaginary suffixes.                                               
"i","j","k"|%{&$g $_}

सुपर प्रभावित नहीं है, लेकिन फिर भी यह एक परिणाम है।

Answer 9

PHP, 179 बाइट्स

$a=[''=>0,'i'=> 0,'j'=>0,'k'=>0];preg_match_all("/([-+]?)(\d*(\.\d+)?)([ijk]?)/",$argv[1],$m,2);foreach($m as$n)if($n[0])$a[$n[4]]=$n[1].($n[2]===''?1:$n[2]);echo implode(',',$a);

परीक्षण सूट की कोशिश करो ।

Answer 10

पायथन 3.5 - 496 बाइट्स [नियमित एक्सप्रेशन का उपयोग करते हुए]:

from re import*
def wq(r):
 a=sub('[+](?![0-9])','+1',sub('[-](?![0-9])','-1',r));q=lambda x:(not x.isdigit(),''.join(filter(str.isalpha,x)))
 for z in findall('(?<![0-9])[a-z]',a):a=a.replace(z,('+1{}'.format(z)))
 if not str(sorted(((sub('[.]','',sub('[+-]',' ',a))).split(' ')),key=q)[0]).isdigit():a+='+0, '
 for i in list(set(findall('[a-z]',a))^{'i','j','k'}):a+='+0{}, '.format(i)
 print(findall('[-]?\d+(?:\.\d+)?',''.join(sorted(sub('(?<=[A-Za-z0-9])(?=[+-])',', ',a).split(' '),key=q))))

यह लंबा हो सकता है, लेकिन मेरे बचाव में, ओपी जो चाहता है, उसे करने में पूरी तरह से काम करता है, क्योंकि दिए गए सभी परीक्षण मामले मेरे कोड का उपयोग करने में सफल रहे।

स्पष्टीकरण के साथ अनगुल्ड संस्करण में शामिल हैं:

from re import*
def w(r):
    # Substitute all minus (-) and plus (+) signs NOT followed by a number  (if there are any) with a "-1"/"+1", respectively.
    a=sub('[+](?![0-9])','+1',sub('[-](?![0-9])','-1',r))
    # Lambda function created for later use to sort the Quaternion. This function, when given as a key to the "sorted" function, arranges the input Quaternion in the order where the whole number comes first, and then the rest are placed in order of increasing letter value (i,j,k in this case) 
    q=lambda x:(not x.isdigit(),''.join(filter(str.isalpha,x)))
    # The following "for" loop replaces the letters NOT preceded by a number with a one followed by that letter
    for z in findall('(?<![0-9])[a-z]',a):
        a=a.replace(z,('+1{}'.format(z)))
    # The following first substitutes all pluses and minuses (+ and -) with a space, and then that new string is split at those spaces, and returned as a list. After that, the list is sorted according the the "lambda" function shown above. Then, the first item in that list, which is supposed to be a lone number, is checked to make sure that it indeed is a lone number. If it isn't, then "+0, " is appended to the Quaternion. 
    if not str(sorted(((sub('[.]','',sub('[+-]',' ',a))).split(' ')),key=q)[0]).isdigit():
        a+='+0, '
    # The following "for" loop finds ALL the letters NOT in the list, by finding the symmetric difference between a set of all the letters found, and a set containing all the letters needed. For the letters not in the list, a '+0' is added the quaternion, followed by that letter, and then a comma and a space.
    for i in list(set(findall('[a-z]',a))^{'i','j','k'}):
        a+='+0{}, '.format(i)
    # Finally, in this last step, a ", " is added IN BETWEEN unicode characters and pluses/minuses (+/-). Then, it splits at those spaces, and the commas separate different parts of the Quaternion from each other (otherwise, you would get something like `12i+3j+4k` from `2i+3j+4k+1`) in a returned list. Then, that list is sorted according to the lambda expression "q" (above), and then, finally, the NUMBERS (of any type, courtesy to Regex) are extracted from that joined list, and printed out in the correct order.
    print(findall('[-]?\d+(?:\.\d+)?',''.join(sorted(sub('(?<=[A-Za-z0-9])(?=[+-])',', ',a).split(' '),key=q))))

यदि उपरोक्त पढ़ना थोड़ा कठिन है, तो मूल रूप से जो हो रहा है, वह है:

1. यदि कोई हो, तो सभी + या - एक नंबर के बाद वाले संकेतों को क्रमशः "+1" / "- 1" के साथ प्रतिस्थापित नहीं किया जाता है।

2. एक lambdaफ़ंक्शन को परिभाषित किया जाता है, जो एक sortedफ़ंक्शन में कुंजी के रूप में उपयोग किए जाने पर, पूरी संख्या को पहले डालने के अनुसार सूची को सॉर्ट करता है, और फिर पत्र के मूल्य में वृद्धि का आदेश देता है ("i", फिर "j", फिर "k" इस उदाहरण में)।

3. क्वाटरनियन, अब सभी +/- संकेतों को 1 के साथ बदल दिया गया है, यदि आवश्यक हो, तो खोज की जाती है, नियमित अभिव्यक्तियों का उपयोग करते हुए, सभी पत्रों के लिए, कम से कम एक नंबर से पहले नहीं, और उन पत्रों को जो मेल खाते हैं उन्हें "+1" के साथ बदल दिया जाता है। वह पत्र।

4. "यदि" कथन तब सभी +/- संकेतों को एक स्थान के साथ बदल देता है, और फिर संशोधित Quaternion अब उन स्थानों पर "विभाजित" है, और एक सूची में वापस आ गया है। फिर, पहले बताए गए लंबोदा फ़ंक्शन के अनुसार सूची को क्रमबद्ध किया जाता है। अंत में, उस सूची में पहला आइटम यह सुनिश्चित करने के लिए जांचा जाता है कि यह एक संख्या है, क्योंकि यह माना जाता है, और यदि ऐसा नहीं है, तो एक "+0", को क्वाटर्नियन में जोड़ा जाता है।

5. दूसरी "लूप" के लिए अभिव्यक्ति में पाए गए उन अक्षरों के एक सेट के बीच एक सममित अंतर और सभी सेटों के बीच एक सममित अंतर का पता लगाने के द्वारा सभी पत्र नहीं पाते हैं। यदि कोई पाया जाता है, तो एक "+0" लापता पत्र और उसके बाद एक स्थान को Quaternion में जोड़ा जाता है।

6. अंत में, इस अंतिम चरण में, एक "," को प्रत्येक वर्ण के बीच +/- प्रतीक के साथ जोड़ा जाता है, और फिर Quaternion को उन स्थानों पर विभाजित किया जाता है, फिर वापस की गई सूची को क्रमबद्ध किया जाता है, अंतिम बार के अनुसार, lambda फ़ंक्शन को पहले "q" के रूप में परिभाषित किया गया है। अभिव्यक्ति में अल्पविराम चार का समुदाय के प्रत्येक भाग को अलग (अन्यथा, आप की तरह कुछ हो रही हो जाएगा 14i+5j+6kसे 4i+5j+6k+1)। अन्त में, कि अब क्रमबद्ध सूची एक स्ट्रिंग में एक साथ शामिल हो गए है, और केवल संख्या किसी भी प्रकार की (रेगुलर एक्सप्रेशन के सौजन्य से) निकाले जाते हैं, और अंत में, हर बार एक सूची में लौट आए, सही क्रम में।