Escreva um programa que use uma string de entrada com 2 ou mais caracteres e inclua a string ~BOO!~ (essa string possui um espaço inicial e final) em um local aleatoriamente uniforme na string que não está em nenhuma das extremidades.

Entradas de amostra não permitidas : 2ou (uma entrada vazia)

Saídas de amostra não permitidas : Hello ~BOO!~ ou ~BOO!~ Hellopara a entradaHello

Entrada de amostra :Hello, World!

Saídas de amostra : Hel ~BOO!~ lo, World!ouHello, Worl ~BOO!~ d!

Isso é código de golfe, pessoal. Aplicam-se regras padrão. O código mais curto em bytes vence.

Parabéns a Dennis por ter o programa mais curto e assustador! Feliz Dia das Bruxas!

Pitão, 19 18 bytes

j" ~BOO!~ "cz]OtUz

Graças a @Jakube por jogar fora 1 byte!

Experimente online.

Como funciona

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

Simples o suficiente - pegue uma string, insira a subcadeia, produza a string. Feito.

Python 3, 60 bytes

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

Nota:

O módulo de hash()será distribuído uniformemente ao longo do comprimento da corda. Se você acha que isso está distorcendo as regras, observe que, devido à randomização de hash do python, isso é realmente aleatório: execuções repetidas com a mesma entrada fornecerão resultados diferentes.

CJam, 20 bytes

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

Experimente online

Explicação:

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

Recebe entrada da linha de comando. Se a entrada tiver espaços ou outros caracteres especiais, ela precisará ser colocada entre aspas.

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

Explicação:

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+⍴⍵}

O APL não possui uma função de inserção, portanto, giramos a 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

Exemplo de entrada no TryAPL

Vitsy, 19 bytes

Observe que ze Zforam editados hoje, mas não para esse desafio.

I1-R1 + \ i "~ OOB ~" zZ
I1- Obter o comprimento da entrada, menos 1
   R Empurre um número aleatório de 0 para o item superior da pilha.
    1+ Adicione um a ele - agora é um número aleatório de 1 a entrada
                      comprimento - 1.
      \ i Consiga muitos itens de entrada.
        "~ OOB ~" Pressione '~ BOO ~' para a pilha.
                 z Obtenha o restante da entrada.
                  Z Mostra tudo.

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:])

Experimente online

Muito auto-explicativo - leia uma sequência, escolha um número inteiro aleatório entre 1 e o comprimento da sequência e imprima a sequência com ' ~BOO!~ 'inserida.

Perl, 35 bytes

Código de 34 bytes + linha de comando de 1 byte

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

Uso:

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!~ "));}}

Expandido:

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

Esta solução pressupõe que a cadeia seja passada como o primeiro parâmetro da linha de comandos. Isso não é usual para C # (stdin é mais normal), então eu também incluí uma solução que usa stdin normal:

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!~ "));}}

Expandido:

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

Inserir uma string no meio de um índice no MATLAB é caro em termos de bytes. Se houvesse uma maneira simples de fazer isso, eu poderia economizar uma quantia razoável, passando para uma função anônima, mas não consigo encontrar uma. Ah bem.

Basicamente, ele obtém um número aleatório entre 1 e o comprimento da string menos 1. Em seguida, ele exibe tudo, inclusive esse índice, seguido pelo ~Boo!~, e tudo depois do índice até o final.

Também funciona com o Octave , para que você possa testá-lo online aqui .

Bash / GNU, 61 bytes

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

Pega a string de entrada como argumento

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

É para o console do navegador; divirta-se apenas colocando isso.

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

Experimente aqui.

EDIT: Somente agora lendo o programa em vez da função / programa padrão na descrição do desafio. Adicionamos o código de borda com a interface e o método principal.

Se uma função fosse permitida, seria ( 99 95 bytes )

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

Experimente aqui.

Explicação:

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)

Muito direto.

CJam, 19 bytes

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