Boustrophedonise

35

संबंधित लेकिन बहुत अलग।

एक बैरस्ट्रोफेडॉन एक ऐसा पाठ है जहां लेखन की हर दूसरी पंक्ति को उलट या उलट कर लिखा जाता है।

इस चुनौती में, हम हर दूसरी पंक्ति को उलट देंगे, लेकिन उपयोग किए गए वास्तविक वर्णों को छोड़ देंगे। आप चुन सकते हैं कि कौन सी पंक्तियों को उल्टा करना है, जब तक कि यह हर दूसरे एक है।

जब तक आप मुद्रण योग्य ASCII की शून्य या अधिक पंक्तियों का समर्थन करते हैं, प्रत्येक को शून्य या अधिक वर्णों के साथ पाठ में ले सकते हैं।

उदाहरण:

["Here are some lines","of text for you","to make a","boustrophedon"]:

["Here are some lines","uoy rof txet fo","to make a","nodehportsuob"] or ["senil emos era ereH","of text for you","a ekam ot","boustrophedon"]


["My boustrophedon"]:

["My boustrophedon"] or ["nodehportsuob yM"]

[]:  
[]

["Some text","","More text","","","Last bit of text"]:

["Some text","","More text","","","txet fo tib tsaL"] or ["txet emoS","","txet eroM","","","Last bit of text"]
code-golf  array-manipulation  typography  text-processing 
— एडम
स्रोत
यह नहीं समझा जा सकता है कि क्या रिटर्न और इनपुट के लिए टेक्स्ट अलग लाइनों की जरूरत है या यह एक फाइल या लाइनों की सूची हो सकती है।
— सर्गिओल
@sergiol डिफ़ॉल्ट PPCG I / O नियम लागू होते हैं।
— Adám
क्या मेरा कोड असंगत रूप से व्यवहार कर सकता है, अर्थात कभी-कभी पहली पंक्ति से और कभी-कभी दूसरी से उलट शुरू होता है?
— को आउटगॉल्फ को एरिक करें
2
@EriktheOutgolfer हाँ, मैंने इसके बारे में पहले पूछा था और "आपने चुना है कि कौन सी पंक्तियों को रिवर्स करना है, जब तक कि यह हर दूसरे एक है।" वास्तव में इसे उस व्यवहार के लिए पर्याप्त रूप से सामान्य बनाने के लिए बदल दिया गया था।
— मार्टिन एंडर
1
@totallyhuman हाँ, ओपी के अनुसार।
— 20

जवाबों:

20

APL (Dyalog Classic) , 4 बाइट्स

⊢∘⌽\

इनपुट चरित्र वैक्टर का एक वेक्टर है।

⌽एक ऐसा कार्य है जो एक वेक्टर को उलट देता है (जब ⌽इसे वैधानिक रूप से लागू किया जाता है)।

⊢" डेक्स " है - एक फ़ंक्शन जो अपना सही तर्क देता है। जब (बना ∘) एक और समारोह के साथ fयह बाद के लिए मजबूर करता monadic के रूप में होने के लिए A ⊢∘f Bके बराबर है A ⊢ (f B)और इसलिए f B।

\है स्कैन ऑपरेटर। g\A B C ...वेक्टर A (A g B) (A g (B g C)) ...जहां gडायडिकली (इन्फिक्स नोटेशन) लगाया जाता है। स्थानापन्न ⊢∘⌽के लिए gयह करने के लिए सरल:

A (A ⊢∘⌽ B) (A ⊢∘⌽ (B ⊢∘⌽ C)) ...
A (⌽B) (⌽⌽C) ....
A (⌽B) C ....

यहां तक ​​कि पदों पर उलट (या आप कैसे गिनती के आधार पर विषम) को रद्द कर देते हैं।

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत
4
है यह सचमुच ]&|.&.>/\उन लोगों के लिए जे पढ़ सकते हैं जो
— FrownyFrog
2
यह वास्तव में चतुर है।
— आउटगोल्फर
13

हास्केल , 26 बाइट्स

zipWith($)l
l=id:reverse:l

इसे ऑनलाइन आज़माएं! उपयोग उदाहरण: zipWith($)l ["abc","def","ghi"]पैदावार ["abc","fed","ghi"]।

स्पष्टीकरण:

lidइकाई फ़ंक्शन और फ़ंक्शन के बीच बारी-बारी से होने वाले कार्यों की एक अनंत सूची है reverse।

मुख्य फ़ंक्शन ज़िप lऔर फ़ंक्शन एप्लिकेशन के साथ इनपुट सूची $, जो ["abc", "def", "ghi"]हमें प्राप्त इनपुट के लिए है [id$"abc", reverse$"def", id$"ghi"]।

— Laikoni
स्रोत
11

भूसी , 4 बाइट्स

z*İ_

लेता है और स्ट्रिंग्स की एक सूची देता है (व्याख्याकार स्पष्ट रूप से मुद्रण से पहले newlines द्वारा परिणाम में शामिल होता है)। पहला तार उलटा है। इसे ऑनलाइन आज़माएं!

व्याख्या

z*İ_  Implicit input.
  İ_  The infinite list [-1,1,-1,1,-1,1..
z     Zip with input
 *    using multiplication.

भूसी में, एक संख्या के साथ एक स्ट्रिंग को गुणा करना कई बार दोहराता है कि संख्या नकारात्मक होने पर भी इसे उलट देती है।

— Zgarb
स्रोत
6

जावास्क्रिप्ट (ईएस 6), फ़ायरफ़ॉक्स, 43 बाइट्स

यह संस्करण फ़ायरफ़ॉक्स के सॉर्ट एल्गोरिथ्म का दुरुपयोग करता है । यह क्रोम पर कचरा उत्पन्न करता है और एज पर सभी तारों को नहीं बदलता है।

a=>a.map((s,i)=>[...s].sort(_=>i&1).join``)

परीक्षण के मामलों

कोड स्निपेट दिखाएं

या इसे ऑनलाइन आज़माएं! (मकड़ीनुमा बन्दर)

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स

a=>a.map(s=>(a^=1)?s:[...s].reverse().join``)

परीक्षण के मामलों

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
6

एपीएल (डायलॉग यूनिकोड) , 10 बाइट्स

⌽¨@{2|⍳≢⍵}

दोनों तरीके से काम करता है:

इसे ऑनलाइन आज़माएं! साथ में⎕IO←1

इसे ऑनलाइन आज़माएं! साथ में⎕IO←0

यह काम किस प्रकार करता है:

⌽¨@{2|⍳≢⍵} ⍝ tacit prefix fn
   {   ≢⍵} ⍝ Length of the input
      ⍳    ⍝ generate indexes from 1 (or 0 with ⎕IO←0)
    2|     ⍝ mod 2; this generates a boolean vector of 0s (falsy) and 1s (truthy)
  @        ⍝ apply to the truthy indexes...
⌽¨         ⍝ reverse each element
— जे। सल्ल
स्रोत
3

के (ओके) , 17 14 बाइट्स

समाधान:

@[;&2!!#x;|]x:

इसे ऑनलाइन आज़माएं!

उदाहरण:

@[;&2!!#x;|]x:("this is";"my example";"of the";"solution")
("this is"
"elpmaxe ym"
"of the"
"noitulos")

स्पष्टीकरण:

reverseइनपुट सूची के विषम सूचकांक पर लागू करें :

@[;&2!!#x;|]x: / the solution
            x: / store input as variable x
@[;      ; ]   / apply @[variable;indices;function] (projection)
          |    / reverse
       #x      / count (length) of x, e.g. 4
      !        / til, !4 => 0 1 2 3
    2!         / mod 2, 0 1 2 3 => 0 1 0 1       
   &           / where true, 0 1 0 1 => 1 3

टिप्पणियाँ:

  • 3 बाइट बचाने के &(#x)#0 1लिए बाहर स्विच किया गया&2!!#x
— streetster
स्रोत
3

जे , 9 बाइट्स

(,|.&.>)/

परिणाम में सभी तारों को उलटते हुए दाएं से बाएं ओर कम करें और अगले स्ट्रिंग को पूर्व की तरह करें।

इसे ऑनलाइन आज़माएं!

हम ngn के दृष्टिकोण का उपयोग करके 6 कर सकते हैं , लेकिन अतिरिक्त स्थान होंगे:

]&|./\

इसे ऑनलाइन आज़माएं!

— FrownyFrog
स्रोत
2

आर , 85 बाइट्स

for(i in seq(l<-strsplit(readLines(),"")))cat("if"(i%%2,`(`,rev)(l[[i]]),"\n",sep="")

इसे ऑनलाइन आज़माएं!

स्टड और आउटपुट से स्टडआउट तक इनपुट।

प्रत्येक पंक्ति को एक लाइनफीड / कैरिज रिटर्न / CRLF द्वारा समाप्त किया जाना चाहिए, और यह एक इसी नई रेखा के साथ प्रिंट करता है। इसलिए, इनपुट के लिए एक अनुगामी लाइनफीड होना आवश्यक है।

— ग्यूसेप
स्रोत
2

जेली , 5 4 बाइट्स

U¹ƭ€

इसे ऑनलाइन आज़माएं!

धन्यवाद -1 बाइट्स के लिए HyperNeutrino ! (वास्तव में क्योंकि मैं कभी नहीं जानता था कि कैसे ƭप्रलेखन की कमी के कारण काम करता है, इस बार मैं भाग्यशाली रहा)

— user202729
स्रोत
(7 बाइट्स) के ¦साथ कोशिश की m। s2U2¦€;/7 बाइट्स भी है।
— user202729 13
2

टी-एसक्यूएल, 65 बाइट्स

हमारे मानक इनपुट नियम SQL को पूर्व-मौजूदा तालिका से इनपुट मानों की अनुमति देते हैं , और चूंकि SQL स्वाभाविक रूप से अनियंत्रित है, मूल पाठ क्रम को संरक्षित करने के लिए तालिका में पंक्ति संख्याएं होनी चाहिए।

मैंने एक पहचान स्तंभ के साथ तालिका को परिभाषित किया है ताकि हम केवल पाठ क्रमिक रूप से पंक्तियों को सम्मिलित कर सकें (बाइट कुल की ओर नहीं गिना जाता):

CREATE TABLE t 
    (i int identity(1,1)
    ,a varchar(999))

तो वैकल्पिक पंक्तियों को चुनने और उलटने के लिए:

SELECT CASE WHEN i%2=0THEN a
ELSE reverse(a)END
FROM t
ORDER BY i

ध्यान दें कि मैं 11 बाइट्स को छोड़कर बचा सकता हूं ORDER BY i, और यह किसी भी उचित लंबाई के लिए मूल क्रम में सूची को वापस करने की संभावना है (यह निश्चित रूप से 4-लाइन उदाहरण के लिए करता है)। लेकिन एसक्यूएल केवल इसकी गारंटी देता है यदि आप इसमें शामिल हैं ORDER BY, इसलिए यदि हमारे पास, 10,000 पंक्तियाँ हैं, तो हमें निश्चित रूप से इसकी आवश्यकता होगी।

— BradC
स्रोत
2

अल्पविराम सीमांकित:

स्टैक्स , 12 बाइट्स

ü«äì╠▒╕█╬pεû

इसे चलाएं और डीबग करें

इनपुट: एबीसी, डीईएफ, जीएचआई, जेसीएल, एमएनओ, पीकेआर, एसटीयू

न्यूलाइन सीमांकित:

स्टैक्स , 8 बाइट्स

Çε÷┘)¼M@

इसे चलाएं और डीबग करें

इनपुट: 

ABC
def
GHI
jkl
MNO
pqr
STU

दोनों के लिए उत्पादन:

CBA
def
IHG
jkl
ONM
pqr
UTS
— 182764125216
स्रोत
1

ऐलिस , 13 बाइट्स

M%/RM\
d&\tO/

इसे ऑनलाइन आज़माएं!

अलग-अलग कमांड-लाइन तर्कों के माध्यम से इनपुट। पहली पंक्ति (और उसके बाद हर दूसरी पंक्ति) को उलट देता है।

व्याख्या

       At the beginning of each loop iteration there will always be zero
       on top of the stack (potentially as a string, but it will be
       converted to an integer implicitly once we need it).
M      Push the number of remaining command-line arguments, M.
%      Take the zero on top of the stack modulo M. This just gives zero as
       long as there are arguments left, otherwise this terminates the
       program due to the division by zero.
/      Switch to Ordinal mode.
t      Tail. Implicitly converts the zero to a string and splits off the
       last character. The purpose of this is to put an empty string below
       the zero, which increases the stack depth by one.
M      Retrieve the next command-line argument and push it as a string.
/      Switch back to Cardinal mode.
d      Push the stack depth, D.
&\R    Switch back to Ordinal mode and reverse the current line D times.
O      Print the (possibly reversed) line with a trailing linefeed.
\      Switch back to Cardinal mode.
       The instruction pointer loops around and the program starts over
       from the beginning.
— मार्टिन एंडर
स्रोत
1

मानक एमएल (एमएलटन) , 51 बाइट्स

fun$(a::b::r)=a::implode(rev(explode b)):: $r| $e=e

इसे ऑनलाइन आज़माएं! उपयोग उदाहरण:$ ["abc","def","ghi"]पैदावार ["abc","fed","ghi"]।

स्पष्टीकरण:

$एक तार की सूची पर एक समारोह की पुनरावृत्ति है। यह दो तार लेता है aऔर bसूची से, पहले को अपरिवर्तित रखता है और दूसरे को स्ट्रिंग को वर्णों explodeकी सूची में revबदलकर ( ), सूची को उलट कर ( ), और इसे वापस स्ट्रिंग ( implode) में बदल देता है ।

— Laikoni
स्रोत
+1, पर्याप्त एमएल समाधान नहीं imo
— jfh
1

रेटिना , 18 बाइट्स

{O$^`\G.

*2G`
2A`

इसे ऑनलाइन आज़माएं! व्याख्या: पहला चरण पहली पंक्ति को उल्टा करता है, फिर दूसरा चरण पहली दो पंक्तियों को प्रिंट करता है, जिसके बाद तीसरा चरण उन्हें हटा देता है। पूरा कार्यक्रम तब तक दोहराता है जब तक कुछ बचा नहीं है। एक अग्रणी की कीमत पर एक अनुगामी न्यूलाइन को हटाया जा सकता है ;।

— नील
स्रोत
1

वोल्फ्राम भाषा (गणितज्ञ) , 33 बाइट्स

Fold[StringReverse@*Append,{},#]&

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

StringReverse@*Append, जब स्ट्रिंग्स की सूची और इनपुट के रूप में एक और स्ट्रिंग दी जाती है, तो स्ट्रिंग को सूची के अंत में जोड़ देता है और फिर सभी स्ट्रिंग को उलट देता है।

Foldउपरोक्त साधन के संबंध में इनपुट को हम:

  • पहली पंक्ति को उलट दें।
  • दूसरी पंक्ति को अंत तक जोड़ें और दोनों को उल्टा कर दें।
  • तीसरी पंक्ति को अंत तक जोड़ें और तीनों को उल्टा करें।
  • चौथी पंक्ति को अंत तक जोड़ें और चारों को उल्टा करें।
  • और इसी तरह, जब तक हम लाइनों से बाहर नहीं निकल जाते।

प्रत्येक रेखा पिछली पंक्ति की तुलना में एक बार कम उलट जाती है, इसलिए लाइनें वैकल्पिक दिशा में होती हैं।

— मिशा लावरोव
स्रोत
1

सीजेएम , 11 बाइट्स

{2/Waf.%:~}

इसे ऑनलाइन आज़माएं! (CJam सरणी शाब्दिक तत्वों को अलग करने के लिए रिक्त स्थान का उपयोग करें)

स्पष्टीकरण:

{              Begin block, stack: ["Here are some lines" "of text for you" "to make a" "boustrophedon"]
 2/            Group by 2:         [["Here are some lines" "of text for you"] ["to make a" "boustrophedon"]]
   W           Push -1:            [["Here are some lines" "of text for you"] ["to make a" "boustrophedon"]] -1
    a          Wrap in array:      [["Here are some lines" "of text for you"] ["to make a" "boustrophedon"]] [-1]
     f.%       Vectorized zipped array reverse (black magic):
                                   [["senil emos era ereH" "of text for you"] ["a ekam ot" "boustrophedon"]]
        :~     Flatten:            ["senil emos era ereH" "of text for you" "a ekam ot" "boustrophedon"]
          }

Waf.%"काला जादू" भाग के लिए स्पष्टीकरण :

  • Wके लिए एक चर है -1। aएक तत्व को एक सरणी में लपेटता है, ऐसा Waहै [-1]।
  • %एक संख्या nऔर सरणी को पॉप करता है और सरणी के aप्रत्येक nवें तत्व को लेता है । जब nनकारात्मक होता है, तो इसका उल्टा भी होता है, जिसका अर्थ हैW% एक सरणी को उलट देता है।
  • .एक बाइनरी ऑपरेशन के बाद एक सरणी के संबंधित तत्वों पर यह ऑपरेशन लागू होता है, ऐसा [1 2 3] [4 5 6] .+है [5 7 9]। यदि एक सरणी दूसरे की तुलना में लंबी है, तो तत्वों को संशोधन के बिना रखा जाता है, जिसका अर्थ हैWa.% एक सरणी के पहले तत्व को उलट देता है।
  • fइसके बाद एक बाइनरी ऑपरेशन स्टैक से एक तत्व लेगा और फिर एक्ट करेगा {<that element> <that operation>}%, यानी एरे में प्रत्येक एलीमेंट के माध्यम से जाएगा, उसके एलिमेंट को पुश करेगा, स्टैक से पहले पोप किए गए एलिमेंट को पुश करें, ऑपरेशन को रन करें, और फिर परिणाम इकट्ठा करें एक सरणी में वापस। इसका मतलब यह है कि Wa.f%सरणी में हर तत्व के पहले तत्व को उलट देता है।
— फल तोड़ना
स्रोत
1

स्विफ्ट , 90 85 82 72 बाइट्स

-10 बाइट्स @ Mr.Xcoder को धन्यवाद

func f(a:[String]){print(a.reduce([]){$0.map{"\($0.reversed())"}+‌​[$1]})}
— हरमन एल
स्रोत
आप printवापसी प्रकार की घोषणा का उपयोग कर सकते हैं और छोड़ सकते हैं :func f(a:[String]){print(a.reduce([]){$0.map{"\($0.reversed())"}+[$1]})}
— श्री एक्सकोडर
1

रूबी , 19 + 2 = 21 बाइट्स

-nlझंडे के लिए +2 बाइट्स ।

$.%2<1&&$_.reverse!

इसे ऑनलाइन आज़माएं!

व्याख्या

व्यावहारिक रूप से पर्ल 5 उत्तर के समान है , हालांकि मैंने ऐसा नहीं देखा था जब मैंने यह लिखा था।

व्हॉट्सएप के साथ, कोड इस तरह दिखता है:

$. % 2 < 1 && $_.reverse!

-pविकल्प इस तरह से रूबी को अपनी लिपि में प्रभावी रूप से लपेटता है:

while gets
  # ...
  puts $_
end

विशेष चर $_में अंतिम पंक्ति को पढ़ा जाता है gets, और $.पंक्ति संख्या शामिल होती है।

-lप्रसंस्करण समाप्त होने के स्वत: लाइन, जो स्वत: कॉल के लिए सक्षम बनाता chop!है जो निकाल देता है प्रत्येक इनपुट लाइन पर, \nइससे पहले कि हम यह रिवर्स।

— जॉर्डन
स्रोत
1

GNU sed , 31 + 1 = 32 बाइट्स

-rझंडे के लिए +1 बाइट ।

G
:
s/(.)(.*\n)/\2\1/
t
s/.//
N

इसे ऑनलाइन आज़माएं!

व्याख्या

G                   # Append a newline and contents of the (empty) hold space
:
  s/(.)(.*\n)/\2\1/   # Move the first character to after the newline
  t                   # If we made the above substitution, branch to :
s/.//               # Delete the first character (now the newline)
N                   # Append a newline and the next line of input
— जॉर्डन
स्रोत
1

चारकोल , 9 बाइट्स

ＥＮ⎇﹪ι²⮌ＳＳ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: चारकोल सूची की लंबाई नहीं जानता है, इसलिए मैंने इसे एक अतिरिक्त तत्व के रूप में जोड़ा है। स्पष्टीकरण:

 Ｎ          First value as a number
Ｅ           Map over implicit range
    ι       Current index
     ²      Literal 2
   ﹪        Modulo
  ⎇         Ternary
       Ｓ    Next string value
      ⮌     Reverse
        Ｓ   Next string value
            Implicitly print array, one element per line.
— नील
स्रोत
1

Befunge-93, 48 बाइट्स

 <~,#_|#*-+92:+1:
#^_@  >:#,_"#"40g!*40p91+,~:1+

यह ऑनलाइन की कोशिश करो

प्रिंट पहली पंक्ति में उल्टे। एक अनुगामी न्यूलाइन है।

मूल रूप से, यह मुद्रण के बीच वैकल्पिक रूप से काम करता है क्योंकि यह इनपुट प्राप्त करता है और स्टैक पर इनपुट संग्रहीत करता है। जब यह एक नई रेखा या इनपुट के अंत तक पहुंचता है, तो यह स्टैक को प्रिंट करता है, एक नई रेखा को प्रिंट करता है, और मोड को बदलने के लिए 0,4 पर वर्ण को संशोधित करता है या तो एक # या कोई-ऑप होता है। यदि यह इनपुट का अंत था, तो कार्यक्रम समाप्त करें

— मजाक कर रहा है
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.