Schreiben Sie ein Programm, das eine Eingabezeichenfolge mit einer Länge von 2 oder mehr Zeichen verwendet und die Zeichenfolge ~BOO!~ (die ein führendes und endendes Leerzeichen enthält) an einer gleichmäßig zufälligen Stelle in der Zeichenfolge hinzufügt, die sich an keinem Ende befindet.

Nicht zugelassene Probeneingaben : 2oder (eine leere Eingabe)

Nicht zugelassene Beispielausgaben : Hello ~BOO!~ oder ~BOO!~ Hellofür die EingabeHello

Beispieleingabe :Hello, World!

Beispielausgaben : Hel ~BOO!~ lo, World!oderHello, Worl ~BOO!~ d!

Das ist Codegolf, Jungs. Es gelten Standardregeln. Kürzester Code in Bytes gewinnt.

Wir gratulieren Dennis zum kürzesten und gruseligsten Programm! Fröhliches Halloween!

Pyth, 19 18 Bytes

j" ~BOO!~ "cz]OtUz

Vielen Dank an @Jakube für das Golfen ab 1 Byte!

Probieren Sie es online aus.

Wie es funktioniert

                    (implicit) Store the input in z.
                Uz  Compute [0, ... len(z)-1].
               t    Remove the first element.
              O     Select an integer, pseudo-randomly.
             ]      Wrap it in an array.
           cz       Split the input string at that point.
j" ~BOO!~ "         Join the split string, using " ~BOO!~ " as separator.

GML, 91 Bytes

s=get_string("","")
show_message(string_insert(" ~BOO!~ ",s,irandom(string_length(s)-2)+1);

Ganz einfach - holen Sie sich eine Zeichenfolge, fügen Sie die Teilzeichenfolge ein und geben Sie die Zeichenfolge aus. Erledigt.

Python 3, 60 Bytes

s=input();n=1+hash(s)%(len(s)-1);print(s[:n],'~BOO!~',s[n:])

Hinweis:

Das Modulo von hash()wird gleichmäßig über die Länge der Saite verteilt. Wenn Sie der Meinung sind, dass dies die Regeln verbiegt, beachten Sie, dass dies aufgrund der Python-Hash-Randomisierung tatsächlich zufällig ist: Wiederholte Ausführungen mit derselben Eingabe führen zu unterschiedlichen Ergebnissen.

CJam, 20 Bytes

l_,(mr)/(" ~BOO!~ "@

Probieren Sie es online aus

Erläuterung:

l       Get input.
_,      Calculate length.
(       Decrement, since the number of possible positions is 1 less than length.
mr      Generate random number between 0 and length-2
)       Increment, giving random number between 1 and length-1.
/       Split. Note that this splits repeatedly, but this will not do any harm.
        We will only really use the first split.
(       Peel off the first fragment after the split.
" ~BOO!~ "
        Push the magic string.
@       Rotate the list with the remaining fragments to the top.

Pip, 19 Bytes

Übernimmt Eingaben von der Kommandozeile. Wenn die Eingabe Leerzeichen oder andere Sonderzeichen enthält, muss sie in Anführungszeichen gesetzt werden.

a^@1RR#aJ" ~BOO!~ "

Erläuterung:

a                    Command-line arg
 ^@                  Split at index...
   1RR#a             ...random integer >= 1 and < length(a) (Python randrange)
        J" ~BOO!~ "  Join on that string and autoprint

Julia, 70 Bytes

print((s=readline())[1:(r=rand(2:length(s)-2))]," ~BOO!~ ",s[r+1:end])

Ungolfed:

# Read a line from STDIN
s = readline()

# Define a random integer within the bounds of s
r = rand(2:length(s)-2)

# Print to STDOUT with boo in there somewhere
print(s[1:r], " ~BOO!~ ", s[r+1:end])

APL, 27 Bytes

{(-⌽' ~BOO!~ ',⍵⌽⍨⊢)?¯1+⍴⍵}

APL hat keine Einfügefunktion, daher drehen wir stattdessen den String.

{                          }    ⍝ Monadic function:
                     ?¯1+⍴⍵     ⍝ Place to insert string, let's say it's X
 (                  )           ⍝ Monadic train:
               ⍵⌽⍨⊢            ⍝ Rotate input by X (⊢) to the left
    ' ~BOO!~ ',                 ⍝ Concatenate ' ~BOO!~ '
  -                             ⍝ -X
   ⌽                            ⍝ Rotate that by X to the right

Beispiel für eine Eingabe in TryAPL

Vitsy, 19 Bytes

Beachten Sie, dass zund Zwurden heute bearbeitet, aber nicht für diese Herausforderung.

I1-R1 + \ i ~ OOB ~ zZ
I1- Liefert die Länge der Eingabe minus 1
   R Schieben Sie eine Zufallszahl von 0 zum obersten Element des Stapels.
    1+ Fügen Sie eine hinzu - dies ist jetzt eine Zufallszahl von 1 zur Eingabe
                      Länge - 1.
      \ i Holen Sie sich so viele Eingaben.
        "~ OOB ~" Drücke '~ BOO ~' auf den Stapel.
                 z Holen Sie sich den Rest der Eingabe.
                  Z Alles ausgeben.

Lua, 75 Bytes

s=io.read()m=math.random(2,#s/2);return s:sub(1,m).." ~BOO!~ "..s:sub(m,#s)

Python 3, 79 Bytes

from random import*;s=input();n=randint(1,len(s)-1);print(s[:n],'~BOO!~',s[n:])

Probieren Sie es online aus

Ziemlich selbsterklärend - lesen Sie eine Zeichenfolge, wählen Sie eine zufällige Ganzzahl zwischen 1 und der Länge der Zeichenfolge und drucken Sie die Zeichenfolge mit ' ~BOO!~ 'eingefügt.

Perl, 35 Bytes

34 Byte Code + 1 Byte Befehlszeile

$-=rand y///c-2;s/..{$-}\K/~BOO!~/

Verwendung:

perl -p entry.pl

C #, 125 Bytes

using System;class X{static void Main(string[]a){Console.Write(a[0].Insert(new Random().Next(a[0].Length-2)+1," ~BOO!~ "));}}

Erweitert:

using System;
class X
{
    static void Main(string[] a)
    {
        Console.Write(a[0].Insert(new Random().Next(a[0].Length - 2) + 1, " ~BOO!~ "));
    }
}

Diese Lösung setzt voraus, dass die Zeichenfolge als erster Befehlszeilenparameter übergeben wird. Dies ist in C # nicht üblich (stdin ist normaler), daher habe ich auch eine Lösung beigefügt, die normales stdin verwendet:

C # 139 Bytes

using System;class X{static void Main(){var x=Console.In.ReadToEnd();Console.Write(x.Insert(new Random().Next(x.Length-2)+1," ~BOO!~ "));}}

Erweitert:

using System;
class X
{
    static void Main()
    {
        var x = Console.In.ReadToEnd();
        Console.Write(x.Insert(new Random().Next(x.Length - 2) + 1, " ~BOO!~ "));
    }
}

MATLAB, 69 Bytes

i=input('');a=randi(nnz(i)-1,1);disp([i(1:a) ' ~Boo!~ ' i(a+1:end)]);

Das Einfügen eines Strings mid string an einem bestimmten Index in MATLAB ist byteweise kostspielig. Wenn es eine einfache Möglichkeit gäbe, könnte ich eine Menge sparen, indem ich zu einer anonymen Funktion wechsle, aber ich kann keine finden. Ah, gut.

Grundsätzlich erhält es eine Zufallszahl zwischen 1 und der Länge des Strings minus 1. Dann zeigt es alles bis einschließlich dieses Index an, gefolgt von ~Boo!~und dann alles nach dem Index bis zum Ende.

Es funktioniert auch mit Octave , so können Sie es versuchen Online - out hier .

Bash / GNU, 61 Bytes

echo $1|sed "s/.\{`shuf -i1-$((${#1}-1)) -n1`\}/\0 ~BOO!~ /"

Übernimmt die Eingabezeichenfolge als Argument

Ruby, 46 Bytes

$><<gets.insert(rand(1..$_.size-2),' ~BOO!~ ')

JavaScript, 79

r=Math.random()*((x=prompt()).length-1)+1;x.substr(0,r)+" ~BOO!~ "+x.substr(r);

Es ist für die Browserkonsole; Viel Spaß beim reinschauen.

Java 8, 158 154 Bytes

interface M{static void main(String[]a){int i=a[0].length()-2;System.out.println(a[0].substring(0,i=1+(i*=Math.random()))+" ~BOO!~ "+a[0].substring(i));}}

Probieren Sie es hier aus.

BEARBEITEN: Lies erst jetzt das Programm anstelle der Standardfunktion / des Standardprogramms in der Herausforderungsbeschreibung. Fügte also den Grenzcode mit der Schnittstelle und der Hauptmethode hinzu.

Wenn eine Funktion erlaubt wäre, wäre es ( 99 95 Bytes )

s->{int i=s.length()-2;return s.substring(0,i=1+(i*=Math.random()))+" ~BOO!~ "+s.substring(i);}

Probieren Sie es hier aus.

Erläuterung:

s->{                        // Method with String as both parameter and return-type
  int i=s.length()-2;       //  The length of the input - 2
  return s.substring(0,i=1  //  Return the first part of the input from index 0 to 1
    +(i*=Math.random()))    //    + a random integer between 0 and length-2
   +" ~BOO!~ "              //   appended with the literal " ~BOO!~ "
   +s.substring(i);         //   appended with the rest of the input-String
}                           // End of method

Chaîne , 23 Bytes

{il1-R1+`} ~BOO!~ {<$/}

TeaScript, 30 Bytes

xh(j=N(xn-1)+1)+' ~BOO!~ '+xS(j)

Sehr einfach.

CJam, 19 Bytes

q_,mr)/(" ~BOO!~ "@