StringgnirtSStringgnirtSStringgnirtS

42

Hier ist eine relativ einfache Herausforderung für Sie.

Bei einer gegebenen Zeichenfolge der Länge N geben Sie die Zeichenfolge N Mal vorwärts, dann rückwärts, dann vorwärts, dann rückwärts usw. aus . Zum Beispiel, wenn Ihre Eingabe war

Hello!

Sie sollten Folgendes ausgeben:

Hello!!olleHHello!!olleHHello!!olleH

Optional können Sie auch eine nachgestellte Newline ausgeben.

Ihre Einreichung kann entweder ein vollständiges Programm oder eine Funktion sein, und Sie können Eingaben und Ausgaben in jedem vernünftigen Format vornehmen . Beispielsweise können Sie E / A von STDIN / STDOUT, Funktionsargumenten und Rückgabewert aus einer Datei usw. übernehmen. Sie können davon ausgehen, dass die Eingabezeichenfolge nicht leer ist und nur druckbares ASCII enthält. Sie müssen die neue Zeichenfolge in einer einzelnen Zeile ausgeben. So zum Beispiel, wenn die Ausgabe zum letzten Beispiel war

Hello!
!olleH
Hello!
!olleH
Hello!
!olleH

Dies wäre keine gültige Lösung!

Hier sind einige weitere Testfälle:

Input:
a
Output:
a

Input:
abcd
Output:
abcddcbaabcddcba

Input:
OK!
Output:
OK!!KOOK!

Input:
4815162342
Output:
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Input:
PPCG
Output:
PPCGGCPPPPCGGCPP

Input:
42
Output:
4224

Bestenlisten

Da dies eine Herausforderung ist, sind Standard-Lücken verboten und die kürzeste Antwort in Bytes gewinnt! Dies ist jedoch auch ein Wettbewerb um die kürzeste Antwort in einer bestimmten Sprache. Obwohl es unwahrscheinlich ist, dass eine Java-Antwort eine Perl-Antwort oder eine Golfsprache übertrifft, ist es dennoch sehr beeindruckend, die kürzeste Java-Antwort zu haben. Sie können also diese Rangliste verwenden, um beide zu sehen

  1. Die kürzeste Antwort aller Sprachen und

  2. Die kürzeste Antwort in jeder einzelnen Sprache.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Nummern in Ihrem Header enthalten sein sollen (zB weil Ihre Punktzahl ist die Summe von zwei Dateien oder Sie wollen Liste Dolmetscher Flagge Strafen separat), stellen Sie sicher , dass die tatsächliche Punktzahl der ist letzte Nummer in der Kopfzeile:

# Perl, 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

DJMcMayhem
quelle
Sollte das in Ihrem Beispiel nicht so sein olleH, nicht elloH?
Arnaud
2
@Downgoat Nein, Sie müssen Eingaben und Ausgaben in demselben Format wie in der Spezifikation beschrieben vornehmen.
DJMcMayhem
4
Sollte der Titel nicht StringgnirtSStringgnirtSStringgnirtS sein ?
Luis Mendo
2
@carusocomputing Es wird nicht: "Sie können davon ausgehen, dass die Eingabezeichenfolge nicht leer ist und nur druckbares ASCII enthält."
Martin Ender
1
en.wikipedia.org/wiki/ASCII#Printable_characters Ah, ich wusste nicht, dass dies eine genau definierte Teilmenge von ASCII ist. Ich stellte mir vor, druckbar zu sein, um \ t, \ n, etc ...
Magic Octopus Urn

Antworten:

22

Vim, 39 , 34 Tastenanschläge

:se ri
Y:s/./<C-r>"/g
<C-o>qqgJC<C-r>"<esc>gJ@qq@q

5 Bytes gespart dank @Lynn!

Hier ist ein GIF, das live passiert: (Beachten Sie, dass dieses GIF von einer früheren Version ist, da ich noch keine Zeit hatte, es neu aufzunehmen).

Bildbeschreibung hier eingeben

Und hier ist eine Erklärung, wie es funktioniert:

:se ri                  "Turn 'reverse indent' on.
Y                       "Yank this line
:s/./<C-r>"/g           "Replace every character on this line with the register
                        "We just yanked followed by a newline
<C-o>                   "Jump to our previous location
     qq                 "Start recording in register 'q'
       gJ               "Join these two lines
         C              "Delete this line, and enter insert mode
          <C-r>"<esc>   "Paste the line we just deleted backwards 
gJ                      "Join these two lines
  @q                    "Call macro 'q'. This will run until we hit the bottom of the buffer.
    q                   "Stop recording.
     @q                 "Start our recursive macro

YNebenbei bemerkt, ergreift eine zusätzliche Newline, die in der Regel ein unangenehmes Merkmal ist. Dies ist wahrscheinlich das erste Mal, dass tatsächlich mehrere Bytes eingespart wurden!

DJMcMayhem
quelle
2
Stattdessen :%s/\n<cr>können Sie v{gJdrei Bytes speichern.
Lynn
2
Eine VIM-Antwort ?! Das ist ein nobler Schachzug für Sie.
Magic Octopus Urn
@Lynn Danke für den Tipp! Am Ende habe ich etwas anderes gemacht und stattdessen 5 abgezogen.
DJMcMayhem
Dies setzt voraus, dass @qzu Beginn leer ist, oder? oder die @qvor dem Beenden der Aufnahme würde etwas beliebiges tun. (Dies führt mich zu meinem Lieblings-Vim-Trivium, das ich mir ausgedacht habe: Jeder weiß, dass das Beenden von Vim so einfach ist wie :q<CR>, aber wie können Sie alle Ihre Dateien schließen und speichern? Einfach: nur qqqqqZZ@qq@q!)
wchargin
@wchargin Ja, dies muss @qleer sein. Warum nicht einfach :wqastattdessen? Wollen Sie auch wissen, wie man in vim ein Fraktal erzeugt? qqqqq<C-w>v<C-w>n@qq@q: D
DJMcMayhem
18

Python, 40 Bytes

f=lambda s,i=0:s[i:]and s+f(s[::-1],i+1)

Eine rekursive Funktion. Stellt die Eingabezeichenfolge sder Umkehrfunktion voran, bis der Zähler idie Länge von überschreitet s.

xnor
quelle
Beeindruckend. Ich wollte gerade eine 56-Byte-Python-Antwort einreichen, haha
DJMcMayhem
@DJMcMayhem schlägt es auch lambda s:(len(s)*(s+s[::-1]))[:len(s)**2]um ein Byte.
Jonathan Allan
Ich habe das, f = lambda s : ''.join([s[((-1)**(i//len(s)) <= 0)*(len(s)-1)+(-1)**(i//len(s))*(i%len(s))] for i in range(len(s)*len(s))])aber es ist 136 Bytes nach sys.sizeof, interessanterweise ist es die gleiche Größe wief = lambda s : ''.join([s[::1] if i%2 else s for i in range(len(s))])
Carel
12

Brain-Flak , 418 378 228 Bytes

Dies ist mein Brain-Flak-Meisterwerk. Es mag nicht gut golfen sein, aber die Herausforderung ist die schwierigste, der ich je begegnet bin.

Probieren Sie es online!

(([])[()]){({}[()]<(({}(<()>))<{({}[()]<(({}()<(({}<>))>)<({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}>)>)}{}{}<>([]){{}({}<>)<>([])}{}<>>)>)}{}([(({}))]{({})({}[()])}{}){(({}[({}<>)<>])<<>({}<><{(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)>)}

Erläuterung

Diese Erklärung ist jetzt ein bisschen veraltet, aber sie erklärt das Programm immer noch recht gut.

Diese Erklärung wird sich ein wenig von meinem regulären Erklärungsprozess unterscheiden. Ich werde erklären, wie ich zu diesem Ergebnis gekommen bin, anstatt das Ergebnis in der richtigen Reihenfolge zu erklären. Hier kommt's:

Walze

Nachdem ich ein bisschen an dem Problem gearbeitet hatte, kam ich auf diesen Code:

(n[()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>

Dieser Code (wobei n das Literal für eine Zahl ist, z. B. ()()) nimmt das Element oben auf dem Stapel und bewegt es n Schritte nach unten. Mit n als Stapelhöhe wird ein Stapel "roll" ausgeführt. dh bewegen Sie den oberen Gegenstand zum Boden des Stapels. So funktioniert das:

Wir setzen den Ort, an den wir den Gegenstand verschieben möchten, auf minus eins auf dem Stapel. Warum minus eins? Ich weiß nicht, dass es einfach so funktioniert.

(n[()])

Wir schleifen dann, bis diese Zahl Null erreicht und verfolgen die Schleife mit a ().

{()<({}[()]<...>)>)>}{}

Bei jeder Schleife nehmen wir den obersten Gegenstand und verschieben ihn auf den anderen Stapel. Dies setzt die Zahl an ihre Stelle.

({}<({}<>)<>>)

Jetzt müssen wir nur noch die Zahlen eintragen, die wir zurückgezogen haben. Wir wechseln zum Off-Stack und geben die Anzahl der durchgeführten Läufe an.

(...<>)

Wir dekrementieren die neu geschobene Zahl in einer Schleife, bis sie Null erreicht. Jedes Mal verschieben wir eine Nummer zurück.

{({}[()]<({}<>)<>>)}{}<>

Umkehren

Als nächstes habe ich die Rolle modifiziert, um einen vollständigen Stapel umzukehren:

(n){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}

N steht wieder für die Tiefe der Umkehrung. Das heißt, die obersten n Elemente auf dem Stapel werden umgekehrt. Wie es funktioniert:

Die Rückseite ist nur eine phantasievoll gewickelte Walze. Wir rollen einfach n-mal die Oberseite des Stapels und verringern die Rollentiefe jedes Mal um eins.

(n){(({}[()])<ROLLER>)}{}

Duplikat

An Ort und Stelle ist die Vervielfältigung schwierig. Sehr hart. Nachdem ich herausgefunden hatte, wie man den Stapel umkehrt, war es immer noch sehr mühsam, den Duplizierungsalgorithmus zu entwickeln.

Hier ist es:

(((n)<{({}[()]<(({}<>))<>>)}{}<>>)<{({}[()]<({}<>)<>([][()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>>)}{}<>([]){{}({}<>)<>([])}{}<>([]){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)

Es ist ein bisschen zu groß, aber so funktioniert es:

Beginnen Sie mit n. n ist die Tiefe des Duplikats. Wir öffnen auch zwei Klammern. Dadurch können wir den Wert von n im Gültigkeitsbereich speichern, bis er erneut benötigt wird.

(((n)<

Als nächstes durchlaufen wir jedes Mal eine n-fache Schleife, indem wir den obersten Wert des Stapels zweimal in den Off-Stack verschieben. Dadurch werden die ersten Duplikate für jede Nummer auf dem Stapel erstellt.

{({}[()]<(({}<>))<>>)}{}

Jetzt haben wir zwei Exemplare jeder Nummer auf dem Stapel. Wir müssen diese in zwei Gruppen unterteilen.

Also wechseln wir in den Offstack und rufen eines der ns auf, die wir zu Beginn gespeichert haben.

<>>)

Wir schleifen n mal.

{({}[()]<...>)}{}

Jedes Mal, wenn wir eine Kopie in den Hauptstapel verschieben.

({}<>)<>

Rollen Sie eine Kopie bis zum Ende des Stapels. (Dies setzt voraus, dass der Offstack zu Beginn leer war und dieses Duplikat nicht sauber gestapelt wurde.)

([][()])ROLLER

Sobald dies erledigt ist, haben wir das Original in zwei Gruppen aufgeteilt, das "Original" und eine Kopie im Offstack (die Kopie ist tatsächlich umgekehrt). Wir verschieben die Kopie einfach in den Hauptstapel und können damit fertig werden.

([]){{}({}<>)<>([])}{}<>

Skeleton-Programm

Nachdem ich alle Teile des Programms erstellt habe, muss ich sie nur noch in einen Frame einfügen.

Der Rahmen verdoppelt den Text einmal weniger als die Höhe des Stapels.

(([])[()])
{
 ({}[()]<
  DUPLICATE 
 >)
>)}{}

Und kehrt dann den Stapel in abnehmenden Schritten der anfänglichen Stapelhöhe von n ^ 2-n auf 0 um.

(({}))
{
 (({}[()])<
  ({}<>)<>(({}))({<({}[()])><>({})<>}{})<>{}<>
  ({}<({}<>)<>>)<>({}<>)
  ({}<
   REVERSE
  >)
 >)
}{}{}
Weizen-Assistent
quelle
5
Tolle. Du machst mir immer klar, was diese Sprache kann! : D
DJMcMayhem
10

Gelee , 4 3 Bytes

,Ṛṁ

Probieren Sie es online! oder Überprüfen Sie alle Testfälle.

Ein Byte dank @ Maltysen gespeichert .

Erläuterung

,Ṛṁ  Input: string S
 Ṛ    Reverse S
,     Join S with reverse of S. Makes a list [S, rev(S)]
  ṁ   Mold [S, rev(S)] to len(S) by repeating elements cyclically
      Return and print implicitly as a string
Meilen
quelle
1
Schimmel braucht nicht dieL
Maltysen
@Maltysen wow danke, wussten Sie , dass aus dem Quellcode oder aus Erfahrung
Meilen
aus Erfahrung, ich weiß nicht , Gelee, aber ich irgendwie gedacht , dass das , was Form auf einer nicht-Zahl tun würde, da Jelly nicht wirklich Überlastungen tun, auch irgendwie erinnerte mich an reshape von J formen
Maltysen
Schimmel nimmt eigentlich nur iterables, aber es wirft Ganzzahlen, um zuerst zu reichen.
Dennis
1
Ja, ich habe Schimmel als Umformung behandelt, also habe ich ihm gewöhnlich eine Nummer gegeben. Es gibt so viele nette kleine Leckerbissen in Jelly, wie zum Beispiel, dass eine Reihe von Zeichenfolgen automatisch als verkettete Zeichenfolge ausgegeben wird
Meilen vom
9

PHP, 54 52 Bytes

(49 Bytes, funktionieren aber nicht, wenn der String '0' enthält)

for(;($a=$argv[1])[$i++];)echo$i%2?$a:strrev($a);

(52 Bytes)

<?=str_pad('',strlen($a=$argv[1])**2,$a.strrev($a));

(54 Bytes)

for(;$i++<strlen($a=$argv[1]);)echo$i%2?$a:strrev($a);
Krypto
quelle
Ich habe es komplett vergessen str_pad. Schön!
Titus
8

2sable , 3 Bytes

Code:

gGÂ

Erläuterung:

g   # Get the length of the input
 G  # Do the following n - 1 times:
  Â # Bifurcate, which duplicates a and reverses the duplicate

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Adnan
quelle
6

Ruby, 39 Bytes

->(s){s.reverse!.gsub(/./){s.reverse!}}

Ich sauge Ruby an. Hilfe beim Golfen ist erwünscht.

Ruby ist dafür eine sehr schöne Sprache .reverse!

Erläuterung

Ich hatte gehofft, dass es so einfach sein würde:

s.gsub(/./){s.reverse!}

aber wegen der Boilerplate / Challenge-Einschränkung ist es länger.

Was s.reverse!ist sehr nützlich. s.reverse!ist im Grunde s = s.reverse!, das heißt, es mutiert auch s.


Was jeder Abschnitt des Programms tut, wird unten beschrieben:

->(s){             # Lambda with argument s
      s.reverse!   # Reverse `s` see above for details
      .gsub(/./)   # Replace every character with...
      {s.reverse!} # the input reversed!

Das s.reverse!Tolle daran ist, dass der String jedes Mal umgedreht wird, wenn er ausgewertet wird. So wie es die Zeichenfolge ersetzt. sist modifiziert!

Downgoat
quelle
Mit der -pFlagge können Sie 4 Bytes speichern:$_.reverse!;gsub(/./){$_.reverse!}
Jordan
@Jordan würde ich nicht ein .chompobwohl auf dem brauchen $_? es scheint im Moment die neue Zeile zu enthalten
Downgoat
Nicht, wenn Sie so etwas tun, wie ruby -pe '$_.reverse!;gsub(/./){$_.reverse!}' < file.txtwo file.txteine Zeile ohne die nachfolgende Zeile ist: V Wie auch immer, wenn Sie sich dazu entschließen, brauchen Sie keine Parens auf dem Lambda, so ->sfunktioniert es
Value Ink
@ValueInk, Sie können eine neue linienlose Eingabe ohne Datei bereitstellen, wenn Sie die Pipe-Funktion verwenden. Oder Sie können es sogar manuell eingeben
manatwork
1
Sie brauchen keine Klammern um das Lambda-Argument. Ich denke auch, dass Sie eines der Ausrufezeichen s.gsub(/./){s.reverse!.reverse}
abschneiden können
6

Perl, 24 Bytes

Beinhaltet +2 für -lp

Geben Sie Input auf STDIN:

rev.pl <<< Hello!

rev.pl:

#!/usr/bin/perl -lp
s%.%s/.?/chop/eg;$`%eg

Überraschenderweise wird der eingebaute reverseOperator nicht verwendet . Dieser Name ist einfach soooo lang, alle Lösungen, an die ich denken könnte, reversesind mindestens 1 Byte länger.

Tonne Hospel
quelle
Ausgezeichnet für die Suche nach einer Lösung, die weniger Bytes benötigt als eine integrierte
MilkyWay90
6

J, 13 8 Bytes

5 Bytes gespart dank Meilen!

#;@$];|.

Dies ist ein 5-Zug mit folgenden Verben:

# ;@$ ] ; |.

Die innere Gabel besteht aus ](Identität), ;(Verbindung) und |.(Rückseite). Beobachten:

   (| ; |.) 'Hello!'
+------+------+
|Hello!|!olleH|
+------+------+

Die beiden äußeren Verben bilden den Rest des Zuges. #ist in diesem Fall die Größe des Arguments, dh die Länge. Das Verb, das diese verknüpft, ist ;@$oder raveldarüber reshape. Beobachten:

   # 'Hello!'
6
   6 $ (] ; |.) 'Hello!'
+------+------+------+------+------+------+
|Hello!|!olleH|Hello!|!olleH|Hello!|!olleH|
+------+------+------+------+------+------+
   ; 6 $ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   6 ;@$ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ (] ; |.)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ ] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (#;@$];|.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

Alte Lösung.

[:,|.^:(i.@#)

Einfach genug. |.ist umgekehrt und ^:ist eine Machtkonjunktion, die ihr linkes Verb (rechte Hand) mehrmals wiederholt. Wenn das richtige Argument ein Verb ist, wird dieses Verb für das Argument aufgerufen. Das richtige Verb reicht in diesem Fall von null ( i.) bis zur Länge ( #). Wenn sie zu einem Array angehoben werden, bleiben die Zwischenergebnisse erhalten. Alles, was getan werden muss, ist das Array mit zu reduzieren ,.

Zwischenergebnisse

   (i.@#) 'Hello!'
0 1 2 3 4 5
   |.^:0 1 2 3 4 5 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   |.^:(i.@#) 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   ([:,|.^:(i.@#)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
Conor O'Brien
quelle
Sie können ein Byte speichern, indem Sie die Länge boxen<@#
Meilen
Eine saubere 8-Byte-Lösung, #;@$];|.die den Anfangs- und den Umkehrstring umrahmt, die Strings umformt und sie zusammennimmt
Meilen,
@ Meilen whoa, das ist ziemlich ordentlich.
Conor O'Brien
5

JavaScript (ES 6), 59 50 Bytes

9 Bytes danke an Hedi und Huntro.

f=(s,n=1)=>s[n]?s+f([...s].reverse().join``,n+1):s

rekursive Funktion.

Das Umkehren des Strings nimmt fast die Hälfte der Größe in Anspruch ( 25 - 22 Byte!) ...
Warum gibt es dafür keinen nativen Weg?

Titus
quelle
1
Sie könnten s[n]?...intead ofn<s.length?...
Hedi
1
Sie können auch 3 Bytes sparen, indem Sie [...s]anstelle vons.split``
Huntro
ja 36 Bytes idealerweisef=(s,n=1)=>n==1?s:s+s.reverse(),n-1)
caub
Nicht-rekursive f=(s,n=1)=>Array.from({length:n},(_,i)=>i%2?s.reverse():s).join``), die auch besser mit etwas besserer Funktion für die Reichweite wäre
caub
@caub: SyntaxError: Unexpected token )JS hat keine native String-Umkehrung. SyntaxError: Invalid or unexpected tokenfür deinen zweiten vorschlag. In welchem ​​Browser funktioniert das?
Titus
4

Minkolang , 17 Bytes:

$oId$z$Dz[rz[O]].

Probieren Sie es hier aus!

Erläuterung

$o                   Read in whole input as characters
  Id                 Push the length of stack and duplicate
    $z               Pop top of stack and store in register (z)
      $D             Pop top of stack (n) and duplicate whole stack n-1 times
        z[     ]     z times, do the following:
          r          Reverse the stack
           z[O]      z times, pop the top of stack and output as character
                .    Stop.
El'endia Starman
quelle
4

8088 Assembly, IBM PC DOS, 29 28 Bytes

Zusammengebaut, xxdentsorgen:

00000000: d1ee ac48 938a cbfc 518a cbf7 da78 01fd  ...H....Q....x..
00000010: acac b40e cd10 e2f9 59e2 ecc3            ........Y...

Zerlegte Auflistung:

D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H) 
AC          LODSB               ; load input string length into AL 
48          DEC  AX             ; remove leading space from length counter 
93          XCHG BX, AX         ; save input length to BL 
8A FB       MOV  BH, BL         ; string output counter in BH 
        S_LOOP: 
FC          CLD                 ; set direction forward 
8A CB       MOV  CL, BL         ; reset char counter in CL 
F7 DA       NEG  DX             ; flip DX to toggle fwd/back output 
78 01       JS   C_START        ; if positive, go forward 
FD          STD                 ; otherwise go backwards 
        C_START: 
AC          LODSB               ; adjust SI to first/last char
        C_LOOP: 
AC          LODSB               ; load next char into AL
B4 0E       MOV  AH, 0EH        ; PC BIOS tty output function
CD 10       INT  10H            ; write char to console
E2 F9       LOOP C_LOOP         ; continue looping through chars
FE CF       DEC  BH             ; decrement string count loop
75 EC       JNZ  S_LOOP         ; if not zero, continue loop
C3          RET                 ; exit to DOS

Eigenständiges ausführbares PC-DOS-Programm. Eingabezeichenfolge über die Befehlszeile, Ausgabe ist Konsole.

Bildbeschreibung hier eingeben

640 KB
quelle
3

Pip , 11-10 Bytes

L#aORVRV:a

Probieren Sie es online!

Erläuterung:

            a is first cmdline argument (implicit)
L#a         Loop len(a) times:
      RV:a   Reverse a and assign back to a
   ORV       Output the reverse of a (since it needs to go forward first then backward)
DLosc
quelle
3

Haskell, 40 36 32 Bytes

m s=take(length s^2)$cycle$s++reverse s

Beispiel:

*Main> m "Hello!"
"Hello!!olleHHello!!olleHHello!!olleH"

Noch kürzer (Dank an Damien):

q s=zip(s>>[s,reverse s])s>>=fst

s >> [s, reverse s] Zyklen ["abc", "cba", ...], die auf die richtige Größe gezippt und mit fst kartiert werden

michi7x7
quelle
2
q s=zip(s>>[s,reverse s])s>>=fst
Damien
3
Oder Pointfree mit der gleichen Größe:(>>=fst).(iterate reverse>>=zip)
Damien
3

Perl 6 ,  31  30 Bytes

{[~] (|($_,.flip)xx*)[^.chars]}

Speichern Sie ein Byte durch Missbrauch .ords, wodurch eine Liste von Ordnungszahlen zurückgegeben wird, und wandeln Sie diese implizit in eine Zahl um, um einen Bereich mit zu erstellen.

{[~] (|($_,.flip)xx*)[^.ords]}

Erläuterung:

# bare block lambda with implicit parameter 「$_」
{
  # reduce using string concatenation operator 「~」
  [~]

  (
    # create a Slip
    |(
      # of the input, and its string reverse
      $_, .flip

    # list repeated infinitely
    ) xx *

  # get the values in the range from 0 up-to and excluding
  # the number of characters 「0 ..^ +$_.ords」
  )[ ^.ords ]
}

Verwendungszweck:

my &code = {[~] (|($_,.flip)xx*)[^.ords]}

say code 'a'; # a
say code 'abcd'; # abcddcbaabcddcba
say code 'OK!'; # OK!!KOOK!
say code 4815162342; # 4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184
Brad Gilbert b2gills
quelle
3

Vim + Coreutils, 32 Tastenanschläge

Sie können nie zu viele Vim-Antworten haben.

qqYv:!rev
Pjq@=len(@")
@q2dkv{gJ

Erläuterung

qq               " Start recording macro
Y                " Yank (copy) line
v:!rev<CR>       " Reverse line with coreutils rev command
Pj               " Paste yanked line above this line
q                " Stop recording
@=len(@")<CR>@q  " Playback macro once for each character
2dk              " Delete last 3 lines
v{gJ             " Join lines
Jordan
quelle
1
Mit Coreutils? Das ist Betrug! : P
Christian Rondeau
3

MATL, 13 12 8 Bytes

Schiebt alle Elemente, kombiniert am Ende.

td"tP]&h

td"  ]     %For loop over string length - 1 due to diff
   tP      %Push copy of string, reverse
      &h   %Concatenate entire stack horizontally

Probieren Sie es online!


Alte Versionen:

Ganz andere Herangehensweise, basierend auf fprintf:

t"t1$0#YDP]x

t"        ]   % For loop over string
  t           % Duplicate string for printing:
   1$0#YD     % `fprintf` with 1 input, 0 output (i.e., to screen).
         P    % Reverse
           x  % Empty stack to prevent implicit output

Version, die auf dem Umkehren einer Vorlagenzeichenfolge basiert

ttd"wPtbYc]Dx

t                 %Duplicate input, to create 'accumulator' string 
                  % (alongside the input string which will serve as 'template'
 td               %Duplicate input, diff to get an stringof size input-1
   "       ]      %For loop over size n-1 string (consumes diff'd string)
     wP           %Get 'template' string on top of stack, and reverse
       tb         %Duplicate template string, and switch with 'accumulator' string
         Yc       %Concatenate template string with accumulator. 
            Dx   %Display top element, delete template string to prevent implicit disp
Sanchises
quelle
Ich mag die kluge Verwendung von td!
DJMcMayhem
@DJMcMayhem Danke! Ich hatte den offensichtlichen tnq:"ersten, aber tn:"ist ein bisschen ein Code-Geruch (siehe diesen Matlab-Golftipp), so dass ich dachte, dass tnq:das auch kompakter sein könnte.
Sanchises
3

Scala, 73 72 71 Bytes

def f(s:String)=for(i<-1 to s.length){print(if(i%2>0)s else s.reverse)}

Dies ist mein erster Versuch, Code Golf zu spielen. Ich bin mir sicher, dass es unzählige Verbesserungen gibt.

Aktualisieren:

1 Byte durch Entfernen von Klammern entfernt.

Dank Destructible Watermelon für den Vorschlag, ein Byte abgeschabt.

Als er selbst12794
quelle
Ich weiß nicht , scala, aber können Sie ändern , i%2==1zu i%2>0?
Destructible Lemon
@DestructibleWatermelon Hatte nicht daran gedacht, ja, ich kann
selbst12794
3

Cubix , 52 Bytes

Ap\:\;.#u/\:qqsoq(?;u.q..$u<../pB@u:\.....\(?q..s..p

Auf einem Würfel:

      A p \
      : \ ;
      . # u
/ \ : q q s o q ( ? ; u
. q . . $ u < . . / p B
@ u : \ . . . . . \ ( ?
      q . .
      s . .
      p . .

Dieser hat Spaß gemacht; Es gibt immer noch Bytes, die aus diesem heraus golfen werden müssen, aber dies wird definitiv funktionieren.

Probieren Sie es online!

Erläuterung:

Eingabe von ABC

  • /A: nach Norden gehen und alle Eingaben als Zeichen einlesen; -1wird am unteren Rand sein
  • p\;.: Entfernen Sie die -1aus dem Stapel
  • u# : Länge der Zeichenfolge (Anzahl der Elemente auf dem Stapel)
  • \:\:qq : Die Saitenlänge zweimal verdoppeln, zwei Kopien bis zum Ende des Stapels schieben
  • Schleife:

    • soq(?/<u : Stapeloberseite vertauschen, Stapeloberseite als ASCII ausgeben, Oberseite (Buchstabe) nach unten drücken, Stapeloberseite verkleinern, nach rechts drehen, wenn nicht erledigt, dann IP an die richtige Stelle verschieben.
    • Am Ende der Schleife sieht der Stapel so aus C B A 3 3 0
  • ;u : Pop oben auf dem Stapel C B A 3 3

  • B : Stapel umkehren 3 3 A B C
  • p( : von unten nach oben bewegen und dekrementieren 3 A B C 2
  • ?Wenn top Null ist, gehe direkt zu @und beende
  • sonst
    • psq:uq : bewegen Sie sich von unten nach oben, tauschen Sie oben und bewegen Sie sich von oben nach unten, und bewegen Sie sich von oben nach unten 3 2 A B C 3
    • $u : überspringen u
    • < bringt uns zurück in die Schleife.

Dolmetscher

Giuseppe
quelle
Hier ist ein 24 Byte . Dieselbe allgemeine Logik wurde nur ein wenig komprimiert.
MickyT
@MickyT Ich würde mich schlecht fühlen, wenn ich 28 Byte Golf kriege. Poste es selbst!
Giuseppe
3

C (GCC) , 88 87 85 83 68 66 83 82 78 Bytes

-1 dank ceilingcat

Alte Version

p,q;f(char*s){p=q=1;for(char*m=s--;*m;s[p+=q]*p?:(m++,p+=q=-q))putchar(s[p]);}

Probieren Sie es online!

Kürzere Version (leicht gebrochen)

Riffing auf dem 76-Byte-Ansatz von ASCII-only in den Kommentaren und -1 Byte von seiner Optimierung meiner Optimierung.

Bearbeiten: Diese Version ist leicht fehlerhaft, da davon ausgegangen wird, dass vor jeder Zeichenfolge ein NULL-Byte steht, was nicht immer der Fall ist. (Siehe letzter Testfall im Link). Zur 83-Byte-Version zurückkehren.

f(char*s){for(char*n=s-1,k=1;*s++;k=-k)for(;*(n+=k);)putchar(*n);}

Probieren Sie es online!

Gastropner
quelle
67
Nur ASCII
@ Nur ASCII 68 ist mit einigen Optimierungen möglich.
Gastropner
: P es ist jetzt 67 lol @ Gastropner
ASCII
@ Nur ASCII 66 :-P
Gastropner
@ Nur ASCII Leider hat sich herausgestellt, dass die Kurzversion in bestimmten Fällen nicht funktioniert.
Gastropner
2

Java, 127 111 88 Bytes

(s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?new StringBuffer(s).reverse():s;return r;};

Ungolfed Testprogramm

    public static void main(String[] args) {
    BiFunction<String, String, String> func = (s, r) -> {
        for (int i = 0; i++ < s.length();) {
            r += i % 2 < 1 ? new StringBuffer(s).reverse() : s;
        }
        return r;
    };
    System.out.println(func.apply("Hello!", ""));
}
Shaun Wild
quelle
Hier kann noch mehr gespielt werden: (s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?s:new StringBuffer(s).reverse();return r;};( 88 Bytes ). Außerdem würde ich angeben, dass dies Java 8 ist.
Kevin Cruijssen
Na, es ist in Ordnung anzunehmen, dass er die neueste Version von Java verwendet.
Shaun Wild
@KevinCruijssen Java 7 wird nicht mehr unterstützt (außer bei großen $$$). Wir sollten die Java-Version nicht angeben müssen. Wenn Sie als Java 7 schreiben, können die meisten Antworten auch in Java 1.1 oder 1.2 geschrieben werden. Solltest du nicht die niedrigste Version schreiben, mit der es funktioniert? Wenn der Code in dieser Antwort Java 7-konform wäre, wäre er Java 1.2-konform und ... würde immer noch in Java 8 funktionieren.
Olivier Grégoire
2

R, 53 Bytes

Es wird davon ausgegangen, dass die Eingabe für jedes Zeichen durch Leerzeichen oder Zeilenumbrüche getrennt ist.

cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")

Einige Testfälle:

> cat(rep(c(i<-scan(,""),rev(i)),len=length(i)^2),sep="")
1: h e l l o !
7: 
Read 6 items
hello!!ollehhello!!ollehhello!!olleh

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a
2: 
Read 1 item
a

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a b c d
5: 
Read 4 items
abcddcbaabcddcba

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: O K !
4: 
Read 3 items
OK!!KOOK!

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 8 1 5 1 6 2 3 4 2
11: 
Read 10 items
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: P P C G
5:    
Read 4 items
PPCGGCPPPPCGGCPP

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 2
3: 
Read 2 items
4224
rturnbull
quelle
2

PowerShell v2 +, 57 Byte

param($a)-join(1..($x=$a.length)|%{($a[$x..0],$a)[$_%2]})

Es gibt keine wirklich saubere Möglichkeit, Stringlängen zu erhalten oder sie umzukehren, daher ist dies ziemlich langwierig.

Übernimmt Eingaben $a, durchläuft Schleifen von 1bis $a.length( $xzur späteren Verwendung gespeichert ). Bei jeder Iteration wird ein Pseudoternär verwendet, um ein Array von entweder $aoder $a[$x..0](dh umgekehrt) zu indizieren , je nachdem, ob unsere Eingabenummer ungerade / gerade ist [$_%2]. Diese sind alle in Parens eingekapselt und -joinzu einer einzigen Zeichenfolge zusammengefasst. Das bleibt in der Pipeline und die Ausgabe ist implizit.

PS C:\Tools\Scripts\golfing> .\stringgnirts.ps1 'TimmyD'
TimmyDDymmiTTimmyDDymmiTTimmyDDymmiT
AdmBorkBork
quelle
2

Java, 151 Bytes

public static void r(String s){String t = new StringBuffer(s).reverse().toString();for(int i=0;i<s.length();i++){System.out.print(((i%2==1)?t:s));}}

}

Ungolfed:

public static void r(String s) {
    String t = new StringBuffer(s).reverse().toString();
    for(int i = 0; i < s.length();i++) {
        System.out.print(((i % 2 == 1) ? t : s));
    }
}

Herb Wolfe
quelle
1
Hallo, willkommen bei PPCG! Zuallererst möchte ich empfehlen, Tipps zum Golfen in Java durchzulesen . Was Ihren Code angeht, gibt es ein paar Dinge, die noch gespielt werden können: Sie können die public staticvor Ihrer Methode entfernen . Sie können die Leerzeichen zwischen entfernen t=new StringBuffer. Sie können die unnötigen Klammern und Klammern entfernen. Und Sie können die Modulprüfung von ==1auf vertauschen <1(was ==0für nicht negative Zahlen gleichbedeutend ist ). Sie können auch i++die letzte Verwendung innerhalb der for-Schleife verschieben.
Kevin Cruijssen
6
Insgesamt wird es also: void r(String s){for(int i=0;i<s.length();)System.out.print(i++%2<1?s:new StringBuffer(s).reverse()+"");}( 105 Bytes )
Kevin Cruijssen
2

94 Bytes

using System.Linq;string R(string n)=>string.Concat(n.SelectMany((c,i)=>1>i%2?n:n.Reverse()));

76 Bytes für die Methode + 18 Bytes für den LINQ-Import.

Wie es funktioniert:

using System.Linq; // Required for LINQ extension methods.

string R(string n) => 
    string.Concat( // Concatenate the following chars into a single string
        n.SelectMany( // Enumerate each char in n, flattening the returned IEnumerable<char>'s into a single IEnumerable<char>
            /*IEnumerable<char> Lambda*/(/*char*/ c, /*int*/ i) => // i = index in n
                1 > i % 2 // Check if i is even or odd
                    ? n // if i is even, add n to the concat
                    : n.Reverse() // else reverse n and concat that
        )
    )
;
Milch
quelle
2

CJam , 10 Bytes

l_,({_W%}*

Probieren Sie es online!

Erläuterung

l            e# Read line
 _           e# Duplicate
  ,(         e# Length minus 1
    {   }*   e# Run code block that many times
     _       e# Duplicate
      W%     e# Reverse
             e# Implicitly display
Luis Mendo
quelle
2

Oktave, 39-35 Bytes

@(x)[x'+~x;flip(x'+~x),''](1:end/2)

f('Hello!')
ans = Hello!!olleHHello!!olleHHello!!olleH

Erläuterung:

@(x)            % Take x as input, inside apostrophes 'Hello!'
x'+~x           % Create a mesh of the ASCII-code of the input letters
                % For input `bcd` this will be:
                %    98    98    98
                %    99    99    99
                %   100   100   100
;flip(x'+~x)   % Concatenate vertically to create:
                %    98    98    98
                %    99    99    99
                %   100   100   100
                %   100   100   100
                %    99    99    99
                %    98    98    98
___,'']         % Short cut to convert ASCII-code to characters
(1:end/2)       % Display the first half of this array of letters, as a
                % horizontal string

4 Bytes gespart dank Luis. ~xAnstatt 0*xein Byte zu speichern (funktioniert, weil alle Elemente von x nicht Null sind. flipAnstatt flipudzwei weitere Bytes zu speichern (ich wusste nicht, dass es flipexistiert).

Stewie Griffin
quelle
2

Bash + Util-Linux, 68 58 53 Bytes

y=$1;for((i;i<${#1};i++)){ echo -n $y;y=`rev<<<$y`;}

Erläuterung

Zwei Dinge mit der forSchleife:

  • Es gibt eine scheinbar undokumentierte Art, forLoops zu schreiben , bei denen man die Schlüsselwörter dound donedurch geschweifte Klammern {und ersetzt }. Der Abstand nach der ersten Klammer ist erforderlich, und das Semikolon am Ende ist ebenfalls erforderlich.
  • Es stellt sich heraus, dass Sie in den "C-style" for-Schleifen nur mit initialisieren können, i;anstatt sie zu verwenden i=0;.
  • Der ${#1}Teil der Bedingung i < ${#1}bezieht sich auf die Länge unserer Eingabe (der erste Parameter $1). Im Allgemeinen können Sie ${#foo}zum Abrufen der Größe der Zeichenfolge verwenden $foo.

Zusätzlich:

  • rev ist das Werkzeug in util-linux, das einen String umkehrt.
  • Wir müssen die -nFlagge passieren echo, um die Zeilenumbrüche loszuwerden.
  • Der Ausdruck rev<<<$ywird als Here-String bezeichnet (siehe diese relevante tldp.org-Seite ), der die Variable $yan die Standardeingabe von übergibt rev.
Frames
quelle
Bitte erläutern Sie einige Ihrer Kenntnisse. Vielleicht kann auch der Raum vor dem Echo entfernt werden, aber ich weiß nicht, was Bash ist
Rohan Jhunjhunwala
@RohanJhunjhunwala Der Antwort wurde eine kleine Erklärung hinzugefügt, um möglicherweise einige Dinge zu klären. Außerdem: Wenn Sie die Schlüsselwörter dound donein einer forSchleife weglassen , benötigen Sie tatsächlich diesen Platz!
Frames
+1 sieht jetzt gut aus. Ich habe nur kommentiert, weil Ihr Code eine automatische Flagge von geringer Qualität gezeichnet hat. Antworten nur mit Code werden automatisch markiert
Rohan Jhunjhunwala
y=$1;for((;i<${#1};i++)){ printf $y;y=`rev<<<$y`;}... ein paar Bytes
gespart
2

Japt , 11 Bytes

ê1 pUÊ ¯Uʲ
ê1          // Append the reverse of the input to the input,
   pUÊ      // then repeat it input length times
       ¯Uʲ // and finally trim to length input length squared.

Probieren Sie es online!

Nit
quelle
@ Shaggy Ich habe versucht, es zu benutzen, aber für mein ganzes Leben kann ich es nicht fassen. : P Vielen Dank für das Beispiel!
Nit
Sorry, hat den falschen Link gepostet, es sind eigentlich 6 Bytes .
Shaggy
1
@ Shaggy Ich hätte nichts dagegen, und es ist anders als Nits Antwort. Mach es, Mann.
Oliver
2

05AB1E , 7 Bytes

vDR}v}J

Probieren Sie es online!

Wird weiter daran arbeiten. Ich mag den Teil "v" nicht wirklich, kann dort wahrscheinlich ein Byte speichern.

Erläuterung

vDR}v}J

v         ; Iterates through each character
 D        ; Duplicate top of stack
  R       ; Push top of stack reversed
   }      ; end for loop
   v}     ; same as other v, effectively pops top of stack off
     J    ; Join everything together
Multi
quelle
1
vÂ}\J 5 Bytes sind das Gleiche wie Ihr Code, jedoch mit den von Ihnen gesuchten Builtins. :)Âist Bifurcate (kurz für Duplicate & Reverse, was genau das ist, was Sie tun). \ löscht das oberste Element auf dem Stapel.
Kevin Cruijssen