Dort habe ich es gebrochen (mit einer Schere)

15

Herausforderung

Schneiden Sie bei einer Zeichenfolge, die eine Schnittregel und eine andere Zeichenfolge beschreibt, Teile aus der zweiten Zeichenfolge mit der von der ersten Zeichenfolge beschriebenen Regel aus.

Beide Zeichenfolgen bestehen aus Buchstaben a-zoder A-Z, je nachdem, welche Sie auswählen (sie müssen nicht auf die gleiche Weise dargestellt werden). Die Art und Weise, wie die zweite Zeichenfolge geändert werden soll, ist nachfolgend beschrieben:

Algorithmus

Nehmen Sie die erste Zeichenfolge und stellen Sie sich vor, Sie füllen die Lücken zwischen nicht benachbarten (aufsteigenden) Buchstaben mit =; zum Beispiel abcfg=> abc==fg. Richten Sie dann die beiden Zeichenfolgen aus und geben Sie alle Zeichen aus der ersten Zeichenfolge zurück, die nicht über einem Gleichheitszeichen liegen. Zum Beispiel gegeben abcfgund qrstuvwals Eingaben:

qrstuvw - Modify
abc==fg - Modifier

qrs--vw -> qrsvw

Wenn der Modifikator nach dem Ausfüllen mit Gleichheitszeichen kürzer ist, sollten alle nachfolgenden Zeichen in der zweiten Zeichenfolge enthalten sein. Wenn der Modifikator länger ist, werden die nachfolgenden Zeichen ignoriert.

Es ist nicht garantiert, dass der Modifikator sortiert ist.

Testfälle

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

Referenzimplementierung (zum Generieren von Testfällen) -> TIO

Regeln

  • Es gelten Standardlücken
  • Sie können Eingaben als zwei Zeichenfolgen, zwei Listen von Zeichen, eine Matrix von Zeichen usw. annehmen (jedes andere vernünftige Format ist akzeptabel).
  • Sie können eine Zeichenfolge oder eine Liste von Zeichen (oder ein anderes Standardformat für Zeichenfolgen) ausgeben.
  • Dies ist Codegolf , daher wird die kürzeste Antwort in Bytes in jeder Sprache zum Gewinner ihrer Sprache erklärt. Es wird keine Antwort akzeptiert.
  • Beide Zeichenfolgen können leer sein.

Viel Spaß beim Golfen!

Inspiriert von Kevin Cruijssens jüngsten zwei Herausforderungen: "Dort habe ich es repariert (mit Klebeband / Seil )."

code-golf  string 
— HyperNeutrino
quelle
4
— Erik die Outgolfer
2
Sehr häufiger Trend, den ich hier
— sehe
@L_Church Herausforderungen folgen manchmal Trends. Da zwei ähnliche Herausforderungen veröffentlicht wurden, entschloss ich mich, den Trend fortzusetzen: DI wollte eine weitere "Ich habe es behoben" -Herausforderung veröffentlichen, aber a) Ich mag es, Dinge besser zu brechen "Idee: P
— HyperNeutrino
16
Nächste Herausforderung:There, I blew it up (with a segfault)
— Magic Octopus Urn
1
@MagicOctopusUrn Jemand hat Sie geschlagen :(
— Caird Coinheringaahing

Antworten:

5

JavaScript (ES6), 81 bis 80 Byte

Übernimmt Eingaben in der Currying-Syntax (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):''

Probieren Sie es online!

Kommentiert

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
— Arnauld
quelle
3

05AB1E , 20 17 Bytes

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

Probieren Sie es online!

Berechnet den ASCII-Abstand zwischen den einzelnen Zeichen, wobei so viele Leerzeichen vorangestellt werden, wenn dies positiv ist. Ein negativer Abstand führt dazu, dass gemäß Spezifikation 0 Leerzeichen angehängt werden. Danach schiebe ich alle Zeichen an die gleichen Indizes in Zeichenfolge 2 wie die Leerzeichen in der ersten manipulierten Zeichenfolge.

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% sicher, dass ich weitere 2-3 Bytes verlieren kann, indem ich keine Leerzeichen verwende, sondern das Zeichen auf Index N drücke. Ich arbeite gerade noch an dieser Variante ... Was meine "bessere Idee" war:

05AB1E , 18 Bytes

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

Probieren Sie es online!

Ich habe das Gefühl, ich vermisse etwas, wenn Sie Verbesserungen sehen ε1‚Z}, ʒ²g‹}oder 0¸ìlmk ...

Ç¥ε1‚Z}ηO0¸ìèwar 13, aber es wickelt, wenn n > |input_2|man input_2[n%|input_2|]...

— Magische Kraken-Urne
quelle
Ihre zweite Version könnte Ç ¥ ε1M} sein. ¥ ʒ²g ‹} è , aber keine der drei Versionen scheint für diese Eingaben zu funktionieren.
— Emigna
Die obige Version könnte durch Hinzufügen behoben werden IgÅ1«, aber vielleicht gibt es einen besseren Weg?
— Emigna
2

Stax , 15 Bytes

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

Führen Sie es aus und debuggen Sie es

Dies ist die ASCII-Darstellung. 

:-Z+{v0|Mt|cB]pFp
  1. Holen Sie sich paarweise Unterschiede.
  2. Stellen Sie eine Null voran.
  3. Für jeden Unterschied wiederholen
    1. Subtrahiere 1 und nimm das Maximum mit Null.
    2. Entfernen Sie so viele Zeichen vom Anfang der Zeichenfolge.
    3. Stoppen Sie, wenn die Zeichenfolge leer ist.
  4. Drucken Sie den Rest der Zeichenfolge.
— rekursiv
quelle
1
Ich mag, wie der Code sagt╟╣i
— Uriel
2

Jelly , 14 Bytes

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

Ein dyadischer Link, der den Modifikator als Liste von Zeichen auf der linken Seite und die Liste der zu ändernden Zeichen auf der rechten Seite akzeptiert und eine Liste von Zeichen zurückgibt.

Probieren Sie es online!

Wie?

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']
— Jonathan Allan
quelle
Habe den ¬Trick in meiner Antwort benutzt. :) (Wir haben technisch den gleichen Algorithmus, aber Sie haben kürzer gemacht, gut gemacht!)
— Erik der Outgolfer
Oh ja, ich wollte etwas dazu sagen ¬, habe es aber vergessen, als ich einen Handy-Fatfinger-Post eines noch nicht fertiggestellten 13-Byte-Versuchs machte.
— Jonathan Allan
2

JavaScript (ES6), 79 Byte

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

Verwendet denselben Algorithmus zum Berechnen des Abstands zwischen Buchstaben wie meine letzte Antwort .

Testfälle:

Code-Snippet anzeigen

— Rick Hitchcock
quelle
2

K (ngn / k) , 27 24 25 Bytes

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

Probieren Sie es online!

{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
— ngn
quelle
1

Kohle , 29 28 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Aufgrund meiner Antwort auf Dort habe ich es mit Klebeband behoben. Erläuterung:

       ⭆θ⁺×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

Hinweis: Dies sollte 28 Byte sein, ist jedoch Andzum Zeitpunkt des Schreibens fehlerhaft.

— Neil
quelle
0

Java 8, 117 Bytes

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;}

Erläuterung:

Probieren Sie es online aus.

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
— Kevin Cruijssen
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.