Hiện tại trong công việc của tôi, chúng tôi chuyển đến một tòa nhà mới. Nó được coi là hiện đại và có đèn tự động, cửa chớp tự động cuộn xuống và hiện được gọi là tòa nhà thân thiện với môi trường nhất trong thị trấn này.
Tuy nhiên, nó không thực sự hoạt động tốt như vậy .. Cửa chớp cuộn xuống đôi khi rơi vào những ngày nhiều mây và khi mặt trời bắt đầu chiếu sáng, và đèn đôi khi gây ra hiệu ứng vũ trường bằng cách bật và tắt luân phiên cứ sau 5-10 phút Ngoài ra, chúng tôi không có bất kỳ cách thủ công nào để kiểm soát các cửa chớp cuộn xuống này, cũng như nhiệt độ, NHƯNG chúng tôi có một điều khiển cho đèn.
Tuy nhiên, các điều khiển từ xa này không có hướng dẫn sử dụng và chứa ít hơn 20 nút làm tất cả các loại ngoại trừ những gì bạn có vẻ muốn ..

PS: Tôi đã viết thử thách này 1,5 tháng trước trong Sandbox. Hiện tại, chúng tôi, biết cách điều khiển từ xa hoạt động ..
Một lợi thế lớn về tòa nhà này, đó là hơn 30 độ Celcius bên ngoài, nhưng bên trong nó luôn giữ nguyên nhiệt độ 21 phòng.

Vì vậy, đó là phần giới thiệu và điều khiển từ xa cho đèn đã truyền cảm hứng cho thử thách này.

Thử thách:

Giả sử ban đầu chúng ta tắt đèn:

L

Sau đó, chúng tôi đẩy tất cả các loại nút và xuất trạng thái của đèn sau đó.

Chúng tôi sử dụng các số sau cho các chức năng khác nhau của điều khiển từ xa cho đèn. Khi một biểu tượng dấu trừ đứng trước số đó, chúng ta làm ngược lại.

• 1= BẬT; -1= TẮT.
• 2= Tăng sức mạnh thêm 25%; -2= Giảm (mờ) cường độ 25%.
• 3= Tăng chênh lệch 50%; -3= Giảm lây lan 50%.
• 4 = Toggling loại ánh sáng.

Vì vậy, điều này khá mơ hồ, vì vậy hãy đi sâu hơn một chút về ý nghĩa của từng điều:

Vì vậy, -1(TẮT) là khá rõ ràng và 1sẽ chuyển sang trạng thái BẬT ban đầu (50% cho 2và 50% cho 3):

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

2và -2là khoảng cách ánh sáng đi được ( ==được nối thêm cho mỗi 25%):

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

25%
L ==

50%
L ====

75%
L ======

100%
L ========

3và -3là bao xa ánh sáng lan rộng:

0%:
L ====

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

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

(LƯU Ý: Khi 2và 3cả hai đều ở mức 100%, bạn sẽ có trạng thái này:

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

4 là để chuyển đổi loại ánh sáng.

Default:
  //
L ==
  \\

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

Đầu vào:

Bạn sẽ nhận được một đầu vào có chứa các lần nhấn nút có thể. Ví dụ:

12-34

Đầu ra:

Trạng thái của đèn sáng sau khi tất cả các nút của đầu vào được nhấn tuần tự phụ. Vì vậy, với ví dụ đầu vào ở trên, chúng ta có đầu ra sau:

L ------

Quy tắc thử thách:

• Đầu vào chỉ chứa 1234-(và không bao giờ a -trước 4).
• Bạn không bao giờ có thể đi dưới 0% hoặc trên 100%. Nếu một số sẽ tăng / giảm vượt quá các ranh giới này, bạn có thể bỏ qua nó.
• Khi đèn tắt, bạn có thể bỏ qua mọi hành động và khi bật lại, nó sẽ trở lại trạng thái BẬT ban đầu (50% cho cả hai 2và 3, mặc định 4). Ví dụ: 12-1-341sẽ chỉ in trạng thái ON ban đầu được đề cập ở trên. (MIPO: Bạn có thể bỏ qua mọi thứ trước khi kết thúc 1đầu vào - không bao gồm -1.)
• Không gian lưu trữ bằng với chiều dài của ánh sáng hoặc một dòng mới duy nhất không bị chặn. Tuy nhiên, việc thêm các dòng mới không cần thiết là không.
• Bạn được phép lấy đầu vào làm danh sách các số nguyên thay vì một chuỗi. Vì vậy, thay vì 12-34, bạn có thể có [1,2,-3,4]đầu vào.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

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

Python 2, 221 byte

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

Vết thương này dài hơn tôi mong đợi. Dòng đầu tiên tính toán trạng thái của đèn, phần còn lại thực hiện in.

Đầu vào được đưa ra thông qua STDIN ở dạng mảng.

Xem các trường hợp thử nghiệm trên ideone

R, 323 320 byte

    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="\\"}}

Ung dung:

z=scan()

đọc một dòng đầu vào (số nguyên cách nhau bằng dấu cách)

a=c=1;b=d=2

khởi tạo các biến a (on-ness), b (độ sáng), c (chiều rộng), d (loại tia). dlà 0 hoặc 2, có nghĩa là chúng ta có thể gọi if (d) muộn hơn là dài hơn nếu (d> 1) hoặc tương tự và lưu một vài byte.

while(any(z|1))

Một cách viết golf-y trong while(length(z))đó z là một vectơ nguyên.

Phần còn lại của dòng đầu tiên xử lý đầu vào thông qua một switchcâu lệnh. Dòng thứ hai in ra.

Có thể một số trong số đó <-có thể được thay thế bằng =, nhưng tôi nghĩ rằng bạn bị ăn sống bởi phạm vi từ vựng ...

Cũng lưu ý rằng trong R, dấu gạch chéo ngược cần được thoát.

c*(c>0)là một cách viết golf-y để max(c,0)cứu một nhân vật.

Nếu đèn không sáng thì *có độ ưu tiên thấp hơn :, for(i in a*b:-b)vòng lặp chỉ lặp lại 0:0.

Cập nhật; đã lưu 3 byte bằng cách thay thế vòng lặp trong dòng đầu tiên bằng một for (thay vì while). Lưu ý rằng 1:sum(1|z)có ít ký tự hơn 1:length(z)hoặc seq_along(z). seq(z)sẽ hoạt động trong hầu hết các trường hợp, nhưng không phải khi zcó độ dài một. Giải pháp đưa ra sẽ không hoạt động đối với đầu vào có độ dài bằng 0 nhưng tôi hy vọng điều đó nằm ngoài phạm vi của cuộc thi.

Kotlin , 445 byte

Golf Kotlin đầu tiên của tôi, ít hơn 38 byte so với Java :)

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

Với không gian trắng và các bài kiểm tra:

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

Thật thú vị, thay vì xác định hàm thông thường và printhoặc returnchuỗi đã tạo, việc sử dụng gán chức năng sẽ ngắn hơn ( fun f() =của lambda được đánh giá. (Mô tả đó có hợp lý không?)

^{_{Tôi chỉ muốn SE có tô sáng cú pháp Kotlin thích hợp}}

Java 8, 484 483 452 446 440 byte

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";}

Cuối cùng .. Ok, thử thách của tôi khó hơn một chút so với dự kiến ​​của tôi ..; P

Điều này chắc chắn có thể bị đánh golf bằng cách sử dụng một cách tiếp cận hoàn toàn khác .. Bây giờ tôi trước tiên xác định phải làm gì, và sau đó in nó. In ấn thực sự là khó khăn nhất của thử thách này, imho.

-6 byte nhờ @ceilingcat .

Giải trình:

Hãy thử nó ở đây.

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"

Mẻ, 552 byte

@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

Lưu ý: set v=chứa một dấu cách và set s=chứa ba. Điều này thực sự rất khó xử, vì bạn không thể dễ dàng in một số lượng biến đổi |trong Batch, vì vậy bạn phải sử dụng trình giữ chỗ và thay thế nó trong câu lệnh echo.

05AB1E , 106 byte

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

Nhập dưới dạng danh sách các số nguyên.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

“/|= 
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

Bây giờ chúng ta có chuỗi:

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

Sau đó tốt:

¶¡               # 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)

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để nén các số nguyên lớn? Và Làm thế nào để liệt kê số nguyên nén? ) Để hiểu tại sao •Wθ¨S9ƒTª»þúÙ•6вlà [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]; và Ž8Ãlà 2234.