Actuellement, à mon travail, nous avons déménagé dans un nouveau bâtiment. Il est censé être à la pointe de la technologie et possède des lumières automatiques, des volets roulants automatiques et est maintenant connu comme le bâtiment le plus écologique de cette ville.
Cependant, cela ne fonctionne pas vraiment bien. Les volets roulants descendent parfois les jours nuageux et se lèvent lorsque le soleil commence à briller, et les lumières provoquent parfois des effets disco en allumant et éteignant alternativement tous les 5-10 minutes. De plus, nous n'avons aucun moyen manuel de contrôler ces volets roulants, ni la température, MAIS nous avons une télécommande pour les lumières.
Ces télécommandes sont toutefois venues sans manuel d'instructions et contiennent un peu plus de 20 boutons faisant toutes sortes de choses à l'exception de ce que vous semblez vouloir ..

PS: J'ai écrit ce défi il y a 1,5 mois dans le Sandbox. Actuellement, nous savons, en quelque sorte, comment fonctionnent les télécommandes.
Un gros avantage de ce bâtiment, il fait plus de 30 degrés Celsius à l'extérieur, mais à l'intérieur, il reste la même température ambiante de 21 à tout moment.

C'était donc l'intro et la télécommande des lumières a inspiré ce défi.

Défi:

Disons que nous avons initialement une lampe éteinte:

L

Ensuite, nous poussons toutes sortes de boutons et émettons l'état de la lampe par la suite.

Nous utilisons les numéros suivants pour les différentes fonctions de la télécommande de la lampe. Quand un symbole moins est devant ce nombre, nous faisons le contraire.

• 1= ON; -1= OFF.
• 2= Augmenter la force de 25%; -2= Diminue (dim) la force de 25%.
• 3= Augmentation de l'écart de 50%; -3= Diminuer l'écart de 50%.
• 4 = Changer le type de lumière.

Donc, tout cela est assez vague, alors allons un peu plus en profondeur ce que chaque chose signifie:

Donc, -1(OFF) est assez évident et 1passera à l'état ON initial (50% pour 2et 50% pour 3):

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

2et -2est la distance parcourue par la lumière ( ==est ajoutée pour chaque 25%):

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

25%
L ==

50%
L ====

75%
L ======

100%
L ========

3et dans -3quelle mesure la lumière se propage:

0%:
L ====

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

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

(REMARQUE: lorsque 2et 3sont tous les deux à 100%, vous aurez cet état:

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

4 est de basculer le type de lumière.

Default:
  //
L ==
  \\

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

Contribution:

Vous recevrez une entrée contenant les pressions de bouton possibles. Par exemple:

12-34

Production:

L'état de la lampe lumineuse après avoir appuyé sur tous les boutons de l'entrée est sous-séquentiel. Donc, avec l'exemple d'entrée ci-dessus, nous avons la sortie suivante:

L ------

Règles du défi:

• L'entrée contient uniquement 1234-(et jamais un -avant le 4).
• Vous ne pouvez jamais descendre en dessous de 0% ou au-dessus de 100%. Si un nombre augmente / diminue au-delà de ces limites, vous pouvez l'ignorer.
• Lorsque la lampe est éteinte, vous pouvez ignorer toutes les actions et lorsqu'elle est rallumée, elle revient à l'état ON initial (50% pour les deux 2et 3, et par défaut 4). Par exemple: 12-1-341imprime simplement l'état ON initial mentionné ci-dessus. (CONSEIL: Vous pouvez ignorer tout avant la finale 1de l'entrée - à l'exclusion -1.)
• Les espaces de fuite égaux à la longueur de la lumière ou une seule nouvelle ligne de fuite n'est pas inhibé. Cependant, l'ajout de nouvelles lignes inutiles supplémentaires n'est pas.
• Vous êtes autorisé à prendre l'entrée comme une liste d'entiers au lieu d'une seule chaîne. Donc, au lieu de 12-34, vous pouvez avoir [1,2,-3,4]en entrée.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de 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 octets

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

Cela s'est avéré plus long que prévu. La première ligne calcule l'état de la lampe, les autres implémentent l'impression.

L'entrée est donnée via STDIN sous la forme d'un tableau.

Voir les cas de test sur ideone

R, 323 320 octets

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

Non golfé:

z=scan()

lit une ligne d'entrée (entiers séparés par des espaces)

a=c=1;b=d=2

initialise les variables a (on-ness), b (luminosité), c (largeur), d (type de faisceau). dest soit zéro soit deux, ce qui signifie que nous pouvons appeler if (d) plus tard que if plus (d> 1) ou similaire et enregistrer quelques octets.

while(any(z|1))

Une manière d'écrire golf-y while(length(z))où z est un vecteur entier.

Le reste de la première ligne gère l'entrée via un switch instruction. La deuxième ligne s'imprime.

Il est possible que certains des <-peuvent être remplacés par= , mais je pense que vous êtes dévoré vivant par la portée lexicale ...

Notez également que dans R, les barres obliques inverses doivent être échappées.

c*(c>0) est une manière d'écrire au golf max(c,0) qui sauve un personnage.

Si la lumière n'est pas allumée, alors depuis *a une priorité inférieure à :, la for(i in a*b:-b)boucle ne fait qu'itérer sur0:0 .

Mettre à jour; économisé 3 octets en remplaçant la boucle de la première ligne par un for (plutôt que while). Notez que 1:sum(1|z)c'est moins de caractères que 1:length(z)ou seq_along(z). seq(z)fonctionnerait dans la plupart des cas, mais pas lorsqu'il zest de longueur un. La solution proposée ne fonctionnera pas pour une entrée de longueur nulle mais j'espère que cela sort du cadre du concours.

Kotlin , 445 octets

Mon premier golf Kotlin, 38 octets de moins que 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"}()

Avec espace blanc et 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)))
}

Fait intéressant, plutôt que de définir la fonction normalement et / printou returnla chaîne créée, il était plus court d'utiliser l'attribution de fonction (celle fun f() =d'un lambda évalué. (Cette description a-t-elle un sens?)

^{_{Je souhaite juste que SE ait une mise en évidence de la syntaxe Kotlin appropriée}}

Java 8, 484 483 452 446 440 octets

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

Enfin .. Ok, mon propre défi est un peu plus difficile que ce à quoi je m'attendais ..; P

Cela peut sans aucun doute être joué en utilisant une approche complètement différente. Je détermine d'abord ce que je dois faire, puis je l'imprime. L'impression est en fait la plus difficile de ce défi, à mon humble avis.

-6 octets grâce à @ceilingcat .

Explication:

Essayez-le ici.

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"

Lot, 552 octets

@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

Remarque: set v=contient un espace de fin et en set s=contient trois. C'était vraiment gênant, car vous ne pouvez pas facilement imprimer un nombre variable de |s dans Batch, vous devez donc utiliser un espace réservé et le remplacer dans l'instruction echo.

05AB1E , 106 octets

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

Entrée sous forme de liste d'entiers.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Nous avons maintenant la chaîne:

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

Alors bien:

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

Voir cette astuce de mes 05AB1E (sections Comment compresser les grands entiers? Et comment les listes entières Compresser? ) Pour comprendre pourquoi •Wθ¨S9ƒTª»þúÙ•6вest [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]; et Ž8Ãest 2234.