M. Mackey est un personnage de South Park bien connu pour avoir ajouté "m'kay" dans tout ce qu'il dit.

Ecrivez un programme ou une fonction qui transforme une chaîne de texte en quelque chose que M. Mackey dirait.

Placement M'kay

• m'kaya une chance de hasard 50% d'être ajouté après les ponctuations ,, ., ?et! . Si tel est le cas, il sera suivi du même signe de ponctuation qui le précède et précédé d'un espace.

  Par exemple, dans la phrase Test, test., il est m'kaypossible d’ajouter deux endroits : après la virgule et après le point, avec une chance de 50% à chaque endroit. Les résultats possibles seraient Test, m'kay, test. ou Test, test. M'kay.ou Test, m'kay, test. M'kay..

• Il doit toujours y avoir au moins un m'kayajouté . De plus, il ne peut pas toujours se trouver au même endroit et chaque endroit valide où m'kayil est possible d’ajouter doit avoir la même probabilité. C'est-à-dire que vous ne pouvez pas m'kaytoujours ajouter à la fin de la chaîne si, par hasard, vous n'en avez jamais ajouté m'kay. S'il n'y en a qu'un m'kay, il doit avoir la même probabilité d'apparaître dans chaque position valide, même si sa présence est imposée.

• Si m'kayest après ?, .ou !, le mdoit être en majuscule.

• Le nombre d' min m'kaydoit être choisi uniformément entre 1 et 3. C'est-à-dire m'kay, mm'kayet mmm'kaysont tous des choix possibles, chacun avec une probabilité de 0,33 ... S'il doit être mis en majuscule (voir la règle ci-dessus), tout mdoit être en majuscule.

Entrées, sorties

• Les entrées sont des chaînes ASCII contenant des caractères de ASCII 32 décembre (espace) à ASCII 126 (tilde ~). Il n'y a pas de sauts de ligne dans l'entrée. Vous pouvez supposer que toute entrée contiendra au moins un des éléments suivants , . ? !.

• Vous pouvez supposer qu'il n'y a aucune m'kayou aucune de ses variantes dans l'entrée.

  Les entrées peuvent provenir de STDIN, des arguments de fonction, de la ligne de commande ou de quelque chose de similaire.

• La sortie peut être via STDOUT, un retour de fonction ou quelque chose de similaire.

Cas de test

• Contribution: Test.

Sortie possible: Test. M'kay.

• Contribution: Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.

Sortie possible: Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. MMM'kay. It's 100% free, mm'kay, no registration required.

• Contribution: Drugs are bad, so, if you do drugs, you're bad, because drugs are bad. They can hurt your body, cause drugs are bad.

Sortie possible: Drugs are bad, m'kay, so, if you do drugs, you're bad, m'kay, because drugs are bad. They can hurt your body, m'kay, cause drugs are bad. M'kay.

• Contribution: Do you understand? Really? Good!

Sortie possible: Do you understand? MM'kay? Really? Good! MMM'kay!

Notation

C'est du code-golf , donc le code le plus court en octets gagne, m'kay?

CJam, 65 52 49 octets

l{_{_",.?!"#:IW>)mr{SI'M'm?3mr)*"'kay"3$}&}%_@=}g

Essayez-le en ligne dans l' interprète CJam .

Comment ça fonctionne

l            e# Read a line from STDIN.
{            e# Do:
  _          e#   Duplicate the line.
  {          e#   For each of its characters:
    _",.?!"# e#     Find its index in that string.
    :IW>     e#     Save the index in I and check if it's greater than -1.
    )        e#     Add 1 to the resulting Boolean.
     mr      e#     Pseudo-randomly select a non-negative integer below that sum.
             e#     If I == -1 the result will always be 0.
    {        e#     If the result is 1:
      S      e#       Push a space.
      I'M'm? e#       Select 'm' if I == 0 (comma) and 'M' otherwise.
      3mr)   e#       Pseudo-randomly select an integer in [1 2 3].
      *      e#       Repeat the M that many times.
      "'kay" e#       Push that string. MMM'kay.
      3$     e#       Copy the proper punctuation.
    }&       e#
  }%         e#
  _          e#   Copy the resulting array.
  @=         e#   Compare it to the copy from the beginning.
}g           e# Repeat the loop while the arrays are equal.
             e# This makes sure that there's at least one m'kay. M'kay.

APL (66)

{∊⍉⍵⍪⍉⍪(¯1+⌈?2×⍵∊',.!?')/¨{' ',⍵,⍨'''kay',⍨'mM'[1+⍵≠',']/⍨?3}¨⍵}⍣≢

Résultat de 10 courses:

      ↑ ({∊⍉⍵⍪⍉⍪(¯1+⌈?2×⍵∊',.!?')/¨{' ',⍵,⍨'''kay',⍨'mM'[1+⍵≠',']/⍨?3}¨⍵}⍣≢)¨ 10/⊂'Test, test. Test! Test?'
Test, m'kay, test. Test! Test?                  
Test, test. M'kay. Test! MMM'kay! Test? M'kay?  
Test, mm'kay, test. Test! MM'kay! Test? MM'kay? 
Test, mmm'kay, test. Test! Test? M'kay?         
Test, mm'kay, test. Test! Test? M'kay?          
Test, test. MM'kay. Test! Test? MMM'kay?        
Test, test. MMM'kay. Test! MMM'kay! Test? M'kay?
Test, test. Test! MM'kay! Test?                 
Test, mm'kay, test. M'kay. Test! Test?          
Test, test. MM'kay. Test! MM'kay! Test?   

Explication:

• {... }⍣≢: applique la fonction à l'entrée jusqu'à ce que la valeur change
  • Générez un M'kaypour chaque personnage:
  • {... }¨⍵: pour chaque caractère de l'entrée:
    • 'mM'[1+⍵≠',']/⍨?3: générer 1 à 3 ms ou Ms selon que le caractère est une virgule ou non.
    • '''kay',⍨: ajoute la chaîne 'kay.
    • ⍵,⍨: ajouter le personnage
    • ' ',: préfixe un espace.
  • (¯1+⌈?2×⍵∊',.!?')/¨: pour chaque M'kay', si le caractère correspondant est l'un des .,!?, sélectionnez-le avec 50% de chance, sinon sélectionnez-le avec 0% de chance.
  • ⍉⍵⍪⍉⍪: associe chaque sélection à son caractère,
  • ∊: liste tous les éléments simples (caractères) dans l'ordre.

K5, 99 90 octets

{f::0;{x;~f}{,/{f::f|r:(*1?2)&#&",.?!"=x;x,("";" ",((1+1?3)#"Mm"@x=","),"'kay",x)@r}'x}/x}

Eh bien, il fallait que quelqu'un lance ça!

Sauvegardé 9 octets en utilisant une méthode moins élégante de mettre en majuscule le M.

Explication

{                                                                                        }  Define a function
 f::0;                                                                                      Set `f` (used to determine when to stop) to 0.
      {x;~f}{                                                                         }/x   While `f` is 0 (no "m'kay"s have been inserted), loop over the string argument
               {                                                                   }'x      For each character in the string
                       (*1?2)&#&",.?!"=x                                                    If we are at a punctuation character, generate a random number between 0 and 1
                     r:                                                                     and assign it to `r`
                f::f|                                                                       If the number is one, an "m'kay" will be inserted, so the outer while loop should exit after this
                                                            "Mm"@x=","                      If the punctuation is a comma, then use a lowecase `m`, otherwise use `M`
                                                    (1+1?3)#                                Repeat the `m` between 1 and 3 times
                                               " ",(                  ),"'kay",x            Join the "m'kay" string to the punctuation and prepend a space
                                         x,("";                                 )@r         If the random number is 1, append the "m'kay" string, to the current string
             ,/                                                                             Join the resulting string

Version de 99 octets

{f::0;{x;~f}{,/{f::f|r:(*1?2)&#&",.?!"=x;x,("";" ",((1+1?3)#`c$(-32*~","=x)+"m"),"'kay",x)@r}'x}/x}

Julia, mm'kay, 115 114 octets

f(s)=(R=replace(s,r"[,.?!]",r->r*(" "*(r==","?"m":"M")^rand(1:3)*"'kay"*r)^rand(0:1));ismatch(r"m'kay"i,R)?R:f(R))

Cela crée une fonction récursive qui accepte une chaîne et renvoie une chaîne.

Ungolfed + explication:

function f(s)
    # Replace occurrences of punctuation using random repeats
    R = replace(s, r"[,.?!]", r -> r*(" " * (r == "," ? "m" : "M")^rand(1:3) * "'kay" * r)^rand(0:1))

    # Check whether anything was replaced
    if ismatch(r"m'kay"i, R)
        # If so, return the replaced string
        R
    else
        # Otherwise recurse
        f(R)
    end
end

Je n'aime pas South Park, mais le tressaillement du golf était trop attrayant pour laisser passer cela. Merci à KRyan pour avoir simplifié une expression rationnelle en économisant 1 octet.

JavaScript ES6, 79 86 108 octets

Il s'avère que la Mrépétition prend beaucoup d'octets.

(s,z=Math.random)=>s.replace(/([!?.,])/g,l=>z(t=t+1)>=.5||t?` ${(l==','?'m':'M').repeat(0|z()*3+1)}'kay`+l:l)

Ancienne version (ne se répète pas) (86 octets)

(s,t=1)=>s.replace(/([!?.,])/g,l=>Math.random()>=.5||--t?` ${l==','?'m':'M'}'kay`+l:l)

Ancienne version (ne se répète pas, ne nécessite pas au moins un m'kay) (79 octets) :

s=>s.replace(/([!?.,])/g,l=>~~(Math.random()*2)?l+` ${l==','?'m':'M'}'kay`+l:l)

La plus ancienne version:

s=>(r=t=>t.replace(/([!?.])/,"$1 M'kay$1").replace(/,/,", m'kay,"),r(s),[for(i of s)~~(Math.random()*2)?r(i):i].join``)

Pyth, 51 50 49

Sauvegardé 1 octet grâce à @Maltysen.

 fnzJsm?&O2}dK",.!?"s[d\ *hO3?xKd\M\m"'kay"d)dz0J

Essayez-le en ligne.

Explication et plus de golf à venir.

C, 170 octets

Première fissure:

n;main(r,v,p)char**v,*p;{for(srand(time(0)),p=v[1];r=rand(),*p;p++)if(strchr(".,?!",putchar(*p))&&r%2||(!*(p+1)&&!n))n=printf(" %.*s'kay%c",r/2%3+1,*p%4?"MMM":"mmm",*p);}

Ungolfed:

n;
main(r,v,p)
char**v,*p;
{
    for(srand(time(0)), p=v[1]; r=rand(), *p; p++) /* loop through string */
        if(strchr(".,?!",putchar(*p)) /* print the char, check if punctuation */
            && r % 2 /* should we say it? */
            || (!*(p+1) && !n)) /* If this is the end of the string and we haven't M'kay'd, then do it now */
            n=printf(" %.*s'kay%c", r/2%3+1, *p%4 ? "MMM" : "mmm", *p); /* say it! */
}

Scala, 191 octets

var(r,s,a,o)=(util.Random,readLine,1>2,"")
while(!a){o=""
for(c<-s)o+=(if(",.?!".contains(c)&&r.nextBoolean){a=2>1
s"$c ${(if(c==46)"M"else"m")*(1+r.nextInt(3))}'kay$c"}else s"$c")}
print(o)

Mathematica, 202 octets

i=0;r=Random;x=r[];
h=" "<>If[#==",","m","M"]~Table~{Ceiling[3r[]]}<>"'kay"<>#&;
(ee/.a:>(If[e~Count~a@__==i&&#==Floor[x*i],h@#2,""]&))@
StringReplace[#,x:","|"."|"?"|"!":>x~~RandomChoice@{i++~a~x,h@x}]&

Des sauts de ligne ont été ajoutés pour améliorer la lisibilité. Evalue en fonction anonyme en prenant la chaîne en argument. ( est un raccourci pour\[Function] .)

Ungolfed:

h[x_]:=" " <> Table[
    If[x==",", "m", "M"],
    { Ceiling[3 Random[]] }
] <> "'kay" <> x;

hprend un char ponctuation et rend " m'kay,", " mm'kay,"etc. au hasard et capitalisé de manière appropriée.

f[s_] := (i = 0;
   StringReplace[s, 
    x : "," | "." | "?" | "!" :> 
     x ~~ RandomChoice[{a[i++, x], h[x]}]]);

fprend une chaîne et cherche n'importe quel caractère de ponctuation x; quand il le trouve, il règle avec une probabilité de 50% celle qui convient h[x]et une expression comme 50% a[3, x]. Il met également à jour ile nombre total de ponctuations remplacées (dans les deux cas). Alors f["X, x."]pourrait évaluer à

"X," ~~ h[","] ~~ " x." ~~ a[1, "."]           ...which might expand to
"X, mmm'kay, x." ~~ a[1, "."]                  , and i would equal 2

Enfin, gva traiter avec le a.

g[expr_] := (r = Random[]; 
  expr /. a -> (If[Count[expr, a[__]] == i && # == Floor[r*i], h[#2], ""] &))

Countcomptera combien anous en avons mis là; si cela équivaut iau nombre total de ponctuation, alors nous n'avons pas ajouté de kay. Dans ce cas, nous aurons des expressions comme a[0, _] ... a[i-1, _], et nous définirons acomme il retournera un m'kay pour exactement un 0..i-1.

Python, 173 168 156

from random import randint as R
    m,k,s,C="mM","'kay",input(),0
    while C<1:
        S=""
        for c in s:r=R(0,c in",.!?");C+=r;S+=c+(' '+m[c!=","]*R(1,3)+k+c)*r
    print(S)

Ungolfed:

from random import randint
m, kay = "mM", "'kay"
string = input()
count = 0
while count < 1: #at least one occurrence
    newString= ""
    for char in s:
        rm  = randint(1,3) #number of "m"
        rmk = randint(0, char in ",.!?") #occurrence of "m'kay"
        count += rmk
        newString += char + (' ' + m[c != ","] * rm + kay + char) * rmk
print(newString)

> <>, 150 octets

i:0(?v
r0&v >
?v~>:0(?v::o1[:::",.?!"{=${=+${=+r=+]
>x~^    >&:0)?;&"."14.
v>&1+&1[:","=&"yak'"&84**"M"+
 >  >84*v
>x::^>22 .
 >: ^]
ol0=?^  >

13 octets perdus, mais je me suis un peu ennuyé en essayant de le réorganiser. Aussi, la randomisation dans un Funge est difficile à jouer.

Perl, 93 89 88 octets

$_=$0=<>;s/[.?!]|(,)/$&.($".($1?"m":M)x(1+rand 3)."'kay$&")[rand 2]/ge while$0eq$_;print

Peut certainement être joué au golf un peu plus!

4 octets coupés grâce à Dom Hastings

C ++ 290

Ma solution

void M(string x){
srand(rand());
string p(",.?!");
char c=0,m='m',n='M';
int r=0;
size_t z=0;
for(size_t i=0;i<x.size();i++)
{
c=x[i];cout<<c;
z=p.find(c);
r=rand()%2;
if(z!=string::npos&&r)
{
cout<<' ';
c=(z?n:m);
r=rand()%3+1;
while(r--){cout<<c;}
cout<<"\'kay";
}
}
}

La variable d’ explication z détermine le signe de ponctuation et z = 0 indique d’utiliser «m» plutôt que «M».

Tester

int main()
{
int x=5;
while(x--){
string S("Do you understand? Really? Good! Yes, I do.");
M(S);
cout<<endl;
}
return 0;
}

JavaScript ES6, 121 octets

(s,r=Math.random,f=t=>t==s?f(s.replace(/[!?.,]/g,m=>r()<.5?m:m+" "+(m==","?"mmm":"MMM").slice(r()*3)+"'kay"+m)):t)=>f(s)

Se bloque si la chaîne donnée ne contient pas de ponctuation appropriée.

Lua, 162 160 octets

r=math.random;s,m=io.read()repeat m=s:gsub("([,.?!])",function(p)return p..(r()>.5 and" "..(p==","and"m"or"M"):rep(r(1)).."'kay"..p or"")end)until s~=m;print(m)

Avez-vous déjà entendu la tragédie de Dark Plagueis The Wise? MM'kay? Je ne pensais pas. MMM'kay. Ce n'est pas une histoire que les Jedi vous raconteraient. M'kay. C'est une légende Sith. Dark Plagueis était un Seigneur Noir des Sith, m'kay, si puissant et si sage qu'il pouvait utiliser la Force pour influencer les midichloriens afin de créer la vie… Il avait une telle connaissance du côté obscur qu'il pouvait même garder ceux qui lui étaient chers. à propos de mourir. MM'kay. Le côté obscur de la Force est une voie d'accès à de nombreuses capacités que certains considèrent comme non naturelles. MM'kay. Il est devenu si puissant… la seule chose dont il avait peur, c'était de perdre son pouvoir, mmm'kay, ce que finalement, mm'kay, bien sûr, il l'a fait. M'kay. Malheureusement, il a appris à son apprenti tout ce qu'il savait, puis son apprenti l'a tué dans son sommeil. M'kay. Ironique. Il pourrait sauver les autres de la mort,