Boustrophedon è un tipo di testo bidirezionale in cui le righe successive si alternano tra la lettura da sinistra a destra e da destra a sinistra. Anche la direzione del personaggio è stata rispecchiata rispetto alla direzione di lettura. Nei sistemi di scrittura boustrophedon al contrario, i personaggi venivano ruotati di 180 anziché specchiati.

Sfida

Scrivi un programma / funzione che accetta una stringa di testo e un numero di colonne e genera la stringa formattata nel numero specificato di colonne con linee alternate capovolte.

Ingresso

Il tuo programma dovrebbe accettare due argomenti:

• S, la stringa di testo da formattare
• N, il numero di colonne

Produzione

Il tuo programma dovrebbe generare S avvolto in N colonne con linee alternate capovolte di 180 gradi.

• La direzione di lettura della prima riga è sempre da sinistra a destra.
• Non preoccuparti di dove posizionare le interruzioni di riga, le linee possono essere divise in qualsiasi carattere, non è necessaria l'ipenazione delle parole.
• Si può presumere che la stringa di input non conterrà alcuna interruzione di riga.

Ecco i personaggi che il tuo programma dovrebbe supportare con le loro controparti capovolte:

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

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

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

Casi test

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

Utilità Bash + GNU, 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 è dato sulla riga di comando e S è dato tramite STDIN:

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

Spiegazione

• fold -N divide l'input in righe di lunghezza N.
• Il resto dell'elaborazione viene eseguito da sed, riga per riga:
  • 2~2 corrisponde a ogni altra riga, a partire dalla riga 2
  • s/.+/printf %'N's "`echo "&"|rev`"/e usa la funzione exec di GNU Sed per chiamare una shell per invertire la linea e spostarla a sinistra con un massimo di N spazi
  • y/ABC.../∀qƆ.../ trasforma i personaggi

La nota ABC...viene generata usando un'espansione bash e printf. Anche alcune citazioni fantasiose per tutti i diversi personaggi.

Japt , 182 179 byte

Japt è una versione abbreviata di 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

Come funziona

             // 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

Ci sono un paio di problemi, ma non dovrebbero influenzare la validità del programma:

1. L'utente @ Vɪʜᴀɴ mi ha di recente aiutato a implementare le scorciatoie Unicode o singoli caratteri nell'intervallo 00A1-00FF che rappresentano sequenze di diversi caratteri di uso comune. Il problema è che attualmente sostituisce le stringhe interne, quindi per ora non possiamo usare direttamente la stringa. L'alternativa sicura \xA1, è di tre byte in più.
2. Al momento è impossibile inserire un carattere tra virgolette doppie. Questo problema verrà risolto a breve.

Forse c'è un modo per accorciare la stringa. I suggerimenti sono benvenuti!

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*

Provalo qui.

Immagino che dovrei cercare di comprimere un po 'quella stringa Unicode ...

Javascript (ES6), 407 400 366 360 353 byte

Sto contando solo le prime due "righe" in questo frammento come il conteggio totale, poiché il resto è un codice per eseguirlo.

s=`ABCDEFGHIJKLMNOPQRSTUVWXYZ∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Zabcdefghijklmnopqrstuvwxyzɐ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));

Spiegazione

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

• Grazie a Dendrobium per -6 byte!
• Grazie al compilatore di chiusura per -34 byte!
• Grazie a ן nɟuɐɯɹɐ ן oɯ per -7 byte!

Pyth, 141 byte

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

Testato con un compilatore Pyth online.

Come funziona

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

Carta geografica

_Normale

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

_{Capovolto (niente di speciale)}

"ɐqɔpǝɟƃɥᴉɾʞlɯuodbɹsʇnʌʍxʎz∀qƆpƎℲפHIſʞ˥WNOԀQɹS┴∩ΛMX⅄Z⅋‾¿¡„,˙'"

Python, 453 363 byte

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