क्रेजी लाइब्रेरियन की कमाल की छँटाई प्रणाली

Question

यह स्कूल के मौसम में वापस आ गया है! इसलिए अंशकालिक नौकरी के लिए, आप स्कूल के पुस्तकालय में मदद कर रहे हैं। समस्या यह है कि हेड लाइब्रेरियन ने कभी भी "डेवी डेसीमल" शब्द नहीं सुना है, अकेले उस सिस्टम को लागू किया है। इसके बजाय, उपयोग में छँटाई प्रणाली "व्यवस्थित" बढ़ी है क्योंकि पुस्तकालय का विस्तार हुआ है ...

अपनी पवित्रता को बनाए रखने के प्रयास में, आपने पुस्तकों को छाँटने में मदद करने के लिए एक कार्यक्रम लिखने का फैसला किया है क्योंकि वे वापस आ गए हैं, क्योंकि यदि आप पुस्तकों को गलत करते हैं तो आप पर शोक होगा। (हेड लाइब्रेरियन बहुत सख्त है।)

इनपुट आउटपुट

• इनपुट एसटीडीआईएन / भाषा के समकक्ष (काल्पनिक) पुस्तक शीर्षक की एक सूची होगी।
• आप एक बार में 100 से अधिक पुस्तकों के इनपुट का अनुमान लगा सकते हैं (आप केवल एक ही बार में पुस्तकालय के आसपास इतने ले जा सकते हैं)।
• पुस्तकों के शीर्षक में कई शब्द हो सकते हैं, और ये शब्द रिक्त स्थान या अन्य विराम चिह्न (जैसे, एक बृहदान्त्र :, एक डैश -, आदि) द्वारा अलग किए जा सकते हैं ।
• गणना में आसानी के लिए, मान लें कि सभी शीर्षक UTF-8 हैं।

आउटपुट समान शीर्षक है, नीचे दिए गए नियमों के अनुसार क्रमबद्ध, फिर से एक पंक्ति में, STDOUT / भाषा के बराबर।

छँटाई के नियम

पुस्तकों को उनके औसत चरित्र मान के आधार पर संख्यात्मक रूप से क्रमबद्ध किया जाता है (यानी, संचयी चरित्र मूल्य को पुस्तक के शीर्षक में वर्णों की संख्या से विभाजित किया गया है), निम्न नियमों द्वारा गिना जाता है:

• सभी वर्ण एक शीर्षक में वर्णों की संख्या निर्धारित करने के लिए गिने जाते हैं।
• लोअरकेस अक्षरों को उनकी स्थिति वर्णमाला में गिना जाता है। (एक = 1, बी = 2, ... z = 26)
• यदि शीर्षक में बड़े अक्षर हैं, तो वे 1.5 उनके लोअरकेस मान (A = 1.5, B = 3, ... Z = 39) की गणना करते हैं। ("कैपिटल अक्षर महत्वपूर्ण हैं!" लाइब्रेरियन कहते हैं।)
• इस सूची में प्रत्येक विराम चिह्न / प्रतीक !@#$%^&*()-=_+[]\{}|;':",./<>?~औसत से पहले संचयी मान से -1 गिना जाता है। ("ग्रान्डोस के शीर्षक नहीं हैं!")
• यदि शीर्षक में एक संख्या है, जो अरबी अंकों में लिखा गया है , तो वह संख्या छँटाई से पहले औसत मूल्य से घटा दी जाती है। एकाधिक लगातार अंकों को एक संख्या के रूप में माना जाता है (उदाहरण के लिए, 4242 घटाना होगा, 4 घटाना नहीं और फिर घटाना 2)। व्यक्तिगत अंक संचयी मान के लिए नहीं गिने जाते (अर्थात, प्रत्येक अंक 0 में योगदान करता है), लेकिन DO वर्णों की संख्या के लिए गिना जाता है। ध्यान दें कि यह एक नकारात्मक मूल्य हो सकता है और उचित रूप से व्यवहार किया जाना चाहिए। (अफवाह यह है, लाइब्रेरियन कई वर्षों के लिए एक गणित प्रशिक्षक पर क्रश पड़ा है, अब।)
• यदि शीर्षक में दो अलग-अलग शब्द हैं जो एक के साथ शुरू होते हैं R, तो पुस्तक को "अनन्तता" का एक अंक मिलता है और इसे कोने में ढेर में डाल दिया जाता है (यानी, सूची के अंत में यादृच्छिक रूप से व्यवस्थित)। (लाइब्रेरियन को एक बार उन आद्याक्षर वाले व्यक्ति द्वारा डंप किया गया था, या इसलिए आपने सुना है।)
• रिक्त स्थान संचयी वर्ण मान के लिए गणना नहीं करते हैं (अर्थात, वे 0 का योगदान करते हैं), लेकिन एक शीर्षक में वर्णों की संख्या में योगदान करते हैं।
• वर्ण जो उपरोक्त नियमों (उदाहरण के लिए ÿ) फिट नहीं होते हैं , वे संचयी वर्ण मान (यानी, वे 0 योगदान करते हैं) के लिए गिनती नहीं करते हैं, लेकिन एक शीर्षक में वर्णों की संख्या में योगदान करते हैं।
• उदाहरण के लिए, एक काल्पनिक पुस्तक का ÿÿÿÿÿ"स्कोर" होगा (0+0+0+0+0) / 5 = 0, लेकिन एक काल्पनिक पुस्तक का ÿÿyÿÿ"स्कोर" होगा (0+0+25+0+0) / 5 = 5।
• दो पुस्तकें जो "स्कोर" करने के लिए होती हैं वही आपकी पसंद के ऑर्डर में आउटपुट हो सकती हैं। (वे वैसे ही शेल्फ पर हैं)

उदाहरण इनपुट 1

War and Peace
Reading Rainbow: The Best Unicorn Ever
Maus
Home for a Bunny

उदाहरण आउटपुट 1 (तर्क को दिखाने के लिए कोष्ठक में "स्कोर" के साथ - आपको उन्हें प्रिंट करने की आवश्यकता नहीं है)

War and Peace (8.5)
Home for a Bunny (10.125)
Maus (15.125)
Reading Rainbow: The Best Unicorn Ever (infinity)

उदाहरण इनपुट 2

Matthew
Mark
Luke
John
Revelations

उदाहरण आउटपुट 2 (कोष्ठक में "स्कोर" के साथ तर्क दिखाने के लिए - आपको उन्हें प्रिंट करने की आवश्यकता नहीं है)

Mark (12.375)
John (13)
Revelations (13.545454...)
Luke (13.75)
Matthew (~13.786)

उदाहरण इनपुट 3

42
9 Kings
1:8
7th

उदाहरण आउटपुट 3 ("स्कोर" के साथ कोष्ठक में तर्क दिखाने के लिए - आपको उन्हें प्रिंट करने की आवश्यकता नहीं है)

42 (-42)
1:8 (-9.3333...)
9 Kings (~0.36)
7th (2.3333...)

अन्य प्रतिबंध

• यह कोड-गोल्फ है, क्योंकि आपको लाइब्रेरियन की कभी-देखने वाली आंखों से कार्यक्रम को गुप्त रखने की जरूरत है, और यह कार्यक्रम जितना छोटा है, इसे छिपाना उतना ही आसान है।
• मानक ढील प्रतिबंध लागू होते हैं
• PPCG पर अपना सारा समय बिताकर लाइब्रेरियन को आप से दूर जाने न दें।

Comments

क्या होगा अगर दो किताबें बिल्कुल एक जैसी हों। यानी आई हैव रीडिंग रेनबो और रूबी रेल्स

— किशन कुमार

@ किशनकुमार उस विशिष्ट उदाहरण में, "सूची के अंत में बेतरतीब ढंग से व्यवस्थित" चूंकि वे दोनों डबल-आर हैं। दूसरे शब्दों में, अपने लेने। सामान्य स्थिति में, यदि दो शब्द समान हैं, तो वे एक-दूसरे के सापेक्ष किसी भी क्रम में दिखाई दे सकते हैं। मैं स्पष्ट करने के लिए एक गोली जोड़ दूंगा।

— AdmBorkBork

आपको एक शब्द की आवश्यकता है ताकि आपके सिस्टम का एक संक्षिप्त नाम हो। मैं पागल लाइब्रेरियन की कमाल की छँटाई प्रणाली की सिफारिश करता हूं: डी

— जियोबिट्स

@Geobits क्या आपके पास CLASS है?

— AdmBorkBork

संख्याएँ केवल दशमलव संख्याएँ हैं? क्या होगा अगर वहाँ कई हैं, उन सभी को अलग से घटाया जाता है?

— पाओलो एबरमन

Answer 1

एपीएल (132)

{⎕ML←3⋄⍵[⍋{2='R'+.=↑¨⍵⊂⍨⍵≠' ':!99⋄↑(+/⍎¨'0',⍵⊂⍨⍵∊⎕D)-⍨((+/∊1.5 1×(⍳×∊⍨)∘⍵¨G)-+/⍵∊(⎕UCS 32+⍳94)~'`',⎕D,∊G←(⊂⎕A),⊂⎕UCS 96+⍳26)÷⍴⍵}¨⍵]}

चूँकि हर कोई एक ही काम कर रहा है, यह भी एक ऐसा फंक्शन है, जो शीर्षक की एक सरणी लेता है और इसे क्रमबद्ध करता है, जैसे:

      titles
┌─────────────┬──────────────────────────────────────┬────┬────────────────┬───────┬────┬────┬────┬───────────┬──┬───────┬───┬───┐
│War and Peace│Reading Rainbow: The Best Unicorn Ever│Maus│Home for a Bunny│Matthew│Mark│Luke│John│Revelations│42│9 Kings│1:8│7th│
└─────────────┴──────────────────────────────────────┴────┴────────────────┴───────┴────┴────┴────┴───────────┴──┴───────┴───┴───┘

      {⎕ML←3⋄⍵[⍋{2='R'+.=↑¨⍵⊂⍨⍵≠' ':!99⋄↑(+/⍎¨'0',⍵⊂⍨⍵∊⎕D)-⍨((+/∊1.5 1×(⍳×∊⍨)∘⍵¨G)-+/⍵∊(⎕UCS 32+⍳94)~'`',⎕D,∊G←(⊂⎕A),⊂⎕UCS 96+⍳26)÷⍴⍵}¨⍵]}titles
┌──┬───┬───────┬───┬─────────────┬────────────────┬────┬────┬───────────┬────┬───────┬────┬──────────────────────────────────────┐
│42│1:8│9 Kings│7th│War and Peace│Home for a Bunny│Mark│John│Revelations│Luke│Matthew│Maus│Reading Rainbow: The Best Unicorn Ever│
└──┴───┴───────┴───┴─────────────┴────────────────┴────┴────┴───────────┴────┴───────┴────┴──────────────────────────────────────┘

स्पष्टीकरण:

• ⎕ML←3: सेट ⎕MLकरने के लिए 3(के लिए ⊂)
• ⍵[⍋{... }¨⍵]: आंतरिक फ़ंक्शन से लौटाए गए मानों द्वारा इनपुट को सॉर्ट करें
  • ↑¨⍵⊂⍨⍵≠' ': प्रत्येक शब्द का पहला वर्ण प्राप्त करें
  • 2='R'+.=: देखें कि क्या इनमें से दो हैं 'R'।
  • :!99: यदि हां, तो 99 लौटें! (10 9.3 × 10 ¹⁵⁵ )। यह काफी अनन्तता नहीं है, लेकिन यह करेगा: एक शीर्षक का स्कोर कभी भी उसकी लंबाई (ZZZZ ...) से 38 गुना से अधिक नहीं हो सकता है, इसलिए जब तक कि कोई भी शीर्षक लगभग 2 × 10 ¹³⁰ यॉटबाइट्स से बड़ा न हो , तब तक गारंटी है कि ये अंत में होंगे।
  • ⋄: अन्यथा:
  • (... )÷⍴⍵: ⍵गणना करने के बाद स्कोर को लंबाई से विभाजित करें :
    • G←(⊂⎕A),(⎕UCS 96+⍳26): Gअपरकेस और लोअरकेस अक्षरों में स्टोर करें
    • (⎕UCS 32+⍳94)~'`',⎕D,∊G: मुद्रण योग्य ASCII वर्ण, अक्षर, अंक, रिक्त स्थान को छोड़कर और '`', वे वर्ण हैं जिनके लिए एक बिंदु घटाया जाता है। (यह उन सभी को लिखने से छोटा है, क्योंकि Gबाद में इसका उपयोग किया जाता है।)
    • +/⍵∊: इन वर्णों की मात्रा गिनें ⍵
    • -: इससे घटाएँ:
    • +/∊1.5 1×(⍳×∊⍨)∘⍵¨G: 1.5 × का योग राजधानियों के लिए स्कोर, और 1 × निचले अक्षरों के लिए स्कोर।
  • -⍨: बाद में, की कुल संख्या घटाएँ ⍵:
    • ⍵⊂⍨⍵∊⎕D: अंकों के समूह को खोजें ⍵
    • '0',: '0'सूची को खाली करने से रोकने के लिए जोड़ें
    • ⍎¨: प्रत्येक स्ट्रिंग का मूल्यांकन करें
    • +/: राशि पाते हैं

Comments

इसके बजाय !99आप उपयोग कर सकते हैं⌊/⍬

— Adám

मुझे एपीएल में लंबे कोड को देखना बहुत पसंद है। मुझे लगता है कि दुनिया आई से बहुत बड़ी है और मुझे प्रतीक पसंद हैं।

— कॉनर ओ'ब्रायन

Answer 2

लुआ 5.3, 366 364 बाइट्स

r={}for i,s in ipairs(arg)do n=0 s:gsub("%l",function(a)n=n+(a:byte()-96)end):gsub("%u",function(a)n=n+(a:byte()-64)*1.5 end):gsub("%p",function(a)n=n-1 end):gsub("^R?.- R.- ?R?",function()n=math.huge end)m=n/utf8.len(s)s:gsub("%d+",function(a)m=m-a end)table.insert(r,{s=s,n=m})end table.sort(r,function(a,b)return a.n<b.n end)for i,v in ipairs(r)do print(v.s)end

यह कोड केवल लुआ 5.3 में काम करता है क्योंकि इसे यूनिकोड वर्णों से निपटने की आवश्यकता है। यदि आप यूनिकोड के बारे में परवाह नहीं करते हैं, तो "utf8" को "स्ट्रिंग" से बदलें और यह लुआ 5.2 या 5.1 के साथ ठीक काम करेगा।

यह कमांड-लाइन तर्कों से अपने इनपुट लेता है, इसलिए या तो इसे कमांड लाइन से चलाएं या इस कोड को मेरे उत्तर के ऊपर रखें:

arg = {"Title 1", "Title 2", "Title 3"}

Comments

मैं अपने मशीन पर लुआ 5.3 की जरूरत नहीं है, लेकिन मैं स्वैप करने के लिए अपने सुझाव का पालन utf8के साथ stringपर Ideone और कोई उत्पादन मिला है।

— AdmBorkBork

@TimmyD मेरे संपादन देख

— Trebuchette

अच्छा। ग्रेवी। और (arg)वहीं बैठी मुझे घूर रही है। इस सवाल ने जाहिर तौर पर मेरे दिमाग को भून डाला है। एक +1 है।

— AdmBorkBork

MoonScript के साथ, यह 266 बाइट्स है: pastebin.com/wr4qVs5h ।

— kirbyfan64sos

Answer 3

गणितज्ञ, 253 216 बाइट्स (214 वर्ण)

r=RegularExpression;c=ToCharacterCode;f=SortBy[Tr@Flatten@Reap[StringCases[#,
{r@"(\\bR.*)+"->∞,r@"\\d+":>0Sow@-FromDigits@"$0",r@"[a-z]":>c@"$0"-96,
r@"[A-Z]":>1.5c@"$0"-96,r@"[!-/:-@[-_{-~]"->-1}]/StringLength@#]&]

जैसे फंक्शन को बुलाओ f[{"42", "9 Kings", "1:8", "7th"}] ; यह आदानों की क्रमबद्ध सूची लौटाएगा।

बस मुश्किल से इसे बनाया है! मैथमेटिका का पैटर्न मिलान उतने संक्षिप्त नहीं है जब तार जुड़े होते हैं, और मैं सिर्फ उन लंबे नामों से मारा जाता हूं। अतिरिक्त दो बाइट्स के लिए हैंInfinity यूनिकोड वर्ण के लिए हैं।

(मुझे पता है अगर मैं किसी भी मानक Loopholes से दूर गिर गया है।)

अद्यतन करें

Edc65 के उत्तर को थोड़ा करीब से देखने पर ऐसा लगता है कि ओपी एक ऐसे फंक्शन को स्वीकार कर लेगा जो स्ट्रिंग्स की एक सूची को सॉर्ट करता है। इस बात को ध्यान में रखते हुए कि हम SortBy(के रूप में गणितज्ञ "ऑपरेटर रूप" कहते हैं) का उपयोग कर सकते हैं ; एक तर्क के साथ (फ़ंक्शन तत्वों को उनके आदेश का निर्धारण करने के लिए लागू किया जाता है) यह एक फ़ंक्शन की तरह व्यवहार करता है जो एक तर्क लेता है, इनपुट के क्रमबद्ध रूप को लौटाता है; यह है, SortBy[list, f]के बराबर है (SortBy[f])[list]।

Ungolfed

Function[{titles},
  SortBy[titles, Function[{str}, (* sort by function value *)
    Total[Flatten[Reap[ (* total up all the parts *)
      StringCases[str, {
        RegularExpression["(\\bR.*){2}"] -> Infinity
          (* matches R at the start of a word twice, adds infinity to the total *),
        RegularExpression["\\d+"] :> 0 * Sow[-FromDigits["$0"]]
          (* matches a number, Sows it for Reap to collect, then multiplies by zero
                                                          to not affect the average *),
        RegularExpression["[a-z]"] :> ToCharacterCode["$0"] - 96
          (* matches a lowercase letter and returns its value *),
        RegularExpression["[A-Z]"] :> 1.5 ToCharacterCode["$0"] - 96
          (* matches an uppercase letter and returns 1.5 its value *),
        RegularExpression["[!-/:-@[-_{-~]"] -> -1
          (* matches a 'grandiose' symbol and returns -1 *)
      }] / StringLength[#] (* averages character values *)
    ]]]
  ]]
]

Comments

अच्छा जवाब, और आपको अपनी गणनाओं में "अनंत" का उपयोग करके शाब्दिक रूप से एक इंटरनेट कुकी मिलती है ;-)

— AdmBorkBork

@ टिमिमद प्रतीकात्मक गणित प्रसंस्करण की सुंदरता =)

— 2012rcampion

संभवत: आपका मतलब 214 चार्ट, 216 बाइट्स से है। अच्छा किया, मैंने मुकाबला करने की कोशिश की लेकिन कोई रास्ता नहीं

— edc65

Answer 4

जावास्क्रिप्ट (ईएस 6), 210 218 251

एक सरणी तर्क के साथ एक फ़ंक्शन के रूप में, वापस सॉर्ट किया गया।

f=L=>(S=s=>([...s].map(c=>t-=(a=s.charCodeAt(l++))>32&a<48|a>57&a<65|a>90&a<96|a>122&a<127?1:a>64&a<123?96-(a<96?a*1.5:a):0,l=t=0),s.split(/\D/).map(n=>t-=n,t/=l),t/!s.split(/\bR/)[2]),L.sort((a,b)=>S(a)-S(b)))

//TEST

test1=['War and Peace','Reading Rainbow: The Best Unicorn Ever','Maus','Home for a Bunny']
test2=['Matthew','Mark','Luke','John','Revelations']
test3=['42','9 Kings','1:8','7th']

;O.innerHTML=f(test1)+'\n\n'+f(test2)+'\n\n'+f(test3);

// The comparing function used to sort, more readable

Sort=s=>(
  t = 0, // running total
  l = 0, // to calc the string length avoiding the '.length' property
  [...s].map(c=>{
    a=s.charCodeAt(l++);
    t-=a>32&a<48|a>57&a<65|a>90&a<96|a>122&a<127
      ? 1 // symbols (ASCII char except space, alphanumeric and backtick)
      : a>64&a<123 
        ? 96-(a<96?a*1.5:a) // alphabetic both upcase and lowcase, and backtick
        // lowcase: 96-a, upcase (64-a)*1.5=>96-a*1.5, backtick is 96 and 96-96 == 0
        : 0 // else space, non ASCII, and numeric : 0
  }),
  t = t/l, // average
  s.split(/\D/).map(n=>t-=n), // sub number values
  f = s.split(/\bR/)[2], // split at words starting with R, if less then 2 f is undefined
  t/!f // dividing by not f I can get the infinity I need
)

<pre id=O></pre>

Comments

अच्छी तरह से किया। किसी और इस जवाब को पढ़ने के लिए संदर्भ के लिए, मैं बदलना पड़ा O.innerHTMLकरने के लिए this.InnerHTMLFirefox के कंसोल में।

— AdmBorkBork

Answer 5

सी #, 352 349 बाइट्स

लिनक के जादू के कारण:

class A{static void Main(string[]a){foreach(var x in a.OrderBy(b=>{var s="0";int j=0;return Regex.Split(b,@"[^\w]+").Count(l=>l[0]=='R')==2?(1/0d):b.Aggregate(0d,(d,e)=>{if(e>47&e<58){s+=e;return d;}d+=(e>64&e<91)?(e-64)*1.5:(e>96&e<123)?e-96:e>32&e<127&e!=96?-1:0;j+=int.Parse(s);s="0";return d;})/b.Length-j-int.Parse(s);}))Console.WriteLine(x);}}

यदि बैकटिक को विराम चिह्नों की सूची में शामिल किया जाएगा तो एक और 6 बाइट्स बचा सकता है!

class A
{
    static void Main(string[] a)
    {
        foreach (var x in a.OrderBy(b =>
            {
                var s = "0";
                int j = 0;
                return Regex.Split(b, @"[^\w]+").Count(l => l[0] == 'R') == 2
                    ? (1 / 0d)
                        : b.Aggregate(0d, (d, e) =>
                        {
                            if (e > 47 & e < 58) { s += e; return d; }
                            d += (e > 64 & e < 91) ? (e - 64) * 1.5 : (e > 96 & e < 123) ? e - 96 : e > 32 & e < 127 & e != 96 ? -1 : 0;
                            j += int.Parse(s);
                            s = "0";
                            return d;
                        }) / b.Length - j - int.Parse(s);
            }))
            Console.WriteLine(x);
    }

}

Answer 6

गो, 7५५ बाइट्स

package main
import("os"
"fmt"
"math"
"bufio"
"regexp"
"sort"
"strconv")
type F float64
type T []F
func(t T)Swap(i,j int){t[i],t[j],S[i],S[j]=t[j],t[i],S[j],S[i]}
func(t T)Len()int{return len(t)}
func(t T)Less(i,j int)bool{return t[i]<t[j]}
var S []string
func main(){var t T
for{b:=bufio.NewReader(os.Stdin)
w,_,_:=b.ReadLine()
if len(w)==0{break}
u:=string(w)
var v F
for _,c:=range u{if 96<c&&c<123{v+=F(c)-F(96)}else
if 64<c&&c<91{v+=(F(c)-64)*1.5}else
if (48>c&&c>32)||(c>57&&c<127){v-=1}}
a:=v/F(len(w))
r,_:=regexp.Compile("[0-9]+")
n:=r.FindAllString(string(w),-1)
for _,x:=range n{y,_:=strconv.Atoi(x);a-=F(y)}
if m,_:=regexp.Match("((^| )R.*){2}",w);m{a=F(math.Inf(1))}
S=append(S,u)
t=append(t,a)}
sort.Sort(t)
for _,o:=range S{fmt.Println(o)}}

स्वरूपित संस्करण:

package main

import (
    "bufio"
    "fmt"
    "math"
    "os"
    "regexp"
    "sort"
    "strconv"
)

type F float64
type T []F

func (t T) Swap(i, j int)      { t[i], t[j], S[i], S[j] = t[j], t[i], S[j], S[i] }
func (t T) Len() int           { return len(t) }
func (t T) Less(i, j int) bool { return t[i] < t[j] }

var S []string

func main() {
    var t T
    for {
        b := bufio.NewReader(os.Stdin)
        w, _, _ := b.ReadLine()
        if len(w) == 0 {
            break
        }
        u := string(w)
        var v F
        for _, c := range u {
            if 96 < c && c < 123 {
                v += F(c) - F(96)
            } else if 64 < c && c < 91 {
                v += (F(c) - 64) * 1.5
            } else if (48 > c && c > 32) || (c > 57 && c < 127) {
                v -= 1
            }
        }
        a := v / F(len(w))
        r, _ := regexp.Compile("[0-9]+")
        n := r.FindAllString(string(w), -1)
        for _, x := range n {
            y, _ := strconv.Atoi(x)
            a -= F(y)
        }
        if m, _ := regexp.Match("((^| )R.*){2}", w); m {
            a = F(math.Inf(1))
        }
        S = append(S, u)
        t = append(t, a)
    }
    sort.Sort(t)
    for _, o := range S {
        fmt.Println(o)
    }
}

एक कस्टम सॉर्ट इंटरफ़ेस को लागू करना अपेक्षा से अधिक लंबा बना। कार्यक्रम STDIN से तब तक पढ़ता है जब तक इनपुट oa रिक्त पंक्ति के अंत में प्रवेश नहीं किया जाता है।

Answer 7

PHP, 362 367 बाइट्स

<?for(;$w=fgets(STDIN);$S[]=$w){for($l=$i=mb_strlen($w);$i--;){$c=array_sum(unpack("C*",mb_substr($w,$i,1)));96<$c&&$c<123 and $v+=$c-96 or 64<$c&&$c<91 and $v+=1.5*$c-96 or 48<$c&&$c>32||$c>57&&$c<127 and $v-=1;}$v/=$l;preg_match_all("/\d+/",$w,$m);$v-=array_sum($m[0]);preg_match("/((^| )R.*){2}/",$w)&&$v=INF;$t[]=$v;}array_multisort($t,$S);echo join("
",$S);

प्रारूपित संस्करण:

<?php
for (; $w = fgets(STDIN); $S[] = $w) {
    for ($l = $i = mb_strlen($w); $i--;) {
        $c = array_sum(unpack("C*", mb_substr($w, $i, 1)));
        96 < $c && $c < 123 and $v += $c - 96
        or 64 < $c && $c < 91 and $v += 1.5 * $c - 96
        or 48 < $c && $c > 32 || $c > 57 && $c < 127 and $v -= 1;
    }
    $v /= $l;
    preg_match_all("/\d+/", $w, $m);
    $v -= array_sum($m[0]);
    preg_match("/((^| )R.*){2}/", $w) && $v = INF;
    $t[] = $v;
}
array_multisort($t, $S);
echo join("
", $S); 

दिलचस्प लाइनें:

$c = array_sum(unpack("C*", mb_substr($w, $i, 1)));

एक एकल UTF-8 चरित्र को उसके बाइट मानों में परिवर्तित करता है और उन्हें गाया जाता है, जिससे हमें ASCII वर्णों के लिए वास्तविक मूल्य और मल्टीबाइट वर्णों के लिए 127 से अधिक मूल्य मिलता है।

96 < $c && $c < 123 and $v += $c - 96
or 64 < $c && $c < 91 and $v += 1.5 * $c - 96
or 48 < $c && $c > 32 || $c > 57 && $c < 127 and $v -= 1;

बनाता है कम ऑपरेटर वरीयता का उपयोग करें andऔर orबिना एक भी बयान में चरित्र मान देना if।

Answer 8

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

sub p{$_=pop;chomp;$c=-y/A-Za-z0-9 \\`//c;map$c+=(32&ord$_?1:1.5)*(31&ord),/[a-z]/gi;$c/=length;map$c-=$_,/\d+/g;$c}say(sort{$y=$b=~/\bR.*\bR/;($x=$a=~/\bR.*\bR/)||$y?$x-$y:(p($a)<=>p$b)}<>)

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