स्टेम-एंड-लीफ प्लॉट को मान्य करें

Question

एक स्टेम और लीफ प्लॉट समूहों में संख्यात्मक मूल्यों का एक गुच्छा प्रदर्शित करता है, जो सभी लेकिन अंतिम अंक द्वारा निर्धारित किए जाते हैं। उदाहरण के लिए, मान लें कि हमारे पास डेटा का यह सेट है:

0, 2, 12, 13, 13, 15, 16, 20, 29, 43, 49, 101

हम इस स्टेम और पत्ती की साजिश का उत्पादन कर सकते हैं:

0|02
1|23356
2|09
3|
4|39
5|
6|
7|
8|
9|
10|1

पहली पंक्ति का स्टेम 0 है, इसलिए इसके "पत्ते" - के बाद के अंक |- 0 समावेशी और 10 अनन्य के बीच के मूल्यों का प्रतिनिधित्व करते हैं। प्रत्येक तने पर पत्तियों को छांटा जाता है। पत्तियों के साथ तने (जैसे 3) अभी भी भूखंड में दिखाई देते हैं। 101 का मान 100 समावेशी और 110 अनन्य के बीच है, इसलिए इसका स्टेम 10 (100 को 10 से विभाजित) है।

आपकी चुनौती यह जांचना है कि क्या पाठ का एक टुकड़ा एक मान्य स्टेम और पत्ती की साजिश है। एक मान्य प्लॉट इन नियमों को संतुष्ट करता है:

• डेटा की सीमा में हर स्टेम (यानी 10-चौड़ा समूह) के लिए एक पंक्ति है (बिना पत्तियों के बीच की सीमा के बीच उपजी सहित)
• सीमा के बाहर कोई उपजा नहीं है
• सभी पत्तियों को दाईं ओर चढ़ते हुए हल किया जाता है
• सभी उपजी नीचे बढ़ते हैं
• केवल संख्यात्मक वर्ण हैं (विभाजक के अलावा |)

आपको उन संख्याओं से निपटने की ज़रूरत नहीं है जिनके अंश आंशिक हैं। आप उपजी में अतिरिक्त अग्रणी शून्य को अनुमोदित या अस्वीकार कर सकते हैं, लेकिन एक खाली स्टेम की अनुमति नहीं है। कम से कम एक मूल्य होगा। आप प्रत्येक पंक्ति में पत्तियों के बाद केवल अतिरिक्त स्थान ग्रहण कर सकते हैं। आप एक अग्रणी और / या नई अनुगामी मान सकते हैं। सभी वर्ण मुद्रण योग्य ASCII होंगे।

आपके फ़ंक्शन या प्रोग्राम को लौटना चाहिए या आउटपुट (स्क्रीन या मानक आउटपुट के लिए) एक वैध भूखंड के लिए एक सत्य मान, या एक अमान्य भूखंड के लिए एक गलत मूल्य। आप मानक इनपुट से, एक फ़ाइल से, एक बड़ी स्ट्रिंग के रूप में, स्ट्रिंग की एक सरणी के रूप में इनपुट ले सकते हैं - जो भी सबसे सुविधाजनक है।

यहां कुछ परीक्षण मामले हैं जो वैध भूखंड हैं (रिक्त लाइनों द्वारा अलग किए गए):

2|00003457
3|35
4|799
5|3

99|3
100|0556
101|
102|
103|8

0|0

यहां कुछ परीक्षण मामले हैं जो अमान्य भूखंड हैं, सही पर टिप्पणी के साथ:

|0               Blank stem

5|347            Missing a stem (6) in the range
7|9

4|               Has a stem (4) outside the range
5|26
6|7

11|432           Leaves aren't sorted correctly
12|9989

5|357            Stems aren't sorted correctly
4|002
6|1

4|5              Duplicate stem
4|6
4|6
5|1

51114            No stem and leaf separator
609

1|2|03           Multiple separators
2|779|

4|8abcdefg9      Invalid characters
5|1,2,3

75 | 4 6         Invalid characters (spaces)
76 | 2 8 8 9

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है! मानक खामियों को अस्वीकार कर दिया जाता है।

Comments

यह एक बहुत अच्छी पहली चुनौती है, बहुत बढ़िया काम! :) मैं एक अमान्य परीक्षण मामला जोड़ूंगा जिसमें एक पंक्ति है जैसे 1|2|3उसमें।

— लिन

बेहतरीन पहली चुनौती!

— AdmBorkBork

अच्छी पहली चुनौती। एक परीक्षण मामला जो आप शायद जोड़ सकते हैं, वह 4|;5|26;6|7उस सीमा के समान है, जिसमें सीमा के बाहर पहला तना होता है, लेकिन अंत में, यानी 12|3;13|4559;14|।

— केविन क्रूज़सेन

Answer 1

पर्ल, 47 बाइट्स

के लिए +2 शामिल है -0p

STDIN पर इनपुट दें

stem.pl:

#!/usr/bin/perl -0p
$"="*";$_=/^((??{$_+$n++})\|@{[0..9,"
"]})+$/

Comments

बेनाम: यह awsome है ... बेनाम: के साथ कि चाल $"बहुत अच्छा है!

— दादा

Answer 2

पिप , 60 58 + 1 = 59 बाइट्स

समस्या पर पहले छुरा, शायद अधिक गोल्फ का उपयोग कर सकता है। -rस्टड से इनपुट की लाइनों को पढ़ने के लिए ध्वज का उपयोग करता है । ट्रू आउटपुट है 1, मिथ्या आउटपुट 0या खाली स्ट्रिंग है।

g=a+,#g&a@vNE'|NEg@v@v&$&{Y(a^'|1)a@`^\d+\|\d*$`&SNy=^y}Mg

स्पष्टीकरण और परीक्षण सूट लंबित है, लेकिन इस बीच: इसे ऑनलाइन आज़माएं!

Answer 3

जावास्क्रिप्ट, 189 बाइट्स

(x,y=x.split`
`.map(a=>a.split`|`),z=y.map(a=>a[0]))=>!(/[^0-9|\n]|^\|/m.exec(x)||/^\d+\|\n|\|$/.exec(x)||y.some((c,i,a)=>c.length!=2||c[1]!=[...c[1]].sort().join``)||z!=z.sort((a,b)=>a-b))

एक ही लंबाई वैकल्पिक समाधान:

(x,y=x.split`
`.map(a=>a.split`|`),z=y.map(a=>a[0]))=>!(/[^0-9|\n]|^\||^.*\|.*\|.*$/m.exec(x)||/^\d+\|\n|\|$/.exec(x)||y.some((c,i,a)=>c[1]!=[...c[1]].sort().join``)||z!=z.sort((a,b)=>a-b))

एक अनाम फ़ंक्शन को परिभाषित करता है जो मल्टीलाइन स्ट्रिंग के रूप में इनपुट लेता है।

मुझे यकीन है कि गोल्फ में और भी कुछ है, इसलिए मुझे बताएं कि क्या आपको कोई संभावित सुधार दिखाई देता है।

स्पष्टीकरण:

फ़ंक्शन कई बुरी चीज़ों के लिए जाँच करता है, और यदि उनमें से कोई भी सत्य है, तो यह गलत है (तार्किक ओआरएस और नॉट का उपयोग करके)

(x,y=x.split("\n").map(a=>a.split`|`),          //y is input in pairs of stem and leaves
z=y.map(a=>a[0]))                               //z is stems
=>                                              //defines function
!(                                              //logical not
/[^0-9|\n]|^\|/m.exec(x)                        //checks for invalid chars and blank stems
||/^\d+\|\n|\|$/.exec(x)                        //checks for stems out of range
||y.some((c,i,a)=>c.length!=2                   //checks for multiple |s in a line
||c[1]!=[...c[1]].sort().join``))               //checks if leaves are in wrong order
||z!=z.sort((a,b)=>a-b))                        //checks for stems in wrong order

वैकल्पिक समाधान में, |एक पंक्ति में कई एस के लिए जाँच पहले regex के हिस्से के रूप में की जाती है।

Comments

यदि आप testइसके बजाय उपयोग करते हैं exec(आप लगभग हमेशा उपयोग करना चाहते हैं testयदि आपको केवल बूलियन परिणाम की आवश्यकता है) तो आप शायद बिटवाइज़ का उपयोग कर सकते हैं या तार्किक के बजाय।

— नील

क्या यह वास्तव में डुप्लिकेट या लापता उपजी के लिए जाँच करता है?

— नील

आप कुछ बाइट्स y.some((c,i,a)=>...को y.some(c=>...तब से बदल सकते हैं iऔर aजिनका उपयोग नहीं किया जाता है। और ऐसा लगता है कि z!=z.sort((a,b)=>a-b)काम नहीं करता है कि इसे प्रतिस्थापित किया जा सकता है''+z!=z.sort()

— हेडी

Answer 4

बैच, 409 बाइट्स

echo off
set/pp=||exit/b1
set t=
set i=%p:|=&set t=%
if "%t%"=="" exit/b1
for /f "delims=0123456789" %%s in ("%i%")do exit/b1
:l
set t=-
set s=%p:|=&set t=%
if "%s%"=="" exit/b1
if not "%s%"=="%i%" exit/b1
set/ai+=1
for /f "delims=0123456789" %%s in ("%t%")do exit/b1
:m
if "%t:~1,1%"=="" goto n
if %t:~0,1% gtr %t:~1,1% exit/b1
set t=%t:~1%
goto m
:n
set/pp=&&goto l
if "%t%"=="" exit/b1

STDIN पर इनपुट लेता है, लेकिन जैसे ही यह एक त्रुटि देखता है, बाहर निकल जाता है।