एक इनपुट के प्रकार का निर्धारण करें

15

चुनौती सरल है: एक इनपुट के प्रकार को निर्धारित करें, और एक पहचानकर्ता को यह बताते हुए आउटपुट करें कि यह किस प्रकार का है।

  • "यूआई", अहस्ताक्षरित पूर्णांक: 0, 1, 34,111111111111111111111111111111111111111111
  • "एसआई", पूर्णांक प्रवेश किया गया: +0, +1, +42, -1, -3,-111111111111111111111111111111111111111111
  • "उद", अहस्ताक्षरित दशमलव: 0.0, 1.23,1234.1234
  • "एसडी", दशमलव प्रवेश किया गया: -0.0, +0.0,-1.235
  • "ले", पत्र: a- zऔर A-Z
  • "SY", प्रतीक: ASCII कोड अंक: [32-47, 58-64, 91-96, 123-126](यानी संख्याओं और अक्षरों को छोड़कर सभी वर्ण)
  • "ST", स्ट्रिंग: दो या दो से अधिक वर्ण जिन्हें उपरोक्त संख्या स्वरूपों में से किसी के रूप में पार्स नहीं किया जा सकता है

नियम:

  • इनपुट 1-99 वर्ण लंबा होगा
  • इनपुट में केवल मुद्रण योग्य ASCII वर्ण, कोड बिंदु: 32-126 होंगे।
  • आउटपुट दो पहचानकर्ता अक्षर होने चाहिए जैसा कि ऊपर परिभाषित किया गया है (UI, SI ...)
  • मानक I / O नियम लागू होते हैं

उदाहरण:

UI:
0
01
34
12938219383278319086135768712319838871631827319218923

SI:
-0
+01
+1
-123
+123

UD:
0.0
3.1415
2.718281828459045235360287471352662497757

SD:
+0.0
-3.1415
+2.718281828459045235360287471352662497757

LE:
a
k
L
Z

SY:
@
"
+
-

ST:
Hello, World!
f2!"
+23df
1234A
'"!
.012
1.
UI
+-1
5+3
code-golf  string  parsing 
— स्टीवी ग्रिफिन
स्रोत
SYएक से अधिक वर्ण हो सकते हैं?
— FryAmTheEggman
मैं 111111111111111111111111111111111111111111पूर्णांक प्रकार का नहीं होगा ।
— मैट
@FryAmTheEggman sy केवल एक चरित्र है।
— स्टीवी ग्रिफिन
तो हम इनपुट को एक स्ट्रिंग के रूप में लेते हैं?
— lirtosiast
6
@ मैट, यह एक uint8या नहीं हो सकता है int64, लेकिन यह निश्चित रूप से पूर्णांक है ।
— स्टिव ग्रिफिन

जवाबों:

0

पायथ - 47 बाइट्स

कुछ फिसलने वाली चाल के साथ कुछ बाइट्स को धीरे-धीरे गोल्फ कर सकते हैं।

.x-+?@z"+-"\S\U?@z\.\D\Isz?!tz?}rzZG"LE""SY""ST

टेस्ट सूट ।

— Maltysen
स्रोत
5

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

x=>(z=x.match(/^([+-])?\d+(\.\d+)?$/))?'SU'[+!z[1]]+'DI'[+!z[2]]:x[1]?'ST':parseInt(x,36)?'LE':'SY'

परीक्षा

f=x=>(z=x.match(/^([+-])?\d+(\.\d+)?$/))?'SU'[+!z[1]]+'DI'[+!z[2]]:x[1]?'ST':parseInt(x,36)?'LE':'SY'

console.log=x=>O.textContent+=x+'\n'

;console.log(['0','01','34','12938219383278319086135768712319838871631827319218923'].map(x=>f(x)+' '+x).join`\n`)
;console.log(['-0','+01','+1','-123','+123'].map(x=>f(x)+' '+x).join`\n`)
;console.log(['0.0','3.1415','2.718281828459045235360287471352662497757'].map(x=>f(x)+' '+x).join`\n`)
;console.log(['+0.0','-3.1415','+2.718281828459045235360287471352662497757'].map(x=>f(x)+' '+x).join`\n`)
;console.log([...'akLZ'].map(x=>f(x)+' '+x).join`\n`)
;console.log([...'@"+-'].map(x=>f(x)+' '+x).join`\n`)
;console.log(['Hello, World!','f2!"','+23df','1234A',`'"!`,'.012','1.','UI','+-1','5+3'].map(x=>f(x)+' '+x).join`\n`)
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
1
मुझे पूरा यकीन था कि कोई साझा मामलों के लिए अनुकूलन करने में सक्षम होगा, लेकिन मुझे पत्रों का पता लगाने के लिए पार्सेइंट का आपका उपयोग पसंद है।
— नील
आपके रेगेक्स में पहला () आवश्यक नहीं है
— अवाशी
@ अश्विनी यह आवश्यक है क्योंकि मुझे S या U को अलग करने के लिए संकेत के लिए एक कैप्चर ग्रुप की आवश्यकता है।
— edc65
@WashingtonGuedes नहीं, यह हो सकता है (\+|-)लेकिन कोई बाइट्स नहीं बचा
— edc65
3

ट्यूरिंग मशीन कोड, 1544 बाइट्स

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

0 + _ r s
0 - _ r s
0 0 _ r u
0 1 _ r u
0 2 _ r u
0 3 _ r u
0 4 _ r u
0 5 _ r u
0 6 _ r u
0 7 _ r u
0 8 _ r u
0 9 _ r u
0 a _ r l
0 b _ r l
0 c _ r l
0 d _ r l
0 e _ r l
0 f _ r l
0 g _ r l
0 h _ r l
0 i _ r l
0 j _ r l
0 k _ r l
0 l _ r l
0 m _ r l
0 n _ r l
0 o _ r l
0 p _ r l
0 q _ r l
0 r _ r l
0 s _ r l
0 t _ r l
0 u _ r l
0 v _ r l
0 w _ r l
0 x _ r l
0 y _ r l
0 z _ r l
0 A _ r l
0 B _ r l
0 C _ r l
0 D _ r l
0 E _ r l
0 F _ r l
0 G _ r l
0 H _ r l
0 I _ r l
0 J _ r l
0 K _ r l
0 L _ r l
0 M _ r l
0 N _ r l
0 O _ r l
0 P _ r l
0 Q _ r l
0 R _ r l
0 S _ r l
0 T _ r l
0 U _ r l
0 V _ r l
0 W _ r l
0 X _ r l
0 Y _ r l
0 Z _ r l
0 * _ r y
s 0 _ r s
s 1 _ r s
s 2 _ r s
s 3 _ r s
s 4 _ r s
s 5 _ r s
s 6 _ r s
s 7 _ r s
s 8 _ r s
s 9 _ r s
s . _ r d
s _ _ r i
s * _ r T
u 0 _ r u
u 1 _ r u
u 2 _ r u
u 3 _ r u
u 4 _ r u
u 5 _ r u
u 6 _ r u
u 7 _ r u
u 8 _ r u
u 9 _ r u
u . _ r D
u _ _ r I
u * _ r T
l _ _ r L
l * _ r T
y _ _ r S
y * _ r T
d 0 _ r d
d 1 _ r d
d 2 _ r d
d 3 _ r d
d 4 _ r d
d 5 _ r d
d 6 _ r d
d 7 _ r d
d 8 _ r d
d 9 _ r d
d _ _ r e
d * _ r T
i 0 _ r i
i 1 _ r i
i 2 _ r i
i 3 _ r i
i 4 _ r i
i 5 _ r i
i 6 _ r i
i 7 _ r i
i 8 _ r i
i 9 _ r i
i _ _ r j
i * _ r T
D 0 _ r D
D 1 _ r D
D 2 _ r D
D 3 _ r D
D 4 _ r D
D 5 _ r D
D 6 _ r D
D 7 _ r D
D 8 _ r D
D 9 _ r D
D _ _ r E
D * _ r T
I 0 _ r I
I 1 _ r I
I 2 _ r I
I 3 _ r I
I 4 _ r I
I 5 _ r I
I 6 _ r I
I 7 _ r I
I 8 _ r I
I 9 _ r I
I _ _ r J
I * _ r T
L * L r M
M * E r halt
S * S r Y
Y * Y r halt
e * S r f
f * D r halt
j * S r k
k * I r halt
E * U r f
J * U r k
T _ S r U
T * _ r T
U * T r halt
— लीक नन
स्रोत
3
कृपया कोड का पूरी तरह से गोल्फ संस्करण शामिल करें। यदि व्हाट्सएप को हटाया नहीं जा सकता है, तो इसे बाइट काउंट में गिना जाना चाहिए।
— मैगू
2
ऐसा लगता है कि इसे हटाया नहीं जा सकता है, कार्यक्रम प्रतीकों के बीच रिक्त स्थान के बिना ठीक से काम नहीं करता है।
— मैथ्यू स्मिथ
यह एसटी के रूप में "+ -1" (उदाहरणों से) को वर्गीकृत नहीं करता है।
— Xantix
2

रेटिना, 98 97 बाइट्स

वास्तव में मेरे regex कौशल का अभ्यास करने का एक अच्छा तरीका है।

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

^(?![+-]?\d+(\.\d+)?$)..+
ST
^([+-]?)\d+$
$1UI
^([+-]?)\d+\.\d+$
$1UD
i`^[a-z]$
LE
^.$
SY
[+-]U
S
— लीक नन
स्रोत
4
आप एक बाइट बचाने के ^[a-zA-Z]$लिए बदल सकते हैंi`^[a-z]$
— डेवको
1

लुआ, 157 बाइट्स

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

golfed:

n=(...)m=string.match s=m(n,"^[+-]")and"S"or"U"print(m(n,"^[+-]?%d+%.%d+$")and s.."D"or m(n,"^[+-]?%d+")and s.."I"or m(n,"^%w$")and"LE"or#n==1 and"SY"or"ST")

Ungolfed:

n = "2.718281828459045"

s = n:sub(1,1):match("[+-]") and "S" or "U"

if n:match("^[+-]?%d+%.%d+$") then
    print(s.."D")
elseif n:match("^[+-]?%d+") then
    print(s.."I")
elseif n:match("^%w$") then
    print("LE")
elseif #n==1 then
    print("SY")
else
    print("ST")
end
— लीक नन
स्रोत
1

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

s=>"UISIUDSDLESYST".substr(s.match(/^((\d+)|([+-]\d+)|(\d+\.\d+)|([+-]\d+\.\d+)|([A-Z])|(.)|(.*))$/i).indexOf(s,2)*2-4,2)

वैकल्पिक संस्करण, 120 बाइट्स:

s=>"STUISIUDSDLESY".substr(s.match(/^(?:(\d+)|([+-]\d+)|(\d+\.\d+)|([+-]\d+\.\d+)|([A-Z])|(.)|.*)$/i).lastIndexOf(s)*2,2)
— नील
स्रोत
निश्चित रूप से रेगेक्स को एक रेक्सएक्स eval(`/regex/`)कंस्ट्रक्टर + टेम्पलेट स्ट्रिंग्स के साथ जोड़ा जा सकता है
— डाउनगेट
0

जावा, 192 बाइट्स

String t(String v){for(String[]x:new String[][]{{"\\d+","UI"},{"[-+]\\d+","SI"},{"\\d+\\.\\d+","UD"},{"[-+]\\d+\\.\\d+","SD"}})if(v.matches(x[0]))return x[1];return (v.length()==1?"SY":"ST");}
— SuperJedi224
स्रोत
return (v.length()==1?"SY":"ST");हो सकता है return v.length()<2?"SY":"ST";(-3 बाइट्स) या यह यह हो सकता है: String t(String v){for(String x:"UI\\d+;SI[-+]\\d+;UD\\d+\\.\\d+;SD[-+]\\d+\\.\\d+".split(";"))if(v.matches(x.substring(2)))return x.substring(0,2);return v.length()<2?"SY":"ST";}( 179 बाइट्स ) और इसके अलावा आप जावा 8 लैम्ब्डा का उपयोग String t(String v)करने v->पर बदल सकते हैं ।
— केविन क्रूज़सेन
0

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

मैंने एक का उपयोग करने की कोशिश की replace अधिक "फैंसी" होने ।

यह एक अनाम फ़ंक्शन बनाता है जो टाइप का स्ट्रिंग लौटाता है।

s=>s.replace(/^((([+-])?(\d+)(\.\d+)?)|([a-z])|([ -~])|([^\0]*))$/i,(_,a,b,c,d,e,f,g)=>b?(c?'S':'U')+(e?'D':'I'):(f?'LE':'S'+(g?'Y':'T')))

इसमें सुधार के किसी भी सुझाव का पूरी तरह से स्वागत होगा।

— इस्माइल मिगुएल
स्रोत
1
1.होना चाहिए ST, नहीं UD। \d*\d+
— edc65
@ edc65 कैसे? वह एक दशमलव है। वह वैसा ही है 1.0।
— इस्माइल मिगुएल
यह मान्य हो सकता है या नहीं (मैं 1.इसके बजाय नहीं लिखता 1) लेकिन यह आपकी पसंद या मेरा नहीं है: परीक्षण के मामले हैं
— edc65
@ edc65 आप सही कह रहे हैं। मैंने बहुत बड़ी सूची को छोड़ दिया। मैंने इसे ठीक कर लिया है। धन्यवाद!
— इस्माइल मिगुएल
0

पायथन 3.5 - 241 240 बाइट्स:

( @CatsAreFluffy के लिए 1 बाइट धन्यवाद )

import re
def r(g):
 y={'^\d+$':'UI','^[+-]\d+$':'SI','^[0-9]\d*(\.\d+)?$':'UD','[+-](?=[0-9]\d*(\.\d+))':'SD','[a-zA-Z]+':'LE','^[^A-Za-z0-9]+$':'SY'};d=[y[i]for i in list(y.keys())if re.match(i,g)]
 if len(d)>0:return d[0]
 else:return'ST'

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

— आर। कप
स्रोत
आप अंतरिक्ष को बचाने के लिए फ़ंक्शन के बाहर आयात पुन: ले जा सकते हैं । (स्टेपिड आईपैड कीबोर्ड विथ नो बैकटिक्स)
— कैलकुलेटरफ्लीन
@CatsAreFluffy हाँ, मैंने ऐसा नहीं सोचा था। धन्यवाद! :)
— आर। काप
@CatsAreFluffy: असल में, आईओएस कीबोर्ड करता बैकटिक अनुमति देते हैं! मुझे दूसरे दिन यह पता चला जब मुझे अपने iPhone का उपयोग करके मार्कडाउन
— homersimpson
@CatsAreFluffy अच्छा लगा! यह जानकर अच्छा लगा।
— आर। काप
इसके अलावा len(d)>0==d>[]
— कैलक्यूलेटरफलाइन
0

Tcl 414 बाइट्स

अपुष्ट कार्यान्वयन, पठनीय:

proc a b {
  if {[string index $b 0] eq "+" || [string index $b 0] eq "-"} {
    set c S
  } elseif {[string match {[A-Za-z]} $b]} {
    return LE
  } elseif {[regexp {^(?![+-]?\d+(\.\d+)?$)..+} $b]} {
    return ST
  } elseif {[regexp {[^a-zA-Z0-9.]} $b]} {
    return SY
  } else {
    set c U
  }
  if {[string match *.* $b]} {
    return $c\U
  } else {
    return $c\I
  }
}
puts [a $argv]
— लेगिट स्टैक
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.