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.