Herausforderung:

Lesen Sie die Eingabe (innerhalb des sichtbaren ASCII-Bereichs) und die Ausgabe mit einigen Änderungen:

1. In jedem Satz von 10 Zeichen der Eingabe zufällig (50/50):
   • Ersetzen Sie ein Zeichen * (durch ein zufälliges ** Zeichen innerhalb des sichtbaren ASCII-Bereichs) (z. lumberjackB. wird lumbeZjack)
   • oder entfernen Sie ein Zeichen (zB lumberjackwird lmberjack)

^{* Wenn das Set weniger als 10 Zeichen enthält, müssen Sie es nicht ändern, können es aber.
** Das Zeichen kann mit der einen Eingabe identisch sein, solange es noch zufällig ist.}

Beispiel:

Eingabe: Go home cat! You're drunk!
Ausgabe: Go hom cat! YouLre drunk!
(nur ein Beispiel, da die Ausgabe zufällig sein kann, nicht als Testfall verwenden)

Regeln:

• Code-Golf , die wenigsten Charaktere gewinnen!

Pyth, 27 25 Bytes

VczTpXNOT?<JOr\ \ÞKC127JK

Testsuite hier verfügbar.

Vielen Dank an Maltysen für das Rasieren von 2 Bytes.

Erläuterung

VczTpXNOT?<JOr\ \ÞKC127JK    z autoinitalizes to input, T autoinitializes to 10 
 czT                         chop input into strings of length 10, returned as list of strings
V                            for each string N in this list:
            Or\ \Þ            randomly pick a char between ' ' (32) and 'Þ' (222)
           J                  and assign it to variable J
                  KC127       assign the DEL char to variable K
         ?<J      K           if J < K:
     XNOT              J       replace a random character in N with J
         ?<J      K           else:
     XNOT               K      replace a random character in N with K
    p                         print this string with no trailing newline

Wie so oft halte ich dies für eine naive Methode, die möglicherweise verbessert wird. Normalerweise finde ich beim Schreiben der Erklärung etwas Offensichtliches, aber diesmal ist mir nichts aufgefallen.

*> <> , 44 46 52 50 Bytes

rl5(?voooo/!|Ou+1Ox:@=?~o~oooo!
ol5(?v" ":/
o;!?l<

Probieren Sie es hier aus!

Dies verwendet ein beliebiges ASCII-Zeichen in der Nähe / über dem Leerzeichen für die zufälligen Zeichen. Dadurch wird immer das 6. Zeichen bearbeitet, es sei denn, es ist das Ende einer Zeichenfolge und die Länge dieser Zeichenfolge ist kein Vielfaches von 10. Dies hat eine 50% ige Chance, das 7. Zeichen zu entfernen, anstatt das 6. Zeichen zu bearbeiten.

Eingang

Der IEEE-Standard für Gleitkomma-Arithmetik (IEEE 754) ist ein technischer Standard für Gleitkomma-Berechnungen, der 1985 vom Institut für Elektro- und Elektronikingenieure (IEEE) eingeführt wurde. Der Standard befasste sich mit vielen Problemen, die in den verschiedenen Gleitkommaimplementierungen auftreten und deren zuverlässige und portable Verwendung erschwert. Viele Hardware-Gleitkommaeinheiten verwenden jetzt den IEEE 754-Standard.

Ausgabe

Der IEE-Standard für Gleitkomma-Aithmetik (EEE 754) ist ein technischer Standard! für Fließkomma-Berechnungen, die 1985 vom Institut für Elektrotechnik und Elektrotechnik (IEE%) gegründet wurden. Der Standard fügte hinzu! Probleme # gefunden in! er Taucher! schwebende Salbenimplementierung ", die es ihnen schwer macht, zuverlässig und portabel zu sein. Viele! Hardware-Foating-Einheiten verwenden den IEEE 754" -Standard.

Bearbeiten: Diese Antwort liegt wahrscheinlich nicht immer im sichtbaren ASCII-Bereich, Bearbeiten ... Behoben.

Edit2: Ich habe nicht gesehen, dass es eine 50/50-Chance geben muss, einen Charakter zu entfernen und erneut zu bearbeiten ... Ich glaube, jetzt ist alles in Ordnung :).

Perl 6 ,  78  67 Bytes

{[~] map {~S/.**{(^.chars).pick}<(./{(' '..'~').pick x Bool.pick}/},.comb(10)}

{[~] .comb(10)».&{~S/.**{10.rand}<(./{(' '..'~').pick x 2.rand}/}}

Versuch es

Erläuterung:

{
  [~]                  # reduce with string concatenation operator

  .comb(10)\           # take input and break it into chunks of up-to 10 chars

  ».\                 # on each of them call the following

  &{
    ~                  # Stringify the following

    S/                 # substituted
      .                # any char
        **             # repeated
           { 10.rand } # a random number of times

      <(               # ignore all of that

      .                # the char to be removed/replaced
    /{

      ( ' ' .. '~' ).pick  # choose a character
      x                    # string repeated
      2.rand               # zero or one times

    }/

  }
}

Pyth - 21 Bytes

smO,XdOTOr;\~.DdOTcQT

Probieren Sie es hier online aus .

Python 3 , 75 Bytes

Das 75-Byte wendet die Transformation auf das erste Zeichen jeder Gruppe an und wählt nur aus 2 zufälligen Zeichen aus, wie in der Jelly-Antwort (welche OP erlaubt):

from random import*
f=lambda s:s and choice(['','a','b'])+s[1:10]+f(s[10:])

Probieren Sie es online aus!

Dies ist eine rekursive Funktion, die bei jeder Iteration entweder nichts vorstellt 'a'oder 'b'sich selbst mit den ersten 10 abgeschnittenen Zeichen aufruft. Die letzte Iteration s andschließt bei (eine leere Zeichenfolge ist falsch) kurz, wodurch eine unendliche Rekursion vermieden wird.

Das Ergebnis aller separaten Aufrufe wird dann verkettet und an den Kontext zurückgegeben, der die Funktion aufgerufen hat.

120 Bytes

Das fühlt sich natürlich ein bisschen wie Betrug an, also hier ist eine, die völlig zufällig ist:

from random import*;r=randint
def f(S):a=S[:10];R=r(0,len(a)-1);print(end=a[:R]+chr(r(32,126))*r(0,1)+a[R+1:]);f(S[10:])

Probieren Sie es online aus!

Gelee , 15 14  13 Bytes 13 Zeichen

2X
s⁵µ¢1¦ṫ¢µ€

TryItOnline!

Ersetzt oder entfernt das erste von zehn Zeichen, einschließlich des letzten 1-9, wenn es einen solchen Block gibt. Wählt aus der zugegebenermaßen kleinen Teilmenge von Zeichen : 1; 2.

Wie?

2X         - Link 1, flip a coin: no arguments
 X         - random choice from
2          - 2 (treated as the integers [1,2])

s⁵µ¢1¦ṫ¢µ€ - Main link: string of printable ASCII
s⁵         - split (s) into chunks of size ten (⁵)
  µ     µ  - monadic chain separation 
         € - for each chunk
   ¢       -     last link as a nilad
    1¦     -     apply to index 1 (replace 1st of the 10 char chunk with the chosen integer)
       ¢   -     last link as a nilad
      ṫ    - tail - if it was 1 this has no effect (50%)
                  - if it was 2 this discards the replaced character (50%)
           - implicit print

So wählen Sie in 21 Bytes aus allen druckbaren ASCII-Elementen aus und nicht nur 1und 2(wobei das erste Zeichen jedes Blocks ersetzt oder entfernt wird):

s⁵µ32r126¤ỌX¤1¦ṫ2X¤µ€

Für eine vollständig zufällige Version (50/50 Entfernen / Ersetzen, einheitlich zufällig druckbares ASCII und eine einheitlich zufällige Zeichenposition in jedem Block) habe ich 30 Bytes (wahrscheinlich nicht optimal):

95R+31ỌX;

s⁵µṙ⁵X¤©Ṗ2X¤Ŀṙ®C¤µ€

Dadurch wird jeder verbleibende Block um einen zufälligen Betrag gedreht, das letzte Zeichen entfernt und dann ein zufälliger der ersten beiden Links aufgerufen, von denen einer leer ist und der andere mit einem zufällig druckbaren ASCII-Zeichen verknüpft ist. es dreht dann den Block wieder nach rechts.

Python3, 188 186 184 114 Zeichen

from random import*
s=input()
for c in[s[i:i+10]for i in range(0,len(s),10)]:print(end=choice(["","x","y"])+c[1:])

Scheint zu lang. Könnte wahrscheinlich mit einem Lambda stark verkürzt werden.

Anscheinend hat das OP die Auswahl des zufälligen Zeichens aus einer Liste von zwei Zeichen erlaubt, und der Index des zu ersetzenden Zeichens kann eine Konstante sein. Nach den Änderungen hätte meine Antwort genauso ausgesehen wie die Übermittlung von @FlipTacks Python. Dies ist also das Formular, bei dem ich bleibe.

@FlipTack hat 5 Bytes gespeichert!

Clojure, 135 139 Bytes

Edit: Passwort zu verwenden , partition-allstatt partition.

(fn[i](apply str(flatten(map #(let[r rand-int [b e](split-at(r 9)%)][b(if(<(rand)0.5)""(char(+(r 25)97)))(rest e)])(partition-all 10 i)))))

Ungolfed:

(def f (fn[i]
         (->> i
              (partition-all 10)
              (map #(let [[begin end] (split-at (rand-int 9) %)]
                      [begin (if (< 0.5 (rand)) "" (char (+(rand-int 25)97))) (rest end)]))
              flatten
              (apply str))))

Mann, diese Funktionsnamen sind lang ... Wie auch immer, es teilt die Eingabe in Partitionen von 10 Zeichen auf, teilt sie an einem zufälligen Punkt in zwei Hälften auf, fügt zufällig eine leere Zeichenfolge oder ein zufälliges Zeichen zwischen ihnen ein und verwirft das erste Zeichen der 2. Hälfte.

Mathematica 133 Bytes (129 Zeichen)

StringReplacePart[#,Table[If[(r=RandomInteger)[]<1,"",FromCharacterCode@r@128],c=⌊StringLength@#/10⌋],Array[{g=10#-9+r@9,g}&,c]]&

76 Zeichen, um die Namen von 8 Funktionen zu schreiben: /

Verwenden Sie ⌊..⌋anstelle von Floor[]5 Zeichen, 1 Byte.

Python 3, 129 Bytes

def f(s):f=id(s)%9+1;print(''.join(j[0:f-1]+chr(33+id(s)%94)*(id(s)//10%2)+j[f:]for j in [s[i:i+10]for i in range(0,len(s),10)]))

Um einige Bytes zu sparen, habe ich anstelle des Zufallsmoduls von Python nur einige Modulo-Operationen an der ID der Zeichenfolge durchgeführt, die jedes Mal anders sein sollten. Zum Beispiel entscheidet das Programm, ob ein Zeichen entfernt oder ersetzt werden soll, basierend darauf, ob es gerade ist oder nicht id(string)//10(ich dividiere durch 10, da die letzte Ziffer immer gerade ist).