Invertir algunos interruptores en una centralita


23

Inspirado en este desafío .

Gol:

Dada una centralita preconfigurada y una lista de índices, invierta los conmutadores en los índices dados.

Una centralita está compuesta por cierto número de interruptores ( vo ^) envueltos en -'s' y dispuestos en filas de longitud variable. Aquí hay un cuadro de distribución de ejemplo:

-v-^-v-
-^-v-
-v-^-v-

Invertir / voltear un interruptor significa cambiarlo de va ^, o de ^a v.

Los interruptores están indexados de izquierda a derecha, de arriba a abajo. Por ejemplo, en el ejemplo anterior, el último ven la primera fila estaría en la posición 3 y el ^de la fila central estaría en 4 (usando la indexación 1).

Entrada:

  • Una cadena (o lista de cadenas) que representa la centralita. Se garantiza que coincida con la expresión regular ((-[v^])+-)(\n(-[v^])+-)*.
  • Una lista posiblemente vacía de números que representan índices, puede ser 0 o 1 (o algún número arbitrario si lo desea) indexado. Estos son los interruptores que deben activarse.

Salida:

  • Una centralita en la misma forma que la entrada con los conmutadores especificados invertidos. Cualquier interruptor no especificado debe conservar su estado inicial.

Reglas:

  • La entrada siempre tendrá el formato correcto y ningún índice dado estará fuera de los límites.
  • La lista de índices se ordenará y no tendrá duplicados.
  • Indique en su respuesta qué indexación usa, ya sea 0, 1 o alguna arbitraria.
  • El espacio en blanco al final está bien siempre que la salida se parezca a la entrada.
  • Este es el por lo que gana el código más corto.

Ejemplos:

#Using 1-indexing
input: #Empty Case
[],
-v-^-v-

output:
-v-^-v-

input: #Single switch
[1],
-v-

output:
-^-

input: #Skip a line
[3,5],
-^-v-v-
-v-
-^-^-

output:
-^-v-^-
-v-
-v-^-

input: #Flip one in each line + number wrap
[3,4,6],
-^-v-v-
-v-
-^-^-

output:
-^-v-^-
-^-
-^-v-

input: #Flip 'em all
[1,2,3,4,5,6],
-^-v-v-
-v-
-^-^-

output:
-v-^-^-
-^-
-v-v-

¿Podemos generar una matriz de caracteres rectangular, rellenando a la derecha las líneas más cortas con espacios? Además, ¿podemos recibir información de esa forma?
Luis Mendo

@LuisMendo Voy a decir que no al tomar eso como entrada. El espacio en blanco final está bien siempre que parezca la entrada.
Veskah

2
Sugerencia para aquellos que verifican si los caracteres son >"-": Como se garantiza que la cadena de entrada comienza -, puede verificar el nombre del parámetro / argumento / variable que está utilizando para eso.
Shaggy

Respuestas:


11

Vim, 60, 46, 38 , 37 bytes / pulsaciones de teclas

qq/\d
ggDJ@"/[v^]
sv^<esc>l?\V<C-r>"
x@qq4u@q

<esc>y <C-r>son ambos 1 byte / pulsación de tecla. Contador de bytes

Caso de prueba 1 (modo detallado)

Caso de prueba 2 (modo detallado)

Gracias a Grimy por las ideas que llevaron a una reducción de 22 bytes :)


2
@Veskah ughhhhhh vim es muy quisquilloso con los casos límite de "hacer algo 0 veces". Ver edición
DJMcMayhem

¿No podría :s/\%V./\='v^'[submatch(0)=='v']ser cl<C-R>='v^'['<C-R>"'=='v']para -13 bytes? (cada <CR> es solo un byte).
Grimmy

2
@ Grimy Ooh, buena idea. Además s == cl, tan -14general.
DJMcMayhem

Otras ideas: s^v!<Esc>?\<C-R>"<CR>xhf!xo s<CR>^v<Esc>:s/\V<C-R>"<CR>kgJ.
Grimmy

1
Pensé en eso, pero falla si el carácter que se va a invertir está al final de una línea ... pero luego la especificación de entrada garantiza que es seguido por a -, ¡así que realmente funciona! Duh
Grimmy


4

K (oK) , 31 27 bytes

Solución:

`0:{@[x;(&x>93)y;"^v"94=]};

Pruébalo en línea!

Explicación:

Respuesta rápida, intentará jugarlo. 0 indexado.

`0:{@[x;(&x>93)y;"^v"94=]}; / the solution
`0:                       ; / print to stdout
   {                     }  / lambda taking 2 implicit args x & y
    @[ ;        ;       ]   / apply @[var;index;function]
                     94=    / 94 (ASCII "v") equal to? returns 0 or 1
                 "v^"       / index into "v^" (ie flip switch)
               y            / index into
        (     )             / do this together
          x>93              / x greater than 93 (ASCII "]")
         &                  / indices where true
      x                     / apply to x

Notas:

  • -4 bytes gracias al >93truco

3

Python 3 , 140 134 103 bytes

(-30 gracias a DJMcMayhem ♦, -1 más gracias a Black Owl Kai)

def f(i,y,x=1):
 for c in y:q=c>'-';p=len(i)and x==i[0]*q;print([c,"v^"[c>'^']][p],end='');x+=q;i=i[p:]

Pruébalo en línea!


Oof, segundo intento de jugar al golf. Esto solo usa un bucle poco sofisticado sobre la cadena, usandox para realizar un seguimiento del índice de cambio actual. Utiliza 1-indexación.

Sin golf:

def f(i,y):
     x = 1
     for c in y:
         nextchar = c # nextchar gets golfed out completely within the print
         if c in 'v^': # golfed as c>'-'
             if len(i) and x==i[0]:
                nextchar = 'v' if c=='^' else '^'
                i = i[1:]
             x += 1
         print(nextchar, end='')



O 104 si python 3 es aceptable
DJMcMayhem

@DJMcMayhem Ooh, gracias por reemplazar catch xd ¿Desea publicar el Python 3 como una respuesta por separado, o cree que es lo suficientemente similar como para agregarlo como una edición?
La transformación de Fourier de Rin

1
Siéntase libre de agregarlo :) Podría publicar una respuesta de Python 3, pero probablemente primero intente proponer mi propio enfoque.
DJMcMayhem

3

Jalea , 12 bytes

O^%5T⁴ịƲ¦40Ọ

Un programa completo que acepta una cadena y una lista de enteros que imprime el resultado.

Pruébalo en línea!

¿Cómo?

O^%5T⁴ịƲ¦40Ọ - Main Link: list of characters, S; inversion indices, I
O            - to ordinals   ('\n':10, '-':45, '^':94, 'v':118)
        ¦    - sparse application...
       Ʋ     - ...to indices: last four links as a monad: f(O(S))
  %5         -   modulo 5   (10:0, 45:0, 94:4, 118:3)
    T        -   truthy indices (giving, X, indices of '^' and 'v' in S)
     ⁴       -   4th command line argument = I
      ị      -   index into X   (giving indices of '^' and 'v' to invert in S)
 ^       40  - ...action: XOR with 40   (94:118, 118:94)
           Ọ - from ordinals
             - implicit print


3

Perl 6 , 31 bytes

->$_,\s{S:nth(s){\^|v}=$/~^'('}

Pruébalo en línea!

(-2 bytes gracias a Jo King)

El operador de sustitución de Perl 6 Stoma convenientemente un nthadverbio que acepta no solo un índice único para hacer el reemplazo, sino una lista de ellos, exactamente como se necesita aquí.

El reemplazo es $/ ~^ '(', donde $/está el texto coincidente (ya sea vo^ ), ~^es el stringwise o-exclusiva operador, y (es el carácter cuyos bits girar ven ^y viceversa.





2

Jalea , 14 bytes

⁾^vḟ$€>”-T⁹ịƲ¦

Pruébalo en línea!

Programa completo

Esto se siente demasiado largo ...


No conozco a Jelly, así que no puedo entender cómo probarlo yo mismo, pero ¿podrías reemplazarlo ”-con el nombre del primer argumento ( ³?), Que está garantizado que comienza con un -, en su lugar?
Shaggy

@Shaggy Nope, porque >vectoriza. Puedes ver que no funciona .
Erik el Outgolfer

ah, eso es exactamente lo que intenté :) Sin embargo, no sabía si era mi falta de conocimiento de Jelly la causa o no. ¿No supones que hay un solo carácter incorporado para obtener el primer carácter del primer argumento?
Shaggy

@Shaggy Eh ... los únicos construidos-ins para los argumentos de línea de comandos son ³, , , y , por primera a la quinta CLA respectivamente. Puede leer la página Atoms para averiguar si existe una función incorporada específica.
Erik the Outgolfer

Ah, bueno, valía la pena intentarlo. Un día, a sumergirse en la jalea correctamente.
Shaggy

2

Stax , 13 bytes

¿╫╦ÜΦ1▌X○!ΩTæ

Ejecutar y depurarlo

Esto utiliza índices basados ​​en 0.

  1. Encuentra todos los índices de la expresión regular [v^] .
  2. Índice en el índice matriz de utilizando la entrada.
  3. En cada resultado, xor el código ASCII de la entrada con 40. Esto es xor('v', '^').

2

Limpio , 93 bytes

import StdEnv
$i=foldl(\s c=s++[if(any((==)(sum[1\\k<-s|k>'-']))i&&c>'-')if(c>'^')'^''v'c])[]

Pruébalo en línea!

Define la función que $ :: [Int] -> [Char] -> [Char]toma una lista de índices indexados a cero y devuelve una función que toma la cadena y devuelve la cadena alterada.




1

JavaScript, 111 bytes

Código

x=>y=>{x.map(i=>eval(`y=y.replace(/(((v|\\^)[^^v]*){${i}})(v|\\^)/,(a,b,c,d,e)=>b+(e<"v"?"v":"^"))`));return y}

Toma la entrada en formato f (x) (y) donde x es los índices e y es la centralita. Los índices son 0 indexados

Pruébalo en línea!

Explicación

Para cada índice

x.map(i=>...

construya la expresión regular que encuentre el índice + 1º "^" o "v"

`.../(((v|\\^)[^^v]*){${i}})(v|\\^)/...`

insertarlo en una cadena para reemplazarlo con el símbolo opuesto "v" <-> "^"

y=y.replace(...,(a,b,c,d,e)=>b+(e<"v"?"v":"^"))

luego evalúa la cadena como una función

eval(...)

Después de recorrer los índices para cambiar, devolver el panel de control

return y

1

Jalea , 17 bytes

⁾^vK;`©⁹e€ky@€⁸¦®

Pruébalo en línea!

Un programa completo que toma los índices como primer y cadena como segundo argumento. Imprime la salida con los interruptores indicados invertidos.


1

Retina 0.8.2 , 66 62 bytes

\d+
$*
T`v^`^v`.(?<=\b(?(3)$)(?<-3>1)+(,1+)*(-|¶|(v|\^))+)
1A`

Pruébalo en línea! El enlace incluye un caso de prueba. 1 indexado. Explicación:

\d+
$*

Convierta los números de entrada a unario.

T`v^`^v`.(?<=\b(?(3)$)(?<-3>1)+(,1+)*(-|¶|(v|\^))+)

Transliterate entre vy ^todos los personajes con la propiedad de que el número de vs, y ^es hasta el momento (inclusive) es igual a uno de los números de entrada.

1A`

Eliminar los números de entrada.


1

Carbón , 23 bytes

⭆η⎇№θ⌕ΦLη№v^§ηλκ§v^⁼vιι

Pruébalo en línea! El enlace es a la versión detallada del código. 0 indexado. Explicación:

 η                      Input string
⭆                       Map over characters and join
  ⎇                     If
   №                    Count of (i.e. exists)
     ⌕                  Index of
               κ        Current index in
       L                Length of
        η               Input string
      Φ                 Implicit range filtered by
         №              Count of (i.e. exists)
             η          Input string
            §           Indexed by
              λ         Current value
          v^            In literal string `v^`
    θ                   In input list
                 v^     Then literal `v^`
                §       Indexed by
                     ι  Current character
                   ⁼    Equal to
                    v   Literal `v`
                      ι Else current character



1

Japt , 15 bytes

®c^(Z>V©øT° *#(

Intentalo

®c^(Z>V©ø°T *#(    U = Input String, V = Array of Indices
®                  Map each Z in U
 c^                   XOR Z's charcode by
   (Z>V                 Z is 'v' or '^'
      ©                 Short-circuiting Logical and
       øT°              The current Z's index is in V
             *#(        Multiply the boolean with 40 (false = 0, true = 1)

1

Japt , 16 14 bytes

Ëc^#(*(D>V©øT°

Intentalo

Ë>V©øT° ?Dc^#(:D     :Implicit input of multi-line string U & integer array V
Ë                    :Map each D in U
 >V                  :  Greater than V? (Coerces V to a string and, conveniently, all digits are > "\n" & "-" and < "^" & "v")
   ©                 :  Logical AND with
    ø                :  Does V contain
     T°              :    T (initially 0) postfix incremented
        ?            :  If true
         Dc          :  Charcode of D
           ^#(       :  XOR with 40
              :D     :  Else D

Aw, su código ya no es feliz (perdió el :D)
Veskah
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.