间隔符号


21

挑战:

输入:

两个整数参数ab(其中a<b和至少相差2)

输出:

输出或返回此文本,ab在其中填写:

(a,b) = ]a,b[ = {a<x<b}   = {a<x&&x<b}   = a+1..b-1
[a,b) = [a,b[ = {a<=x<b}  = {a<=x&&x<b}  = a..b-1
(a,b] = ]a,b] = {a<x<=b}  = {a<x&&x<=b}  = a+1..b
[a,b] = [a,b] = {a<=x<=b} = {a<=x&&x<=b} = a..b

挑战规则:

  • I / O是灵活的。可以打印到STDOUT,以字符串/字符数组等形式返回。可以以两个整数,十进制数和字符串形式输入(不知道为什么,因为您需要计算a+1and b-1,但是请成为我的客人。),等等。
  • 允许任何数量的前导和/或尾随新行,并且允许每行任何数量的尾随和/或前导空格。
  • 等号(包括在同一列中对齐的空格)是必需的,其他字符之间不允许有空格。
  • a+1b-1在这些计算之后,将其替换为正确的值。
  • 您不得使用代替<=
  • 您不得使用&代替&&
  • 您可以输出带有的数字.0(只要是一致的,并且不超过一个十进制的零)。
  • 您可以假设a比至少低2b(为了(a,b)正确)。
  • 线路应按所示顺序输出。

例:

输入:a=-5, b=10
输出:

(-5,10) = ]-5,10[ = {-5<x<10}   = {-5<x&&x<10}   = -4..9
[-5,10) = [-5,10[ = {-5<=x<10}  = {-5<=x&&x<10}  = -5..9
(-5,10] = ]-5,10] = {-5<x<=10}  = {-5<x&&x<=10}  = -4..10
[-5,10] = [-5,10] = {-5<=x<=10} = {-5<=x&&x<=10} = -5..10

一般规则:

  • 这是,因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
  • 标准规则适用于您的答案,因此您可以使用STDIN / STDOUT,具有正确参数的函数/方法和返回类型的完整程序。你的来电。
  • 默认漏洞是禁止的。
  • 如果可能的话,请添加一个带有测试代码的链接。
  • 另外,如有必要,请添加说明。

PS:对于那些在沙盒中仍遇到过挑战a并进行了b硬编码的人,我已将其更改为输入挑战,以防止像我们通常看到的那样使无聊的硬编码和编码答案无聊KC挑战。


2
那么a=5, b=6仍然输出(5,6) = ... = 6...5
l4m2 '18

1
@ l4m2啊..没想到。您可以假设ab至少相隔2。我将编辑挑战。
凯文·克鲁伊森

2
事实证明,这比我预期的要有趣得多。好挑战!
Arnauld

@DigitalTrauma对不起,但是这个确切的顺序。
凯文·克鲁伊森

Answers:


2

Stax,74 个字节

ÉyU≤₧pΔz▀σ┬`♪•a≤☻Σ╕←k►¬╗Ö)ßâL╫§▐ƒ┼°╚íS3:Y¶7]7♂e╖à╙ô≥;M0h8♦Oún┼ë`←B╠╫║┌♂α▲╚

运行并调试

这会大量使用stax的字符串模板。拆开包装,松开包装并进行评论,看起来像这样。

Y                   save second input in Y register (first is already in X)
.)].([|*            cross product of ")]" and "(["; this produces [")(", ")[", "](", "]["]
{                   begin block to map over interval delimiters
  E"`x,`y"a++       push delimiters separately, then wrap them around the inputs    e.g. "(-5,10)"
  c"(])["|t         copy last value, then replace parentheses with braces           e.g. "]-5,10["
  ih'=              push half the iteration index and "="                           e.g. 0 "="
  |;'=              push iteration parity (alternating 0 and 1) and "="             e.g. 0 "=" 0 "="
  "{`x<`*x<`*`y}"   multiply each equal sign by its occurrence, and template        e.g. "{-5<x<10}"
  c'x.x&:mR         copy last value, then replace "x" with "x&&x"                   e.g. "{-5<x&&x<10}"
  yvih xi|e         calculate final bounds offsets                                  e.g. -5 1 10 -1
  "`+..`+"          add inputs to offsets, and embed in template                    e.g. "-4..9"
  5l                combine last 5 values into array
m                   map [")(", ")[", "](", "]["] using block
:<                  left-align grid colums to add extra spaces
m" = "*             for each row, join with " = " and output

运行这个


10

的JavaScript(ES6),184个 182 181 180字节

以currying语法接受输入(a)(b)。返回由4个字符串组成的数组。

a=>b=>[1,2,3,4].map(k=>'31,23 = 31,23 = {10x72}4{10x&&x72}45..6'.replace(/\d/g,(n,i)=>[(+n?k<3:k&1)?'<':'<=',a,b,'][)([[]('[(i*17^k*718)%9],'   = '.slice(k/2),a+k%2,b-(k<3)][n%7]))

在线尝试!

怎么样?

对于每一行ķ1≤ķ≤4 ,我们先从下面的模板:

"31,23 = 31,23 = {10x72}4{10x&&x72}45..6"

并根据下表替换位置i处的每个十进制数字n

  n  | Replaced with           | Code
-----+-------------------------+------------------------------------------
 0,7 | comparison operator     | (+n ? k < 3 : k & 1) ? '<' : '<='
  1  | a                       | a
  2  | b                       | b
  3  | interval bound          | '][)([[]('[(i * 17 ^ k * 718) % 9]
  4  | a substring of '   = '  | '   = '.slice(k / 2)
  5  | either 'a' or 'a + 1'   | a + k % 2
  6  | either 'b' or 'b - 1'   | b - (k < 3)

4

Python 2中225个 203 195字节

a,b=input()
for d in 0,1:
 for m in 0,1:k=`a`+','+`b`;o='{'+`a`+'<'+m*'=';c='x<'+d*'='+`b`+'}'+'  '[m+d:];print' = '.join(['(['[m]+k+')]'[d],']['[m]+k+'[]'[d],o+c,o+'x&&'+c,`a+1-m`+'..'+`b-1+d`])

在线尝试!


3

Python 2,187字节

t=a,b=input()
for j in 1,0:
 for i in 1,0:print"%%s%d,%d%%s = "%t*2%('[('[i],'])'[j],'[]'[i],']['[j])+"{%d<%sx%%s<%s%d}%s = "%(a,'='[i:],'='[j:],b,' '*(i+j))*2%('','&&x')+`a+i`+'..'+`b-j`

在线尝试!


3

Java(JDK 10),251字节

a->b->("(a,b)q]a,b[q{a<x<b}  q{a<x&&x<b}  q"+-~a+".."+~-b+"\n[a,b)q[a,b[q{a<=x<b} q{a<=x&&x<b} qa.."+~-b+"\n(a,b]q]a,b]q{a<x<=b} q{a<x&&x<=b} q"+-~a+"..b\n[a,b]q[a,b]q{a<=x<=b}q{a<=x&&x<=b}qa..b").replace("a",a+"").replace("b",b+"").replace("q"," = ")

在线尝试!

学分


我仍在打高尔夫球...
OlivierGrégoire'18

打高尔夫球几乎完成了吗?我建议删除85个字节。;)
Kevin Cruijssen

@KevinCruijssen我已经完成了,但是我删除的字节数远远少于85个字节……
OlivierGrégoire18年

1
251个字节,三个无聊.replace
凯文·克鲁伊森

是的,基本上我的第一个解决方案确实是使用replace而不是格式化。真好 确实很无聊,但是很好!:-)
OlivierGrégoire'18

3

Perl 5,181个字节

我以为这会缩短很多时间...

$_="sd,ds = sd,ds = {dsxsd}s= {dsx&&xsd}s= d..d
"x4;s!s!("()][<<   [)[[<=<  (]]]<<=  [][]<=<= "=~s/[<= ]+/$&$&/gr=~/ +|<=|./g)[$-++]!ge;s/d/$F[$x%2]+{8,1,9,-1,19,-1,28,1}->{$x++}/ge

在线尝试!

说明

最初,这是使用printf格式字符串,但sd组合使用时,具有和较短s///

首先,将格式字符串内置$_并进行四倍处理,然后根据替换索引,将所有ss替换为相应的方括号<<=或空格。我希望通过复制每个块的最后5个字符来节省更多的字节,但是最终只节省了2个字节。生成的字符串分为空格元素<=或单个字符。

最后,将所有ds替换为所需的数字,并通过一个哈希键根据当前替换的索引进行调整。


3

JavaScript中,190个 189字节

x=>y=>`(0)7]0[7{1<x<2}  7{1<52}  73..4
[0)7[0[7{18x<26{185261..4
(0]7]0]7{1<x826{1<5=263..2
[0]7[0]7{18x82}7{185=2}71..2`.replace(/\d/g,d=>[[x,y],x,y,x+1,y-1,`x&&x<`,`}  = `,` = `,`<=`][d])

在线尝试


3

M4,194

似乎是宏处理器的工作。不确定m4是否符合我们的编程语言标准。它确实具有循环能力和算术评估功能,因此我认为它接近标记。

define(l,`$1a,b$2 = $3a,b$4 = {a<$5x<$6b} $8= {a<$5x&&x<$6b} $8= $7')dnl
l(`(',`)',],[,,,incr(a)..decr(b),`  ')
l([,`)',[,[,=,,a..decr(b),` ')
l(`(',],],],,=,incr(a)..b,` ')
l([,],[,],=,=,a..b,)

这是我对M4的第一个非凡的了解,因此我怀疑我错过了更多的高尔夫机会。

-D在命令行使用宏定义传递输入。据我所知,不确定是否需要为这些分数添加任何内容,这是有意义地传递参数的唯一方法:

$ m4 -Da=-5 -Db=10 intnot.m4
(-5,10) = ]-5,10[ = {-5<x<10}   = {-5<x&&x<10}   = -4..9
[-5,10) = [-5,10[ = {-5<=x<10}  = {-5<=x&&x<10}  = -5..9
(-5,10] = ]-5,10] = {-5<x<=10}  = {-5<x&&x<=10}  = -4..10
[-5,10] = [-5,10] = {-5<=x<=10} = {-5<=x&&x<=10} = -5..10 $

在线尝试


感谢@Dennis 如此快地 M4 添加到TIO


1
我不明白为什么m4不是有效的编程语言来回答,但是我知道什么。;)至于-D论点,那是完全可以的。在我的挑战说明中,我说过I / O是完全灵活的,因此无论您将输入作为STDIN,函数参数,程序命令行参数,编译器标志,读取文件还是您能想到的任何其他输入方法,都是完全可以的由你决定。
凯文·克鲁伊森

2

Python 2中277个 199 193 189字节

a,b=input()
for i in 4,3,2,1:x,y=i%2,i>2;e='=';p=`a`+','+`b`;print'(['[x]+p+'])'[y],e,']['[x]+p+']['[y],e,2*('{%d<%s<%s%d} %s= '%(a,e*x+'%sx',e[y:],b,i/2*' '))%('','x&&')+`a+1-x`+'..'+`b-y`

在线尝试!


2*('{%d<%s<%s%d} %s= '%(a,e*x+'%sx',e[y:],b,i/2*' '))%('','x&&')-> 2*('{%d<%s%%sx<%s%d} %s= '%(a,e*x,e[y:],b,i/2*' '))%('','x&&')保存两个:)
乔纳森·艾伦

1

Excel,399个字节

="("&A1&","&B1&") = ]"&A1&","&B1&"[ = {"&A1&"<x<"&B1&"}   = {"&A1&"<x&&x<"&B1&"}   = "&A1+1&".."&B1-1&"
 ["&A1&","&B1&") = ["&A1&","&B1&"[ = {"&A1&"<=x<"&B1&"}  = {"&A1&"<=x&&x<"&B1&"}  = "&A1&".."&B1-1&"
 ("&A1&","&B1&"] = ]"&A1&","&B1&"] = {"&A1&"<x<="&B1&"}  = {"&A1&"<x&&x<="&B1&"}  = "&A1+1&".."&B1&"
 ["&A1&","&B1&"] = ["&A1&","&B1&"] = {"&A1&"<=x<="&B1&"} = {"&A1&"<=x&&x<="&B1&"} = "&A1&".."&B1

这里没有什么特别有趣的。


1

C(gcc)224237字节

f(a,b,c,m,n,o){for(c=0;++c<5;printf("%c%d,%d%c = %c%d,%d%c = {%d<%sx<%s%d}%*s= {%d<%sx&&x<%s%d}%*s= %d..%d\n","[("[m],a,b,"])"[n],"[]"[m],a,b,"]["[n],a,"="+m,"="+n,b,o,"",a,"="+m,"="+n,b,o,"",a+m,b-n)){m=c%2;n=c<3;o=3-c/2;}}

在线尝试!

将“ <[=]”移动到格式字符串中后,我就可以完全删除该数组。另外,printf()进入for循环可节省分号。

原始答案

f(a,b,c,m,n,o){char*e[]={"<=","<"};for(c=0;++c<5;){m=c%2;n=c<3;o=3-c/2;printf("%c%d,%d%c = %c%d,%d%c = {%d%sx%s%d}%*s= {%d%sx&&x%s%d}%*s= %d..%d\n","[("[m],a,b,"])"[n],"[]"[m],a,b,"]["[n],a,e[m],e[n],b,o,"",a,e[m],e[n],b,o,"",a+m,b-n);}}

在线尝试!

这里没有什么特别值得注意的地方:我使用了通常的技巧来削减函数的大小(将自动提升int到函数头中,使用K&R样式,索引到字符串常量。)将{“ <=”,“ <”}存储到一个事实证明,数组比插入格式说明符更具挑战性,因为它已被多次使用。



1

的Javascript,273个 258 232字节

感谢Kevin Cruijssen为我节省了15个字节!

e=>f=>'(j)h]j[h{a<x<b}  h{a<x&&x<b}  hc..d\n[j)h[j[h{a<=x<b} h{a<=x&&x<b} ha..d\n(j]h]j]h{a<x<=b} h{a<x&&x<=b} hc..b\n[j]h[j]h{a<=x<=b}h{a<=x&&x<=b}ha..b'.replace(/a|b|c|d|h|j/g,m=>{return{a:e,b:f,c:e+1,d:f-1,h:" = ",j:e+","+f}[m]})

在线尝试

感谢TFeld给我这个想法,从我的原始答案中节省了大约60个字节。

松散

e => f => '(j)h]j[h{a<x<b}  h{a<x&&x<b}  hc..d'
 + '\n[j)h[j[h{a<=x<b} h{a<=x&&x<b} ha..d'
 + '\n(j]h]j]h{a<x<=b} h{a<x&&x<=b} hc..b'
 + '\n[j]h[j]h{a<=x<=b}h{a<=x&&x<=b}ha..b'
.replace(/a|b|c|d|h|j/g, m=>{
        return {a:e,b:f,c:e+1,d:f-1,h:" = ",j:e+","+f}[m]
    }
)

Javascript(原始答案),340字节

(a,b)=>alert(`(${a},${b}) = ]${a},${b}[ = {${a}<x<${b}}   = {${a}<x&&x<${b}}   = ${a+1}..${b-1}\n[${a},${b}) = [${a},${b}[ = {${a}<=x<${b}}  = {${a}<=x&&x<${b}}  = ${a}..${b-1}\n(${a},${b}] = ]${a},${b}] = {${a}<x<=${b}}  = {${a}<x&&x<=${b}}  = ${a+1}..${b}\n[${a},${b}] = [${a},${b}] = {${a}<=x<=${b}} = {${a}<=x&&x<=${b}} = ${a}..${b}\n`)

1
的新行 {a<=x&&\nx<=b}不应该出现,而您错过了第一个(a,b) = 。至于打高尔夫球:您可以返回结果而不是发出警报。(m)=>可以m=>(e,f)=>可以e=>f=>。你可以使用g直接而不是创建let g=m=>{return{a:e,b:f,c:e+1,d:f-1}[m]}在线尝试258字节甚至更多,可以golfed,我不是太熟练JS ..
凯文Cruijssen

好吧,你看起来比我更熟练。感谢您的提示,我将它们添加到答案中
随机家伙

嗯,我主要是人谁在Java(或空格)打高尔夫球,而这些高尔夫球的技巧同样适用于Java的答案,这主要是为什么我也认识他们:(m)->m->; (e,f)->e->f->var g=new int[]{...}return g[m]return new int[]{...}[m]。;)另外,我已经在这种SO上工作了两年多了,所以我以前也看到JS答案也使用了这类东西。
凯文·克鲁伊森

1

视网膜,216字节

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$4$1$5 = $6$1$7 = {$2$8x$9$3}$10 = {$2$8x&&x$9$3}$10 = $2_$8..$3_$9
_<=

\d+_
$&*___
T`<`_` _+<|\.-_+<
___<
_
__<
-1
_(_*)
$.1
-0
0

在线尝试!说明:

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$4$1$5 = $6$1$7 = {$2$8x$9$3}$10 = {$2$8x&&x$9$3}$10 = $2_$8..$3_$9

建立结果的主要部分。

_<=

如果变量涉及宽松的不等式,则该值包含在内,因此我们可以删除占位符。

\d+_
$&*___

将值转换为一元并加2。

T`<`_` _+<|\.-_+<

删除占位符,以获取严格的下等式或否定的严格上等式。它仍然添加了2个,但是稍后将减去1个,从而得到所需的结果。

___<
_

从其他非零严格不等式中减去2,恢复原始值,之后再从中减去1。

__<
-1

将的严格上限不等式更改0-1

_(_*)
$.1

从剩余的严格不等式中减去1并转换为十进制。

-0
0

修复另一个边缘情况。


1

Python 3,180个字节:

lambda a,b:[eval('f"'+"{%r[j]}{a},{b}{%r[i]} = "*2%('([',')]','][','[]')+"{{{a}<{'='[:j]}x%s<{'='[:i]}{b}}}{'  '[i+j:]} = "*2%('','&&x')+'{a+j}..{b-i}"')for i in(1,0)for j in(1,0)]

说明

基本上构建一个f字符串,该字符串在列表理解中进行评估。老款式%字符串插值用于延迟对表达式的求值,直到对f字符串求值为止。

lambda a,b:[
    eval(
      'f"' +                                                            # f-string prefix
      "{%r[j]}{a},{b}{%r[i]} = "*2%('([',')]','][','[]') +              # first two terms
      "{{{a}<{'='[:j]}x%s<{'='[:i]}{b}}}{'  '[i+j:]} = "*2%('','&&x') + # second two terms
      '{a+j}..{b-i}"'                                                   # last term
      )
    for i in(1,0)for j in(1,0)
    ]

字符串的第一部分“ f”将成为f字符串的前缀。

字符串的第二部分为前两个间隔表达式构建格式字符串。 %r用于保存不需要使用以下格式的引号,即"{%r[j]}""{'%s'[j]}"。计算f字符串时,选择正确的括号。

字符串的第三部分将构建以下两个间隔表达式。

最后一部分格式化f字符串的“ a..b”部分。

组装好的f弦如下所示: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

评估f字符串时,大括号{}中的所有表达式都将替换为其值。因此, {a}将替换为的值a,如果j为0或j为1 {'(['[j]}(则替换[为。



0

Python 3,248个字节

def f(a,b):
 l=[['(',')','[','<',1],['[',']',']','<=',0]]
 r=[0,1]
 for i in r:
  for j in r:
   print(('%s%d,%d%s='*2+'{%d%sx%s%d}={%d%sx&&x%s%d}=%d..%d')%((l[j][0],a,b,l[i][1],l[1-j][2],a,b,l[i][2])+(a,l[j][3],l[i][3],b)*2+(a+l[j][4],b-l[i][4])))

在线尝试!

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.