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 Code-Golf- 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

var QUESTION_ID=93261,OVERRIDE_USER=31716;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

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

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!

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.

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

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

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

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!

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!

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.

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

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?

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.

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.

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)

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

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

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

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

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.

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

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!

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!", ""));
}

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

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

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

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

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

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

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.

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!

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