Şu anda işimde yeni bir binaya taşındık. En son teknoloji olması gerekiyordu ve otomatik ışıkları, otomatik panjurları var ve şimdi bu şehirdeki en çevre dostu bina olarak biliniyor.
Ancak, o kadar da işe yaramaz .. Yuvarlanan panjurlar bazen bulutlu günlerde ve güneş parlamaya başladığında yükselir ve ışıklar bazen her 5-10'da bir açıp kapatarak disko etkilerine neden olur. dakika. Ayrıca, bu panjurları kontrol etmek için manuel bir yolumuz yok, ne de sıcaklık, ama ışıklar için bir uzaktan kumanda var.
Ancak bu uzaktan kumandalar kullanım kılavuzu olmadan geldi ve 20'den az düğme içeriyor.

Not: Bu meydan okumayı 1.5 ay önce Sandbox'ta yazdım. Şu anda, uzaktan kumandaların nasıl çalıştığını biliyoruz ..
Bu bina hakkında büyük bir avantaj, dışarıda 30+ derece Celcius, ama içinde her zaman aynı 21 oda sıcaklığında kalır.

Yani, bu girişti ve ışıkların uzaktan kumandası bu zorluğa ilham verdi.

Meydan okuma:

Diyelim ki başlangıçta bir lambamız kapalı:

L

Sonra her türlü düğmeye basıyoruz ve daha sonra lambanın durumunu çıkarıyoruz.

Lamba için uzaktan kumandanın farklı fonksiyonları için aşağıdaki numaraları kullanıyoruz. Bu sayının önünde eksi sembolü olduğunda, bunun tam tersini yaparız.

• 1 = AÇIK; -1= KAPALI.
• 2 = Gücü% 25 artırın; -2= Gücü% 25 azaltın.
• 3 = Yayılmayı% 50 artırın; -3= Yayılmayı% 50 azaltın.
• 4 = Işık türünü değiştirme.

Yani, bunların hepsi oldukça belirsiz, bu yüzden her şeyin ne anlama geldiğini biraz daha derinlemesine inceleyelim:

Yani, -1(KAPALI) oldukça açıktır ve 1başlangıç ​​AÇIK durumuna (% 250 ve% 50 için 3) gider :

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

2ve -2ışığın ne kadar yol kat ettiği ( ==her% 25'e eklenir):

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

25%
L ==

50%
L ====

75%
L ======

100%
L ========

3ve -3ışığın ne kadar uzağa yayıldığı:

0%:
L ====

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

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

(NOT: 2ve 3% 100 olduğunda , bu duruma sahip olursunuz:

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

4 ışık türünü değiştirmektir.

Default:
  //
L ==
  \\

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

Giriş:

Olası düğme basmalarını içeren bir giriş alırsınız. Örneğin:

12-34

Çıktı:

Girişin tüm düğmelerinden sonraki ışık lambasının durumu alt sıraya basıldığında. Yukarıdaki örnek girdi ile aşağıdaki çıktıya sahibiz:

L ------

Zorluk kuralları:

• Giriş yalnızca içeren 1234-(ve asla -önce4 ).
• Asla% 0'ın altına veya% 100'ün üzerine çıkamazsınız. Bir sayı bu sınırların ötesinde artar / azalırsa, yok sayabilirsiniz.
• Lamba kapandığında, herhangi bir eylemi göz ardı edebilirsiniz ve tekrar açıldığında ilk AÇIK durumuna geri döner (hem 2ve hem de 3varsayılan için% 50 4). Örneğin: 12-1-341sadece yukarıda belirtilen ilk AÇIK durumunu yazdıracaktır. (İPUCU: 1Giriş hariç, hariç her şeyi göz ardı edebilirsiniz -1.)
• Işığın uzunluğuna eşit olan arka boşluklar veya tek bir sondaki yeni çizgi engellenmez. Ancak gereksiz yeni satırlar eklemek değildir.
• Girdiyi tek bir dize yerine tamsayı listesi olarak almanıza izin verilir. Bunun yerine, girdi olarak 12-34sahip olabilirsiniz [1,2,-3,4].

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyon / yöntemi uygun parametrelerle, tam programları kullanmanıza izin verilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, gerekirse bir açıklama ekleyin.

Test senaryoları:

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 bayt

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

Bu beklediğimden daha uzun oldu. İlk satır lambanın durumunu hesaplar, geri kalanı baskıyı uygular.

Girdi STDIN üzerinden dizi formunda verilir.

İdeone'deki test örneklerine bakın

R, 323 320 bayt

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

Ungolfed:

z=scan()

bir girdi satırı okur (boşluklarla ayrılmış tamsayılar)

a=c=1;b=d=2

a (açıklık), b (parlaklık), c (genişlik), d (ışın tipi) değişkenlerini başlatır. dsıfır veya ikidir, yani (d> 1) veya benzeri bir şey yerine (d) daha sonra arayabilir ve birkaç bayt kaydedebiliriz.

while(any(z|1))

Z'nin while(length(z))bir tamsayı vektörü olduğu bir golf-y yazma yolu .

İlk satırın geri kalanı girişi bir switch ifade . İkinci satır yazdırılır.

Bazılarının <-yerini alabilmek mümkündür =, ama bence sözcüksel kapsam belirleme ile canlı yiyorsun ...

Ayrıca, R'de ters eğik çizgilerin kaçması gerektiğini unutmayın.

c*(c>0)max(c,0)bir karakteri kurtaran golf-y yazma yoludur .

Işık yanmıyorsa, *önceliğe göre daha düşük önceliğe sahip olduğundan :, for(i in a*b:-b)döngü sadece tekrar eder 0:0.

Güncelleme; ilk satırdaki döngüyü bir for (yerine) yerine değiştirerek 3 bayt kaydetti. Bunun veya 1:sum(1|z)karakterinden daha az karakter olduğunu unutmayın . çoğu durumda işe yarar, ancak uzunluk bir olduğunda değil . Verilen çözüm sıfır uzunluklu girdi için işe yaramayacaktır, ancak umarım bu rekabetin kapsamı dışındadır.1:length(z)seq_along(z)seq(z)z

Kotlin , 445 bayt

İlk Kotlin golfüm, Java'dan 38 bayt daha az :)

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

Beyaz boşluk ve testlerle:

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

İlginç bir şekilde, işlevi normal olarak printveya returnoluşturulan dizeyi tanımlamak yerine , işlev atamasını kullanmak daha kısaydı ( fun f() =değerlendirilmiş bir lambda'nın. (Bu açıklama mantıklı mı?)

^{_{Keşke SE'nin uygun Kotlin sözdizimi vurgulaması olsaydı}}

Java 8, 484 483 452 446 440 bayt

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

Sonunda .. Tamam, kendi zorluğum beklediğimden biraz daha zor ..; P

Bu hiç şüphesiz tamamen farklı bir yaklaşımla golf edilebilir .. Şimdi önce ne yapacağımı belirledim ve sonra yazdırıyorum. Baskı aslında bu zorluğun en zoru, imho.

@ Ceilingcat sayesinde -6 bayt .

Açıklama:

Burada deneyin.

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"

Toplu, 552 bayt

@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

Not: set v=bir boşluk ve set s=üç boşluk içerir. |Toplu olarak değişken sayıda s'yi kolayca yazdıramayacağınız için bu gerçekten garipti, bu nedenle bir yer tutucu kullanmanız ve echo ifadesinde değiştirmeniz gerekir.

05AB1E , 106 bayt

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

Tamsayıların bir listesi olarak girin.

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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

Şimdi dizemiz var:

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

O zaman iyi:

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

Bu 05AB1E ucuma bakın (neden büyük tamsayılar nasıl sıkıştırılır ? Ve tamsayı listeleri nasıl sıkıştırılır? ) Bölümlerinin neden •Wθ¨S9ƒTª»þúÙ•6вolduğunu anlamak için [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]; ve Ž8Ãöyle 2234.