तार कैसे मुड़ जाते हैं

घुमा एल्गोरिथ्म बहुत सरल है। प्रत्येक कॉलम को उसके सूचकांक द्वारा नीचे स्थानांतरित कर दिया जाता है (कॉल 0 से नीचे 0, कॉल 1 चाल 1, ...)। स्तंभ शिफ्ट शीर्ष पर लपेटता है। यह इस तरह काम करता है:

aaaa
bbbb
cccc

हो जाता है:

a
ba
cba
----
 cba
  cb
   c

रेखा के नीचे सब कुछ के साथ शीर्ष पर लपेटकर। वास्तविक उदाहरण:

Original:
\\\\\\\\\\\\
............
............
............

Twisted:
\...\...\...
.\...\...\..
..\...\...\.
...\...\...\

इनपुट

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

उत्पादन

मुड़ स्ट्रिंग, मल्टी-लाइन आउटपुट से एसटीडी-आउट (या निकटतम विकल्प)।

उदाहरण:

( >इनपुट को दर्शाता है, अनुगामी स्थान महत्वपूर्ण है)

>Hello, world!
>I am another 
>string to be 
>twisted!     

Hwrmoe oo br!
Ieii ,dttr e 
s lsna !ohl  
ttaltgnw  ed 


>\\\\\\\\\\\\
>............
>............
>............

\...\...\...
.\...\...\..
..\...\...\.
...\...\...\


>abcdefg
>.......

a.c.e.g
.b.d.f.


>abcdefghij
>..........
>..........

a..d..g..j
.b..e..h..
..c..f..i.


>\\\\.....././
>...../.......
>........././.
>..../.^\\....

\.........../
.\....^..../.
..\../.\../..
...\/...\/...

>cdeab
>deabc
>eabcd
>abcde

cbbbb
ddccc
eeedd
aaaae


>aeimquy37
>bfjnrvz48
>cgkosw159
>dhlptx260

ahknqx147
beloru258
cfipsvy69
dgjmtwz30


>abcdefghi
>jklmnopqr
>stuvwxyz1
>234567890

a3ume7yqi
jb4vnf8zr
skc5wog91
2tld6xph0

code-golf string

— जे एटकिन
स्रोत

12

इसके लिए मैथेमेटिका का निर्माण बेहतर नहीं है।

— मामा फन रोल

1

क्या हम मान सकते हैं कि इनपुट में केवल ASCII होगा? या केवल मुद्रण योग्य ASCII + लाइनफीड या कुछ और?

— मार्टिन एंडर

हां, सिर्फ ASCII और newline (जब तक आप एक ऐरे के रूप में इनपुट नहीं लेते)।

— जे एटकिन

3

ब्रेकीलॉग , 5 बाइट्स

iᵇ↻₎ᵐ

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

कॉलम की एक सरणी के रूप में इनपुट प्राप्त करता है (जो प्रश्न के विनिर्देशों के भीतर लगता है)।

iᵇ- सरणी में प्रत्येक तत्व के लिए, इसे अपने (0-आधारित) सूचकांक के साथ जोड़ दें
ᵐ - परिणाम के प्रत्येक तत्व के लिए इस विधेय को मैप करें:
↻₎- अंतिम तत्व (सूचकांक) के रूप में निर्दिष्ट राशि द्वारा परिपत्र (स्तंभ) को परिपत्र रूप से बताएं।

आसानी से एक एकल मल्टीलाइन स्ट्रिंग को स्वीकार करने वाले संस्करण में विस्तारित किया गया:

13 बाइट्स

ṇẹ\iᵇ↻₎ᵐ\cᵐ~ṇ

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

— sundar - मोनिका को बहाल करना
स्रोत

यह अद्भुत सूचना संपीड़न है।

— जे एटकिन

7

अजगर, ११

jC.>R~hZC.z

इसे यहाँ आज़माएँ

jC.>R~hZC.z    ##  implicit: .z = list of input split by lines
        C.z    ##  transpose .z to get columns
  .>R~hZ       ##  shift each column by it's index
               ##  equivalent to .e.>bk
jC             ##  transpose back and join by newlines

— FryAmTheEggman
स्रोत

7

एपीएल (डायलॉग) , 7 बाइट्स

⊖⊖⊖⍨⍬⍋⍉

आवश्यक है ⎕io←0

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

⍬⍋⍉0 से सीमा तक स्तंभों की संख्या
⊖विपरीत रूप से
⊖⊖⍨⍬⍋⍉घूमती है (अनुलंब रूप से) (लंबवत) उल्टे इनपुट को 0,1..
⊖उल्टा करके , और इसे वापस लौटाएं।

— H.PWiz
स्रोत

6

रेटिना , 111 101 92 87 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

(?<=((.))*)(?=(?<1>.*¶)*.*(?<=(?=(?<-2>.)*(.))(?<-1>.+¶)*.*(.(?<=^(?<-1>¶?.+)*))*)).
$3

वू, इसे एकल रेगेक्स प्रतिस्थापन में हल किया। :) (संभावना है, कई का उपयोग करके एक छोटा समाधान है, लेकिन उस में मज़ा कहाँ है ...)

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

व्याख्या

इसके लिए संतुलन समूहों के कुछ बुनियादी ज्ञान की आवश्यकता होती है । संक्षेप में, .NET का रेगेक्स फ्लेवर आपको एक ही समूह के साथ कई बार कैप्चर करने की अनुमति देता है, एक स्टैक पर सभी कैप्चर को धक्का देता है। उस स्टैक को भी पॉप किया जा सकता है, जो हमें रेगेक्स के अंदर चीजों की गिनती के लिए इसका उपयोग करने की अनुमति देता है।

(?<=((.))*)

यह दोनों समूहों पर 1और 2मैच के सामने प्रत्येक चरित्र के लिए (वर्तमान लाइन में) एक धक्का देता है । यही है, यह मैच की क्षैतिज स्थिति को गिनता है।

बाकी एक नज़र में है:

(?=(?<1>.*¶)*.* [...] )

हम प्रत्येक पंक्ति से मेल खाते हैं और इसे समूह पर भी धक्का देते हैं 1, जैसे कि समूह 1अब क्षैतिज और ऊर्ध्वाधर स्थिति का योग है (जहां बाद को नीचे से गिना जाता है )। यह अनिवार्य रूप से नीचे के बाएं कोने से शुरू होने वाले बढ़ते मूल्यों के साथ ग्रिड के विकर्णों को लेबल करता है। यही कारण है कि .*फिर बस स्ट्रिंग के अंत करने के लिए इंजन के कर्सर ले जाता है।

अब हम एक खोजबीन में स्विच करते हैं, जो .NET में दाईं से बाईं ओर से मेल खाता है:

(?<= [...] (.(?<=^(?<-1>¶?.+)*))*)

यह बार-बार Hसमूह से कैप्चर करेगा 1(जहां Hइनपुट की ऊंचाई है)। उस का उद्देश्य समूह modulo लेना है H। बाद में, समूह 1में वर्तमान स्तंभ में नया वर्ण चुनने के लिए पंक्ति (नीचे से गिना गया) होता है।

(?=(?<-2>.)*(.))(?<-1>.+¶)*.*

एक और खोज, फिर से दाईं ओर से शुरू। (?<-1>.+¶)*.+अब समूह 1का उपयोग करता है जिससे वह पंक्ति ढूंढता है जिससे नया वर्ण चुना जाता है और फिर समूह का उपयोग करके सही स्तंभ ढूंढता है 2।

वांछित चरित्र को समूह में कैद किया 3जाता है और प्रतिस्थापन द्वारा वापस लिखा जाता है।

— मार्टिन एंडर
स्रोत

आह, रेटिना के स्रोत को पढ़ना अच्छा और स्पष्ट था :) $+उपयोगी लगता है ... खासकर यदि आप केवल एक प्रतिस्थापन करना चाहते हैं: ^)

— FryAmTheEggman

@FryAmTheEggman $+वास्तव में बहुत बेकार है ... यह MSDN पर वर्णन बहुत अधिक उपयोगी लगता है क्योंकि यह इसका अर्थ है कि (a)|(b)-> $+$+सभी as और bs को दोगुना कर देगा, लेकिन इसके बजाय यह सभी as को हटा देता है , क्योंकि यह सिर्फ वाक्यगत रूप से अंतिम समूह को संदर्भित करता है । इसका मतलब है कि यह सभी समूहों की गिनती से बचने का एक तरीका है यदि आप बहुत आलसी हैं (जैसे मैं था)। गोल्फिंग के लिए यह केवल बाइट्स को बचाता है जब आपके पास 9 से अधिक समूह होते हैं, जो संभवतः इसके साथ शुरू करने के लिए काफी दुर्लभ है।

— मार्टिन एंडर

यह दुर्भाग्यपूर्ण है ... शायद रेटिना में एक नया प्रतिस्थापन समूह प्रकार हो सकता है जो अंतिम गैर-खाली मैच समूह लौटाएगा? वैसे भी, स्पष्टीकरण के लिए धन्यवाद! :)

— FryAmTheEggman

@FryAmTheEggman यह होगा (यह उन चीजों में से एक है, जो मैंने Regex.Replaceरेटिना के लिए पुनर्लेखन करते समय ध्यान में रखा था , लेकिन मुझे इसे लागू करने के लिए अभी तक नहीं मिला है)।

— मार्टिन एंडर

4

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

qN/zee::m>zN*

इसका परीक्षण यहां करें।

व्याख्या

q    e# Read all input.
N/   e# Split into lines.
z    e# Transpose to get an array of columns.
ee   e# Enumerate, pairing each column with its index.
::m> e# Map: fold: rotate (cyclically shifting each column by its index).
z    e# Transpose again.
N*   e# Join with linefeeds.

— मार्टिन एंडर
स्रोत

2

आप उस सोर्स कोड का लगभग उच्चारण कर सकते हैं।

— mınxomaτ

4

टीस्क्रिप्ट, 10 बाइट्स

xHl@C(r╢tD

TeaScript 3 के बेहद संक्षिप्त वाक्यविन्यास के लिए धन्यवाद, यह वास्तव में कम है: D

अगर सिग्मा लूप छोटी गाड़ी नहीं थी तो 1 बाइट छोटी होगी

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

व्याख्या

      // Implicit, x = input
xH    // Transpose input
l@    // Loop
 C(r╢   // Cycle column by index
        // `╢` exits loop
t    // Transpose
D    // Join on \n

— Downgoat
स्रोत

3

पायथन 3, 164 बाइट्स

एक लंबे शॉट का सबसे अच्छा जवाब नहीं, लेकिन पायथन में पहला ...

s=list(zip(*open(0).readlines()))[:-1]
r=[[s[i][(j-i)%len(s[i])] for j in range(len(s[i]))] for i in range(len(s))]
print('\n'.join([''.join(l) for l in zip(*r)]))

— josh2112
स्रोत

1

आप एक मुट्ठी भर बाइट को बचा सकते हैं, जो अंतरिक्ष में )या ]अधिकांश मामलों में पीछा करता है , उदाहरण के ''.join(l)for l in....लिए पूरी तरह से वैध है

— wnnmaw

3

MATLAB, 92 36 बाइट्स

s=bsxfun(@circshift,s,0:size(s,2)-1)

यह मानते हुए कि इनपुट स्ट्रिंग sपहले से 2 डी चार सरणी / मैट्रिक्स के रूप में है, उदाहरण के लिए

s = ['abcdefg';'.......'];
s = ['\\\\.....././';'...../.......';'........././.';'..../.^\\....'];

स्पष्टीकरण: मैट्रिक्स के कॉलम के माध्यम से पुनरावृति। प्रत्येक कॉलम के लिए कॉलम इंडेक्स (MATLAB इंडेक्सिंग के कारण -1) के बराबर वर्णों की संख्या द्वारा अपने तत्वों की एक परिपत्र शिफ्ट करते हैं।

— मथायस डब्ल्यू।
स्रोत

2

ब्रेकीलॉग , 96 बाइट्स

$\:0{h_.|[M:I]hh:I{bh0,?h.|[C:I]h$)D,I-1=:Dr:2&.}C,I+1=J,Mb:J:1&:[C]rc.}$\{hA,[A]:"~s
"w,?b:3&;}

यह इनपुट और आउटपुट के रूप में वर्ण कोड स्ट्रिंग की सूची की अपेक्षा करता है, उदा brachylog_main([`aaaa`,`bbbb`,`cccc`],_).

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

व्याख्या

§ Main Predicate

$\:0{}$\{}                            § Create a list containing the transposed input and 0
                                      § Call sub-predicate 1 with this list as input
                                      § Transpose its output and pass it as input to
                                      § sub-predicate 3


§ Sub-predicate 1

h_.                                   § If the matrix is empty, output is empty list
   |                                  § Else
    [M:I]hh:I{}C,                     § Input is [M,I], call sub-predicate 2 with the first
                                      § line of M and I as input. Its output is C.
                 I+1=J,Mb:J:1&        § Call sub-predicate 1 with M minus the first line
                                      § and I+1 as input
                              :[C]rc. § Its output is appended after C, which is then
                                      § unified with the output of sub-predicate 1.


§ Sub-predicate 2

bh0,?h.                               § If the second element of the input list is 0,
                                      § output is the first element of the input
       |                              § Else
        [C:I]                         § Input is [C,I]
             h$)D,                    § Perform a circular permutation of C from left to
                                      § right (e.g. [a,b,c] => [c,a,b]) and unify it with D
                  I-1=:Dr:2&.         § Call sub-predicate 2 with D and I-1 as input, unify
                                      § its output with sub-predicate 2's output


§ Sub-predicate 3

hA,[A]:"~s\n"w,                       § Write the first line of the input as a char codes
                                      § string followed by a new line

               ?b:3&;                 § Call sub-predicate 3 with input minus the first
                                      § line. If it fails (empty input), terminate

— Fatalize
स्रोत

2

जावास्क्रिप्ट, 92 89 बाइट्स

3 बाइट्स थैंक्स @Neil ।

s=>(z=s.split`
`).map((m,i)=>m.replace(/./g,(n,j)=>z[((l=z.length)*j+i-j)%l][j])).join`
`

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

f=s=>
    (z=s.split`\n`).map((m,i)=>
        m.replace(/./g,(n,j)=>
            z[((l=z.length)*j+i-j)%l][j]
        )
    ).join`\n`

Input.value = `abcdefghij
..........
..........`

textarea{display:block;width:250px;height:75px;}

<textarea id='Input'></textarea>
<button id='Run' onClick='Output.value=f(Input.value);'>Run</button>
<textarea id='Output'></textarea>

स्निपेट का विस्तार करें

— हटा दिया
स्रोत

आप का उपयोग कर 3 बाइट्स बचा सकता है replace: m.replace(/./g,(n,j)=>z[((l=z.length)*j+i-j)%l][j])।

— नील

1

वास्तव में, [...m].map(पहले और बाद के सभी तरीके .join।

— नील

2

पायथन 2, 115 बाइट्स

lambda s:'\n'.join("".join(s)for s in zip(*[k[-i%len(k):]+k[:-i%len(k)]for i,k in enumerate(zip(*s.split('\n')))]))

zipयह एक लाइन के लिए नीचे लाने में कामयाब के आश्चर्य के लिए धन्यवाद । इसे यहां कार्रवाई में देखें ।

— wnnmaw
स्रोत

2

MATL , 18 21 बाइट्स

Zy2):"G@Z)@qYS]N$h

इनपुट फॉर्म का है

['Hello, world!'; 'I am another '; 'string to be '; 'twisted!']

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

यह कैसे काम करता है :

Zy       % implicitly take input: 2D char array. Get its size
2)       % second element from size vector: number of columns, say n
:        % create vector [1,2,...,n]
"        % for each element k in that vector
  G      %   push input
  @      %   push k
  Z)     %   k-th column from input
  @qYS   %   circularly shift k-1 positions
]        % end for loop
N$h      % concatenate all stack contents horizontally
         % implicitly display

— लुइस मेंडो
स्रोत

1

एफ #, 105 बाइट्स

इस पर मेरा पहला छुरा (केवल एक \nचरित्र की आवश्यकता है):

let m x y=(x%y+y)%y
let f(a:string[])=Array.mapi(fun i x->String.mapi(fun j _->a.[m(i-j)a.Length].[j])x)a

उपयोग:

f [| @"\\\\\\\\\\\\"
     "............"
     "............"
     "............" |]

— pswg
स्रोत

मुझे नहीं लगता कि मैंने पहले पीपीसीजी पर एफ # देखा है।

— J Atkin 14

1

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

t=>t.replace(/./g,(_,i)=>t[(i+s*l-i%l*l)%s],l=t.search`
`+1,s=t.length+1)

व्याख्या

t=>
  t.replace(/./g,(_,i)=> // replace each character at index i
    t[                   // get the character at index:
      (i                 // start at i
        +s*l             // add s*l to ensure the result is always positive for %s
        -i%l*l           // move the index upwards the num of chars from start of the line
      )%s                // shift the index into the the range of s
    ],
    l=t.search`
`+1,                     // l = line length
    s=t.length+1         // s = input grid length (+1 for the missing newline at the end)
  )

परीक्षा

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

var solution = t=>t.replace(/./g,(_,i)=>t[(i+s*l-i%l*l)%s],l=t.search`
`+1,s=t.length+1)

<textarea id="input" rows="5" cols="40">\\\\.....././
...../.......
........././.
..../.^\\....</textarea><br>
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

स्निपेट का विस्तार करें

— user81655
स्रोत

1

जाप, 29 बाइट्स

Uy £XsV=(Y*Xl -Y %Xl)+X¯V}R y

इसे ऑनलाइन टेस्ट करें!

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

Uy        // Transpose rows and columns in the input string.
£     }R  // Map each item X and index Y in the result, split at newlines, to:
Y*Xl -Y   //  Take Y times X.length and subtract Y.
%Xl)      //  Modulate the result by X.length.
XsV=      //  Set V to the result of this, and slice off the first V chars of X.
+X¯V      //  Concatenate this with the first V chars of X.
y         // Transpose the result again.
          // Implicit: output last expression

— ETHproductions
स्रोत

1

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

let t=transpose in t.snd.mapAccumR(\c l -> 1+c,take(length l)(drop c$cycle l))0.t

CJam उदाहरण को फिर से लागू करना, हालांकि रिवर्स, मैप और एन्युमरेट मैपएक्यूआरएमआर का हिस्सा है, एसएनडी संचयकर्ता को हटा देता है क्योंकि हमें अब इसकी आवश्यकता नहीं है, रिवर्सल सही गुना का एक साइड इफेक्ट है।

— डैनियल हिल
स्रोत

1

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

g l@("":_)=l;g l|t<-tail<$>l=zipWith(:)(head<$>l)$g$last t:init t

प्रयोग उदाहरण: g ["1111","2222","3333"]-> ["1321","2132","3213"]।

— nimi
स्रोत

1

MATL , 9 बाइट्स

"@X@qYS&h

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

लुइस मेंडो के मौजूदा MATL उत्तर के समान सुंदर , लेकिन उन विशेषताओं का उपयोग करके कम है जो शायद उस बिंदु पर भाषा में नहीं थे: 1. "स्वचालित रूप से अब एक मैट्रिक्स के कॉलम के माध्यम से पुनरावृत्त करता है, इसलिए स्तंभ सूचकांकों के निर्माण और उन पर अनुक्रमण करने का कोई महंगा व्यवसाय नहीं है ( यह बिग्गी है), 2. &hकहने का एक संक्षिप्त तरीका है N$h, और 3. निहित लूप अंत यदि ]निर्दिष्ट नहीं है।

वैकल्पिक रूप से, एक ही बायटेकाउंट के लिए:

tsn:ql&YS

इसे MATL ऑनलाइन पर आज़माएं

      &YS   % circularly shift the matrix
     l      % across rows (i.e. shift each column) by the amounts
            %  given by this array:
tsn         % duplicate input, get the sum of each column, get the 
            %  number of elements in that (which is the number of columns)
   :q       % construct range 1 to ncols, then decrement to start at 0
            % (implicit output)

— sundar - मोनिका को बहाल करना
स्रोत

0

सी (क्लैंग) , 114 बाइट्स

जीएनजी में मिनगॉ के तहत काम करता है। TIO का GCC strlenलूप के लिए पहले की init अभिव्यक्ति का उपयोग करके भ्रमित हो जाता है ।

f(L,n)char**L;{for(int l=strlen(*L),i=0,j,c;i<n;i++)for(j=c=0;j<=l;j++,c=c?c-1:n-1)putchar(l^j?L[(c+i)%n][j]:10);}

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

— gastropner
स्रोत

गोल्फ एक स्ट्रिंग ट्विस्टर

तार कैसे मुड़ जाते हैं

इनपुट

उत्पादन

उदाहरण:

ब्रेकीलॉग , 5 बाइट्स

13 बाइट्स

अजगर, ११

एपीएल (डायलॉग) , 7 बाइट्स

रेटिना , 111 101 92 87 बाइट्स

व्याख्या

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

व्याख्या

टीस्क्रिप्ट, 10 बाइट्स

व्याख्या

पायथन 3, 164 बाइट्स

MATLAB, 92 36 बाइट्स

ब्रेकीलॉग , 96 बाइट्स

व्याख्या

जावास्क्रिप्ट, 92 89 बाइट्स

पायथन 2, 115 बाइट्स

MATL , 18 21 बाइट्स

एफ #, 105 बाइट्स

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

व्याख्या

परीक्षा

जाप, 29 बाइट्स

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

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

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

MATL , 9 बाइट्स

सी (क्लैंग) , 114 बाइट्स