Inverser certains commutateurs sur un standard


23

Inspiré par ce défi .

Objectif:

Étant donné un standard préconfiguré et une liste d'index, inversez les commutateurs aux index donnés.

Un tableau est composé d'un certain nombre de commutateurs ( vou ^) enveloppés de -'s et disposés en rangées de longueur variable. Voici un exemple de standard:

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

Pour inverser / basculer un commutateur, il faut le changer de và ^, ou de ^àv .

Les commutateurs sont indexés de gauche à droite, de haut en bas. Par exemple, dans l'exemple ci-dessus, le dernier vde la première ligne serait en position 3 et le^ de la ligne du milieu serait à 4 (en utilisant l'indexation 1).

Contribution:

  • Une chaîne (ou une liste de chaînes) représentant le standard. Il est garanti pour correspondre à l'expression régulière((-[v^])+-)(\n(-[v^])+-)* .
  • Une liste éventuellement vide de nombres représentant des index, peut être 0 ou 1 (ou un certain nombre arbitraire si vous le souhaitez) indexé. Ce sont les commutateurs qui doivent être actionnés.

Sortie:

  • Un tableau de distribution de la même forme que l'entrée avec les commutateurs spécifiés inversés. Tout commutateur non spécifié doit conserver son état initial.

Règles:

  • L'entrée sera toujours correctement formatée et aucun index donné ne sera hors limites.
  • La liste des index sera triée et n'aura pas de doublons.
  • Indiquez dans votre réponse quelle indexation vous utilisez, que ce soit 0, 1 ou arbitraire.
  • La fin des espaces blancs est correcte tant que la sortie ressemble à l'entrée.
  • C'est le donc le code le plus court gagne.

Exemples:

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

Pouvons-nous produire un tableau de caractères rectangulaire, remplissant à droite les lignes plus courtes avec des espaces? Pouvons-nous également prendre des informations sous cette forme?
Luis Mendo

@LuisMendo Je vais dire non en prenant ça comme entrée. La fin de l'espace blanc est correcte tant qu'elle ressemble à l'entrée.
Veskah

2
Astuce pour ceux qui vérifient si les caractères sont >"-": Comme la chaîne d'entrée est garantie pour commencer -, vous pouvez vérifier par rapport au paramètre / argument / nom de variable que vous utilisez pour cela à la place.
Shaggy

Réponses:


11

Vim, 60, 46, 38 , 37 octets / touches

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

<esc>et <C-r>sont tous deux 1 octet / frappe. Compteur d'octets

Cas de test 1 (mode détaillé)

Cas de test 2 (mode détaillé)

Merci à Grimy pour les idées qui ont conduit à une réduction de 22 octets :)


2
@Veskah ughhhhhh vim est très pointilleux sur les cas de bord "faire quelque chose 0 fois". Voir le montage
DJMcMayhem

Ne peut pas :s/\%V./\='v^'[submatch(0)=='v']être cl<C-R>='v^'['<C-R>"'=='v']pour -13 octets? (chaque <CR> n'est qu'un octet).
Grimmy

2
@Grimy Ooh, bonne idée. Aussi s == cl, donc dans l' -14ensemble.
DJMcMayhem

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

1
J'y ai pensé, mais cela échoue si le caractère à inverser est à la fin d'une ligne… mais alors la spécification d'entrée garantit qu'il est suivi d'un -, donc ça marche vraiment! Duh.
Grimmy


4

K (oK) , 31 27 octets

Solution:

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

Essayez-le en ligne!

Explication:

Réponse rapide, va essayer de jouer au golf. 0 indexé.

`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

Remarques:

  • -4 octets grâce à >93trick

3

Python 3 , 140 134 103 103 octets

(-30 grâce à DJMcMayhem ♦, -1 de plus grâce à 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:]

Essayez-le en ligne!


Oof, deuxième essai de jouer au golf. Cela utilise simplement une boucle plutôt simple sur la chaîne, en utilisantx permettant de garder la trace de l'index de commutateur actuel. Utilise l'indexation 1.

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



Ou 104 si python 3 est acceptable
DJMcMayhem

@DJMcMayhem Ooh, merci pour ce remplacement catch xd Souhaitez-vous publier le Python 3 comme une réponse distincte, ou pensez-vous qu'il est suffisamment similaire pour ajouter une modification à cela?
Transformée de Fourier de Rin le

1
N'hésitez pas à l'ajouter :) Je pourrais poster une réponse python 3, mais j'essaierais probablement de trouver ma propre approche en premier.
DJMcMayhem

3

Gelée , 12 octets

O^%5T⁴ịƲ¦40Ọ

Un programme complet acceptant une chaîne et une liste d'entiers qui imprime le résultat.

Essayez-le en ligne!

Comment?

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 octets

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

Essayez-le en ligne!

(-2 octets grâce à Jo King)

L'opérateur de substitution de Perl 6 Sprend commodément un nthadverbe qui accepte non seulement un seul index auquel effectuer le remplacement, mais une liste d'entre eux, exactement comme nécessaire ici.

Le remplacement est $/ ~^ '(', où $/est le texte correspondant (soit vou ^), ~^est exclusif ou alphabétiquement opérateur, et (est le caractère dont les bits transformer ven ^et vice - versa.





2

Gelée , 14 octets

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

Essayez-le en ligne!

Programme complet.

Cela semble trop long ...


Je ne connais pas Jelly, donc je ne sais pas comment l'essayer moi-même, mais pourriez-vous le remplacer ”-par le nom du premier argument ( ³?), Qui est garanti de commencer par un -, à la place?
Shaggy

@Shaggy Nope, car >vectorise. Vous pouvez voir que cela ne fonctionne pas .
Erik the Outgolfer le

ah, c'est exactement ce que j'ai essayé :) Je ne savais pas si c'était mon manque de connaissance de Jelly qui était la cause ou non. Ne supposez pas qu'il existe un seul caractère intégré pour obtenir le premier caractère du premier argument?
Shaggy

@Shaggy Erm ... les seuls built-ins pour les arguments de ligne de commande sont ³, , , et , pour la première à la cinquième ALC , respectivement. Vous pouvez lire la page Atomes pour savoir s'il existe une fonction intégrée spécifique.
Erik the Outgolfer

Ah, eh bien, ça valait le coup. Un jour, je vais plonger dans Jelly correctement.
Shaggy

2

Stax , 13 octets

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

Exécuter et déboguer

Cela utilise des indices basés sur 0.

  1. Trouver tous les indices de l'expression régulière [v^] .
  2. Index dans l' index tableau d' utilisant l'entrée.
  3. À chaque résultat, xou le code ascii de l'entrée avec 40. C'est ça xor('v', '^').

2

Nettoyer , 93 octets

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

Essayez-le en ligne!

Définit la fonction en $ :: [Int] -> [Char] -> [Char]prenant une liste d'index zéro indexée et en retournant une fonction qui prend la chaîne et renvoie la chaîne modifiée.




1

JavaScript, 111 octets

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}

Prend l'entrée au format f (x) (y) où x est les indices et y est le standard. Les indices sont 0 indexés

Essayez-le en ligne!

Explication

Pour chaque indice

x.map(i=>...

construire l'expression régulière qui trouve l'index + 1 e "^" ou "v"

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

insérez-le dans une chaîne pour le remplacer par le symbole opposé "v" <-> "^"

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

puis évaluer la chaîne en fonction

eval(...)

Après avoir parcouru les indices pour basculer, renvoyez le standard

return y

1

Gelée , 17 octets

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

Essayez-le en ligne!

Un programme complet prenant les indices comme premier et la chaîne comme deuxième argument. Imprime la sortie avec les commutateurs indiqués basculés.


1

Rétine 0,8,2 , 66 62 octets

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

Essayez-le en ligne! Le lien inclut un cas de test. 1 indexé. Explication:

\d+
$*

Convertissez les nombres entrés en unaire.

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

Translittérer entre vet ^tous les caractères avec la propriété que le nombre de vs et ^s jusqu'à présent (inclus) est égal à l'un des nombres d'entrée.

1A`

Supprimez les numéros saisis.


1

Fusain , 23 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. 0 indexé. Explication:

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

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

Essayez-le

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

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

Essayez-le

Ë>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, votre code n'est plus content (il a perdu le :D)
Veskah
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.