현재 직장에서 우리는 새로운 건물로 이사했습니다. 그것은 최첨단 기술이어야하며 자동 조명, 자동 롤 다운 셔터가 있으며 현재이 도시에서 가장 친환경적인 건물로 알려져 있습니다.
롤 다운 셔터는 때때로 흐린 날이나 해가지기 시작하면 올라가고, 조명은 때때로 5-10 번마다 번갈아 켜고 끌 때 디스코 효과를 일으 킵니다. 의사록. 또한 이러한 롤 다운 셔터를 제어하는 ​​수동 방법이나 온도는 없지만 조명에 대한 리모콘이 있습니다.
그러나이 리모컨에는 사용 설명서가 포함되어 있지 않으며 원하는 것 이외의 모든 작업을 수행하는 20 개가 넘는 버튼이 있습니다.

추신 : 1.5 개월 전에 샌드 박스 에이 도전을 썼습니다. 현재 우리는 리모콘의 작동 방식을 알고 있습니다.
이 건물의 가장 큰 장점 중 하나는 섭씨 30도 이상이지만 내부는 항상 같은 21 실 온도를 유지합니다.

이것이 바로 소개였으며 조명용 리모콘이이 과제에 영감을주었습니다.

도전:

처음에 램프가 꺼져 있다고 가정 해 봅시다.

L

그런 다음 모든 종류의 버튼을 누르고 램프 상태를 출력합니다.

램프 리모콘의 다양한 기능에 다음 번호를 사용합니다. 빼기 기호가 그 숫자 앞에 있으면 반대의 행동을합니다.

• 1= ON; -1= 꺼짐.
• 2= 힘을 25 % 증가시킵니다. -2= (딤) 강도를 25 % 줄입니다.
• 3= 스프레드 50 % 증가; -3= 스프레드를 50 % 줄입니다.
• 4 = 빛의 유형을 전환합니다.

따라서 이것은 모두 모호한 것이므로 각각의 의미에 대해 좀 더 깊이 살펴 보겠습니다.

따라서 -1(OFF)는 매우 명백 1하며 초기 ON- 상태 (50 % 2및 50 % 3)로 이동합니다.

   //
  //
L ====
  \\
   \\

2그리고 -2빛이 얼마나 멀리 이동하는지 ( ==25 %마다 추가됩니다) :

0% (equal to a light bulb that is OFF)
L

25%
L ==

50%
L ====

75%
L ======

100%
L ========

3그리고 -3빛이 퍼지는 정도입니다.

0%:
L ====

50%:
   //
  //
L ====
  \\
   \\

100%:
|| //
||//
L ====
||\\
|| \\

(참고 : 언제 2그리고 3이 상태를해야합니다, 100 % 모두 :

||   //
||  //
|| //
||//
L ========
||\\
|| \\
||  \\
||   \\

4 빛의 유형을 토글하는 것입니다.

Default:
  //
L ==
  \\

After toggling (note the single space before '/' instead of two):
 /
L --
 \

입력:

가능한 버튼 누름이 포함 된 입력이 수신됩니다. 예를 들면 다음과 같습니다.

12-34

산출:

입력의 모든 버튼이 순차적으로 눌린 후 조명 램프의 상태입니다. 위의 예제 입력으로 다음과 같은 출력이 있습니다.

L ------

도전 규칙 :

• 입력은 포함하고 1234-( -앞에는 포함 하지 않음 4).
• 0 % 이하 또는 100 % 이상으로 갈 수 없습니다. 숫자가이 경계를 넘어 증가 / 감소하면 무시할 수 있습니다.
• 램프가 꺼지면 모든 작업을 무시할 수 있으며 다시 켜면 초기 ON 상태 ( 2및 50 % 3및 기본값 모두 50 %)로 다시 설정됩니다 4. 예를 들어 : 12-1-341위에서 언급 한 초기 ON 상태 만 인쇄합니다. (팁 : 1입력 의 마지막 부분을 ​​제외한 모든 항목은 무시해도 -1됩니다.)
• 빛의 길이와 같은 후행 공백이나 단일 후행 줄 바꿈은 제한되지 않습니다. 그러나 불필요한 새로운 줄을 추가하는 것은 아닙니다.
• 입력을 단일 문자열 대신 정수 목록으로 사용할 수 있습니다. 따라서 대신 입력으로 12-34사용할 수 있습니다 [1,2,-3,4].

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수가있는 기능 / 방법, 전체 프로그램을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

12-34
L ------

12-1-341
   //
  //
L ====
  \\
   \\

14-3224333-2
||  //
|| //
||//
L ======
||\\
|| \\
||  \\

142-1-314-3-322
L --------

1324-2-3
  /
 /
L ----
 \
  \

134
| /
|/
L ----
|\
| \

1-2-2-214-3-3-3
L ----

파이썬 2, 221 바이트

for b in[-1]+input():exec["p=b>0;d=2;s=1;t=2","d+=b/2*(-2<d+b<6)","s+=b/3*(-3<s+b<5)","t=3-t"][abs(b)-1]
i=c=(s>0)*d*p
q='print" |"[s/2]*t+" "*i+t*%r;'
exec('i-=1;'+q%'/')*c
print"L "+" -="[t]*2*d*p
exec(q%'\\'+'i+=1;')*c

이 상처는 내가 예상했던 것보다 길다. 첫 번째 줄은 램프의 상태를 계산하고 나머지는 인쇄를 구현합니다.

입력은 STDIN을 통해 배열 형태로 제공됩니다.

이데온 의 테스트 사례보기

R, 323320 바이트

    z=scan();a=c=1;b=d=2;for(i in 1:sum(1|z)){s=sign(y<-z[i]);switch(y/s,b<-d<-2*(c<-a<-y),b<-b+s,c<-c+s,d<-2-d);b=min(b,4);c=min(c,2);b=b*(b>0);c=c*(c>0)}
    s="/";v=if(c>1)"|"else" ";for(i in a*b:-b){if(i)cat(v,if(d)v,rep(" ",abs(i)-1),s,if(d)s,"\n",sep="")else{cat("L ",if(d)rep("==",b)else rep("--",b),"\n",sep="");s="\\"}}

언 골프 드 :

z=scan()

입력 줄을 읽습니다 (공백으로 구분 된 정수)

a=c=1;b=d=2

변수 a (on-ness), b (brightness), c (width), d (beam type)를 초기화합니다. d는 0 또는 2입니다. 이는 더 긴 if (d> 1) 또는 이와 유사한 것이 아니라 나중에 if (d)를 호출하여 몇 바이트를 저장할 수 있음을 의미합니다.

while(any(z|1))

기입 골프-Y 방향 while(length(z)), Z는 정수 벡터이다.

첫 번째 줄의 나머지 부분은 switch명령문을 통해 입력을 처리합니다 . 두 번째 줄이 인쇄됩니다.

의 일부가 <-로 대체 될 수는 =있지만 어휘 범위 지정으로 살아있는 것으로 생각됩니다 ...

또한 R에서는 백 슬래시를 이스케이프해야합니다.

c*(c>0)골프를 쓰는 글쓰기 방식으로 max(c,0)캐릭터를 보호합니다.

표시등이 켜지지 않는 경우, 그 이후로는 *보다 낮은 우선 순위가 :1, for(i in a*b:-b)루프는 반복 처리를 0:0.

최신 정보; 첫 번째 줄의 루프를 for 대신에 대신하여 3 바이트를 절약했습니다. 주 1:sum(1|z)보다 적은 문자입니다 1:length(z)또는 seq_along(z). seq(z)대부분의 경우 작동하지만 z길이가 1 인 경우에는 작동하지 않습니다 . 주어진 해결책은 길이가 0 인 입력에는 작동하지 않지만 경쟁 범위를 벗어나길 바랍니다.

코 틀린 , 445 바이트

Java보다 38 바이트 적은 첫 번째 Kotlin 골프

fun f(z:IntArray)={var a=1<0;var b=2;var c=1;var d=a
z.map{when(it){1->{a=1>0;b=2;c=1;d=!a}-1->a=1<0;2->if(b<4)b+=1;-2->if(b>0)b-=1;3->if(c<2)c+=1;-3->if(c>0)c-=1;4->d=!d}}
var r="";val l=if(c>1)if(d)"|" else "||" else if(d)" " else "  "
if(c>0)for(i in b downTo 1)r+="${l+" ".repeat(i-1)+if(d)"/" else "//"}\n"
r+="L ${(if(d)"--" else "==").repeat(b)}\n"
if(c>0)for(i in 1..b)r+=l+" ".repeat(i-1)+"${if(d)"\\" else "\\\\"}\n"
if(a)r else "L"}()

공백과 테스트 :

fun f(z: IntArray) = {
    var a = false // ON / OFF
    var b = 2 // Strength [0,4]
    var c = 1 // Spread [0,2]
    var d = a // Type

    // Find state to print
    z.map {
        when (it) {
            1 -> {
                a = true
                b = 2
                c = 1
                d = !a
            }
            -1 -> a = false
            2 -> if (b < 4) b += 1
            -2 -> if (b > 0) b -= 1
            3 -> if (c < 2) c += 1
            -3 -> if (c > 0) c -= 1
            4 -> d = !d
        }
    }

    var r = ""
    val l = if (c > 1) if (d) "|" else "||"
    else if (d) " " else "  "

    // Print state
    if (c > 0) for (i in b downTo 1) {
        r += "${l + " ".repeat(i - 1) + if (d) "/" else "//"}\n"
    }
    r += "L ${(if (d) "--" else "==").repeat(b)}\n"
    if (c > 0) for (i in 1..b) {
        r += "${l + " ".repeat(i - 1) + if (d) "\\" else "\\\\"}\n"
    }

    /* return */ if (a) r else "L"
}()

fun main(args: Array<String>) {
    println(f(intArrayOf(1, 2, -3, 4)))
    println(f(intArrayOf(1, 2, -1, -3, 4, 1)))
    println(f(intArrayOf(1, 4, -3, 2, 2, 4, 3, 3, 3, -2)))
    println(f(intArrayOf(1, 4, 2, -1, -3, 1, 4, -3, -3, 2, 2)))
    println(f(intArrayOf(1, 3, 2, 4, -2, -3)))
    println(f(intArrayOf(1, 3, 4)))
    println(f(intArrayOf(1, -2, -2, -2, 1, 4, -3, -3, -3)))
}

흥미롭게도, 함수를 정상적으로 정의 print하거나 return문자열을 생성하는 대신 함수 할당 ( fun f() =평가 된 람다) 을 사용하는 것이 더 짧았습니다 .

^{_{나는 SE가 적절한 Kotlin 구문 강조를 원했으면 좋겠다.}}

자바 8, 484 483 452 446 440 바이트

z->{int a=1,b=2,c=1,d=0,j,k;for(int i:z){d=i==1?0:i>3?1-d:d;a=i*i==1?i:a;b+=i==1?2-b:i==2&b<4?1:i==-2&b>0?-1:0;c+=i==1?1-c:i==3&c<2?1:i==-3&c>0?-1:0;}String t=d<1?"=":"-",q=d<1?"//":"/",x=d<1?"\\\\":"\\",n="\n",y=" ",w=d<1?y+y:y,g=c>1?d<1?"||":"|":w,r="";if(c>0)for(r+=g,j=b;j-->0;r+=q+n+(j>0?c>1?g:w:""))for(k=j;k-->0;r+=y);for(r+="L ",j=b;j-->0;r+=t+t);r+=n;if(c>0)for(r+=g;++j<b;r+=x+n+(j<b-1?g:""))for(k=j;k-->0;r+=y);return a>0?r:"L";}

마지막으로 .. 좋아, 내 자신의 도전은 예상보다 조금 어렵다 ..; P

이것은 완전히 다른 접근법을 사용하여 의심의 여지없이 골퍼 될 수 있습니다. 이제 먼저해야 할 일을 결정한 다음 인쇄합니다. 인쇄는 실제로이 문제 중 가장 어려운 일입니다 (imho).

@ceilingcat 덕분에 -6 바이트 .

설명:

여기에서 시도하십시오.

z->{                          // Method with integer-array parameter and String return-type
  int a=1,                    //  ON/OFF flag, initially ON
      b=2,                    //  Strength, initially 50%
      c=1,                    //  Spread, initially 50%
      d=0,                    //  Type of light, initially two lines
      j,k;                    //  Index-integers
  for(int i:z){               //  Loop over the input-array
    d=i==1?0:i>3?1-d:d;       //   Determine the new type of light
    a=i*i==1?i:a;             //   Determine if the light is ON/OFF
    b+=i==1?2-b:i==2&b<4?1:i==-2&b>0?-1:0;
                              //   Determine the new strength
    c+=i==1?1-c:i==3&c<2?1:i==-3&c>0?-1:0;}
                              //   Determine the new spread
  String t=d<1?"=":"-",       //  Horizontal light symbol
         q=d<1?"//":"/",      //  Upper diagonal light symbol
         x=d<1?"\\\\":"\\",   //  Bottom diagonal light symbol
         n="\n",              //  New-line
         y=" ",               //  Space
         w=d<1?y+y:y,         //  One or two spaces?
         g=c>1?d<1?"||":"|":w,//  Space(s) or vertical light symbol(s)?
         r="";                //  Result String, starting empty
  if(c>0)                     //  Do we have spread >0%?
    for(r+=g,j=b;j-->0;r+=q+n+(j>0?c>1?g:w:""))for(k=j;k-->0;r+=y);
                              //   Create upper light part
  r+="L ";                    //  Light-bulb
  for(j=b;j-->0;r+=t+t);      //  Horizontal light next to the light-bulb
  r+=n;
  if(c>0)                     //  Do we have spread >0%?
    for(r+=g;++j<b;r+=x+n+(j<b-1?g:""))for(k=j;k-->0;r+=y);
                              //   Create bottom light part
  return a>0?                 //  Is the light turned ON?
             r                //   Return the created result-String
            :                 //  Else:
             "L";}            //   Return just "L"

배치, 552 바이트

@echo off
for %%a in (1 %*) do call:l %%a
set/aw*=o,l*=o
if %w% gtr 0 for /l %%a in (%l%,-1,1)do call:w %%a /
set s=----
if %t%==1 set s=====
call echo L %%s:~-%l%%%%%s:~-%l%%%
if %w% gtr 0 for /l %%a in (1,1,%l%)do call:w %%a \
exit/b
:w
set v= 
set u=%2
if %w%==2 set v=l
if %t%==1 set u=%2%2&set v=%v%%v%
set s=    
call set s=%%s:~-%1%%
echo %v:l=^|%%s:~1%%u%
exit/b
:l
if %1==1 set/ao=w=t=1,l=2
if %1==-1 set/ao=0
if %1==2 set/al+=1-l/4
if %1==-2 set/al-=!!l
if %1==3 set/aw+=1-w/2
if %1==-3 set/aw-=!!w
if %1==4 set/at^=1

참고 : set v=하나의 후행 공백과 set s=3 개의 공백이 있습니다. |Batch에서 가변 개수의 s를 쉽게 인쇄 할 수 없으므로 자리 표시자를 사용하고 echo 문에서 대체해야하기 때문에 이것은 정말 어색 했습니다.

05AB1E , 106 바이트

“/|= 
L“•Wθ¨S9ƒTª»þúÙ•6вèJ¶¡sŽ8ÃS«1¡θΣÄ}.γÄ}ODd*©н8‚ß8αF樚NÈi¨]R®θ8Öi"||//="2ô…|/-S:}®Ås3/©_iθ}®i'|ð:}».∊

정수 목록으로 입력하십시오.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

“/|= 
L“               # Push string "/|=\nL"
  •Wθ¨S9ƒTª»þúÙ• # Push compressed integer 9569494169631511496055972036
   6в            # Converted to Base-6 as list: [5,3,2,2,2,2,2,2,2,2,4,1,1,0,0,4,1,1,3,0,0,4,1,1,3,3,0,0,4,1,1,3,3,3,0,0]
     è           # Index each into the string
      J          # Join everything together

이제 문자열이 있습니다 :

L ========
||//
|| //
||  //
||   //

그럼 우리는 :

¶¡               # Split it by newlines: ["L ========","||//","|| //","||  //","||   //"]
s                # Swap to take the (implicit) input-list
 Ž8Ã             # Push compressed integer 2234
    S            # Converted to a list of digits: [2,2,3,4]
     «           # Append it at the end of the input-list
                 #  i.e. [4,3,3,2,1,3,2,4,-2,-3] → [4,3,3,2,1,3,2,4,-2,-3,2,2,3,4]
 1¡              # Then split on 1
                 #  i.e. [4,3,3,2,1,3,2,4,-2,-3,2,2,3,4]
                 #   → [[4,3,3,2],[3,2,4,-2,-3,2,2,3,4]]
   θ             # Only leave the last inner list
                 #  i.e. [[4,3,3,2],[3,2,4,-2,-3,2,2,3,4]] → [3,2,4,-2,-3,2,2,3,4]
    ΣÄ}          # Sort on the absolute value
                 #  i.e. [3,2,4,-2,-3,2,2,3,4] → [2,-2,2,2,3,-3,3,4,4]
       .γÄ}      # Then group by absolute value
                 #  i.e. [2,-2,2,2,3,-3,3,4,4] → [[2,-2,2,2],[3,-3,3],[4,4]]
           O     # Then take the sum of each group
                 #  i.e. [[2,-2,2,2],[3,-3,3],[4,4]] → [4,3,8]
            Dd   # Duplicate it, and check for each if it's non-negative (>= 0)
                 #  i.e. [4,3,8] → [1,1,1]
              *  # Multiply the two lists
                 #  i.e. [4,3,8] and [1,1,1] → [4,3,8]
               © # And store the result in the register (without popping)
н                # Now take the first value (the strength)
                 #  i.e. [4,3,8] → 4
 8‚              # Pair it with 8
                 #  i.e. 4 → [4,8]
   ß             # Pop and push the minimum of the two
                 #  i.e. [4,8] → 4
    8α           # And then calculate the absolute difference with 8
                 #  i.e. 4 → 4
      F          # Loop that many times:
       ć         #  Extract the head of the string-list
                 #   i.e. ["L ========","||//","|| //","||  //","||   //"] → "L ========"
        ¨        #  Remove the last character
                 #   i.e. "L ========" → "L ======="
         š       #  And prepend it back to the list again
                 #   i.e. ["||//","|| //","||  //","||   //"] and "L ======="
                 #    → ["L =======","||//","|| //","||  //","||   //"]
       NÈi       #  And if the loop-index is even:
          ¨      #   Also remove the last item of the string-list
                 #    i.e. ["L =======","||//","|| //","||  //","||   //"]
                 #     → ["L =======","||//","|| //","||  //"]
      ]          # Close both the if and loop
                 #  i.e. ["L ========","||//","|| //","||  //","||   //"] and 4
                 #   → ["L ====","||//","|| //"]
       R         # Then reverse the list
                 #  i.e. ["L ====","||//","|| //"] → ["|| //","||//","L ===="]
®                # Push the list from the register again
 θ               # Now take the last value (the toggle)
                 #  i.e. [4,3,8] → 8
  8Öi         }  # If it's divisible by 8:
                 #  i.e. 8 → 1 (truthy)
     "||//="     # Push string "||//="
            2ô   # Split into parts of size 2: ["||","//","="]
     …|/-        # Push string "|/-"
         S       # Split into characters: ["|","/","-"]
     :           # And replace all of them in the string-list
                 #  i.e. ["|| //","||//","L ===="] → ["| /","|/","L ----"]
®                # Push the list from the register again
 Ås              # Now take the middle value (the spread)
                 #  i.e. [4,3,8] → 3
   3/            # Divide it by 3
                 #  i.e. 3 → 1
     ©           # Store it in the register (without popping)
      _i }       # If it's exactly 0:
                 #   i.e. 1 → 0 (falsey)
        θ        #  Only leave the last value of the string-list
     ®i    }     # If it's exactly 1 instead:
                 #   i.e. 1 → 1 (truthy)
       '|ð:     '#  Replace all "|" with spaces " "
                 #   i.e. ["| /","|/","L ----"] → ["  /"," /","L ----"]
»                # Then join the string-list by newlines
                 #  i.e. ["  /"," /","L ----"] → "  /\n /\nL ----"
 .∊              # And finally intersect mirror everything vertically
                 # (which automatically converts the slashes)
                 #  i.e. "  /\n /\nL ----" → "  /\n /\nL ----\n \\n  \"
                 # (And output the result implicitly)

내이 05AB1E 팁을 참조하십시오 (섹션에서는 어떻게 큰 정수를 압축하는 데 어떻게? 와 압축 정수 목록에 어떻게? ) 이유를 이해하는 •Wθ¨S9ƒTª»þúÙ•6в것입니다 [5,3,2,2,2,2,2,2,2,2,4,1,1,0,0,4,1,1,3,0,0,4,1,1,3,3,0,0,4,1,1,3,3,3,0,0]; 하고 Ž8Ã있다 2234.