Ecco una sfida relativamente semplice per te.

Data una stringa di lunghezza N , emetti la stringa in avanti, quindi all'indietro, quindi in avanti, quindi all'indietro ... ecc. N volte. Ad esempio, se il tuo input è stato

Hello!

Dovresti produrre:

Hello!!olleHHello!!olleHHello!!olleH

È inoltre possibile produrre facoltativamente una nuova riga finale.

Il tuo invio può essere un programma completo o una funzione e puoi accettare input e output in qualsiasi formato ragionevole . Ad esempio, è possibile prendere IO da STDIN / STDOUT, argomenti di funzione e valore di ritorno, da un file, ecc. Potete tranquillamente presumere che la stringa di input non sia vuota e conterrà solo ASCII stampabile. È necessario generare la nuova stringa su una sola riga. Quindi, ad esempio, se l'output dell'ultimo esempio fosse

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

Questa non sarebbe una soluzione valida!

Ecco alcuni altri casi di 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

Classifiche

Dato che si tratta di una sfida con il golf del codice , le scappatoie standard sono vietate e vince la risposta più breve in byte! Tuttavia , questa è anche una competizione per avere la risposta più breve in una particolare lingua. Mentre è improbabile che una risposta Java superi una risposta in perl, o in qualche linguaggio del golf, è comunque molto impressionante avere la risposta Java più breve. Quindi, puoi usare questa classifica per vedere entrambi

1. La risposta più breve da tutte le lingue e

2. La risposta più breve in ogni singola lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Tasti Vim, 39 , 34

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

5 byte salvati grazie a @Lynn!

Ecco una gif di ciò che sta accadendo dal vivo: (Nota che questa gif è di una versione precedente poiché non ho ancora avuto il tempo di registrarlo di nuovo).

Ed ecco una spiegazione di come funziona:

: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

Una nota a Ymargine , prende una nuova riga in più, che di solito è una caratteristica odiosa. Questa è probabilmente la prima volta in assoluto che ha effettivamente salvato diversi byte!

Python, 40 byte

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

Una funzione ricorsiva. Prepara la stringa di input salla funzione del contrario fino a quando il contatore non isupera la lunghezza di s.

Brain-Flak , 418 378 228 byte

Questo è il mio capolavoro di Brain-Flak. Potrebbe non essere ben golfato, ma la sfida è la più difficile che abbia mai incontrato.

Provalo online!

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

Spiegazione

Questa spiegazione è ora un po 'datata ma fa comunque un ottimo lavoro nel spiegare il programma.

Questa spiegazione sarà leggermente diversa dal mio normale processo di spiegazione. Spiegherò come sono arrivato a questo risultato piuttosto che spiegare il risultato in ordine. Eccolo:

Rullo

Dopo aver lavorato un po 'sul problema, ho pensato a questo codice:

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

Questo codice (dove n è il valore letterale di un numero. Ad es. ()()) Prenderà l'oggetto in cima alla pila e lo sposterà in basso di n punti. Con n come altezza della pila, questo eseguirà un "tiro" di pila. cioè sposta l'elemento in cima al fondo della pila. Ecco come funziona:

Mettiamo il posto in cui vogliamo spostare l'oggetto a meno uno in pila. Perché meno uno? Non so che funzioni così.

(n[()])

Quindi eseguiamo il loop fino a quando questo numero non raggiunge lo zero tenendo traccia del loop con a ().

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

Ogni volta che eseguiamo il loop prendiamo l'oggetto in alto e spostiamo l'oggetto sottostante nell'altro stack. Questo mette il numero in cima al suo posto.

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

Tutto quello che dobbiamo fare ora è mettere i numeri che abbiamo spostato indietro. Passiamo allo stack off e spingiamo il numero di run effettuati dal loop.

(...<>)

Ripetiamo ripetutamente il numero appena premuto fino a raggiungere lo zero. Ogni volta che spostiamo indietro di un numero.

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

Inverso

Successivamente ho modificato il rotolo per invertire un intero stack:

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

Ancora una volta n rappresenta la profondità del contrario. Cioè i primi n oggetti in pila verranno invertiti. Come funziona:

Il retro è solo un rullo avvolto in modo fantasioso. Rotoliamo semplicemente la parte superiore della pila n volte diminuendo di una volta la profondità del rotolo.

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

Duplicare

Al suo posto la duplicazione è difficile. Davvero difficile. Dopo aver capito come invertire lo stack, ci è voluto ancora molto sforzo per elaborare l'algoritmo di duplicazione.

Ecco qui:

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

È un po 'grande ma ecco come funziona:

Inizia premendo n. n è la profondità del duplicato. Apriamo anche due parentesi. Questi ci consentono di memorizzare il valore di n nell'ambito fino a quando non è nuovamente necessario.

(((n)<

Successivamente eseguiamo il ciclo n volte ogni volta spingendo due volte il valore superiore dello stack nello stack off. Questo rende i duplicati iniziali per ogni numero nello stack.

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

Ora abbiamo due copie di ogni numero sullo stack. Dobbiamo separarli in due gruppi.

Quindi passiamo allo offstack e ricordiamo una delle ns che abbiamo salvato all'inizio.

<>>)

Facciamo un giro n volte.

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

Ogni volta che spostiamo una copia sul mainstack.

({}<>)<>

E rotola una copia in fondo alla pila. (Ciò presuppone che lo offstack fosse vuoto all'inizio per rendere questo duplicato non impilabile)

([][()])ROLLER

Fatto ciò, abbiamo diviso l'originale in due gruppi, "originale" e una copia sullo stack (la copia è in realtà al contrario). Quindi spostiamo semplicemente la copia nello stack principale e possiamo farcela.

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

Programma scheletro

Ora che ho realizzato tutti i pezzi del programma, devo solo inserirli in una cornice.

La cornice raddoppia il testo uno in meno rispetto all'altezza della pila volte Usando duplicato.

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

E quindi inverte lo stack in incrementi decrescenti dell'altezza dello stack iniziale da n ^ 2-n a 0.

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

Gelatina , 4 3 byte

,Ṛṁ

Provalo online! oppure Verifica tutti i casi di test.

Salvataggio di un byte grazie a @ Maltysen .

Spiegazione

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

(49 byte, ma non funzionano se la stringa contiene '0')

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

(52 byte)

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

(54 byte)

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

2 file , 3 byte

Codice:

gGÂ

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!

Rubino, 39 byte

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

Faccio schifo a Ruby. L'aiuto del golf è apprezzato.

Ruby è davvero un bel linguaggio per questo a causa di .reverse!

Spiegazione

Speravo fosse qualcosa di semplice come:

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

ma a causa della restrizione della caldaia / sfida è più lungo.

Ciò che s.reverse!è molto utile. s.reverse!è fondamentalmente s = s.reverse!, nel senso che muta anche s.

Di seguito viene descritto ciò che fa ogni sezione del programma:

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

La cosa interessante s.reverse!è che ogni volta che viene valutata la stringa viene capovolta. Così come sostituisce la stringa. sè modificato!

Perl, 24 byte

Include +2 per -lp

Dare input su STDIN:

rev.pl <<< Hello!

rev.pl:

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

Sorprendentemente questo non usa l' reverseoperatore incorporato . Quel nome è veramente lungo, tutte le soluzioni che mi reversevengono in mente sono almeno 1 byte più lunghe.

J, 13 8 byte

Risparmiato 5 byte grazie alle miglia!

#;@$];|.

Questo è un treno 5 con i seguenti verbi:

# ;@$ ] ; |.

La forcella interna è composta da ](identità), ;(collegamento) e |.(retro). Osservare:

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

I due verbi esterni formano il resto del treno. #è, in questo caso, la dimensione dell'argomento, ovvero la lunghezza. Il verbo che collega questi è ;@$, o ravelsopra reshape. Osservare:

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

Vecchia soluzione

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

Abbastanza semplice. |.è inverso ed ^:è congiunzione di potere, che ripete il verbo sinistro (mano destra) # volte. Quando l'argomento giusto è un verbo, quel verbo viene chiamato sull'argomento. Il verbo giusto in questo caso è range da zero ( i.) a length ( #). Se elevato a un array, i risultati intermedi vengono mantenuti. Tutto ciò che deve essere fatto è appiattire l'array con ,.

Risultati intermedi

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

9 byte grazie a Hedi e Huntro.

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

funzione ricorsiva.

L'inversione della stringa richiede quasi la metà della dimensione ( 25 22 byte!) ...
Perché non esiste un modo nativo per quello?

Minkolang , 17 byte:

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

Provalo qui!

Spiegazione

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

Assemblato, xxdscarico:

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

Elenco non assemblato:

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

Programma eseguibile DOS per PC autonomo. Stringa di input tramite riga di comando, l'output è console.

Pip , 11 10 byte

L#aORVRV:a

Provalo online!

Spiegazione:

            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 byte

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

Esempio:

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

Ancora più breve (credito a Damien):

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

s >> [s, reverse s] cicli ["abc", "cba", ...] che è zippato per correggere la dimensione e concatMap'ped con fst

Perl 6 ,  31  30 byte

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

Salvare un byte utilizzando in modo improprio .ords, che restituisce un elenco di ordinali, quindi trasformarlo implicitamente in un numero con cui creare un intervallo.

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

Spiegazione:

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

Uso:

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 sequenze di tasti

Non puoi mai avere troppe risposte Vim.

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

Spiegazione

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 byte

Spinge tutti gli elementi, combina alla fine.

td"tP]&h

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

Provalo online!

Vecchie versioni:

Approccio completamente diverso, basato su 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

Versione basata sull'inversione di una stringa di modello

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 byte

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

Questo è il mio primo tentativo di giocare a golf, quindi sono sicuro che ci sono innumerevoli miglioramenti.

Aggiornare:

Rimosso a golf 1 byte rimuovendo le parentesi.

Grazie all'anguria distruttibile per il suggerimento, rasato un byte.

Cubix , 52 byte

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

Su un cubo:

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

Questo è stato divertente; ci sono ancora byte da risolvere ma questo funzionerà sicuramente.

Provalo online!

spiegazione:

Ingresso di ABC

• /A: vai a nord e leggi tutti gli input come caratteri; -1sarà in fondo
• p\;.: rimuove il -1dalla pila
• u# : spingere la lunghezza della stringa (numero di oggetti in pila)
• \:\:qq : duplica due volte la lunghezza della stringa, spingi due copie in fondo alla pila

• ciclo continuo:

  • soq(?/<u : scambia la parte superiore dello stack, espandi la parte superiore dello stack come ASCII, spingi la parte superiore (lettera) verso il basso, diminuisci la parte superiore dello stack, gira a destra se non lo fai, quindi sposta IP nel posto giusto.
  • alla fine del ciclo, lo stack apparirà C B A 3 3 0

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

• B : pila inversa 3 3 A B C
• p( : sposta dal basso verso l'alto e diminuisce 3 A B C 2
• ?se top è zero, vai direttamente a @e termina
• altro
  • psq:uq : sposta dal basso verso l'alto, scambia dall'alto e sposta dall'alto verso il basso dup, e sposta dall'alto verso il basso 3 2 A B C 3
  • $u : Salta u
  • < ci riporta al ciclo.

Interprete

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

-1 grazie a ceilingcat

Vecchia versione

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

Provalo online!

Versione più corta (leggermente rotta)

Riffing sull'approccio a 76 byte solo da ASCII nei commenti e -1 byte dal suo tweak del mio tweak.

Modifica: questa versione è leggermente interrotta in quanto presuppone che ogni stringa sia preceduta da un byte NULL, che non è sempre vero. (Vedi l'ultimo caso di prova nel link). Ripristino della versione a 83 byte per ora.

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

Provalo online!

Java, 127 111 88 byte

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

Programma di test non golfato

    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 byte

Presuppone che l'input sia separato da spazio o newline per ciascun personaggio.

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

Alcuni casi di 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 byte

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

Non c'è un vero modo pulito per ottenere lunghezze di stringa o invertirle, quindi è piuttosto lungo.

Accetta input $a, loop da 1a $a.length(archiviati $xper l'uso in seguito). Ogni iterazione che usiamo con uno pseudo-ternario per indicizzare in un array di uno $ao $a[$x..0](cioè, invertito), in base al fatto che il nostro numero di input sia pari / dispari [$_%2]. Questi sono tutti incapsulati in parentesi e messi -joininsieme per formare una singola stringa. È rimasto sulla pipeline e l'output è implicito.

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

Java, 151 byte

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 byte

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

76 byte per il metodo + 18 byte per l'importazione LINQ.

Come funziona:

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 byte

l_,({_W%}*

Provalo online!

Spiegazione

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

Ottava, 39 35 byte

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

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

Spiegazione:

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

Salvati 4 byte grazie a Luis. ~xinvece di 0*xun byte salvato (funziona perché tutti gli elementi di x sono diversi da zero. flipInvece di flipudsalvare altri due byte (non sapevo flipesistesse).

bash + util-linux, 68 58 53 byte

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

Spiegazione

Due cose con il forloop:

• C'è un modo apparentemente non documentato di scrivere forcicli in cui si sostituiscono le parole chiave doe donecon parentesi graffe {e }. Lo spazio dopo la prima staffa sia necessario, e la virgola alla fine è anche necessario.
• Si scopre che nei forloop "C-style" , puoi semplicemente inizializzare i;invece di usare i=0;.
• La ${#1}parte della condizione si i < ${#1}riferisce alla lunghezza del nostro input (il primo parametro $1). In generale, è possibile utilizzare ${#foo}per recuperare la dimensione della stringa $foo.

Inoltre:

• rev è lo strumento in util-linux che inverte una stringa.
• Dobbiamo passare la -nbandiera per echosbarazzarci di newline.
• L'espressione rev<<<$yè chiamata stringa qui (vedere questa pagina tldp.org pertinente ), che passa la variabile $yall'input standard di rev.

Japt , 11 byte

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

Provalo online!

05AB1E , 7 byte

vDR}v}J

Provalo online!

Continuerà a lavorarci su. Non mi piace molto la parte "v}", probabilmente può salvare un byte lì.

Spiegazione

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