Golf einen Saitendreher

24

Wie Saiten verdreht sind

Der Verdrehungsalgorithmus ist sehr einfach. Jede Spalte wird um ihren Index nach unten verschoben (Spalte 0 verschiebt sich um 0, Spalte 1 verschiebt sich um 1, ...). Die Spaltenverschiebung wird nach oben verschoben. Es funktioniert so:

aaaa
bbbb
cccc

Wird:

a
ba
cba
----
 cba
  cb
   c

Alles unter der Linie nach oben. Reales Beispiel:

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

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

Eingang

Die Eingabe ist entweder ein Array von Zeichenfolgen oder eine mehrzeilige Zeichenfolge. Alle Zeilen haben die gleiche Länge.

Ausgabe

Die verdrillte Zeichenfolge, mehrzeilige Ausgabe bis zur Standardausgabe (oder nächstgelegenen Alternative).

Beispiele:

( >kennzeichnet die Eingabe, Leerzeichen sind wichtig)

>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 
— J Atkin
quelle
12
Es gibt dafür besser kein Mathematica.
— Mama Fun Roll
1
Können wir davon ausgehen, dass die Eingabe nur ASCII enthält? Oder nur druckbare ASCII + Zeilenvorschübe oder so?
— Martin Ender
Ja, nur ASCII und Newline (es sei denn, Sie nehmen die Eingabe als Array entgegen).
— J Atkin

Antworten:

3

Brachylog , 5 Bytes

iᵇ↻₎ᵐ

Probieren Sie es online!

Ruft die Eingabe als Array von Spalten ab (was innerhalb der Spezifikation der Frage zu liegen scheint).

iᵇ- Verbinden Sie jedes Element im Array mit seinem (0-basierten) Index.
ᵐ - Ordnen Sie dieses Prädikat jedem Element des Ergebnisses zu:
↻₎- Permutieren Sie (die Spalte) zirkulär um den Betrag, der als letztes Element (den Index) angegeben wurde

Einfache Erweiterung auf eine Version, die eine einzelne mehrzeilige Zeichenfolge akzeptiert:

13 Bytes

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

Probieren Sie es online!

— Sundar - Setzen Sie Monica wieder ein
quelle
Dies ist eine erstaunliche Informationskomprimierung.
— J Atkin
7

Pyth, 11

jC.>R~hZC.z

Probieren Sie es hier aus

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

APL (Dyalog) , 7 Bytes

⊖⊖⊖⍨⍬⍋⍉

Benötigt ⎕io←0

Probieren Sie es online!

⍬⍋⍉Ruft den Bereich von 0 bis zur Anzahl der Spalten ab.
⊖Umkehrungen
⊖⊖⍨⍬⍋⍉drehen (vertikal) die (vertikal) umgekehrte Eingabe, indem Sie diese 0,1..
⊖umkehren und zurückgeben.

— H.PWiz
quelle
6

Retina , 111 101 92 87 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Woo, löste es in einer einzigen Regex-Ersetzung. :) (Wahrscheinlich gibt es eine kürzere Lösung mit mehreren, aber wo macht das Spaß ...)

Probieren Sie es online!

Erläuterung

Dies setzt einige Grundkenntnisse der Bilanzkreise voraus . Kurz gesagt, mit der regulären Ausprägung von .NET können Sie mehrere Erfassungen mit einer einzigen Gruppe durchführen und alle Erfassungen auf einen Stapel verschieben. Dieser Stapel kann auch gelöscht werden, sodass wir ihn zum Zählen von Dingen innerhalb des regulären Ausdrucks verwenden können.

(?<=((.))*)

Dadurch wird ein Capture auf beide Gruppen 1und 2für jeden Charakter vor dem Match (in der aktuellen Zeile) übertragen. Das heißt, es zählt die horizontale Position des Spiels.

Der Rest ist in einer Vorausschau:

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

Wir passen jede Zeile an und verschieben sie auch in die Gruppe 1, sodass die Gruppe 1nun die Summe der horizontalen und vertikalen Position ist (wobei letztere von unten gezählt wird ). Dies kennzeichnet im Wesentlichen die Diagonalen des Gitters mit ansteigenden Werten, beginnend in der unteren linken Ecke. Das .*bewegt dann nur den Cursor der Engine an das Ende der Zeichenkette.

Wir wechseln nun in einen Lookbehind, der in .NET von rechts nach links übereinstimmt:

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

Dies wird wiederholt genau HCaptures aus der Gruppe 1(wo Hist die Höhe der Eingabe) Pop . Der Zweck davon ist, die Gruppe modulo zu nehmen H. Danach 1enthält group die Zeile (von unten gezählt), aus der das neue Zeichen in der aktuellen Spalte ausgewählt werden soll.

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

Wieder ein Blick von rechts. (?<-1>.+¶)*.+Verwenden Sie jetzt group 1, um die Zeile zu finden, aus der das neue Zeichen ausgewählt werden soll, und dann findet der Lookahead die richtige Spalte mithilfe von group 2.

Das gewünschte Zeichen wird in einer Gruppe erfasst 3und durch die Ersetzung zurückgeschrieben.

— Martin Ender
quelle
Ah, die Quelle von Retina zu lesen war nett und klar :) $+sieht nützlich aus ... vor allem, wenn Sie nur eine Substitution machen möchten: ^)
— FryAmTheEggman
@FryAmTheEggman $+ist eigentlich ziemlich nutzlos ... die Beschreibung auf MSDN klingt viel nützlicher als es ist, weil es impliziert, dass (a)|(b)-> $+$+alle as und bs verdoppelt, aber stattdessen alle as entfernt, weil es sich nur auf die syntaktisch letzte Gruppe bezieht . Das heißt, es ist nur ein Weg, um zu vermeiden, dass alle Gruppen gezählt werden, wenn Sie zu faul sind (wie ich). Beim Golfen werden nur bei mehr als 9 Gruppen Bytes gespart, was anfangs wohl eher selten vorkommt.
— Martin Ender
Das ist bedauerlich ... Vielleicht könnte die Retina einen neuen Ersatzgruppentyp haben, der die letzte nicht leere Übereinstimmungsgruppe zurückgibt? Trotzdem danke für die Erklärung! :)
— FryAmTheEggman
@FryAmTheEggman Es wird (es ist eines der Dinge, die ich beim Umschreiben Regex.Replacefür Retina im Sinn hatte , aber ich bin noch nicht dazu gekommen, es zu implementieren).
— Martin Ender
4

CJam, 13 Bytes

qN/zee::m>zN*

Teste es hier.

Erläuterung

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.
— Martin Ender
quelle
2
Sie können diesen Quellcode fast aussprechen.
— Mittwoch,
4

TeaScript, 10 Bytes

xHl@C(r╢tD

Dank der äußerst präzisen Syntax von TeaScript 3 ist dies wirklich kurz: D

Wäre 1 Byte kürzer, wenn die Sigma-Schleife nicht fehlerhaft wäre

Probieren Sie es online aus

Erläuterung

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

Python 3, 164 Bytes

Bei weitem nicht die beste Antwort, aber die erste in Python ...

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
quelle
1
Sie können eine Handvoll Bytes sparen, indem Sie den Speicherplatz )]''.join(l)for l in....
— herausnehmen,
3

MATLAB, 92 36 Bytes

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

Angenommen, die Eingabezeichenfolge shat bereits die Form eines 2D-Zeichenarrays / einer 2D-Zeichenmatrix, z

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

Erläuterung: Durchlaufen Sie die Spalten der Matrix. Führen Sie für jede Spalte eine kreisförmige Verschiebung ihrer Elemente um die Anzahl der Zeichen durch, die dem Spaltenindex entspricht (-1 aufgrund der MATLAB-Indizierung).

— Matthias W.
quelle
2

Brachylog , 96 Bytes

$\: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&;}

Dies erwartet eine Liste von Zeichencode-Zeichenketten als Eingabe und keine Ausgabe, z brachylog_main([`aaaa`,`bbbb`,`cccc`],_).

Das ist eine lächerlich lange Antwort, und es gibt wahrscheinlich einen viel kürzeren Weg, dies zu tun.

Erläuterung

§ 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
— Tödlich
quelle
2

JavaScript, 92 89 Bytes

3 Bytes weg danke @Neil .

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

Code-Snippet anzeigen

— entfernt
quelle
Sie können maximal 3 Bytes speichern mit replace: m.replace(/./g,(n,j)=>z[((l=z.length)*j+i-j)%l][j]).
— Neil
1
In der Tat den [...m].map(ganzen Weg bis einschließlich der ersten .join.
— Neil
2

Python 2, 115 Bytes

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')))]))

Dank dem Wunder zipgelang es, dies auf eine Zeile zu bringen. Sehen sie in Aktion hier .

— wnnmaw
quelle
2

MATL , 18 21 Bytes

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

Die Eingabe hat die Form 

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

Probieren Sie es online!

Wie es funktioniert :

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
— Luis Mendo
quelle
1

F #, 105 Bytes

Mein erster Versuch (nur ein \nCharakter ist erforderlich):

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

Verwendung:

f [| @"\\\\\\\\\\\\"
     "............"
     "............"
     "............" |]
— pswg
quelle
Ich glaube nicht, dass ich F # schon einmal bei PPCG gesehen habe.
— J Atkin
1

JavaScript (ES6), 73 Byte

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

Erläuterung

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

Prüfung

Code-Snippet anzeigen

— user81655
quelle
1

Japt, 29 Bytes

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

Testen Sie es online!

Wie es funktioniert

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
quelle
1

Haskell, 81 Bytes

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

Neuimplementierung des CJam-Beispiels. Obwohl das Umkehren, Zuordnen und Aufzählen Teil von mapAccumR ist, entfernt snd den Akkumulator, da wir ihn nicht mehr benötigen. Die Umkehrung ist nur ein Nebeneffekt der rechten Falte.

— Daniel Hill
quelle
1

Haskell, 65 Bytes

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

Anwendungsbeispiel: g ["1111","2222","3333"]-> ["1321","2132","3213"].

— nimi
quelle
1

MATL , 9 Bytes

"@X@qYS&h

Probieren Sie es online!

Im Kern ziemlich ähnlich zu Luis Mendos vorhandener MATL-Antwort , aber kürzer, wenn Features verwendet werden, die zu diesem Zeitpunkt wahrscheinlich nicht in der Sprache waren: 1. "Durchläuft die Spalten einer Matrix jetzt automatisch, sodass das Erstellen und Indizieren von Spaltenindizes kein kostspieliges Unterfangen darstellt ( Dies ist der Biggie), 2. &hals Kurzformel zu sagenN$h und 3. implizites Schleifenende, wenn ]nicht angegeben.

Alternativ für das gleiche bytecount: 

tsn:ql&YS

Probieren Sie es auf MATL Online aus

      &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 - Setzen Sie Monica wieder ein
quelle
0

C (clang) , 114 Bytes

Arbeitet in GCC unter MinGW. Der GCC von TIO wird durch die Verwendung strlendes Init-Ausdrucks der ersten for-Schleife verwirrt .

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);}

Probieren Sie es online!

— Gastropner
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.