Attualmente al mio lavoro ci siamo trasferiti in un nuovo edificio. Dovrebbe essere all'avanguardia e ha luci automatiche, tapparelle automatiche ed è ora noto come l'edificio più ecologico in questa città.
Tuttavia, non funziona davvero così bene .. Le persiane a volte scendono a volte nelle giornate nuvolose e si alzano quando il sole inizia a brillare, e le luci a volte causano effetti da discoteca alternando l'accensione e lo spegnimento ogni 5-10 minuti. Inoltre, non abbiamo alcun modo manuale per controllare queste tapparelle, né la temperatura, MA abbiamo un telecomando per le luci.
Questi telecomandi tuttavia sono arrivati ​​senza manuale di istruzioni e contengono poco più di 20 pulsanti che fanno tutto il genere di cose tranne quello che sembri volere.

PS: ho scritto questa sfida 1,5 mesi fa nella Sandbox. Attualmente, sappiamo un po 'come funzionano i telecomandi.
Un grande vantaggio di questo edificio, è di oltre 30 gradi Celcius all'esterno, ma all'interno mantiene sempre la stessa temperatura ambiente di 21 volte.

Quindi, questa è stata l'introduzione e il telecomando per le luci ha ispirato questa sfida.

Sfida:

Diciamo che inizialmente abbiamo una lampada spenta:

L

Quindi premiamo tutti i tipi di pulsanti e successivamente emettiamo lo stato della lampada.

Utilizziamo i seguenti numeri per le diverse funzioni del telecomando per la lampada. Quando un simbolo meno è davanti a quel numero, facciamo il contrario.

• 1= ON; -1= OFF.
• 2= Aumenta la forza del 25%; -2= Riduzione della forza (debole) del 25%.
• 3= Aumenta lo spread del 50%; -3= Riduzione dello spread del 50%.
• 4 = Commutazione del tipo di luce.

Quindi, tutto questo è piuttosto vago, quindi andiamo un po 'più in profondità cosa significa ogni cosa:

Quindi, -1(OFF) è abbastanza ovvio e 1passerà allo stato ON iniziale (50% per 2e 50% per 3):

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

2ed -2è la distanza percorsa dalla luce ( ==aggiunta ogni 25%):

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

25%
L ==

50%
L ====

75%
L ======

100%
L ========

3ed -3è quanto lontano la luce si diffonde:

0%:
L ====

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

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

(NOTA: quando 2e 3sono entrambi al 100%, avrai questo stato:

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

4 è attivare / disattivare il tipo di luce.

Default:
  //
L ==
  \\

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

Ingresso:

Riceverai un input contenente le possibili pressioni dei pulsanti. Per esempio:

12-34

Produzione:

Lo stato della spia luminosa dopo aver premuto tutti i pulsanti dell'ingresso sub-sequenziali. Quindi, con l'input di esempio sopra, abbiamo il seguente output:

L ------

Regole della sfida:

• L'input contiene solo 1234-(e mai -prima 4).
• Non puoi mai andare sotto lo 0% o sopra il 100%. Se un numero aumenta / diminuisce oltre questi limiti, è possibile ignorarlo.
• Quando la lampada è spenta, è possibile ignorare tutte le azioni e quando poi in posizione ON si resetta di nuovo alla ON-stato iniziale (50% per entrambi 2e 3, e di default 4). Ad esempio: 12-1-341stamperà solo lo stato ON iniziale menzionato sopra. (SUGGERIMENTO: puoi ignorare tutto prima della finale 1dell'input - escluso -1.)
• Spazi di trascinamento pari alla lunghezza della luce o una singola nuova linea di trascinamento non sono inibiti. L'aggiunta di nuove righe non necessarie non è tuttavia.
• È consentito accettare l'input come un elenco di numeri interi anziché come singola stringa. Quindi, invece di 12-34, puoi avere [1,2,-3,4]come input.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

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

Questo è finito più a lungo di quanto mi aspettassi. La prima riga calcola lo stato della lampada, il resto implementa la stampa.

L'input viene fornito tramite STDIN nella forma dell'array.

Vedi i casi di test su 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="\\"}}

Ungolfed:

z=scan()

legge una riga di input (numeri interi separati da spazi)

a=c=1;b=d=2

inizializza le variabili a (on-ness), b (luminosità), c (larghezza), d (tipo di fascio). dè zero o due, il che significa che possiamo chiamare if (d) in seguito piuttosto che un if più lungo (d> 1) o simile e salvare un paio di byte.

while(any(z|1))

Un modo di scrivere golf-y in while(length(z))cui z è un vettore intero.

Il resto della prima riga gestisce l'input tramite switchun'istruzione. La seconda riga viene stampata.

È possibile che alcuni dei <-possano essere sostituiti con =, ma penso che tu venga mangiato vivo da scoping lessicale ...

Si noti inoltre che in R, le barre rovesciate devono essere sfuggite.

c*(c>0)è un modo di scrivere da golf max(c,0)che salva un personaggio.

Se la luce non è accesa, dal momento che *ha una precedenza inferiore rispetto a :, il for(i in a*b:-b)ciclo continua solo iterando 0:0.

Aggiornare; salvato 3 byte sostituendo il loop nella prima riga con un for (piuttosto che while). Si noti che il 1:sum(1|z)numero di caratteri è inferiore a 1:length(z)o seq_along(z). seq(z)funzionerebbe nella maggior parte dei casi, ma non quando zè di lunghezza uno. La soluzione fornita non funzionerà con input di lunghezza zero ma spero che esuli dall'ambito della concorrenza.

Kotlin , 445 byte

Il mio primo golf Kotlin, 38 byte in meno di 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"}()

Con spazi bianchi e test:

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

È interessante notare che, piuttosto che definire la funzione normalmente e / printo returnla stringa creata, è stato più breve utilizzare l'assegnazione della funzione (il valore fun f() =di una lambda valutata. ( Ha senso questa descrizione?)

^{_{Vorrei solo che SE avesse il giusto evidenziazione della sintassi di Kotlin}}

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

Finalmente .. Ok, la mia sfida è un po 'più dura di quanto mi aspettassi ..; P

Questo può essere senz'altro risolto usando un approccio completamente diverso .. Ora ora decido prima cosa devo fare e poi lo stampo. La stampa è in realtà la più difficile di questa sfida, imho.

-6 byte grazie a @ceilingcat .

Spiegazione:

Provalo qui.

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"

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

Nota: set v=contiene uno spazio finale e ne set s=contiene tre. Questo è stato davvero imbarazzante, poiché non è possibile stampare facilmente un numero variabile di |s in Batch, quindi è necessario utilizzare un segnaposto e sostituirlo nell'istruzione 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'|ð:}».∊

Inserire come un elenco di numeri interi.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Ora abbiamo la stringa:

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

Quindi:

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

Vedere questo 05AB1E punta del mio (sezioni Come comprimere grandi numeri interi? E come liste di interi comprimere? ) Per capire perché •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]; ed Ž8Ãè 2234.