구간 표기


21

도전:

입력:

두 개의 정수 매개 변수 ab( a<b차가 2 이상인 경우)

산출:

출력하거나 텍스트를 반환 a하고 b채워됩니다 :

(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+1b-1내 손님을하지만, 수 ..) 등
  • 임의의 양의 선행 및 / 또는 후행 개행이 허용되며 각 라인에 대한 임의의 양의 후행 및 / 또는 선행 공간이 허용됩니다.
  • 등호의 공백 (동일한 열에 정렬하는 공백 포함)은 필수이며 다른 문자 사이의 공백은 허용되지 않습니다.
  • a+1그리고 b-1이러한 계산 후에 정확한 값으로 대체한다.
  • 대신 사용할 수 없습니다 <=.
  • &대신 사용할 수 없습니다 &&.
  • .0(일관되고 하나 이상의 10 진수 0이 아닌 한) 숫자를 출력 할 수 있습니다.
  • ( 정확 하기 위해) a보다 최소 2 이상 이라고 가정 할 수 있습니다 .b(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, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
  • 기본 허점 은 금지되어 있습니다.
  • 가능하면 코드 테스트 링크를 추가하십시오.
  • 또한 필요한 경우 설명을 추가하십시오.

추신 : 한 사람들을 위해 샌드 박스에서이 문제를 볼 수 는 여전히 때 와 도전 ab하드 코딩, 나는 우리가 일반적으로 볼처럼 하드 코딩 및 인코딩 답변을 지루 방지하기 위해 입력 도전을 변경했습니다 KC 도전.


2
그래서 a=5, b=6여전히 출력 (5,6) = ... = 6...5?
l4m2

1
@ l4m2 아 .. 그것에 대해 생각하지 않았다. 당신은 가정 수 ab항상 떨어져 적어도이 될 것입니다. 도전을 편집하겠습니다.
Kevin Cruijssen

2
내가 기대했던 것보다 훨씬 재미있었습니다. 좋은 도전!
Arnauld

@DigitalTrauma 죄송하지만이 정확한 순서입니다.
Kevin Cruijssen

답변:


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

자바 스크립트 (ES6) 184 182 181 180 바이트

카레 구문으로 입력을 (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]))

온라인으로 사용해보십시오!

방법?

각 행에 대해 K1 ≤ K ≤ 4 , 우리는 다음과 같은 템플릿으로 시작하기 :

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

다음 표에 따라 i 위치의 각 10 진수 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)



3

자바 (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"," = ")

온라인으로 사용해보십시오!

크레딧


나는 아직도 골프를
치고있다

골프를 거의 끝냈습니까? 85 바이트를 제거하라는 제안이 있습니다. ;)
Kevin Cruijssen

@KevinCruijssen 나는 끝났지 만 85 바이트보다 훨씬 적게 제거했습니다 ...
Olivier Grégoire

1
세 개의 지루한 251 바이트.replace .
Kevin Cruijssen

예, 기본적으로 포맷 대신 replace를 사용하는 첫 번째 솔루션입니다. 좋은. 실제로 지루하지만 멋지다! :-)
Olivier Grégoire

3

펄 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

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 $

온라인으로 사용해보십시오 .


TIO에 m4를 너무 빨리 추가해 주셔서 감사합니다 @Dennis !


1
왜 m4가 대답하기에 유효한 프로그래밍 언어가 아닌지 알지 못하지만 무엇을 알고 있습니까? ;) -D논쟁은 완전히 괜찮습니다. 내 도전 설명에서 I / O는 완전히 유연하다고 말 했으므로 STDIN, 함수 매개 변수, 프로그램 명령 줄 인수, 컴파일러 플래그, 파일 읽기 또는 다른 입력 방법으로 입력 할 수 있습니다. 당신에게 달려 있습니다.
Kevin Cruijssen

2

파이썬 (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&&')두 저장 :)
Jonathan Allan

1

엑셀, 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. array는이 챌린지에 대해 형식 지정자를 두 번 이상 사용했기 때문에 삽입하는 것보다 크기가 훨씬 효율적입니다.



1

자바 스크립트, 273 258 232 바이트

저를 15 바이트 절약 해 주신 Kevin Cruijssen에게 감사드립니다!

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]})

온라인으로 사용해보십시오

내 아이디어에서 60 바이트를 절약하면서 그 아이디어를 주신 TFeld에 감사드립니다.

언 골프 :

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]
    }
)

자바 스크립트 (원래 답변), 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을 만드는 대신 직접 사용할 수 있습니다 . 온라인 258 바이트로 사용해보십시오 . 그리고 아마도 더 많은 골프를 치고있을 수 있습니다. 저는 JS에 너무 능숙하지 않습니다 ..let g=m=>{return{a:e,b:f,c:e+1,d:f-1}[m]}
Kevin Cruijssen

글쎄요, 당신은 나보다 더 능숙 해 보입니다. 팁 주셔서 감사합니다, 답변에 추가
임의의 사람

글쎄요, 저는 주로 Java (또는 공백)에서 골프를하는 사람이며,이 골프 팁은 Java 답변에도 적용 (m)->됩니다 m->. (e,f)->e->f->, 그리고 var g=new int[]{...}return g[m]return new int[]{...}[m]. ;) 또한, 나는 2 년이 조금 넘게이 SO에 대해 활발히 활동 해 왔으므로 JS 답변이 이전에도 이런 종류의 것들을 사용하는 것을 보았습니다.
Kevin Cruijssen

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을 빼서 원하는 결과를 얻습니다.

___<
_

0이 아닌 다른 엄격한 부등식에서 2를 빼고 원래 값을 복원하면 나중에 1을 뺍니다.

__<
-1

의 상위 부등식을 0로 변경하십시오 -1.

_(_*)
$.1

나머지 엄격한 부등식에서 1을 빼고 10 진수로 변환합니다.

-0
0

다른 엣지 케이스를 수정하십시오.


1

파이썬 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]}대체 도착 (j는 0 인 경우 또는 [J가 1이면.



0

파이썬 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])))

온라인으로 사용해보십시오!

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.