Invertire alcuni interruttori su un centralino


23

Ispirato da questa sfida .

Obbiettivo:

Dato un centralino preconfigurato e un elenco di indici, invertire gli interruttori in corrispondenza degli indici indicati.

Un centralino è costituito da un numero di interruttori ( vo ^) avvolti in -'s e disposti in file di varia lunghezza. Ecco un esempio di centralino:

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

Invertire / capovolgere un interruttore significa cambiarlo da va ^, o da ^a v.

Gli interruttori sono indicizzati da sinistra a destra, dall'alto verso il basso. Ad esempio, nell'esempio sopra, l'ultimo vnella prima riga sarebbe in posizione 3 e quello ^nella riga centrale sarebbe a 4 (usando l'indicizzazione 1).

Ingresso:

  • Una stringa (o un elenco di stringhe) che rappresenta il centralino. È garantito per abbinare il regex ((-[v^])+-)(\n(-[v^])+-)*.
  • Un elenco eventualmente vuoto di numeri che rappresentano indici, può essere indicizzato 0 o 1 (o un numero arbitrario, se lo si desidera). Questi sono gli interruttori che devono essere ruotati.

Produzione:

  • Un centralino della stessa forma dell'ingresso con gli interruttori specificati invertiti. Eventuali switch non specificati devono mantenere il loro stato iniziale.

Regole:

  • L'input sarà sempre formattato correttamente e nessun indice dato sarà fuori dai limiti.
  • L'elenco degli indici verrà ordinato e non avrà duplicati.
  • Indica nella tua risposta quale indicizzazione usi, che sia 0, 1 o arbitraria.
  • Gli spazi bianchi finali vanno bene purché l'output assomigli all'input.
  • Questo è quindi vince il codice più breve.

Esempi:

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

Possiamo produrre un array di caratteri rettangolare, riempiendo a destra le linee più corte con spazi? Inoltre, possiamo prendere input in quel modulo?
Luis Mendo,

@LuisMendo Dirò di no prendendo questo come input. Lo spazio bianco finale va bene purché assomigli all'input.
Veskah,

2
Suggerimento per quelli che controllano se i caratteri sono >"-": Poiché la stringa di input è garantita per iniziare -, puoi invece confrontare il parametro / argomento / nome della variabile che stai usando per quello.
Shaggy,

Risposte:


11

Vim, 60, 46, 38 , 37 byte / sequenze di tasti

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

<esc>e <C-r>sono entrambi 1 byte / sequenza di tasti. Byte Counter

Caso di prova 1 (modalità dettagliata)

Caso di prova 2 (modalità dettagliata)

Grazie a Grimy per le idee che hanno portato a una riduzione di 22 byte :)


2
@Veskah ughhhhhh vim è super schizzinoso riguardo ai casi limite "fai qualcosa 0 volte". Vedi modifica
DJMcMayhem

Non potrebbe :s/\%V./\='v^'[submatch(0)=='v']essere cl<C-R>='v^'['<C-R>"'=='v']per -13 byte? (ogni <CR> è solo un byte).
Grimmy,

2
@Grimy Ooh, buona idea. Inoltre s == cl, nel -14complesso.
DJMcMayhem

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

1
Ci ho pensato, ma non riesce se il carattere da invertire è alla fine di una riga ... ma poi le specifiche di input garantiscono che è seguito da un -, quindi funziona davvero! Duh.
Grimmy


4

K (oK) , 31 27 byte

Soluzione:

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

Provalo online!

Spiegazione:

Risposta rapida, proverò a giocare a golf. 0-indicizzati.

`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

Gli appunti:

  • -4 byte grazie al >93trucco

3

Python 3 , 140 134 103 byte

(-30 grazie a DJMcMayhem ♦, -1 in più grazie 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:]

Provalo online!


Oof, secondo tentativo di giocare a golf. Questo utilizza solo un ciclo piuttosto sofisticato sulla stringa, usando xper tenere traccia dell'indice di switch corrente. Utilizza 1-indicizzazione.

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



O 104 se python 3 è accettabile
DJMcMayhem

@DJMcMayhem Ooh, grazie per quello sostituisci catch xd Vorresti pubblicare Python 3 come risposta separata o pensi che sia abbastanza simile da aggiungere come modifica a questo?
Rin Fourier trasforma il

1
Sentiti libero di aggiungerlo :) Potrei pubblicare una risposta a Python 3, ma probabilmente proverei prima a trovare il mio approccio.
DJMcMayhem

3

Gelatina , 12 byte

O^%5T⁴ịƲ¦40Ọ

Un programma completo che accetta una stringa e un elenco di numeri interi che stampa il risultato.

Provalo online!

Come?

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 byte

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

Provalo online!

(-2 byte grazie a Jo King)

L'operatore di sostituzione di Perl 6 Sprende convenientemente un nthavverbio che accetta non solo un singolo indice in cui effettuare la sostituzione, ma un elenco di essi, esattamente come necessario qui.

La sostituzione è $/ ~^ '(', dove $/è il testo corrispondente (sia vo ^), ~^è lo stringwise esclusivo o operatore, ed (è il personaggio cui bit girare vin ^e viceversa.





2

Gelatina , 14 byte

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

Provalo online!

Programma completo.

Sembra troppo lungo ...


Non conosco Jelly, quindi non riesco a capire come provarlo da solo, ma potresti sostituirlo ”-con il nome del primo argomento ( ³?), Che è garantito per iniziare con un -, invece?
Shaggy,

@Shaggy No, perché >vettorializza. Puoi vedere che non funziona .
Erik the Outgolfer, il

ah, è esattamente quello che ho provato :) Non sapevo se fosse la mia mancanza di conoscenza di Jelly a causare o no. Non supponiamo che sia incorporato un singolo personaggio per ottenere il primo personaggio del primo argomento?
Shaggy,

@Shaggy Ehm ... gli unici built-in per gli argomenti della riga di comando sono ³, , , e , per la prima al quinto CLA rispettivamente. Puoi leggere la pagina Atomi per scoprire se esiste una funzione incorporata specifica.
Erik the Outgolfer, il

Ah, beh, valeva la pena provare. Un giorno, io sarò tuffarsi in Jelly correttamente.
Shaggy,

2

Stax , 13 byte

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

Esegui ed esegui il debug

Questo utilizza indici basati su 0.

  1. Trova tutti gli indici della regex [v^].
  2. Indicizza nella matrice dell'indice usando l'input.
  3. Ad ogni risultato, xo il codice ASCII dell'input con 40. Questo è xor('v', '^').

2

Pulito , 93 byte

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

Provalo online!

Definisce la funzione $ :: [Int] -> [Char] -> [Char]prendendo un elenco di indici con indice zero e restituendo una funzione che accetta la stringa e restituisce la stringa modificata.




1

JavaScript, 111 byte

Codice

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

Accetta input nel formato f (x) (y) dove x è l'indice e y è il centralino. Gli indici sono 0 indicizzati

Provalo online!

Spiegazione

Per ogni indice

x.map(i=>...

costruire la regex che trova l'indice + 1 ° "^" o "v"

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

inseriscilo in una stringa per sostituirlo con il simbolo opposto "v" <-> "^"

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

quindi valuta la stringa come una funzione

eval(...)

Dopo aver ripetuto gli indici per passare, restituisci il centralino

return y

1

Gelatina , 17 byte

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

Provalo online!

Un programma completo che prende gli indici come primo e la stringa come secondo argomento. Stampa l'uscita con gli interruttori indicati invertiti.


1

Retina 0.8.2 , 66 62 byte

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

Provalo online! Il link include un caso di test. 1-indicizzati. Spiegazione:

\d+
$*

Converti i numeri di input in unario.

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

Traslitterare tra ve ^tutti i caratteri con la proprietà che il numero di vs ed ^è così lontano (compreso) è uguale a uno dei numeri di ingresso.

1A`

Elimina i numeri di input.


1

Carbone , 23 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. 0-indicizzati. Spiegazione:

 η                      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 byte

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

Provalo

®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 byte

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

Provalo

Ë>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, il tuo codice non è più felice (ha perso il :D)
Veskah
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.