Voici un défi relativement simple pour vous.

Avec une chaîne de longueur N , affichez la chaîne en avant, puis en arrière, puis en avant, puis en arrière, etc. N fois. Par exemple, si votre contribution était

Hello!

Vous devriez produire:

Hello!!olleHHello!!olleHHello!!olleH

Vous pouvez également éventuellement sortir une nouvelle ligne de fin.

Votre soumission peut être un programme complet ou une fonction, et vous pouvez saisir les entrées et les sorties dans un format raisonnable . Par exemple, vous pouvez prendre IO de STDIN / STDOUT, des arguments de fonction et une valeur renvoyée, d'un fichier, etc. Vous pouvez supposer en toute sécurité que la chaîne d'entrée ne sera pas vide et ne contiendra que de l'ASCII imprimable. Vous devez sortir la nouvelle chaîne sur une seule ligne. Ainsi, par exemple, si la sortie du dernier exemple était

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

Ce ne serait pas une solution valable!

Voici quelques autres cas de test:

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

Classements

Comme il s’agit d’un défi de code-golf , les échappatoires standard sont interdites et la réponse la plus courte en octets l’emporte! Cependant , il s’agit également d’ un concours visant à obtenir la réponse la plus courte dans une langue donnée. Bien qu'il soit peu probable qu'une réponse Java batte une réponse en perl ou dans un langage de golf, il est toujours très impressionnant de disposer de la réponse Java la plus courte. Donc, vous pouvez utiliser ce classement pour voir à la fois

1. La réponse la plus courte de toutes les langues, et

2. La réponse la plus courte dans chaque langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](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 frappes

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

5 octets sauvés grâce à @Lynn!

Voici un gif de ce qui se passe en direct: (Notez que ce gif est d'une version précédente depuis que je n'ai pas encore eu le temps de le réenregistrer).

Et voici une explication de la façon dont cela fonctionne:

: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

Sur une note de côté, Ysaisit une nouvelle ligne, ce qui est généralement une caractéristique odieuse. C'est probablement la toute première fois qu'il enregistre plusieurs octets!

Python, 40 octets

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

Une fonction récursive. Ajoute la chaîne d'entrée sà la fonction de l'inverse jusqu'à ce que le compteur idépasse la longueur de s.

Brain-Flak , 418 378 228 octets

Ceci est mon chef-d'œuvre Brain-Flak. Ce n'est peut-être pas bien joué, mais le défi est le plus difficile que j'ai jamais rencontré.

Essayez-le en ligne!

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

Explication

Cette explication est maintenant un peu dépassée, mais elle explique quand même assez bien le programme.

Cette explication sera un peu différente de mon processus d’explication habituel. Je vais expliquer comment je suis arrivé à ce résultat plutôt que d'expliquer le résultat dans l'ordre. Ici ça va:

Rouleau

Après avoir travaillé un peu sur le problème, je suis arrivé avec ce code:

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

Ce code (où n est le littéral d’un nombre donné, par exemple ()()) prend l’élément en haut de la pile et le déplace vers le bas de n étapes. Avec n comme hauteur de pile, cela effectuera une pile "roll". c'est-à-dire déplacer l'élément du haut vers le bas de la pile. Voici comment cela fonctionne:

Nous plaçons l'endroit où nous souhaitons déplacer l'élément de moins un sur la pile. Pourquoi moins un? Je ne sais pas si ça marche comme ça.

(n[()])

On boucle ensuite jusqu'à ce que ce nombre atteigne zéro en gardant trace de la boucle avec un ().

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

Chaque fois que nous faisons une boucle, nous sélectionnons l’élément supérieur et le déplaçons sous celui-ci vers l’autre pile. Cela met le nombre en haut à sa place.

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

Tout ce que nous avons à faire maintenant, c'est de remettre les chiffres que nous avons reculés. Nous passons en mode hors pile et poussons le nombre de points de la boucle.

(...<>)

Nous lançons en boucle décrémentant le nombre nouvellement poussé jusqu'à ce qu'il atteigne zéro. A chaque fois, on avance d'un numéro.

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

Sens inverse

J'ai ensuite modifié le lancer pour faire un reverse stack complet:

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

Encore une fois, n représente la profondeur de l'inverse. C'est-à-dire que les n premiers éléments de la pile seront inversés. Comment ça marche:

Le revers n'est qu'un rouleau enroulé de manière fantaisiste. On fait simplement rouler le haut de la pile n fois en décrémentant la profondeur du rouleau d'une fois.

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

Dupliquer

La duplication en place est difficile. Vraiment dur. Après avoir compris comment inverser la pile, il fallait encore beaucoup d'efforts pour trouver l'algorithme de duplication.

C'est ici:

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

C'est un peu gros, mais voici comment cela fonctionne:

Commencez par appuyer sur n. n est la profondeur du duplicata. Nous ouvrons également deux parenthèses. Celles-ci nous permettent de stocker la valeur du n dans la portée jusqu'à ce que nous en ayons besoin.

(((n)<

Ensuite, on boucle n fois à chaque fois en poussant deux fois la valeur supérieure de la pile vers la pile. Cela crée les doublons initiaux pour chaque numéro de la pile.

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

Nous avons maintenant deux copies de chaque numéro sur la pile. Nous devons les séparer en deux groupes.

Nous passons donc hors pile et rappelons l’un des ns sauvegardés au début.

<>>)

Nous faisons une boucle n fois.

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

Chaque fois que nous déplaçons une copie vers la pile principale.

({}<>)<>

Et roulez une copie au bas de la pile. (Cela suppose que la pile hors pile était vide pour commencer par faire en sorte que cette copie ne soit pas empilée)

([][()])ROLLER

Une fois que cela est fait, nous avons divisé l'original en deux groupes: "l'original" et une copie hors pile (la copie est en réalité inversée). Donc, nous déplaçons simplement la copie vers la pile principale et nous pouvons en finir.

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

Programme squelette

Maintenant que j'ai créé tous les éléments du programme, il ne me reste plus qu'à les insérer dans un cadre.

Le cadre double le texte d'un pouce en moins par rapport à la hauteur de la pile, en utilisant dupliquer.

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

Et puis inverse la pile par incréments décroissants de la hauteur initiale de la pile de n ^ 2-n à 0.

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

Gelée , 4 3 octets

,Ṛṁ

Essayez-le en ligne! ou Vérifiez tous les cas de test.

Enregistré un octet grâce à @ Maltysen .

Explication

,Ṛṁ  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 octets

(49 octets, mais ne fonctionne pas si la chaîne contient '0')

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

(52 octets)

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

(54 octets)

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

2sable , 3 octets

Code:

gGÂ

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

Ruby, 39 octets

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

Je suce à Ruby. L'aide au golf est appréciée.

Ruby est un très bon langage pour cela à cause de .reverse!

Explication

J'espérais que ce serait simple comme:

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

mais à cause de la restriction standard et du challenge, c'est plus long.

Ce qui s.reverse!est très utile s.reverse!est fondamentalement s = s.reverse!, ce qui signifie qu'il mute également s.

Ce que chaque section du programme fait est décrit ci-dessous:

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

Le point s.reverse!positif est que chaque fois qu’il est évalué, la chaîne est inversée. Donc, comme il remplace la chaîne. sest modifié!

Perl, 24 octets

Comprend +2 pour -lp

Donnez votre avis sur STDIN:

rev.pl <<< Hello!

rev.pl:

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

Étonnamment, cela n’utilise pas l’ reverseopérateur intégré . Ce nom est tellement long, toutes les solutions auxquelles je pourrais penser reversesont au moins 1 octet plus long.

J, 13 8 octets

5 octets sauvés grâce aux miles!

#;@$];|.

C'est un 5 train avec les verbes suivants:

# ;@$ ] ; |.

La fourchette intérieure est composée de ](identité), ;(lien) et |.(inversion). Observer:

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

Les deux verbes extérieurs forment le reste du train. #est, dans ce cas, la taille de l’argument, c’est-à-dire la longueur. Le verbe qui les relie est ;@$ou est ravelterminé reshape. Observer:

   # '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

Ancienne solution.

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

Assez simple. |.est inverse, et ^:est une conjonction de pouvoir, qui répète son verbe à gauche (main droite) # de fois. Lorsque le bon argument est un verbe, ce verbe est appelé sur l'argument. Le verbe droit dans ce cas va de zéro ( i.) à la longueur ( #). Lorsque élevés dans un tableau, les résultats intermédiaires sont conservés. Tout ce qui reste à faire est d’aplatir le tableau ,.

Résultats intermédiaires

   (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 octets

9 octets grâce à Hedi et Huntro.

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

fonction récursive.

Inverser la chaîne prend presque la moitié de la taille ( 25 22 octets!) ...
Pourquoi n’existe-t-il pas une méthode native pour cela?

Minkolang , 17 octets:

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

Essayez-le ici!

Explication

$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 octets

Assemblé, xxdvidage:

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

Liste non assemblée:

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

Programme exécutable autonome PC DOS. Chaîne d'entrée via la ligne de commande, la sortie est console.

Pip , 11 à 10 octets

L#aORVRV:a

Essayez-le en ligne!

Explication:

            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 octets

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

Exemple:

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

Encore plus court (crédit à Damien):

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

s >> [s, inverser s] cycles ["abc", "cba", ...] compressés avec la taille voulue et concatapés avec fst

Perl 6 ,  31  30 octets

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

Enregistrez un octet en utilisant de manière abusive .ords, ce qui retourne une liste d'ordinaux, puis transformez-le implicitement en un nombre pour créer une plage.

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

Explication:

# 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 ]
}

Usage:

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 frappes

Vous ne pouvez jamais avoir trop de réponses à Vim.

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

Explication

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 octets

Pousse tous les éléments, combine à la fin.

td"tP]&h

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

Essayez-le en ligne!

Anciennes versions:

Approche complètement différente, basée sur 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 basée sur l'inversion d'une chaîne de modèle

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 octets

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

C’est ma première tentative de jouer au golf, alors je suis certain que d’innombrables améliorations ont été apportées.

Mise à jour:

Golfé 1 octet en supprimant les supports.

Merci à la pastèque destructible pour suggestion, rasé un octet.

Cubix , 52 octets

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

Sur un cube:

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

Celui-ci était amusant; il reste encore des octets à jouer, mais cela fonctionnera certainement.

Essayez-le en ligne!

explication:

Entrée de ABC

• /A: allez au nord et lisez toutes les entrées sous forme de caractères; -1sera au bas
• p\;.: enlever le -1de la pile
• u# : pousse la longueur de la chaîne (nombre d'éléments sur la pile)
• \:\:qq : dupliquez deux fois la longueur de la chaîne, placez deux copies au bas de la pile

• boucle:

  • soq(?/<u : échangez le haut de la pile, le haut de la pile en ASCII, poussez le haut (lettre) vers le bas, décrémentez le haut de la pile, tournez à droite si ce n’est pas fait, puis déplacez l’IP au bon endroit.
  • en fin de boucle, la pile ressemblera à C B A 3 3 0

• ;u : pop top of stack C B A 3 3

• B : pile inverse 3 3 A B C
• p( : déplacer de bas en haut et décrémenter 3 A B C 2
• ?si top est zéro, allez directement @et terminez
• autre
  • psq:uq : se déplacer de bas en haut, échanger de haut en bas, de haut en bas, et de haut en bas 3 2 A B C 3
  • $u : sauter u
  • < nous remet dans la boucle.

Interprète

C (gcc) , 88 87 85 83 68 66 66 82 82 octets

-1 grâce à ceilingcat

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

Essayez-le en ligne!

Version plus courte (légèrement cassée)

Riffing sur l'approche de 76 octets par ASCII uniquement dans les commentaires, et -1 octet de son tweak de mon tweak.

Edit: Cette version est légèrement cassée car elle suppose que chaque chaîne est précédée d’un octet NULL, ce qui n’est pas toujours vrai. (Voir dernier cas de test en lien). Revenons à la version de 83 octets pour le moment.

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

Essayez-le en ligne!

Java, 127 111 88 octets

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

Programme de test non-golfé

    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 octets

Suppose que l'entrée est séparée par une ligne ou une nouvelle ligne pour chaque caractère.

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

Quelques cas de test:

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

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

Aucune méthode vraiment propre pour obtenir des longueurs de chaîne ou les inverser, c'est donc assez long.

Prend les entrées $a, boucles de 1à $a.length(stockées $xpour une utilisation ultérieure). À chaque itération, nous utilisons un pseudo-ternaire pour indexer dans un tableau composé de $aou $a[$x..0](c.-à-d., Inversé), en fonction du nombre impair ou pair de notre entrée [$_%2]. Ceux-ci sont tous encapsulés dans des parenthèses et édités -joinensemble pour former une seule chaîne. Cela reste sur le pipeline et la sortie est implicite.

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

Java, 151 octets

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

C #, 94 octets

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

76 octets pour la méthode + 18 octets pour l'importation LINQ.

Comment ça marche:

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 octets

l_,({_W%}*

Essayez-le en ligne!

Explication

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

Octave, 39 35 octets

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

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

Explication:

@(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

Sauvegardé 4 octets grâce à Luis. ~xau lieu de 0*xsauvegarder un octet (fonctionne car tous les éléments de x sont non nuls. flipau lieu de flipudsauvegarder deux autres octets (je ne savais pas qu’il flipexistait).

bash + util-linux, 68 58 53 octets

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

Explication

Deux choses en forboucle:

• Il existe un moyen apparemment non documenté d’écrire des forboucles dans lequel on remplace les mots do- doneclés et par des accolades {et des }. L'espace après le premier crochet est nécessaire et le point-virgule à la fin est également nécessaire.
• Il s'avère que dans les forboucles "C-style" , vous pouvez simplement initialiser avec i;au lieu d'utiliser i=0;.
• La ${#1}partie de la condition i < ${#1}fait référence à la longueur de notre entrée (le premier paramètre $1). En général, vous pouvez utiliser ${#foo}pour récupérer la taille de la chaîne $foo.

Aditionellement:

• rev est l'outil dans util-linux qui inverse une chaîne.
• Nous devons passer le -ndrapeau echopour nous débarrasser des nouvelles lignes.
• L'expression rev<<<$yest appelée une chaîne here (voir la page correspondante de tldp.org ), qui transmet la variable $yà l'entrée standard de rev.

Japt , 11 octets

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

Essayez-le en ligne!

05AB1E , 7 octets

vDR}v}J

Essayez-le en ligne!

Continuera à y travailler. Je n'aime pas vraiment la partie "v}", je peux probablement y sauvegarder un octet.

Explication

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