डी-इंटरलेव लॉग लाइनें [डुप्लिकेट]

Question

आपको एक सर्वर विरासत में मिला है, जो कई ऐप चलाता है जो सभी एक ही लॉग में आउटपुट करते हैं।

आपका कार्य स्रोत द्वारा लॉग फ़ाइल की लाइनों को डी-इंटरलेवे करना है। सौभाग्य से, प्रत्येक पंक्ति एक टैग से शुरू होती है जो इंगित करती है कि यह किस ऐप से है।

लॉग्स

प्रत्येक पंक्ति कुछ इस तरह दिखाई देगी:

[app_name] Something horrible happened!

• एप्लिकेशन टैग हमेशा चौकोर कोष्ठक के बीच होते हैं और इसमें केवल अल्फ़ान्यूमेरिक वर्ण और अंडरस्कोर होते हैं।
• सभी लाइनों में शुरुआत में एक ऐप टैग होगा। पूर्ववर्ती व्हाट्सएप या किसी भी अन्य वर्ण नहीं होंगे।
• ऐप टैग के बाद हमेशा कम से कम एक जगह होगी
• ऐप टैग्स नॉनम खाली हैं
• किसी भी लाइन पर बाद में अन्य वर्ग ब्रैकेट हो सकते हैं।
• टैग के बाद कोई संदेश हो सकता है या नहीं
• लॉग खाली हो सकता है
• फ़ाइल में कितने अनूठे ऐप टैग मौजूद होंगे इसकी कोई सीमा नहीं है।

उदाहरण

संपूर्ण लॉग इस तरह दिख सकता है:

[weather] Current temp: 83F
[barkeep] Fish enters bar
[barkeep] Fish orders beer
[stockmarket] PI +3.14
[barkeep] Fish leaves bar
[weather] 40% chance of rain detected

जिसे तीन अलग-अलग लॉग का उत्पादन करना चाहिए:

[weather] Current temp: 83F
[weather] 40% chance of rain detected

[barkeep] Fish enters bar
[barkeep] Fish orders beer
[barkeep] Fish leaves bar

[stockmarket] PI +3.14

आपको समय से पहले ऐप टैग का नाम नहीं दिया जाता है। आपको उन्हें केवल लॉग फ़ाइल का विश्लेषण करके निर्धारित करना होगा।

नियम और स्कोरिंग

• यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।
• मानक नियम और खामियां लागू होती हैं
• किसी भी सुविधाजनक IO प्रारूप का उपयोग करें, बशर्ते कि प्रत्येक इनपुट लाइन को स्ट्रिंग के रूप में दर्शाया गया हो, न कि पूर्व-पार्स्ड टैग + संदेश। अनुमत आउटपुट की गैर-विस्तृत सूची:
  • प्रत्येक टैग के नाम पर कई फाइलें
  • तार की कई सूची
  • एक विभाजक की सूची जिसमें एक विभाजक के साथ या उसके बिना टैग की गई पंक्तियाँ होती हैं (विभाजक को टैग से शुरू नहीं होना चाहिए)
  • ऊपर के रूप में भी, लेकिन stdout या एक फ़ाइल के लिए।
• जिस क्रम में अलग-अलग लॉग होते हैं वह आउटपुट अप्रासंगिक है, हालांकि प्रत्येक समूह के भीतर लॉग लाइनों को उस आदेश को संरक्षित करना चाहिए जो उन्हें मूल फ़ाइल में मिला था

Answer 1

बैश , 4 11 बाइट्स

Shaggy द्वारा इंगित एक बग को ठीक करने के लिए 7 बाइट्स जोड़े गए ।

sort -sk1,1

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

व्हॉट्सएप द्वारा अलग किए गए sपहले क्षेत्र ( k1,1) पर आधारित एक स्थिर सॉर्ट ( कमांड लाइन तर्क) करता है ।

Answer 2

आर , 50 46 बाइट्स

function(r)split(r,substr(r,1,regexpr("]",r)))

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

listप्रत्येक तत्व के साथ के रूप में आउटपुट named के साथ [tag]। प्रत्येक सूची तत्व अपने टैग के भीतर क्रम बनाए रखता है। named list()खाली इनपुट के लिए एक खाली नाम सूची देता है।

-2 बाइट्स रॉबिन राइडर और डोमिनिक वैन एसेन को धन्यवाद!

Answer 3

अजगर , 3 बाइट्स

ohc

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

इनपुट प्रारूप तार की एक सूची है:

["[weather] Current temp: 83F","[barkeep] Fish enters bar","[barkeep] Fish orders beer","[stockmarket] PI +3.14","[barkeep] Fish leaves bar","[weather] 40% chance of rain detected"]

कोड कैसे काम करता है:

• o: द्वारा आदेश

• h: का पहला तत्व

• c: प्रत्येक स्ट्रिंग रिक्त स्थान पर विभाजित होती है

Answer 4

पायथन , 44 बाइट्स

lambda a:sorted(a,key=lambda l:l.split()[0])

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

लूज़ I / O हमें लाइनों की एक सूची लेने और देने की अनुमति देता है। चूँकि हमें समूहों को अलग करने की आवश्यकता नहीं है, इसलिए समस्या प्रत्येक स्थान के पहले भाग के उपसर्ग पर स्थिर प्रकार की रेखाओं के प्रदर्शन के लिए कम हो जाती है, split()कुछ अन्य सफेद-अंतरिक्ष वर्णों में भी विभाजित हो जाएगी , लेकिन कोई भी इसमें मौजूद नहीं हो सकता है। आवेदन टैग भाग।

Answer 5

APL (Dyalog विस्तारित) , 10 बाइट्स ( SBCS )

बेनामी tacit उपसर्ग समारोह। तर्क के रूप में वर्ण सूचियों की एक सूची लेता है। प्रत्येक पंक्ति में एक लॉग के साथ, वर्ण सूचियों का एक मैट्रिक्स लौटाता है।

⊢⊢⌸⍨≠⊃⍤⊆¨⊢

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

⊢ तर्क पर,

≠ गैर-रिक्त स्थान का उपयोग करें…

⊆¨ प्रत्येक सूची को सूचियों की सूची में विभाजित करें (रिक्त स्थान हटाता है, गैर-रिक्त स्थान के रन रखता है),

⊃⍤ फिर पहले [प्रत्येक] (यानी टैग) रखें,

⊢⌸⍨ समूह की कुंजी के रूप में उन का उपयोग करें ...

⊢ बहस

Answer 6

विम, १३ ११ बाइट्स

:sor/\w\+/r

Bugfix और बाइट @Dingus के लिए धन्यवाद बचाओ!

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

Answer 7

स्काला, 26 बाइट्स

_.sortBy(_.split("]")(0))

एक रिटर्न List[String]के बीच में कोई विभाजक के साथ है, लेकिन यह टैग के अनुसार क्रमबद्ध किया गया है।

इसे स्कैस्टी में आज़माएं

---

रिटर्न एक Map[String,List[String]], 26 बाइट्स

_ groupBy(_.split("]")(0))

स्ट्रिंग्स की एक सूची लेता है और Map[List[String]]जहां कुंजी टैग हैं और रिटर्न उस टैग से जुड़े लॉग हैं।

इसे स्कैस्टी में आज़माएं

---

पिछला समाधान, 66 बाइट्स

_ groupBy{case s"[$t]$r"=>t}map(_._2 mkString "\n")mkString "\n"*2

इसे स्कैस्टी में आज़माएं (जो भी कारण हो, sTIO में काम नहीं करता है)

प्रत्येक ऐप के लॉग को 2 नईलाइनों से अलग किया जाता है (अगर मैं सिर्फ एक नया चरित्र होना चाहता था तो 2 बाइट्स बचा सकता है)। इनपुट स्ट्रिंग्स की एक सूची है, और आउटपुट एक बड़ा स्ट्रिंग है।

Answer 8

05AB1E , 3 बाइट्स

Σ#¬

इनपुट और आउटपुट लॉग की एक सूची है।

स्पष्टीकरण:

Σ#¬
Σ          Sort by:
 #         Split (each log) by spaces
  ¬        Head (which is the tagname)

यह आवश्यकतानुसार लॉग के क्रम को भी बनाए रखता है।

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

Answer 9

रेटिना 0.8.2 , 14 13 बाइट्स

O$`(\w+).*
$1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: चूंकि कोई आउटपुट समूह विभाजक की आवश्यकता नहीं है, लाइनों को बस ऐप टैग द्वारा सॉर्ट किया जाता है, जो मैच को कैप्चर \w+करके और $1सॉर्ट कुंजी के रूप में निर्दिष्ट करके प्राप्त किया जाता है । रेटिना में छंटनी स्थिर है, ताकि समान उपसर्ग वाली रेखाएं उनके क्रम को बनाए रखें। संपादित करें: ऐप टैग से मिलान करने का आसान तरीका बताने के लिए @FryAmTheEggman को 1 बाइट धन्यवाद दिया गया। ध्यान दें कि हालांकि मैच में अग्रणी शामिल नहीं है [, सभी लाइनें इसके साथ शुरू होती हैं [, ताकि सॉर्ट के परिणाम को प्रभावित न करें।

Answer 10

AWK , 62 58 बाइट्स

डोमिनिक वैन एसेन के लिए 4 बाइट्स धन्यवाद बचा !!!

{a[$1][i++]=$0}END{for(k in a)for(j in a[k])print a[k][j]}

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

एक 2D साहचर्य सरणी में सभी पंक्तियों को संग्रहीत करता है a। पहली कुंजी पहला क्षेत्र (व्हॉट्सएप द्वारा अलग) है। तो एक ही क्षेत्र से शुरू होने वाली सभी लाइनें एक साथ संग्रहीत होती हैं। दूसरी कुंजी बढ़ती हुई पूर्णांक अनुक्रमणिका है। सबसे ENDक्रिया भाग वह क्रिया है जो aउपस्थिति के क्रम में पहले क्षेत्र द्वारा समूहीकृत की गई सामग्री को प्रिंट करती है ।

Answer 11

जाप , 4 बाइट्स

एक पंक्ति के रूप में इनपुट लेता है, एक 2 डी-सरणी आउटपुट करता है।

ü_¸g

कोशिश करो

Answer 12

आईओ , 73 बाइट्स

method(i,i map(split first)unique map(I,i select(split first==I))flatten)

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

Answer 13

पर्ल 6 , 16 बाइट्स

*.sort:{~m/\w+/}

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

अल्फ़ान्यूमेरिक वर्णों के पहले तार से सॉर्ट करता है, जो ऐप का नाम होना चाहिए

Answer 14

पायथन 3 , ¹⁴⁸ 127 बाइट्स

a={}
try:
 while 1:
  b=input();c=b.split("]")[0]
  if 1-(c in a):a[c]=[]
  a[c]+=[b]
except:[print(e)for k in a for e in a[k]]

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

Answer 15

वी (विम) , 5 बाइट्स

úr/?]

नोट: ?उपरोक्त अप्राप्य बाइट \ की जगह है$\text{\x}81\$ ("नो ब्रेक हियर" कंट्रोल कैरेक्टर)।

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

ध्यान दें कि यह रिक्त स्थान की कमी के साथ काम करता है (यहां तक ​​कि सीधे पहले ]ब्रैकेट के बाद भी ), []लॉग संदेश में कोष्ठक की उपस्थिति के साथ, और एक असंबद्ध एप्लिकेशन की उपस्थिति के साथ, इसे ऑनलाइन आज़माएं!

कैसे?

úr/?]
ú     - sort by:
 r    -   with flag=r: use match (default behaviour is to use what's after the match)
  /   -     with the pattern:
   ?  -       (byte 83) a shortcut for .\{-}
                                       .     - match any character
                                        \{-} - 0 or more times matching as few times as possible
    ] -       match a literal ']' character

Answer 16

ऑटोहोटकी, 74 बाइट्स

Loop,Read,f
{
s:=A_LoopReadLine
FileAppend,%s%`n,% StrSplit(s,"]","[")[1]
}

नाम की फ़ाइल से पढ़ता है fऔर टैग के आधार पर कई फ़ाइलों में आउटपुट करता है।

Answer 17

SimpleTemplate 0.84, 109 बाइट्स

हाँ, यह बहुत लंबा है, लेकिन काम करता है!

{@callexplode intoL EOL,argv.0}{@eachL}{@if_ matches"@^(\[.*\])@"M}{@setS.[M.1]S.[M.1],_,EOL}{@/}{@/}{@echoS}

इस कोड के साथ एक सरणी उत्पन्न करता है <old content>, line, <end of line>।

{@echoS} स्वचालित रूप से सरणी को समतल करता है और इसे प्रदर्शित करता है।

---

Ungolfed:

हां, यह गड़बड़ है, लेकिन यहां एक क्लीनर संस्करण है:

{@call explode into lines EOL, argv.0}
{@set storage null}
{@each lines as line}
    {@if line matches "@^(\[.*\])@" match}
        {@set storage.[match.1] storage.[match.1], line, EOL}
    {@/}
{@/}
{@echo storage}

फ़ंक्शन explodeएक मानक PHP फ़ंक्शन है, लेकिन मेरी भाषा से सुलभ है।

---

आप इस पर कोशिश कर सकते हैं: http://sandbox.onlinephpfunctions.com/code/9c66f8bacc6315ae56e7c193170e430f9cf9d902

Answer 18

सी # (.NET कोर) , 181 162 160 बाइट्स

input.GroupBy(l=>l.Split()[0]).ToList().ForEach((g)=>{using(var sw = new StreamWriter(g.Key.Trim('[').Trim(']')+".log")){foreach(var v in g)sw.WriteLine(v);}});

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 179 बाइट्स

i=>i.GroupBy((l)=>{return l.Split(' ')[0];}).ToList().ForEach((g)=>{using(var sw = new StreamWriter(g.Key.Trim(new char[]{'[',']'})+".log")){foreach(var v in g)sw.WriteLine(v);}})

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

मुझे यकीन नहीं है कि पहला समाधान कोड खाड़ी अनुपालन है, इसलिए दूसरा समाधान एक लंबोदर अभिव्यक्ति का उपयोग करता है।

Answer 19

हास्केल, 37 बाइट्स

import Data.List
f=sortOn(head.words)

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

Answer 20

जंग, 40 बाइट्स

|a|a.sort_by_key(|x|x.split("]").next())

तार के एक स्लाइस के लिए एक परस्पर संदर्भ लेता है और इसे सॉर्ट करता है।

जंग के खेल के मैदान पर इसे आज़माएं

Answer 21

पर्ल 5 -M5.10.0 -Mort = स्थिर, 53 बाइट्स

say sort{(split('\]',$a))[0]cmp(split('\]',$b))[0]}<>

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