Oraciones retorcidas

17

Reglas

El programa debe recibir una cadena / matriz de palabras como entrada. Para cada palabra en la cadena / matriz, reconstruirá la palabra tomando caracteres de forma alterna desde el frente y el reverso de la palabra.

12345678 9 -> 15243687 9.

Luego reorganizará las palabras de manera alterna entre la palabra más antigua y la más reciente en la cadena.

15243 687 9 -> 15243 9 687

Finalmente, reconstruirá la cadena colocando los espacios, las pestañas y las nuevas líneas en los índices donde se ubicaron inicialmente antes de generar el resultado.

12345 678 9-> 15243 687 9 -> 15243 9 687 -> 15243 968 7

La salida debe ser del mismo tipo de datos que la entrada.

Las lagunas estándar están prohibidas

Ejemplos

Entrada:
El rápido zorro marrón salta sobre el perro perezoso.
Salida:
Teh d.ogq kucil yaz bnrwo tehf xoo rvej supm

Entrada:
El rápido zorro marrón salta
sobre el perro perezoso.
Salida:
Teh d.ogq kucil yaz bnrwo
tehf xoo rvej supm

Entrada:
Aflack
Salida:
Akfcla

Este es el por lo que el código más corto gana

fəˈnɛtɪk
fuente
66
Esto se siente como un duplicado. Juro que he visto esto antes.
Addison Crump
¿Entonces solo los caracteres tabulación, espacio y línea nueva no se consideran parte de una palabra?
Jonathan Allan
@JonathanAllan eso es correcto
fəˈnɛtɪk
¿Podemos asumir ASCII? o Unicode?
MayorMonty
@MayorMonty Puede suponer que los caracteres son de cualquier forma que le resulte más fácil siempre que trate los espacios correctamente.
fəˈnɛtɪk

Respuestas:

3

Jalea , 15 14  8 bytes

Un enorme ahorro de 6 bytes de Dennis (moviendo el aplanamiento y el molde dentro del enlace 1 no hay necesidad de dividirlos en dos y cabeza, ¡y un aplanamiento ya está allí para que se vuelvan uno!)

żṚFṁ
Ç€Ç

(de las dos líneas: żṚFœs2Ḣy Ç€ÇFṁ⁸)

Pruébalo en línea!

Toma una matriz de palabras y devuelve una matriz de palabras nuevas. (El pie de página en TIO llama a esto y une la matriz con espacios para que se imprima bien).

Nota: manejar una sola cadena, dividir en espacios de pestañas y nuevas líneas, luego volver a ensamblar resultó ser bastante complicado; Una vez que vi que una lista de palabras era una opción, ¡las cosas se volvieron mucho más fáciles!

¿Cómo?

Ç€Ç - Main link: list of words
Ç€  - call the last link (1) as a monad for €ach word
  Ç - call the last link (1) as a monad for the result

żṚFṁ - Link 1: Do a twist: list (here, a list of words or characters)
                            e.g. input = [A,B,C,D,E,F,G]
ż    - zip the list with                 [A,    B,    C,    D,    E,    F,    G]
 Ṛ   - the reverse of the list             [G,    F,    E,    D,    C,    B,    A]
                                        [[A,G],[B,F],[C,E],[D,D],[E,C],[F,B],[G,A]]
  F  - flatten into a single list        [A,G,  B,F,  C,E,  D,D,  E,C,  F,B,  G,A]
                                         [A,G,B,F,C,E,D,D,E,C,F,B,G,A]
   ṁ - mould like the input list         [A,G,B,F,C,E,D]
Jonathan Allan
fuente
Esto debería funcionar. Pruébalo en línea!
Dennis
Dulce guardar; ¡Demasiado fácil para olvidar esa maniobra!
Jonathan Allan
2

JavaScript (ES6), 89 bytes

Toma y emite una serie de palabras.

a=>a.map(w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(a.map(F)).slice(p,p+=w.length),p=0)

Prueba

Versión de cadena, 112 bytes

Toma y emite una cadena.

s=>s.replace(/\S+/g,w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(s.split(/\s/).map(F)).slice(p,p+=w.length),p=0)

Prueba

Arnauld
fuente
2

Perl , 77 bytes

74 bytes de código + 3 bytes para -0pabanderas.

map{s/.\K/chop/ge,s/../chop/reg}@F;s/\S/($r||=$F[$i++].pop@F)=~s%.%%,$&/ge

Pruébalo en línea!

Guardado 8 bytes gracias a un viejo @Ton Hospel 's puesto en el que 'robé' s/../chop/reg. (Previamente tuve $c=y///c/2,s/.{$c}$//)

Dada
fuente
0

Perl 6 , 84 bytes

{my &t={(|(.shift,.pop)xx*)[^$_]}
map({|t [.comb]},t [$_]).rotor($_».chars)».join}

Entradas y salidas de una lista de palabras.

Cómo funciona

Dentro de la lambda, definí otra lambda para realizar la torsión de " tomar caracteres de forma alterna desde el frente y la espalda ":

my &t={                        }   # Lambda, assigned to a variable.
          .shift,.pop              # Remove an element from the front an back,
                      xx*          # an infinite number of times,
        |(           )             # and make sure this infinite list is flattened.
                          [^$_]    # Take as many elements as the input had elements.

Esto funciona porque el xxoperador se parece más a una macro que a una función, ya que proporciona una evaluación mágica perezosa.

Luego en la lambda principal:

                   [$_]                          # Create a fresh array from the input,
                 t                               # and twist it (destructively).
map({          },                                # For each element (i.e. word):
      t [.comb]                                  #   Split it into characters and twist them,
     |                                           #   and slip them into the outer list.
                        .rotor($_».chars)        # Partition this flat list of characters,
                               $_».chars         # using the original word lengths.
                                         ».join  # Turn each sub-list into a word.

Perl 6 , 87 bytes

{my &t={(|(.shift,.pop)xx*)[^$_]}
my @a=map {|t [.comb]},t [.words];S:g/\S/{@a.shift}/}

Esta es una variación de lo anterior, que ingresa y emite una cadena, conservando diferentes caracteres de espacio en blanco.

smls
fuente
0

Haskell , 115 95 93 98 95 bytes

f(a:b)=a:f(reverse b)
f e=e
a!(y:z)|elem y" \t\n"=y:a!z|b:c<-a=b:c!z
a!z=z
(!)=<<(f=<<).f.words

Llamada con (!)=<<(f=<<).f.words $ "some string".Pruébalo en línea!

Gracias a @nimi por señalar que leí mal el desafío anteriormente.

La función frealiza la torsión en una lista, por lo que puede usarse en cadenas (lista de caracteres) y una lista de cadenas. a!binserta el espacio en blanco de la cadena ben la cadena a.

(!)=<<(f=<<).f.wordses equivalente a \s0 -> (concatMap f . f . words $ s0) ! s0:

            s0 = "The quick brown fox jumps\nover the lazy dog."
      words s0 = ["The","quick","brown","fox","jumps","over","the","lazy","dog."] = s1
          f s1 = ["The","dog.","quick","lazy","brown","the","fox","over","jumps"] = s2
concatMap f s2 = "Tehd.ogqkucilyazbnrwotehfxoorvejsupm"                           = s3
       s3 ! s0 = "Teh d.ogq kucil yaz bnrwo\ntehf xoo rvej supm"
Laikoni
fuente