确定输入的类型

15

挑战很简单：确定输入的类型，然后输出一个标识它是什么类型的标识符。

  • “UI”，无符号整数：0，1，34，111111111111111111111111111111111111111111
  • “SI”，有符号整数：+0，+1，+42，-1，-3，-111111111111111111111111111111111111111111
  • “UD”无符号十进制：0.0，1.23，1234.1234
  • “SD”，符号十进制：-0.0，+0.0，-1.235
  • “ LE”，字母：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 
— 斯蒂夫·格里芬
source
可以SY超过一个字符吗？
— FryAmTheEggman '16
我不会认为111111111111111111111111111111111111111111是整数类型。
— 马特
@FryAmTheEggman sy只是一个字符。
— Stewie Griffin
那么我们将输入作为字符串吗？
— lirtosiast '16
6
@Matt，它可能不是uint8or int64，但绝对是整数。
— Stewie Griffin

Answers:

0

Pyth-47个字节

可以用一些切片技巧使高尔夫球运动几字节。

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

测试套件。

— 马尔蒂森
source
5

JavaScript（ES6），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
source
1
我非常确定有人可以针对共享案例进行优化，但是我喜欢您使用parseInt检测字母。
— Neil
不需要在正则表达式中的第一个（）
— Awashi '16
@Awashi它是必要的，因为我需要一个捕获组的符号来区分S或U.
— edc65
@WashingtonGuedes不行，可以，(\+|-)但不保存任何字节
— edc65 '16
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
— 漏尼姑
source
3
请提供完整版本的代码。如果不能删除空格，则必须将其计入字节数。
— Mego
2
看起来无法将其删除，程序在符号之间没有空格的情况下无法正常运行。
— 马修·史密斯
似乎没有将“ + -1”（从示例中）归类为ST。
— Xantix '16
2

视网膜，98 97字节

确实是一种练习我的正则表达式技能的好方法。

在线尝试！

^(?![+-]?\d+(\.\d+)?$)..+
ST
^([+-]?)\d+$
$1UI
^([+-]?)\d+\.\d+$
$1UD
i`^[a-z]$
LE
^.$
SY
[+-]U
S
— 漏尼姑
source
4
您可以更改^[a-zA-Z]$为i`^[a-z]$保存一个字节
— daavko '16
1

Lua，157个字节

在线尝试！

打高尔夫球：

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")

取消高尔夫：

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
— 漏尼姑
source
1

的JavaScript（ES6），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)
— 尼尔
source
当然，可以将正则表达式与正则表达式eval(`/regex/`)构造函数+模板字符串一起使用
— Downgoat
0

Java，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");}
— 超级绝地224
source
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字节），此外，您可以更改String t(String v)为v->使用Java 8 lambda的时间。
— 凯文·克鲁伊森
0

Javascript（ES6），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')))

任何改善此问题的技巧都将受到欢迎。

— 伊斯梅尔·米格尔（Ismael Miguel）
source
1
1.应该是ST，不是UD。更改\d*为\d+
— edc65 '16
@ edc65怎么样？那是一个小数。与相同1.0。
— 伊斯梅尔·米格尔
它可能有效还是无效（我不写1.而不是1）但是，这不是您的选择，也不是我的：有测试用例
— edc65
@ edc65你是对的。我跳过了非常庞大的清单。我已经解决了。谢谢！
— 伊斯梅尔·米格尔
0

Python 3.5- 3.5-241240字节：

（由于@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'

它可能会有点长，但是可以很好地完成工作。这是提高我的正则表达能力的一种非常好的方法。感谢您的挑战。:)如果可以的话，我会尽量缩短它的时间。

— 卡普
source
您可以将import re移到该功能之外以节省空间。（无反引号的愚蠢iPad键盘）
— CalculatorFeline
@CatsAreFluffy是的，我没有想到。谢谢！:)
— R. Kap
@CatsAreFluffy：实际上，iOS键盘确实允许反引号！前几天，我需要使用iPhone编写降价记录时发现了这一点：）meta.stackexchange.com/questions/133673/…–
— homersimpson
@CatsAreFluffy不错！很高兴知道。
— R. Kap
也len(d)>0==d>[]
— CalculatorFeline
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]
— 合法堆栈
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.