Inspiriert von dieser Herausforderung .

Tor:

Bei einer vorkonfigurierten Schalttafel und einer Liste von Indizes müssen die Schalter an den angegebenen Indizes invertiert werden.

Eine Schalttafel besteht aus einer Anzahl von Schaltern ( voder Schaltern ^) -, die in Reihen unterschiedlicher Länge angeordnet sind. Hier ist ein Beispiel für eine Telefonzentrale:

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

Um einen Schalter zu invertieren / umzudrehen, müssen Sie ihn von vauf ^oder von ^auf ändern v.

Die Schalter sind von links nach rechts und von oben nach unten indiziert. Im obigen Beispiel vwäre beispielsweise der letzte in der ersten Reihe an Position 3 und der ^in der mittleren Reihe an Position 4 (mit 1-Indexierung).

Eingang:

• Eine Zeichenfolge (oder eine Liste von Zeichenfolgen), die die Telefonzentrale darstellt. Es ist garantiert, dass es zum regulären Ausdruck passt ((-[v^])+-)(\n(-[v^])+-)*.
• Eine möglicherweise leere Liste von Zahlen, die Indizes darstellen, kann mit 0 oder 1 (oder einer beliebigen Zahl, wenn Sie möchten) indiziert sein. Dies sind die Schalter, die umgedreht werden müssen.

Ausgabe:

• Eine Schalttafel in der gleichen Form wie der Eingang, wobei die angegebenen Schalter invertiert sind. Alle nicht angegebenen Schalter sollten ihren ursprünglichen Zustand beibehalten.

Regeln:

• Eingaben werden immer korrekt formatiert und keine angegebenen Indizes sind außerhalb der Grenzen.
• Die Liste der Indizes wird sortiert und enthält keine Duplikate.
• Geben Sie in Ihrer Antwort an, welche Indizierung Sie verwenden, sei es 0, 1 oder eine beliebige.
• Das nachgestellte Leerzeichen ist in Ordnung, solange die Ausgabe wie die Eingabe aussieht.
• Das ist Code-Golf, also gewinnt der kürzeste Code.

Beispiele:

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

Vim, 60, 46, 38 , 37 Bytes / Tastenanschläge

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

<esc>und <C-r>sind beide 1 Byte / Tastendruck. Byte-Zähler

Testfall 1 (ausführlicher Modus)

Testfall 2 (ausführlicher Modus)

Vielen Dank an Grimy für die Ideen, die zu einer Reduzierung von 22 Bytes geführt haben :)

JavaScript, 63 59 Bytes

a=>s=>s.replace(/v|\^/g,x=>"^v"[a.includes(n++)^x>"^"],n=0)

Probieren Sie es online!

4 Bytes dank Arnauld gespeichert .

K (oK) , 31 27 Bytes

Lösung:

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

Probieren Sie es online!

Erläuterung:

Schnelle Antwort, werde versuchen, Golf zu spielen. 0-indiziert.

`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

Anmerkungen:

• -4 Bytes dank >93Trick

Python 3 , 140 134 103 Bytes

(-30 dank DJMcMayhem ♦, -1 dank 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:]

Probieren Sie es online!

Oof, zweiter Versuch überhaupt etwas zu golfen. Dies verwendet nur eine ziemlich unkomplizierte Schleife über den String, xum den aktuellen Schalterindex zu verfolgen. Verwendet 1-Indizierung.

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

Gelee , 12 Bytes

O^%5T⁴ịƲ¦40Ọ

Ein vollständiges Programm, das eine Zeichenfolge und eine Liste von Ganzzahlen akzeptiert, die das Ergebnis ausgeben.

Probieren Sie es online!

Wie?

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

Python 3.8 (Vorabversion) , 80 , 78 , 77 , 71 , 70 Bytes

lambda x,s,i=0:''.join([c,'^v'[c<'v']][c>s and(i:=i+1)in x]for c in s)

-1 Byte, danke an @Shaggy

Probieren Sie es online!

Perl 6 , 31 Bytes

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

Probieren Sie es online!

(-2 Bytes dank Jo King)

Der Substitutionsoperator von Perl 6 verwendet Spraktischerweise ein nthAdverb, das nicht nur einen einzelnen Index akzeptiert, an dem die Ersetzung vorgenommen werden soll, sondern eine Liste von diesen, genau wie hier benötigt.

Die Ersetzung ist $/ ~^ '(', wo $/der übereinstimmende Text ist (entweder voder^ ), ~^ist der stringwise Exklusiv-ODER - Operator und (das Zeichen , die Bits drehen vin ^und umgekehrt.

MATL , 29 Bytes

c!tt45>o2yfi)(2=XK)t106-E-K(!

Probieren Sie es online!Oder überprüfen Sie alle Textfälle .

Die Eingabe ist ein Zellenarray von Zeichenfolgen und ein Zeilenvektor von Zahlen mit 1-basierter Indizierung. Die Ausgabe wird mit Leerzeichen rechts aufgefüllt.

Python 2 , 105 97 91 Bytes

lambda a,s:reduce(lambda(t,i),c:(t+[c,'^v'[c<'v']][c>'-'and i in a],i+(c>'-')),s,('',0))[0]

Probieren Sie es online!

6 Bytes gespeichert durch Stehlen mit Rins Fourier - Transformation ‚s c>'-'stattc in'^v' .

0-indexiert.

Jelly , 14 Bytes

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

Probieren Sie es online!

Volles Programm.

Das fühlt sich zu lang an ...

Stax , 13 Bytes

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

Führen Sie es aus und debuggen Sie es

Dies verwendet 0-basierte Indizes.

1. Hier finden Sie alle Indizes des regulären Ausdrucks [v^].
2. Indizieren Sie mithilfe der Eingabe in das Index- Array.
3. Bei jedem Ergebnis xoder den ASCII-Code der Eingabe mit 40. Das ist xor('v', '^').

Sauber , 93 Bytes

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

Probieren Sie es online!

Definiert die Funktion, $ :: [Int] -> [Char] -> [Char]die eine mit Nullen indizierte Liste von Indizes verwendet und eine Funktion zurückgibt, die die Zeichenfolge verwendet und die geänderte Zeichenfolge zurückgibt.

JavaScript (Node.js) , 101 98 93 91 77 67 Byte

a=>s=>[...s].map(c=>t+=c>s?"^v"[a.includes(i++)^c>"^"]:c,t=i=``)&&t

Probieren Sie es online!

10 Bytes, danke an Vorschläge von Shaggy .

Port meiner Python-Antwort . Nicht gewohnt, Javascript zu spielen!

V , 20 Bytes

ÑñÀ/vüÞ
sv^l?Ö"
xH

Probieren Sie es online!

Verwendet einige neue Funktionen, zum Beispiel Ñdie unglaublich nützlich sind.

JavaScript, 111 Bytes

Code

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

Übernimmt Eingaben im Format f (x) (y), wobei x die Indizes und y die Schalttafel ist. Indizes sind 0 indiziert

Probieren Sie es online!

Erläuterung

Für jeden Index

x.map(i=>...

Konstruieren Sie den regulären Ausdruck, der den Index + 1 "^" oder "v" findet.

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

füge es in eine Zeichenkette ein, um es durch das entgegengesetzte Symbol "v" <-> "^" zu ersetzen

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

Werten Sie dann den String als Funktion aus

eval(...)

Geben Sie die Schalttafel zurück, nachdem Sie die Indizes zum Wechseln durchlaufen haben

return y

Gelee , 17 Bytes

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

Probieren Sie es online!

Ein vollständiges Programm, das die Indizes als erstes und den String als zweites Argument verwendet. Druckt die Ausgabe mit umgedrehten Schaltern.

Retina 0.8.2 , 66 62 Bytes

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

Probieren Sie es online! Link enthält Testfall. 1-indiziert. Erläuterung:

\d+
$*

Wandle die eingegebenen Zahlen in unäre um.

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

Transkribieren Sie zwischen vund ^alle Zeichen mit der Eigenschaft, dass die Anzahl von vs und ^s bis jetzt (einschließlich) einer der eingegebenen Zahlen entspricht.

1A`

Löschen Sie die eingegebenen Nummern.

Holzkohle , 23 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. 0-indiziert. Erläuterung:

 η                      Input string
⭆                       Map over characters and join
  ⎇                     If
   №                    Count of (i.e. exists)
     ⌕                  Index of
               κ        Current index in
       Ｌ                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

Ruby , 56 Bytes

1-indiziert.

->s,i{j=0;s.gsub(/[v^]/){i==i-[j+=1]?$&:"v^".tr($&,'')}}

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 73 Byte

a=>b=>{int i=0;return a.Select(x=>x>45&&b.Contains(++i)?(char)(x^40):x);}

Probieren Sie es online!

Japt , 15 Bytes

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

Versuch es

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

Japt , 16 14 Bytes

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

Versuch es

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