Écrivez un programme qui prend une chaîne d'entrée de 2 caractères ou plus et ajoute la chaîne ~BOO!~ (cette chaîne a un espace de début et de fin) à un endroit uniformément aléatoire de la chaîne qui n'est à aucune extrémité.

Entrées d'échantillon non autorisées : 2ou (une entrée vide)

Sorties d'échantillons non autorisées : Hello ~BOO!~ ou ~BOO!~ Hellopour l'entréeHello

Exemple d'entrée :Hello, World!

Exemples de sorties : Hel ~BOO!~ lo, World!ouHello, Worl ~BOO!~ d!

C'est du golf de code, les gars. Des règles standard s'appliquent. Le code le plus court en octets gagne.

Félicitations à Dennis pour avoir le programme le plus court et le plus effrayant! Joyeux Halloween!

Pyth, 19 18 octets

j" ~BOO!~ "cz]OtUz

Merci à @Jakube d'avoir joué au golf sur 1 octet!

Essayez-le en ligne.

Comment ça fonctionne

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

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

Assez simple - obtenez une chaîne, insérez-y la sous-chaîne, sortez la chaîne. Terminé.

Python 3, 60 octets

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

Remarque:

Le module de hash()sera réparti uniformément sur la longueur de la chaîne. Si vous pensez que cela déforme les règles, notez qu'en raison de la randomisation du hachage de python, c'est en fait aléatoire: des exécutions répétées avec la même entrée donneront des résultats différents.

CJam, 20 octets

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

Essayez-le en ligne

Explication:

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 octets

Prend des entrées de la ligne de commande. Si l'entrée contient des espaces ou d'autres caractères spéciaux, elle devra être placée entre guillemets.

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

Explication:

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 octets

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

Non golfé:

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

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

APL n'a pas de fonction d'insertion, nous faisons donc tourner la chaîne à la place.

{                          }    ⍝ 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

Exemple d'entrée sur TryAPL

Vitsy, 19 octets

Notez que zetZ ont été modifiés aujourd'hui, mais pas pour ce défi.

I1-R1 + \ i "~ OOB ~" zZ
I1- Obtenez la longueur de l'entrée, moins 1
   R Poussez un nombre aléatoire de 0 à l'élément supérieur de la pile.
    1+ Ajoutez-en un - c'est maintenant un nombre aléatoire de 1 à entrer
                      longueur - 1.
      \ i Obtenez autant d'éléments d'entrée.
        "~ OOB ~" Poussez '~ BOO ~' dans la pile.
                 z Obtenez le reste de l'entrée.
                  Z Sortez tout.

Lua, 75 octets

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

Python 3, 79 octets

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

Essayez-le en ligne

Assez explicite - lisez une chaîne, choisissez un entier aléatoire entre 1 et la longueur de la chaîne, et imprimez la chaîne avec ' ~BOO!~ 'inséré.

Perl, 35 octets

Code de 34 octets + ligne de commande de 1 octet

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

Usage:

perl -p entry.pl

C #, 125 octets

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

Étendu:

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

Cette solution suppose que la chaîne est transmise en tant que premier paramètre de ligne de commande. Ce n'est pas habituel pour C # (stdin est plus normal), j'ai donc également inclus une solution qui utilise stdin normal:

C #, 139 octets

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

Étendu:

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 octets

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

L'insertion d'une chaîne au milieu d'une chaîne à un index donné dans MATLAB est coûteuse en termes d'octets. S'il y avait un moyen simple de le faire, je pourrais économiser une bonne quantité en passant à une fonction anonyme, mais je n'en trouve pas. Et bien.

Fondamentalement, il obtient un nombre aléatoire compris entre 1 et la longueur de la chaîne moins 1. Ensuite, il affiche tout jusqu'à et y compris cet index, suivi de ~Boo!~, puis de tout après l'index jusqu'à la fin.

Il fonctionne également avec Octave , vous pouvez donc l'essayer en ligne ici .

Bash / GNU, 61 octets

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

Prend la chaîne d'entrée comme argument

Rubis, 46 octets

$><<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);

C'est pour la console du navigateur; Amusez-vous simplement à insérer ça.

Java 8, 158 154 octets

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

Essayez-le ici.

EDIT: Seulement en train de lire le programme au lieu de la fonction / programme par défaut dans la description du défi. Ainsi, le code de bord a été ajouté avec l'interface et la méthode principale.

Si une fonction était autorisée, ce serait ( 99 95 octets )

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

Essayez-le ici.

Explication:

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 octets

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

TeaScript, 30 octets

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

Très simple.

CJam, 19 octets

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