Dada una cadena que contiene solo letras (no distingue entre mayúsculas y minúsculas), divídala en palabras de longitud uniformemente aleatoria, utilizando la distribución a continuación, con la excepción de la última palabra, que puede tener cualquier longitud válida (1-10). Su salida es estas palabras, como una cadena separada por espacios ( "test te tests"), una matriz de cadenas ( ["test","te","tests"]) o cualquier otro formato de salida similar.

Distribución de longitud de palabra

Word Length - Fractional Chance / 72 - Rounded Percentage
1 - 2 / 72 - 2.78%
2 - 14 / 72 - 19.44%
3 - 16 / 72 - 22.22%
4 - 12 / 72 - 16.67%
5 - 8 / 72 - 11.11%
6 - 6 / 72 - 8.33%
7 - 5 / 72 - 6.94%
8 - 4 / 72 - 5.56%
9 - 3 / 72 - 4.17%
10 - 2 / 72 - 2.78%

No es necesario que sus probabilidades coincidan exactamente: pueden estar apagadas por 1/144th o .69%en cualquier dirección (pero obviamente aún deben sumar 72/72o 100%).

Datos aproximados de la cuarta página, primera figura de este documento .

Casos de prueba con salida de muestra

El comportamiento en casos de prueba muy cortos (longitud <11) no está definido.

Tenga en cuenta que los creé a mano, por lo que pueden seguir o no la distribución uniforme anterior.

abcdefghijklmnopqrstuvwxyz
abcd efgh i jklmnopq rs tu vwx yz

thequickbrownfoxjumpedoverthelazydog
t heq uick brown fo xj ump edo vert helazydog

ascuyoiuawerknbadhcviuahsiduferbfalskdjhvlkcjhaiusdyfajsefbksdbfkalsjcuyasjehflkjhfalksdblhsgdfasudyfekjfalksdjfhlkasefyuiaydskfjashdflkasdhfksd
asc uyoi uawer k nb a dhcviua hsid ufe r bfa lskd jhv lkcj haius dy faj se fbks dbfkals jcuyasjehf lkjh falk sd blhsgdf asudyfekjf alk sdjfhlk asefyu iaydskfja shdflk as dhf ksd

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Jalea , 28 bytes

“¤Œæ׿®¬©¥¤‘Jẋ"$FẋLẊ‘1¦+\Ṭœṗ

Un enlace monádico que toma una lista y devuelve una lista de listas.

Pruébalo en línea! (el pie de página separa la lista resultante de listas con espacios)

¿Cómo?

Utiliza todos los porcentajes en la distribución redondeados a su número entero más cercano (estando así dentro de los umbrales permitidos del 0,69%).

“¤Œæ׿®¬©¥¤‘Jẋ"$FẋLẊ‘1¦+\Ṭœṗ - Link: list (of characters), s
“¤Œæ׿®¬©¥¤‘                 - code page indexes = [3,19,22,17,11,8,7,6,4,3]
               $             - last two links as a monad:
            J                -   range of length = [1, 2, 3, 4, 5,6,7,8,9,10]
              "              -   zip with:
             ẋ               -     repeat list = [[1,1,1],...,[9,9,9,9],[10,10,10]]
                F            - flatten (into one list of length 100)
                  L          - length of s
                 ẋ           - repeat list (one list of length 100*length(s) with the
                             -              correct distribution of integer lengths)
                   Ẋ         - shuffle
                      ¦      - sparse application of:
                    ‘        -   increment
                     1       -   to indexes: 1 (offset indexes for the partition below)
                        \    - cumulative reduce by:
                       +     -   addition (e.g. [4,4,7,1,...] -> [4,8,15,16,...])
                         Ṭ   - untruth (yield a list with 1s at those indexes (1 indexed)
                          œṗ - partition s at truthy indexes (note: excess ignored)

PHP, 94 bytes

for(;$c=$argn[$k++];print$c." "[--$e])if(!$e)for($r=rand(0,71);$r>ord(x^"ywgSKAF:=?"[$e++]););

Ejecutar como tubería -nRo probarlo en línea .

Descompostura

for(;$c=$argn[$i++];            # loop $c through string
    print$c                         # 2. print current character,
        ." "                        # 4. if remaining length is 0, print space
        [--$e]                      # 3. decrement remaining length
    )
    if(!$e)                         # 1. if remaining length is 0,
        for($r=rand(0,71);              # get random value from 0 to 71
            $r>ord(x^"ywgSKAF:=?"[$e++])    # and increment $e while $r is > probability
        ;);

Nota: ywgSKAF:=?representa las probabilidades crecientes -1:[1,15,31,43,51,57,62,66,69,71]

Octava, 108 bytes

@(s)mat2cell(s,1,[k=(w=repelems(1:10,[1:10;'AMOKGEDCBA'-63])(randi(72,1,n=nnz(s))))(cumsum(w)<=n) n-sum(k)])

Pruébalo en línea!

* Toma la cadena como entrada y genera una matriz de cadenas.

* El último elemento de la salida puede ser una cadena vacía.

Python 2, 154 150 147 145 bytes

Muy bien, este es mi primer intento de golf de código. Directamente con el código:

import numpy.random as r
def f(s):
 i=0
 while i<len(s):
    i+=r.choice(11,p=[x/72. for x in [0,2,14,16,12,8,6,5,4,3,2]])
    s=s[:i]+' '+s[i:]
    i+=1
 return s

El segundo guión es por una pestaña como puede ver en mi versión TIO: Pruébelo en línea .

Lo que hago es agregar un espacio en la cadena de acuerdo con la distribución dada. Fijé mi distribución usando:

import collections
dist = r.choice(11,100000,p=[x/72. for x in [0,2,14,16,12,8,6,5,4,3,2]])
print collections.Counter(dist)

Lo que me dio:

Word Length - Rounded Percentage as asked - Rounded Percentage as counted
1 - 2.78% - 2.794%
2 - 19.44% - 19.055%
3 - 22.22% - 22.376%
4 - 16.67% - 16.638%
5 - 11.11% - 11.246%
6 - 8.33% - 8.362%
7 - 6.94% - 7.063%
8 - 5.56% - 5.533%
9 - 4.17% - 4.153%
10 - 2.78% - 2.780%

Lo cual creo que es lo suficientemente correcto. Luego repito ese proceso de agregar un espacio hasta que la longitud de mi cadena tenga éxito. También incremento mi índice de posición en uno después de agregar un espacio. Espero que alguien pueda ayudarme a jugar golf en esta línea, pero no vi cómo sacarla sin falsificar el primer espacio.

Al ver mi texto, reconozco que tengo que aprender mucho sobre este sitio. ¿Podría alguien vincularme una guía sobre cómo usar la función de respuesta de Stackoverflow en los comentarios para que pueda aprender para mis próximas publicaciones?

Editar:

Aparentemente, mientras releía mi publicación, descubrí una forma de deshacerme de i + = 1. Así que ahorré 4 bytes al hacer eso. El nuevo código se ve así:

import numpy.random as r
def f(s):
 i=-1
 while i<len(s):
  i+=r.choice(11,p=[x/72. for x in[0,2,14,16,12,8,6,5,4,3,2]])+1
  s=s[:i]+' '+s[i:]
 return s

Pruébalo en línea!

Descubrí que puedo eliminar algunos saltos de línea.

import numpy.random as r
def f(s):
 i=-1
 while i<len(s):i+=r.choice(11,p=[x/72. for x in[0,2,14,16,12,8,6,5,4,3,2]])+1;s=s[:i]+' '+s[i:]
 return s

from numpy.random import*
def f(s,i=-1):
 while i<len(s):i+=choice(11,p=[x/72. for x in[0,2,14,16,12,8,6,5,4,3,2]])+1;s=s[:i]+' '+s[i:]
 return s

Pruébalo en línea!

Dyalog APL, 90 bytes

{k←⍵⋄{' '~⍨(2⊃⍵)↓k↑⍨⊃⍵}¨(↓(o[1;2]),0),↓o←1↓⍉2(1-⍨≢⍵)⍴+\((2 14 16 12 8,⌽1+⍳5)\⍳10)[72?⍨≢⍵]}

Pruébalo en línea! Presiona Ejecutar varias veces para ver cómo cambia.

¿Cómo?

72?⍨≢⍵ - tirar 72 dados de longitud de los tiempos de entrada

[...] - índice dentro

(2 14 16 12 8,⌽1+⍳5)\⍳10- ampliar el rango de 10 por 2 14 16 12 8 6 5 4 3 2(para crear aleatorio ponderado)

+\ - suma acumulativa

⍉2(1-⍨≢⍵)⍴- forma como una mesa con cremallera x y z→z x, x y, y z

o←1↓ - soltar el primer elemento

(↓(o[1;2]),0),↓o - encase con su primera coordenada emparejada con 0

¨ - para cada par (x, y)

(2⊃⍵)↓k↑⍨⊃⍵ - tomar entrada del índice xay

' '~⍨ - y eliminar espacios

Python 2 , 155 bytes

from random import*
def f(s):
 i=sum([[i+1]*[2,14,16,12,8,6,5,4,3,2][i]for i in range(10)],[])[randint(0,71)]
 return s if len(s)<11else s[:i]+' '+f(s[i:])

Pruébalo en línea!

Mathematica, 164 bytes

(s=Length[c=Characters@#];t=0;l={};While[t<s,If[t+(r=RandomChoice[{2,14,16,12,8,6,5,4,3,2}->Range@10])<=s,l~AppendTo~r];t=Tr@l];""<>#&/@FoldPairList[TakeDrop,c,l])&

toma una cadena como entrada
salidas matriz de cadenas

Carbón , 43 39 bytes

ＦθＦ⁺¹Ｉ‽⪫Ｅχ×Ｉκ⌕᧔v↷£o8″!”κω⊞υ⎇κω Ｆθ⁺ι⊟υ

Pruébalo en línea! El enlace es a la versión detallada del código. Emite un espacio final si la última palabra tenía el tamaño exacto elegido al azar.

Perl 5 , 107 bytes

@B=((1,10,9,5,2)x2,(2,3,4)x12,(5,6)x6,7,(3,7,8)x4,9);while(10<length){$i=$B[rand 72];s/.{$i}//;print"$& "}

Pruébalo en línea!

106 bytes de código +1 para -p

Rubí , 96 + 1 = 97 bytes

Usa la -pbandera.

i=0
m=[3,19,22,17,11,8,7,6,4,3].flat_map{|k|[i+=1]*k}
i=0
$_[i-1,0]=' 'while~/$/+1>i+=1+m.sample

Pruébalo en línea!

> <> , 168152 bytes

<v?(0:i
~/<r
/x\/oo \
012\oo~\!/ !ox\
\v/:1=?^?\ooo>>
 x^
v\:1\/>> o
|/o\=\x^!/
voo/? >x
v\o~/ v_
>" "\?\x>xoo\
^oooooo<<< \
^.22/ \>x!/xv
^ooooooo_o<<<

¡Pruébelo en línea o mírelo en el área de juegos para peces !

La aleatoriedad es complicada en> <>: solo hay una instrucción aleatoria, x , que establece la dirección del pez en arriba, abajo, izquierda o derecha. Este es un programa complicado, así que aquí hay un diagrama codificado por colores para ayudarlo:

Traté de dividir las probabilidades en fragmentos para que las probabilidades dentro y entre los fragmentos fueran bastante simples (prefiriendo, por ejemplo, 1/3 a 25/72). Hice esto de la siguiente manera:

El pez comienza en la parte gris del código ( X ). Este es un código> <> bastante estándar para leer en toda la entrada. Se pone más interesante, así que sigamos adelante.

A continuación, el pez llega a las secciones verde claro y oscuro ( Y ). Puede observar en el árbol de probabilidad que las tres ramas principales suman cada una 1/3, y que cada una de estas ramas se divide en una sub-rama 2/3 y una sub-rama 1/3. Las secciones verdes del código cubren estos dos niveles del árbol. Primero, elegimos un número aleatorio de 0, 1, 2 con la misma probabilidad de cada uno, en el lóbulo superior del bit verde claro. Podemos simular una probabilidad de 1/3 usando la instrucción de cuatro vías xcortando una de las salidas para que solo redirija a los peces de regreso a x- entonces solo hay tres rutas de escape de la x, y por simetría tienen probabilidades iguales.

El siguiente x, un poco debajo de este, envía el pescado al^ siguiente con 2/3 de probabilidad: tenga en cuenta que el pez se enrolla si nada desde el x- y baja a un\ 1/3 de probabilidad. El pez luego nada a lo largo de una de las dos colas de la sección verde claro. Estas colas son funcionalmente iguales: cada una verifica si presionamos 0, 1 o 2 antes, y se ramifica en consecuencia. Y esto completa los dos primeros niveles del árbol.

Las siguientes seis secciones ( A - F ), en esencia, usan más xs para ramificar aún más el pez, y luego usan algunos os para imprimir varias letras de la entrada. Estas secciones van desde sencillas (por ejemplo, azul oscuro,  C , que solo imprime tres letras) hasta, bueno, no tan sencillas (por ejemplo, naranja, D , que necesita dos xs para simular una división 3 / 8–5 / 8, imprimiendo letras en etapas múltiples). Los detalles de estos se dejan como un ejercicio. (Estoy particularmente satisfecho con el amarillo, E , que envía al pez en un bucle!)

Después de cada una de estas ramas, el pez finalmente llega a la sección rosa ( Z ). Esto vuelve a unir todas las ramas, imprime un espacio, luego finalmente hace que el pez salte a la posición (2,2) en la cuadrícula y comience nuevamente desde el principio x.

En caso de que la explicación "es complicada" anterior no lo convenza de que esto da las probabilidades correctas, también probé esto en una cadena de entrada de 65,000 de longitud (64 KiB, ¡solo 13 segundos en TIO!), Y la distribución resultante de las longitudes de palabras fue

{{1,0.027377},{2,0.191237},{3,0.226599},{4,0.164128},{5,0.113064},{6,0.0818627},{7,0.0703885},{8,0.0543515},{9,0.0426089},{10,0.0283835}}

Estas probabilidades están a lo más 0.0044 lejos de las probabilidades esperadas.