Texto de Boustrophedon inverso

19

Boustrophedon es un tipo de texto bidireccional en el que las líneas sucesivas alternan entre la lectura de izquierda a derecha y de derecha a izquierda. La dirección del personaje también se reflejó con respecto a la dirección de lectura. En los sistemas de escritura de boustrofedón inverso, los caracteres se giraban 180 en lugar de reflejarse.

Desafío

Escriba un programa / función que acepte una cadena de texto y una cantidad de columnas, y genere la cadena formateada en la cantidad especificada de columnas con líneas alternas invertidas.

Entrada

Su programa debe aceptar dos argumentos:

  • S, la cadena de texto para formatear
  • N, el número de columnas

Salida

Su programa debería generar S envuelto en N columnas con líneas alternas invertidas 180 grados.

  • La dirección de lectura de la primera línea siempre es de izquierda a derecha.
  • No se preocupe por dónde colocar saltos de línea, las líneas se pueden dividir en cualquier carácter, no se requiere la exageración de las palabras.
  • Puede suponer que la cadena de entrada no contendrá saltos de línea.

Estos son los caracteres que su programa debe admitir con sus contrapartes invertidas:

Uppercase:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Z

Lowercase:
abcdefghijklmnopqrstuvwxyz
ɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz

Punctuation:
&_?!"'.,
⅋‾¿¡„,˙'

Casos de prueba

S: The quick brown fox jumps over the lazy dog.
N: 30
Output:
The quick brown fox jumps over
                ˙ƃop ʎzɐl ǝɥʇ 

S: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vel libero arcu. Nunc dictum elementum lectus nec aliquet. Donec dolor nunc, sodales at dolor rhoncus, hendrerit scelerisque purus. Pellentesque vel sagittis libero, et rutrum leo. Nullam vulputate enim et massa dictum, vitae venenatis augue lobortis. Fusce sollicitudin ultrices consequat. Vestibulum quis nunc non tortor eleifend facilisis. In at nunc elit. Aliquam pellentesque, lectus quis aliquam posuere, quam lectus sagittis metus, ut auctor sem quam a neque. Integer rhoncus lobortis nisl. Pellentesque mi dui, laoreet in metus quis, mollis accumsan est. Nunc dignissim tortor ac eleifend tempus. Ut ut tellus aliquam, luctus nulla quis, consectetur nunc. Suspendisse viverra molestie condimentum. Curabitur et hendrerit augue.
N: 50
Output:
Lorem ipsum dolor sit amet, consectetur adipiscing
uǝɯǝlǝ ɯnʇɔᴉp ɔunN ˙nɔɹɐ oɹǝqᴉl lǝʌ ǝnbsᴉnQ ˙ʇᴉlǝ 
tum lectus nec aliquet. Donec dolor nunc, sodales 
lǝԀ ˙snɹnd ǝnbsᴉɹǝlǝɔs ʇᴉɹǝɹpuǝɥ 'snɔuoɥɹ ɹolop ʇɐ
lentesque vel sagittis libero, et rutrum leo. Null
sᴉʇɐuǝuǝʌ ǝɐʇᴉʌ 'ɯnʇɔᴉp ɐssɐɯ ʇǝ ɯᴉuǝ ǝʇɐʇndlnʌ ɯɐ
 augue lobortis. Fusce sollicitudin ultrices conse
ɔɐɟ puǝɟᴉǝlǝ ɹoʇɹoʇ uou ɔunu sᴉnb ɯnlnqᴉʇsǝΛ ˙ʇɐnb
ilisis. In at nunc elit. Aliquam pellentesque, lec
ʇǝɯ sᴉʇʇᴉƃɐs snʇɔǝl ɯɐnb 'ǝɹǝnsod ɯɐnbᴉlɐ sᴉnb snʇ
us, ut auctor sem quam a neque. Integer rhoncus lo
snʇǝɯ uᴉ ʇǝǝɹoɐl 'ᴉnp ᴉɯ ǝnbsǝʇuǝllǝԀ ˙lsᴉu sᴉʇɹoq
 quis, mollis accumsan est. Nunc dignissim tortor 
u snʇɔnl 'ɯɐnbᴉlɐ snllǝʇ ʇn ʇ∩ ˙sndɯǝʇ puǝɟᴉǝlǝ ɔɐ
ulla quis, consectetur nunc. Suspendisse viverra m
˙ǝnƃnɐ ʇᴉɹǝɹpuǝɥ ʇǝ ɹnʇᴉqɐɹnƆ ˙ɯnʇuǝɯᴉpuoɔ ǝᴉʇsǝlo
Dendrobium
fuente

Respuestas:

5

Bash + GNU utilidades, 204

fold -$1|sed 2~2{s/.\\+/printf\ %$1's "`echo "&"|rev`"/e
y/'`printf %s {A..Z} {a..z}`"&_?!\"'.,/∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Zɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz⅋‾¿¡„,˙'/
}"

N se da en la línea de comando y S se da a través de STDIN:

$ echo "The quick brown fox jumps over the lazy dog." | ./boustrophedon.sh 30
The quick brown fox jumps over
                ˙ƃop ʎzɐl ǝɥʇ 
$ 

Explicación

  • fold -N divide la entrada en líneas de longitud N.
  • El resto del procesamiento se realiza por sed, línea por línea:
    • 2~2 coincide con cualquier otra línea, comenzando en la línea 2
    • s/.+/printf %'N's "`echo "&"|rev`"/e usa la función ejecutiva de GNU Sed para llamar a un shell para invertir la línea y rellenarla con hasta N espacios
    • y/ABC.../∀qƆ.../ transformar personajes

La nota ABC...se genera usando una expansión bash e printf. También algunas citas elegantes para todos los personajes diferentes.

Trauma digital
fuente
Gracias @isaacg. Pensé que había intentado hacer doble backticks, pero supongo que me perdí eso.
Trauma digital
3

Japt , 182 179 bytes

Japt es una versión abreviada de Ja vaScri pt . Interprete

Ur'.+".?"pV-1 ,@A++%2?SpV-Xl)+Xw m@"„\xA1⅋,'˙¿∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Z[\\]^‾`ɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz"g(Q+"!&',.?"+65o124 m@Xd)a)bX)||X +R:X+R

Cómo funciona

             // Implicit: U = input string, V = input number, A = 10
Ur           // Take U and replace each group X of:
'.+".?"pV-1  //  at least one char, followed by up to V-1 other chars
             //   literally: RegExp("." + ".?".repeat(V-1))
@            // with: (@ is compiled to (X,Y,Z)=>)
A++%2?       //  If we're on an odd row:
SpV-Xl)+     //   Pad it with spaces, then concatenate it with
Xw m@        //   X reversed, with each character X mapped to:
"..."g       //   The character at position N in the string, where N is:
(Q+"!&',.?"  //    Build a string from a quote mark and these chars,
65o124 m@Xd)a) //   and all chars from A..z.
bX)          //    Return the index of X in this string.
||X          //   or if this number is outside the string, default to the original char.
+R           //   Either way, add a newline.
:X+R         //  Otherwise, return the original row text plus a newline.
             // Implicit: output last expression

Hay un par de problemas, pero no deberían afectar la validez del programa:

  1. El usuario @ Vɪʜᴀɴ me ayudó recientemente a implementar accesos directos Unicode, o caracteres individuales en el rango 00A1-00FF que representan las secuencias de varios caracteres comúnmente utilizadas. El problema con esto es que actualmente reemplaza las cadenas internas, por lo que no podemos usar ¡directamente en la cadena por ahora. La alternativa segura \xA1, es tres bytes más larga.
  2. Actualmente es imposible ingresar un carácter de comillas dobles. Esto se solucionará en breve.

Quizás haya una forma de acortar la cuerda. ¡Sugerencias son bienvenidas!

ETHproducciones
fuente
¡Agradable! Quería intentar convertir mi solución a Japt más tarde, pero esto se lleva la palma.
Scott
2

CJam, 152

l~_q/\f{Se]}2/{)26,'Af+_el+"&_?!'.,"`+"∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Zɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz„⅋‾¿¡,˙'"erW%}%N*

Pruébalo aquí.

Supongo que debería considerar comprimir un poco esa cadena Unicode ...

Martin Ender
fuente
Comprimir esa cadena Unicode es difícil: los puntos de código están por todas partes. Como experimento, intenté 'zopfli'ing toda mi entrada (incluidos los bits de sed) y terminé más grande. Estaré mirando con interés para ver cómo lo abordas :)
Digital Trauma
2

Javascript (ES6), 407 400 366 360 353 bytes

Solo cuento las dos primeras "líneas" en este fragmento como el recuento total, ya que el resto es código para ejecutarlo.

s=`ABCDEFGHIJKLMNOPQRSTUVWXYZqƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMXZabcdefghijklmnopqrstuvwxyzɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz&_?!"'.,⅋‾¿¡„,˙'`,f=(i,w)=>(i=i.match(RegExp(`.{1,${w}}`,"g")),i.map((c,x)=>x%2?" ".repeat(w-c.length)+[...c].reverse().map(b=>(d=s.indexOf(b),"A"<=b&&"z">=b?s[d+26]:" "==b?b:s[d+8])).join``:c).join`
`)

let input = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vel libero arcu. Nunc dictum elementum lectus nec aliquet. Donec dolor nunc, sodales at dolor rhoncus, hendrerit scelerisque purus. Pellentesque vel sagittis libero, et rutrum leo. Nullam vulputate enim et massa dictum, vitae venenatis augue lobortis. Fusce sollicitudin ultrices consequat. Vestibulum quis nunc non tortor eleifend facilisis. In at nunc elit. Aliquam pellentesque, lectus quis aliquam posuere, quam lectus sagittis metus, ut auctor sem quam a neque. Integer rhoncus lobortis nisl. Pellentesque mi dui, laoreet in metus quis, mollis accumsan est. Nunc dignissim tortor ac eleifend tempus. Ut ut tellus aliquam, luctus nulla quis, consectetur nunc. Suspendisse viverra molestie condimentum. Curabitur et hendrerit augue.";
console.log(f(input, 50));

Explicación

s=`A∀ .. ZZaɐ .. &⅋ ..`,                            //Character translation "map"
f=(i,w)=>                                           //Create a function named "f" that takes an (i)nput string and (w)idth
    (                                               //Implicitly return
        i=i.match(RegExp(`.{1,${w}}`,"g")),         //Cut string into arrays every w-th match of anything
        i.map((c,x)=>                               //Loop through each element in array by (c)ut at inde(x)
            x%2                                     //If the index is odd
                ?" ".repeat(w-c.length)                 //Output spaces for padding
                    +[...c].reverse()                   //Split this cut into each character, and read it backwards
                    .map((b,d)=>(                       //Translate each character
                        d=s.indexOf(b),                 //Save where this character appears in the mapping
                        "A"<=b&&"z">=b                  //If the character is a-zA-Z
                        ?s[d+26]                            //Print the flipped character by looking 26 characters ahead of where this character is found
                        :" "==b                             //Else, if it's a space
                            ?b                              //Output the space
                            :s[d+8]))                   //Else, print the flipped punctuation character (only 8 of these)
                    .join``                         //Join everything back into a continuous string
                :c                                  //Else just output the whole cut
            ).join`                                 
`)                                                  //Finally join each cut by a newline

  • ¡Gracias a Dendrobium por -6 bytes!
  • ¡Gracias al compilador de cierre por -34 bytes!
  • ¡Gracias a ן nɟuɐɯɹɐ ן oɯ por -7 bytes!
Scott
fuente
1
Puede reducir todos sus .split("")'s' y .join("")'s .split``y .join``recortar algunos bytes. El .join("\n")también se puede reescribir como el anterior con una nueva línea literal en lugar de \n.
Dendrobium
Grandes consejos, muchas gracias!
Scott
1
Puede eliminar la nueva palabra clave para la expresión regular. También use exec en lugar de match. Oh sí, use [... c] en lugar de c.split ''.
Mama Fun Roll
@ ן nɟuɐɯɹɐ ן oɯ Bien, gracias! Sin embargo, no pude entender cómo usarlo execy mantenerlo corto, ya que es execnecesario realizar un bucle para obtener todos los partidos.
Scott
Oh, no importa el ejecutivo ...
Mama Fun Roll
1

Pyth, 141 bytes

FNrZlKczQI%N2X.[" "Q_@KN++GrG1"&_?!\"'.,""ɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Z⅋‾¿¡„,˙'")E@KN

Probado con un compilador Pyth en línea.

Cómo funciona

FNrZlKczQI%N2X.[" "Q_@KN)E@KN    █
                                 █
FN                               █ For N in 
  r                              █  ├ Range
   Z                             █  |  ・Start: 0 
                                 █  |  ・End: 
    l                            █  |     Length of
     K                           █  |      └─K = 
      c                          █  |         Split
       z                         █  |           ・String z
        Q                        █  |           ・By input int Q
         I%N2                    █  └─If divisible by 2
             X                   █     └─Translate
                                 █         ├─Source:
              .[                 █         | ├─Pad left
                " "              █         | |   ・With spaces
                   Q             █         | |   ・Until input int Q
                    _            █         | └──Reverse
                     @KN         █         |     ・Nth line of K
                        ++GrG1...█         ├─From: Normal  (See below)
                        "ɐqɔpǝ...█         └─To:   Flipped (See below)
                        )E@KN    █     Else print Nth line of K

Mapa

Normal

++                               █ Append:
  G                              █  1) a to z
   rG1                           █  2) A to Z
      "&_?!\"'.,"                █  3) Punctuation

Volteado (nada lujoso)

"ɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Z⅋‾¿¡„,˙'"
Helix Quar
fuente
Esto tiene 108 caracteres de largo; sin embargo, la forma predeterminada de medir la longitud de los programas de código de golf es en bytes . Según esta página , la longitud de esta respuesta es 141 bytes .
ETHproductions
@ETHproductions Gracias. Cambiado.
Helix Quar
0

Python, 453 363 bytes

s,n=input()
o="""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz&_?!"'.,"""
p="""∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Zɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz⅋‾¿¡„,˙'""".decode('utf8')
s=map(''.join,zip(*[iter(s+' '*(n-1))]*n))
for i in range(len(s)):
 if i%2:s[i]=''.join(p[o.find(c)].encode('utf8')for c in s[i][::-1])
for l in s:print l
TFeld
fuente