Défi

Étant donné une chaîne décrivant une règle de coupe et une autre chaîne, coupez des parties de la deuxième chaîne en utilisant la règle décrite par la première chaîne.

Les deux chaînes seront constituées de lettres a-zou A-Z, selon celle que vous choisissez (elles ne doivent pas être représentées de la même manière). La façon dont la deuxième chaîne doit être modifiée est décrite ci-dessous:

Algorithme

Prenez la première chaîne et imaginez remplir les espaces entre les lettres non adjacentes (croissantes) avec =; par exemple, abcfg=> abc==fg. Ensuite, alignez les deux chaînes et renvoyez tous les caractères de la première chaîne qui ne sont pas au-dessus d'un signe égal. Par exemple, étant donné abcfget qrstuvwen entrée:

qrstuvw - Modify
abc==fg - Modifier

qrs--vw -> qrsvw

Si le modificateur est plus court après avoir été rempli de signes égaux, tous les caractères de fin de la deuxième chaîne doivent être inclus. Si le modificateur est plus long, les caractères de fin sont ignorés.

Le modificateur n'est pas garanti d'être trié.

Cas de test

abcfg, qrstuvw -> qrsvw
abqrs, qwertyuiopasdfghjklzxcvbnm -> qwjklzxcvbnm
za, qr -> qr
azazaz, qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq -> qmn

Implémentation de référence (utilisée pour générer des cas de test) -> TIO

Règles

• Les échappatoires standard s'appliquent
• Vous pouvez prendre la saisie comme deux chaînes, deux listes de caractères, une matrice de caractères, etc. (tout autre format raisonnable est acceptable)
• Vous pouvez produire une chaîne ou une liste de caractères (ou un autre format standard pour les chaînes)
• Il s'agit de code-golf , donc la réponse la plus courte en octets dans chaque langue est déclarée gagnante pour sa langue. Aucune réponse ne sera acceptée.
• L'une ou l'autre chaîne peut être vide.

Bon golf!

_{^{Inspiré par les deux derniers défis de Kevin Cruijssen, "Là, je l'ai corrigé (avec du ruban / corde )"}}

JavaScript (ES6), 81 80 octets

Prend des entrées dans la syntaxe de curry (modify)(modifier).

s=>g=([c,...a],d=i=0,x=s[k=parseInt(c,36),i+=c?d&&(k-d+26)%26:1])=>x?x+g(a,k):''

Essayez-le en ligne!

Commenté

s =>                       // outer function, taking the string s to modify
  g = (                    // recursive inner function g(), taking:
    [c, ...a],             //   c = current modifier character; a[] = remaining characters
    d = i = 0,             //   d = code of previous modifier character; i = pointer in s
    x = s[                 //   x = i-th character of s
      k = parseInt(c, 36), //     k = code of the current modifier character in [10..35]
      i += c ?             //     update i; if c is defined:
        d &&               //       if d = 0, let i unchanged
        (k - d + 26) % 26  //       otherwise, add the difference between k and d (mod 26)
      :                    //     else:
        1                  //       just pick the next character by adding 1
    ]                      //   end of character lookup in s
  ) =>                     //
    x ?                    // if x is defined:
      x + g(a, k)          //   append x and do a recursive call to g()
    :                      // else:
      ''                   //   stop recursion

Python 3 , 99 octets

lambda a,b:[x for x,y in zip(a,''.join(d+(ord(c)+~ord(d))%26*'='for c,d in zip(b[1:],b))+a)if'='<y]

Essayez-le en ligne!

05AB1E , 20 17 octets

ćsv¹Ç¥Nè<yú«}SðÊÏ

Essayez-le en ligne!

Calcule la distance ASCII entre chaque caractère, en ajoutant autant d'espaces s'il est positif. Une distance négative entraîne l'ajout de 0 espace, conformément aux spécifications. Après cela, je pousse tous les caractères aux mêmes indices dans la chaîne 2 que les espaces dans la première chaîne manipulée.

Input: [azaz,qwertyuiopasdfghjklzxcvbnm]
--------------------------------------------------------------------------------

ćs                # Remove head, swap                           | [a, zaz]
  v               # Iterate...                                  | ............
   ¹Ç¥            # Push deltas between each char of string 1   | [a,[25,-25,25,-25]]
      Nè          # Push delta at index...                      | [a, 25]
        <         # Decrement (for 1-indexed answer)            | [a, 24]
         y        # Push current char in iteration...           | [a, 24, z]
          ú       # Append b spaces to a...                     | [a, '(spaces)z']
           «      # Concat                                      | [a(spaces)z]
            }     # End loop.                                   | [a(spaces)za(spaces)z]
             SðÊ  # Split, push 1 for non-space elements.       | [Long array of 1/0]
                Ï # Push chars from 2 that aren't spaces in 1.  | ['qmn']

90% sûr que je peux perdre encore 2 à 3 octets en n'utilisant pas d'espaces, mais en poussant le caractère à l'index N. Toujours en train de travailler sur cette variante ... Quelle est ma "meilleure idée":

05AB1E , 18 octets

Ç¥ε1‚Z}ηO0¸ìʒ²g‹}è

Essayez-le en ligne!

J'ai l'impression de manquer quelque chose, si vous voyez des améliorations ε1‚Z}, ʒ²g‹}ou 0¸ìlmk ...

Ç¥ε1‚Z}ηO0¸ìèétait de 13, mais il enveloppe quand n > |input_2|à input_2[n%|input_2|]...

Stax , 15 octets

Ç«|¢Äα•è@╟╣i`vF

Exécuter et déboguer

Ceci est la représentation ascii.

:-Z+{v0|Mt|cB]pFp

1. Obtenez des différences par paire.
2. Ajoutez un zéro.
3. Pour chaque différence, répétez
   4. Soustrayez 1 et prenez le maximum avec zéro.
   5. Supprimez autant de caractères au début de la chaîne.
   6. Arrêtez si la chaîne est vide.
4. Imprimez le reste de la chaîne.

Gelée , 14 octets

OI’R¬⁸żFḣL}aḟ0

Un lien dyadique acceptant le modificateur comme une liste de caractères à gauche et la liste de caractères à modifier à droite renvoyant une liste de caractères.

Essayez-le en ligne!

Comment?

OI’R¬⁸żFḣL}aḟ0 - Link list of characters Modifier, list of characters InStr
               -                       e.g.  ['a','c','g','a'], ['n','m','l','k','j']
O              - ordinals of Modifier        [97,99,103,97]
 I             - incremental differences     [2,4,-6]
  ’            - decrement                   [1,3,-7]
   R           - range                       [[1],[1,2,3],[]]
    ¬          - NOT (vectorises)            [[0],[0,0,0],[]]
     ⁸         - chain's left argument, Modifier
      ż        - zip together                [['a',[0]],['c',[0,0,0]],['g',[]],['a']]
       F       - flatten                     ['a',0,'c',0,0,0,'g','a']
         L}    - length of right (InStr)     5
        ḣ      - head to index               ['a',0,'c',0,0] (if shorter or equal, no effect)
           a   - AND with InStr (vectorises) ['n',0,'l',0,0]
            ḟ0 - filter out zeros            ['n','l']

JavaScript (ES6), 79 octets

f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

Utilise le même algorithme pour calculer la distance entre les lettres que ma dernière réponse .

Cas de test:

f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

console.log(f('abcfg','qrstuvw')) // -> qrsvw
console.log(f('abqrs','qwertyuiopasdfghjklzxcvbnm')) // -> qwjklzxcvbnm
console.log(f('za','qr')) // -> qr
console.log(f('azazaz','qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq')) // -> qmn

APL (Dyalog Classic) , 35 34 32 octets

{⍵∩⍨⊃¨↓∘⍵¨+\0,1⌈(-2-/⎕ucs⍺),=⍨⍵}

Essayez-le en ligne!

K (ngn / k) , 27 24 25 octets

{y[+\0,1|1_-':x,!#y]^" "}

Essayez-le en ligne!

{y[+\0,1|1_-':x,!#y]^" "}

{                       } function with x and y as arguments
                 #y       the length of y
                !#y       0 1 2 ... (#y)-1
              x,          x concatenated with
           -':            differences between pairs
         1_               rm extra leading item
       1|                 max between 1 and
     0,                   prepend 0
   +\                     partial sums
 y[                ]      index y with that
                    ^" "  rm spaces due to out-of-bounds indexing

Haskell , 49 octets

(x:r)#(y:n:s)=x:drop(length[y..n]-2)r#(n:s)
r#_=r

Essayez-le en ligne!

Perl 5 , 45 octets

s/./v0.$;x(ord($')-1-ord$&)/eg;$_|=<>;s/\W//g

Essayez-le en ligne!

Ruby , 68 64 octets

->m,z,i=1{z[i,[0,m[i].ord+~m[i-1].ord].max]&&='';m[i+=1]?redo:z}

Essayez-le en ligne!

Fusain , 29 28 octets

⭆η×ιＩ§⁺⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1⭆η1κ

Essayez-le en ligne!Le lien est vers la version détaillée du code. Sur la base de ma réponse à Là, je l'ai fixé avec du ruban adhésif. Explication:

       ⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1        Fix it with tape, but map to 1s and 0s
      ⁺                 ⭆η1     Append extra 1s just in case
⭆η                              Map over the second string
     §                     κ    Get the character from the fixed string
    Ｉ                           Cast to integer
  ×ι                            Repeat the current character that many times
                                Implicitly print

Remarque: Cela devrait être de 28 octets, mais Andest rompu au moment de l'écriture.

Java 8, 117 octets

a->b->{for(int i=0,j;++i<a.length;b=j>0&b.length()>=i+j?b.substring(0,i)+b.substring(i+j):b)j=a[i]+~a[i-1];return b;}

Explication:

Essayez-le en ligne.

a->b->{                   // Method with char-array + String parameters and String return
  for(int i=0,j;++i<a.length;
                          //  Loop `i` in range [1; length_of_array)
      b=                  //    After every iteration: change the String-input to:
        j>0               //     If `j` is larger than 0,
        &b.length()>=i+j? //     and the length of `b` is larger or equal to `i+j`:
         b.substring(0,i) //      Take the substring [0; i)
         +b.substring(i+j)//      + the substring [i+j; end_of_string]
        :                 //     Else:
         b)               //      Leave `b` the same
    j=a[i]+~a[i-1];       //   Set `j` to the difference between two adjacent chars - 1
  return b;}              //  Return the modified input-String