Inverter alguns comutadores em um painel de distribuição


23

Inspirado por este desafio .

Objetivo:

Dado um painel de controle pré-configurado e uma lista de índices, inverta os switches nos índices fornecidos.

Um quadro de distribuição é composto por um número de interruptores ( vou ^) enrolados em -'s' e organizados em linhas de comprimento variável. Aqui está um quadro de distribuição de exemplo:

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

Inverter / inverter um interruptor significa alterá-lo de vpara ^ou de ^para v.

Os comutadores são indexados da esquerda para a direita, de cima para baixo. Por exemplo, no exemplo acima, o último vna primeira linha estaria na posição 3 e o ^na linha do meio estaria em 4 (usando a indexação 1).

Entrada:

  • Uma sequência (ou lista de sequências) representando o quadro de distribuição. É garantido que corresponda ao regex ((-[v^])+-)(\n(-[v^])+-)*.
  • Uma lista possivelmente vazia de números representando índices pode ser 0 ou 1 (ou algum número arbitrário, se você quiser) indexado. Esses são os comutadores que precisam ser invertidos.

Saída:

  • Um quadro de distribuição na mesma forma que a entrada com os interruptores especificados invertidos. Quaisquer opções não especificadas devem manter seu estado inicial.

Regras:

  • A entrada sempre será formatada corretamente e nenhum índice fornecido ficará fora dos limites.
  • A lista de índices será classificada e não terá duplicatas.
  • Declare em sua resposta qual indexação você usa, seja 0, 1 ou alguma arbitrária.
  • O espaço em branco à direita é bom, desde que a saída se pareça com a entrada.
  • Isso é então o código mais curto vence.

Exemplos:

#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 gerar uma matriz de caracteres retangular, preenchendo à direita as linhas mais curtas com espaços? Além disso, podemos receber informações dessa forma?
Luis Mendo

@LuisMendo eu vou dizer não, tomando isso como entrada. O espaço em branco à direita é bom, desde que pareça com a entrada.
Veskah 24/07

2
Dica para aqueles que verificam se os caracteres são >"-": Como é garantido o início da sequência de entrada -, você pode verificar o parâmetro / argumento / nome da variável que está usando para isso.
Shaggy

Respostas:


11

Vim, 60, 46, 38 , 37 bytes / pressionamentos de tecla

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

<esc>e <C-r>são ambos 1 byte / pressionamento de tecla. Contador de bytes

Caso de teste 1 (modo detalhado)

Caso de teste 2 (modo detalhado)

Agradecimentos a Grimy pelas idéias que levaram a uma redução de 22 bytes :)


2
O @Veskah ughhhhhh vim é super meticuloso com casos extremos "faça algo 0 vezes". Ver edição
DJMcMayhem

Não pode :s/\%V./\='v^'[submatch(0)=='v']ser cl<C-R>='v^'['<C-R>"'=='v']de -13 bytes? (cada <CR> é apenas um byte).
Grimmy 24/07

2
@ Grimy Ooh, boa ideia. Além disso s == cl, de modo -14geral.
DJMcMayhem

Outras idéias: s^v!<Esc>?\<C-R>"<CR>xhf!xou s<CR>^v<Esc>:s/\V<C-R>"<CR>kgJ.
Grimmy 24/07

1
Pensei nisso, mas falhará se o caractere a ser invertido estiver no final de uma linha… mas, em seguida, a especificação de entrada garante que é seguido por um -, então realmente funciona! Duh.
Grimmy 24/07


4

K (oK) , 31 27 bytes

Solução:

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

Experimente online!

Explicação:

Resposta rápida, tentará jogar golfe. Indexado a 0.

`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 graças ao >93truque

3

Python 3 , 140 134 103 bytes

(-30 graças a DJMcMayhem ♦, -1 mais graças 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:]

Experimente online!


Oof, segunda tentativa de jogar golfe. Isso apenas usa um loop pouco sofisticado sobre a string, usandox para acompanhar o índice atual do switch. Usa indexação 1.

Ungolfed:

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='')



Ou 104, se o python 3 for aceitável
DJMcMayhem

@DJMcMayhem Ooh, obrigado por substituir o catch xd Deseja postar o Python 3 como uma resposta separada, ou você acha que é semelhante o suficiente para adicionar como edição a isso?
Fourier de Rin transforma

1
Sinta-se à vontade para adicioná-lo :) Eu posso postar uma resposta em python 3, mas provavelmente tentaria criar minha própria abordagem primeiro.
DJMcMayhem

3

Gelatina , 12 bytes

O^%5T⁴ịƲ¦40Ọ

Um programa completo que aceita uma string e uma lista de números inteiros que imprime o resultado.

Experimente online!

Quão?

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}=$/~^'('}

Experimente online!

(-2 bytes graças a Jo King)

O operador de substituição do Perl 6 Sleva convenientemente umnth advérbio que aceita não apenas um índice único para fazer a substituição, mas uma lista deles, exatamente como necessário aqui.

A substituição é $/ ~^ '(', onde $/está o texto correspondente (seja vou ^), ~^é o stringwise ou-exclusivo do operador, e (é o personagem cujos bits transformar vem ^e vice-versa.





2

Gelatina , 14 bytes

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

Experimente online!

Programa completo.

Isso parece muito longo ...


Eu não conheço Jelly, por isso não consigo descobrir como tentar isso sozinho, mas você poderia substituir ”-pelo nome do primeiro argumento ( ³?), Que é garantido que começa com a -, em vez disso?
Shaggy

@ Shaggy Nope, porque >vetoriza. Você pode ver que isso não funciona .
Erik the Outgolfer

ah, foi exatamente isso que eu tentei :) Não sabia se era a minha falta de conhecimento sobre geléia que era a causa ou não. Não suponha que exista um único caractere para obter o primeiro caractere do primeiro argumento?
Shaggy

@Shaggy Erm ... os únicos built-ins para argumentos de linha de comando são ³, , , e , para o primeiro ao quinto CLA, respectivamente. Você pode ler a página Átomos para descobrir se existe uma função interna específica.
Erik the Outgolfer

Ah, valeu a pena tentar. Um dia, vou mergulhar em Jelly corretamente.
Shaggy

2

Stax , 13 bytes

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

Execute e depure

Isso usa índices baseados em 0.

  1. Encontre todos os índices da regex [v^].
  2. Índice na matriz de índice usando a entrada
  3. Em cada resultado, x ou o código ascii da entrada com 40. Isto é xor('v', '^').

2

Limpo , 93 bytes

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

Experimente online!

Define a função $ :: [Int] -> [Char] -> [Char]obtendo uma lista de índices indexada a zero e retornando uma função que pega a string e retorna a string 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}

Recebe a entrada no formato f (x) (y) em que x são os índices e y é o quadro de distribuição. Os índices são indexados 0

Experimente online!

Explicação

Para cada índice

x.map(i=>...

construa o regex que encontra o índice + 1 th "^" ou "v"

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

insira-o em uma string para substituí-lo pelo símbolo oposto "v" <-> "^"

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

então avalie a string como uma função

eval(...)

Depois de percorrer os índices para alternar, retorne o quadro de distribuição

return y

1

Geléia , 17 bytes

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

Experimente online!

Um programa completo, tendo os índices como primeiro e string como segundo argumento. Imprime a saída com os interruptores indicados virados.


1

Retina 0.8.2 , 66 62 bytes

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

Experimente online! O link inclui caso de teste. 1 indexado. Explicação:

\d+
$*

Converta os números de entrada em unário.

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

Transliterate entre ve ^todos os personagens com a propriedade de que o número de vs e ^s tão longe (inclusive) é igual a um dos números de entrada.

1A`

Exclua os números de entrada.


1

Carvão , 23 bytes

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

Experimente online! Link é a versão detalhada do código. Indexado a 0. Explicação:

 η                      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

Japonês , 15 bytes

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

Tente

®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

Japonês , 16 14 bytes

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

Tente

Ë>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

Ah, seu código não está mais feliz (perdeu o :D)
Veskah 31/07
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.