Derzeit sind wir bei meiner Arbeit in ein neues Gebäude umgezogen. Es soll auf dem neuesten Stand der Technik sein und verfügt über automatische Lichter, automatische Rollläden und ist heute als das umweltfreundlichste Gebäude in dieser Stadt bekannt.
Es funktioniert jedoch nicht wirklich gut. Die Rollläden gehen manchmal an bewölkten Tagen herunter und steigen auf, wenn die Sonne scheint, und die Lichter verursachen manchmal Disco-Effekte, indem sie alle 5-10 abwechselnd ein- und ausgeschaltet werden Protokoll. Wir haben auch keine manuelle Möglichkeit, diese Rollläden oder die Temperatur zu steuern, ABER wir haben eine Fernbedienung für die Lichter.
Diese Fernbedienungen wurden jedoch ohne Bedienungsanleitung geliefert und enthalten etwas mehr als 20 Tasten, die alle möglichen Dinge erledigen, außer dem, was Sie zu wollen scheinen.

PS: Ich habe diese Herausforderung vor 1,5 Monaten in der Sandbox geschrieben. Momentan wissen wir, wie die Fernbedienungen funktionieren.
Ein großer Vorteil dieses Gebäudes ist, dass es außen über 30 Grad Celsius hat, innen aber immer die gleiche Raumtemperatur von 21 Grad hat.

Das war also das Intro, und die Fernbedienung für die Lichter inspirierte diese Herausforderung.

Herausforderung:

Nehmen wir an, wir haben zunächst eine Lampe ausgeschaltet:

L

Dann drücken wir alle Arten von Tasten und geben anschließend den Zustand der Lampe aus.

Wir verwenden die folgenden Nummern für die verschiedenen Funktionen der Fernbedienung für die Lampe. Wenn sich vor dieser Zahl ein Minuszeichen befindet, machen wir das Gegenteil.

• 1= EIN; -1= AUS.
• 2= Festigkeit um 25% erhöhen; -2= Verringern Sie die (schwache) Festigkeit um 25%.
• 3= Spread um 50% erhöhen; -3= Spread um 50% verringern.
• 4 = Umschalten der Lichtart.

Das ist alles ziemlich vage, also gehen wir etwas genauer darauf ein, was jedes Ding bedeutet:

Also, -1(AUS) ist ziemlich offensichtlich und 1geht in den anfänglichen EIN-Zustand (50% für 2und 50% für 3):

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

2und -2ist, wie weit sich das Licht bewegt ( ==wird alle 25% angehängt):

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

25%
L ==

50%
L ====

75%
L ======

100%
L ========

3und -3wie weit verbreitet sich das Licht:

0%:
L ====

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

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

(HINWEIS: Wenn 2und 3beide zu 100% sind, haben Sie diesen Status:

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

4 ist die Art des Lichts umzuschalten.

Default:
  //
L ==
  \\

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

Eingang:

Sie erhalten eine Eingabe mit den möglichen Tastendrücken. Beispielsweise:

12-34

Ausgabe:

Der Status der Lichtlampe, nachdem alle Tasten des Eingangs nacheinander gedrückt wurden. Mit der obigen Beispieleingabe haben wir also die folgende Ausgabe:

L ------

Herausforderungsregeln:

• Die Eingabe enthält nur 1234-(und niemals ein -vorheriges 4).
• Sie können niemals unter 0% oder über 100% gehen. Wenn eine Zahl über diese Grenzen hinaus zunehmen / abnehmen würde, können Sie sie ignorieren.
• Wenn die Lampe ausgeschaltet ist, können Sie alle Aktionen ignorieren. Wenn sie wieder eingeschaltet wird, wird sie wieder in den ursprünglichen EIN-Zustand zurückgesetzt (50% für beide 2und 3, und Standard 4). Beispiel: 12-1-341Druckt nur den oben genannten anfänglichen EIN-Zustand. (TIPP: Sie können alles vor dem Ende 1der Eingabe ignorieren - ausgenommen -1.)
• Leerzeichen, die der Länge des Lichts oder einer einzelnen neuen Zeile entsprechen, sind nicht gesperrt. Das Hinzufügen zusätzlicher unnötiger neuer Zeilen ist jedoch nicht möglich.
• Sie können die Eingabe als Liste von Ganzzahlen anstelle einer einzelnen Zeichenfolge verwenden. Anstelle von 12-34können Sie also [1,2,-3,4]als Eingabe haben.

Allgemeine Regeln:

• Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich nicht von Code-Golf-Sprachen davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, eine möglichst kurze Antwort für "jede" Programmiersprache zu finden.
• Für Ihre Antwort gelten Standardregeln , sodass Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme verwenden dürfen. Ihr Anruf.
• Standardschlupflöcher sind verboten.
• Wenn möglich, fügen Sie bitte einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie bei Bedarf auch eine Erklärung hinzu.

Testfälle:

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 Bytes

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

Dies dauerte länger als ich erwartet hatte. Die erste Zeile berechnet den Zustand der Lampe, der Rest implementiert den Druck.

Die Eingabe erfolgt über STDIN im Array-Formular.

Siehe die Testfälle auf ideone

R, 323 320 Bytes

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

liest eine Eingabezeile (durch Leerzeichen getrennte Ganzzahlen)

a=c=1;b=d=2

initialisiert die Variablen a (Einssein), b (Helligkeit), c (Breite), d (Strahlentyp). dist entweder null oder zwei, was bedeutet, dass wir if (d) später und nicht länger if (d> 1) oder ähnliches aufrufen und ein paar Bytes speichern können.

while(any(z|1))

Eine Golf-y-Schreibweise, while(length(z))bei der z ein ganzzahliger Vektor ist.

Der Rest der ersten Zeile behandelt die Eingabe über eine switchAnweisung. Die zweite Zeile wird ausgedruckt.

Es ist möglich, dass einige <-davon durch ersetzt werden können =, aber ich denke, Sie werden durch lexikalisches Scoping lebendig gefressen ...

Beachten Sie auch, dass in R Backslashes maskiert werden müssen.

c*(c>0)ist eine golfartige Schreibweise max(c,0), die einen Charakter rettet.

Wenn das Licht nicht an *ist :, wird die for(i in a*b:-b)Schleife nur wiederholt , da sie eine niedrigere Priorität als hat 0:0.

Aktualisieren; 3 Bytes wurden gespart, indem die Schleife in der ersten Zeile durch ein for (anstatt while) ersetzt wurde. Beachten Sie, dass 1:sum(1|z)weniger Zeichen als 1:length(z)oder vorhanden sind seq_along(z). seq(z)würde in den meisten Fällen funktionieren, aber nicht, wenn die zLänge eins ist. Die angegebene Lösung funktioniert nicht für Eingaben der Länge Null, aber ich hoffe, dass dies außerhalb des Rahmens des Wettbewerbs liegt.

Kotlin , 445 Bytes

Mein erster Kotlin Golf, 38 Bytes weniger als 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"}()

Mit Leerraum und Tests:

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

Interessanterweise war es kürzer, die Funktionszuweisung (die eines ausgewerteten Lambdas) zu verwenden , anstatt die Funktion normal und / printoder returndie erstellte Zeichenfolge zu definieren fun f() =. (Ist diese Beschreibung sinnvoll?)

^{_{Ich wünschte nur, SE hätte die richtige Hervorhebung der Kotlin-Syntax}}

Java 8, 484 483 452 446 440 Bytes

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

Endlich .. Ok, meine eigene Herausforderung ist etwas schwieriger als ich erwartet hatte ..; P.

Dies kann ohne Zweifel mit einem völlig anderen Ansatz gespielt werden. Ich bestimme jetzt zuerst, was zu tun ist, und drucke es dann aus. Der Druck ist tatsächlich die schwierigste dieser Herausforderung, imho.

-6 Bytes dank @ceilingcat .

Erläuterung:

Probieren Sie es hier aus.

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"

Stapel, 552 Bytes

@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

Hinweis: set v=Enthält ein nachfolgendes Leerzeichen und set s=drei. Dies war sehr umständlich, da Sie |in Batch nicht einfach eine variable Anzahl von s drucken können. Sie müssen daher einen Platzhalter verwenden und ihn in der Echo-Anweisung ersetzen.

05AB1E , 106 Bytes

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

Eingabe als Liste von ganzen Zahlen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Wir haben jetzt die Zeichenfolge:

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

Nun gut:

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

Lesen Sie diesen 05AB1E-Tipp von mir (Abschnitte Komprimieren großer Ganzzahlen und Komprimieren ganzzahliger Listen? ) , Um zu verstehen, warum dies so •Wθ¨S9ƒTª»þúÙ•6вist [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]. und Ž8Ãist 2234.