आलसी प्रोग्रामर का XML पार्सर

Question

पृष्ठभूमि

आप एक कार बिक्री कंपनी के लिए एक प्रोग्रामर के रूप में काम कर रहे हैं। इस सप्ताह के लिए आपका कार्य एक XML पार्सर को प्रोग्राम करना है जो विभिन्न कार निर्माताओं से उपलब्ध मॉडल के बारे में डेटा लेता है, और नवीनतम मॉडल के बारे में सुंदर-प्रिंट जानकारी देता है। आपके लिए सौभाग्य से, परीक्षण विभाग ने केवल एक परीक्षण मामला प्रदान किया है! जितनी तेजी से आप इसे पास करने वाले कोड लिख सकते हैं, उतना ही आपके पास सप्ताह के बाकी समय में शिथिलता के लिए अधिक समय होगा।

इनपुट

आपका इनपुट बिल्कुल XML डेटा का एक टुकड़ा है, जिसे परीक्षण विभाग द्वारा आपूर्ति की जाती है। इसमें कुछ कार निर्माताओं के बारे में डेटा, कारों की उनकी श्रृंखला और इन श्रृंखलाओं में मॉडल शामिल हैं। आप एक अनुगामी न्यूलाइन मान सकते हैं।

<?xml version="1.0" ?>
<products>
  <manufacturer name="Test Manufacturer 1">
    <series title="Supercar" code="S1">
      <model>
        <name>Road Czar</name>
        <code>C</code>
        <year>2011</year>
      </model>
      <model>
        <name>Ubervehicle</name>
        <code>U</code>
        <year>2013</year>
      </model>
      <model>
        <name>Incredibulus</name>
        <code>I</code>
        <year>2015</year>
      </model>
      <model>
        <name>Model 1</name>
        <code>01</code>
        <year>2010</year>
      </model>
    </series>
    <series title="Test series 22" code="Test">
      <model>
        <name>Test model asdafds</name>
        <code>TT</code>
        <year>2014</year>
      </model>
    </series>
  </manufacturer>
  <manufacturer name="Car Corporation">
    <series title="Corporation Car" code="CC">
      <model>
        <name>First and Only Model</name>
        <code>FOM</code>
        <year>2012</year>
      </model>
    </series>
  </manufacturer>
  <manufacturer name="Second Test Manufacturer">
    <series title="AAAAAAAAAAAAAA" code="D">
      <model>
        <name>Some older model</name>
        <code>O</code>
        <year>2011</year>
      </model>
      <model>
        <name>The newest model</name>
        <code>N</code>
        <year>2014</year>
      </model>
    </series>
    <series title="BBBBBBBBBBBBBBB" code="asdf">
      <model>
        <name>Another newest model here</name>
        <code>TT</code>
        <year>2015</year>
      </model>
    </series>
  </manufacturer>
</products>

उत्पादन

आपका आउटपुट यह स्ट्रिंग है। यह कार निर्माताओं को वर्णमाला क्रम में सूचीबद्ध करता है, इसके बाद एक बृहदान्त्र और उनके द्वारा बनाई गई श्रृंखला की संख्या। प्रत्येक निर्माता के तहत, यह श्रृंखला के नाम, मॉडल का नाम, और उनके प्रत्येक मॉडल के कोड को सूचीबद्ध करता है, जो नए से शुरू होकर वर्ष तक पिछड़ रहा है। ट्रेलिंग व्हाट्सएप और लाइन ब्रेक स्वीकार्य हैं, जब तक कि प्रिंट होने पर आपका आउटपुट इसके समान दिखता है।

Car Corporation: 1 series
  Corporation Car, First and Only Model (CC-FOM)
Second Test Manufacturer: 2 series
  BBBBBBBBBBBBBBB, Another newest model here (asdf-TT)
  AAAAAAAAAAAAAA, The newest model (D-N)
  AAAAAAAAAAAAAA, Some older model (D-O)
Test Manufacturer 1: 2 series
  Supercar, Incredibulus (S1-I)
  Test series 22, Test model asdafds (Test-TT)
  Supercar, Ubervehicle (S1-U)
  Supercar, Road Czar (S1-C)
  Supercar, Model 1 (S1-01)

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

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

ध्यान दें कि इनपुट निश्चित है: आपको यहां दिए गए किसी भी अन्य इनपुट का समर्थन करने की आवश्यकता नहीं है। यदि इनपुट को किसी भी तरह से संशोधित किया जाता है, तो आपके प्रोग्राम को बकवास या दुर्घटनाग्रस्त होने की अनुमति दी जाती है। यदि आप चाहें तो इनपुट और हार्ड-कोड आउटपुट को भी अनदेखा कर सकते हैं। हालाँकि, आप XML या HTML पार्सर लाइब्रेरी या बिल्ट-इन का उपयोग नहीं कर सकते हैं ।

Comments

क्या एक HTML पार्सर की अनुमति दी जाएगी या जो नियमों को झुका रहा होगा?

— डाउनगेट

मैं कभी इस कंपनी से कार नहीं खरीदना चाहता।

— kirbyfan64sos

@vihan मैं (बल्कि मनमाने ढंग से) तय करता हूं कि HTML पार्सर की अनुमति नहीं है, क्योंकि दोनों प्रारूप समान हैं।

— जर्बग सिप

XSLT के बारे में क्या? ;)

— बीटा डिके

@ BetaDecay मैं XSLT को एक अपवाद के रूप में अनुमति देने जा रहा हूं, क्योंकि यह शायद बहुत थकाऊ और कष्टप्रद होगा कि उस भाषा में XML पार्सिंग ऑपरेशन का उपयोग न करें। : P और यह वैसे भी CJam उत्तर के साथ प्रतिस्पर्धा नहीं करेगा।

— जरगब सिप

Answer 1

CJam, 109 107 बाइट्स

"rzn ¸À¨ 4T\$D"S/q"<>"'"er'"/
f{\:i2/_E5bf.+.+\ff=)1<_s,9/+":  series
"2/.+\"  ,  ()
-"2/Z4e\f.\}

ध्यान दें कि शुरुआत में स्ट्रिंग के चार अक्षर अप्राप्य हैं।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

यह मूल रूप से एक हार्डकोड है जो इनपुट को < , > और " सभी घटनाओं में विभाजित करता है, विशिष्ट चंक्स का चयन करता है और आउटपुट के शेष हिस्सों के साथ उन्हें इंटरलेक्ट करता है।

इनपुट को विभाजित करने के बाद, अनुक्रमणिका 110 , 114 और 122 में हिस्सा कार कॉर्पोरेशन , कॉर्पोरेशन कार और फ़र्स्ट एंड ओनली मॉडल हैं । श्रृंखला और नाम के लिए कोड 116 और 126 सूचकांक में पाए जा सकते हैं, जिन्हें नामों के अनुक्रमित में 2 और 4 जोड़कर गणना की जा सकती है। अंत में, श्रृंखला की संख्या स्ट्रिंग कार कॉर्पोरेशन की लंबाई 9 (स्पष्ट रूप से) से विभाजित है ।

इस प्रकार, हम आउटपुट के उस भाग को एन्कोड करते हैं [114 122 110]जो स्ट्रिंग के रूप में या इसके बजाय इस निर्माता से मेल खाता है "rzn"।

कोड

e# Split the string at spaces.

"rzn ¸À¨ 4T\$D"S/

e# After replacing characters with their code points, this will be the result:
e# [[114 122 110] [184 192 144 168 144 152 140] [12 52 84 92 12 36 12 20 12 68 8]]

e# Read from STDIN, replace < and > with " and split at double quotes.

q"<>"'"er'"/ 

f{       e# For each chunk of the split string, push the split input; then:
\:i2/    e# Replace characters with character codes and split into chunks of
         e# length 2.
_E5b     e# Copy the result and push [2 4].
f.+      e# Replace each pair [I J] in the copy with [I+2 J+4].
.+       e# Vectorized concatenation.
         e# For the first chunk, we've achieved
         e# [114 122 110] -> [[114 122] [110]]
         e#               -> [[114 122] [110]] [[116 126] [110 112 4]]
         e#               -> [[114 122 116 126] [110 112 4]]
\ff=     e# Replace each integer with the chunk of the split input at that index.
)1<      e# Pop the first chunk and reduce it to the first string.
_s,9/    e# Divide that strings length by 9 and append the integer to the array.
":  series
"2/      e# Push [": " " s" "er" "ie" "s\n"].
.+       e# Vectorized concatenation; pushes the manufacturer line.
\        e# Swap the remaining strings on top of the stack.
"  ,  ()
-"2/     e# Push ["  " ", " " (" ")\n" "-"].
Z4e\     e# Swap the chunks at indexes 3 and 4.
\f.\     e# Interleave both arrays of strings.
}

Answer 2

बबलगम , 227 225 बाइट्स

0000000: 6d 50 45 b6 02 31 10 dc cf 29 6a 87 eb 92 1d ee 0e 07  mPE..1...)j.......
0000012: 08 93 1e 3c e1 45 be 9d fe 37 ae bd 2b 7d 95 54 85 41  ...<.E...7..+}.T.A
0000024: 55 9b 83 36 c2 ad b5 2a a1 00 4b 66 4d 36 c0 23 0f f6  U..6...*..KfM6.#..
0000036: a5 d1 58 1b eb 20 94 c4 50 ed 7e d1 d7 92 76 88 57 ab  ..X.. ..P.~...v.W.
0000048: 99 c6 b0 9f 08 a6 14 6a 96 66 c4 9e be 50 3e 12 a1 f3  .......j.f...P>...
000005a: 86 4c 09 c5 7b 67 e5 f9 d2 28 2b ed 56 64 a0 e8 9b 83  .L..{g...(+.Vd....
000006c: d8 9f 3a 99 20 c4 85 95 51 66 36 4b 70 ac fc 74 69 cc  ..:. ...Qf6Kp..ti.
000007e: 56 f4 9c 88 d7 32 83 4f c6 a9 de 13 f4 4e 92 b9 1b 87  V....2.O.....N....
0000090: 89 e0 6d 24 0a 4f 33 a7 fe 40 26 e4 37 a3 ad 42 43 72  ..m$.O3..@&.7..BCr
00000a2: bd f0 3b 6f 11 9f 16 32 ed 04 eb a7 fc d9 8d 62 91 f7  ..;o...2.......b..
00000b4: dc 97 f0 6a 11 49 f6 1e b9 cb fc 7b dd 7c 41 e6 8b 56  ...j.I.....{.|A..V
00000c6: eb 70 47 a7 b6 f9 b3 3c d1 42 a2 fa 27 cc 49 ac 3e 89  .pG....<.B..'.I.>.
00000d8: 97 ff 2e 9c a4 7c 21 f1 0f                             .....|!..

यह बहुत प्रतिस्पर्धात्मक नहीं है, लेकिन मैं सिर्फ एक वास्तविक kolmogorov- जटिलता चुनौती के लिए अपना पहला बबलगम उत्तर पोस्ट करने के लिए विरोध नहीं कर सका ।

हेक्सडंप के साथ उलटा हो सकता है xxd -r -c 18 > xml.bg।

कोड पूरी तरह से इनपुट को अनदेखा करता है। संपीड़न zopfli के साथ किया गया है , जो DEFLATE प्रारूप का उपयोग करता है, लेकिन (g) ज़िप की तुलना में बेहतर अनुपात प्राप्त करता है।

-2 बाइट्स के लिए @ Sp3000 को धन्यवाद!

Answer 3

सीड, 449 बाइट्स

-nrविकल्पों के साथ चलाने के लिए sed मानता है ।

/\?|<p/d;:M
/<ma/{s/.*"(.*)".*/Q\1: X series/;/C/ s/X/1/;s/X/2/;H;d}
/<se/{s/.*"([^"]*)".*"([^"]*)".*/@\1!\2/;H;d}
/<mo/{
G;s/.*@(.*)*$/\1/;x;s/@(.*)*$//;x;:A N
/<\/m/!bA
s/\n/!/g;s/  +//g;s|<[/a-z]*>||g;s/(.*)!(.*)!(.*)!(.*)!(.*)!/%\1, \3 (\2-\4)@\1!\2/;H}
/<\/se/{x;s/\n*@.*$//;x}
$!{n;bM}
x;s/\n//g;s/Q(.*)Q(.*)%(.*)Q(.*)/\2\n  \3\n\4\n\1/
s/%(.*)%(.*)%(.*)\n(.*)%(.*)%(.*)%(.*)%(.*)%(.*)/\n  \3\n  \2\n  \1\n\4\n  \7\n  \9\n  \6\n  \5\n  \8/;p

Ungolfed संस्करण:

# Remove first 2 lines
/\?|<p/ d

:M
#manufacturer
/<ma/ {
    s/.*"(.*)".*/Q\1: X series/
    #Car corp
    /C/ s/X/1/
    #other
    s/X/2/
    H
    d
}

#series: store in hold buffer. (treating the hold buffer as a list, with @ as a delimeter)
/<se/{
    s/.*"([^"]*)".*"([^"]*)".*/@\1!\2/
    H
    d
}
/<mo/ {
    # pull series from hold buffer
    G
    s/.*@(.*)*$/\1/

    # remove series from hold buffer
    x
    s/@(.*)*$//
    x

    # Concatenate model into one line
    :A N
    /<\/m/ !{
        bA
    }
    s/\n/!/g

    # Remove junk
    s/  +//g
    s|<[/a-z]*>||g

    # Append formatted line to hold buffer, replace series at the end
    s/(.*)!(.*)!(.*)!(.*)!(.*)!/%\1, \3 (\2-\4)@\1!\2/
    H
}
/<\/se/ {
    #pop series name
    x
    s/\n*@.*$//
    x
}

$ ! {
    n
    b M
}
# end of loop

x
s/\n//g

# "sort"
s/Q(.*)Q(.*)%(.*)Q(.*)/\2\n  \3\n\4\n\1/
s/%(.*)%(.*)%(.*)\n(.*)%(.*)%(.*)%(.*)%(.*)%(.*)/\n  \3\n  \2\n  \1\n\4\n  \7\n  \9\n  \6\n  \5\n  \8/
p

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— डेनिस

Answer 4

बैश, 388 368 365

base64 -d<<<H4sICKVS9FUCA2hlcmUAbVFBasMwELwH8oc92mBD5GNuqUogB9dQOw9QpDUWKFJYWS3t6yvJtI3T7k07szOzKy4IuKObIzFrZ/fAwCNp9NsN3APABVVw1ORnEFZBZ80HtE6hgYLz+ti15XbTo3QRGzCSWmHDKOQcCGkPzZ3q07oqOFg3T0hg8T1NXrNqbCAUwquxHoYyzR1WVcEw4XqkeK5f/mX27orgjIoeP8wuMv8EBbaO2ocbkkybn6wkVPoSTPBQ9Kw+ZaessPChaarlvXjE6GJUkZx63zv8Cp4vSG84aWkw650f8FcnFPDP+D0J5Q/ocnmWsR0rvwC2OTuexgEAAA==|zcat

छोटा परीक्षण क्योंकि:

$ bash ./go_procrastination.sh cars.xml
Car Corporation: 1 series
  Corporation Car, First and Only Model (CC-FOM)
Second Test Manufacturer: 2 series
  BBBBBBBBBBBBBBB, Another newest model here (asdf-TT)
  AAAAAAAAAAAAAA, The newest model (D-N)
  AAAAAAAAAAAAAA, Some older model (D-O)
Test Manufacturer 1: 2 series
  Supercar, Incredibulus (S1-I)
  Test series 22, Test model asdafds (Test-TT)
  Supercar, Ubervehicle (S1-U)
  Supercar, Road Czar (S1-C)
  Supercar, Model 1 (S1-01)

Comments

यहां तक ​​कि अगर आप अनपेक्षित वर्णों और चेतावनियों से बचने पर जोर देते हैं, तो इसे बहुत कम किया जा सकता है। 1. आपकी संपीड़ित फ़ाइल में मूल फ़ाइल का नाम है car_manufacturer.txt,। 2. यहाँ एक स्ट्रिंग 3 बाइट्स छोटी होगी। 3. वेनिला गज़िप के बजाय ज़ोफ़ली का उपयोग करना 12 और बाइट्स बचाता है।

— डेनिस

सलाह के लिए धन्यवाद। दरअसल कुछ बाइट्स को बचाया। लेकिन चुनौती के मूड में रखने के लिए, आलसीपन ने zopfli या PAQ डेटा संपीड़न प्रोग्राम में से एक को स्थापित करने को हतोत्साहित किया। :)

— लुकस्ट्रीम

हालांकि यहां स्ट्रिंग एक आसान गोल्फ है। बस के <<Lसाथ बदलें <<<(base encoded stuff)।

— डेनिस

और 3 बाइट्स मुंडा। अच्छा लगा।

— LukStorms