StringgnirtSStringgnirtSStringgnirtS

42

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

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

DJMcMayhem
la source
Dans votre exemple, ne devrait pas être que olleH, non elloH?
Arnaud
2
@ Downgoat Non, vous devez utiliser les entrées et les sorties dans le même format que celui décrit dans les spécifications.
DJMcMayhem
4
Le titre ne devrait-il pas être StringgnirtSStringgnirtSStringgnirtS ?
Luis Mendo
2
@carusocomputing Cela ne sera pas: "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."
Martin Ender
1
fr.wikipedia.org/wiki/ASCII#Printable_characters Ah, je ne savais pas que c'était un sous-ensemble bien défini d'ASCII. J'ai imaginé imprimable pour inclure \ t, \ n, etc ...
Urne Octopus magique

Réponses:

22

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

entrez la description de l'image ici

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!

DJMcMayhem
la source
2
Au lieu de :%s/\n<cr>, vous pouvez faire v{gJpour sauvegarder trois octets.
Lynn
2
Une réponse VIM?! C'est un geste chic de votre part.
Magic Octopus Urn
@ Lynn Merci pour le tuyau! J'ai fini par faire quelque chose de légèrement différent et j'ai pris 5 au lieu de cela.
DJMcMayhem
Cela suppose qu’il @qest vide au début, non? ou @qavant l'enregistrement arrêter ferait quelque chose d'arbitraire. (Cela m'amène à mon vim trivium préféré que je viens de citer: tout le monde sait que quitter vim est aussi simple que :q<CR>ça, mais comment pouvez-vous fermer et sauvegarder tous vos fichiers? Facile: juste qqqqqZZ@qq@q!)
wchargin
@wchargin Oui, cela nécessite @qd'être vide. Pourquoi ne pas simplement faire à la :wqaplace? Vous voulez aussi savoir comment générer une fractale dans vim? qqqqq<C-w>v<C-w>n@qq@q: D
DJMcMayhem
18

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.

Xnor
la source
Sensationnel. J'étais sur le point de soumettre une réponse en python de 56 octets, haha
DJMcMayhem
@DJMcMayhem, il bat également lambda s:(len(s)*(s+s[::-1]))[:len(s)**2]d'un octet.
Jonathan Allan
Je l'ai eu 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))])mais c'est 136 octets selon sys.sizeof, curieusement c'est la même taille quef = lambda s : ''.join([s[::1] if i%2 else s for i in range(len(s))])
Carel
12

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
  >)
 >)
}{}{}
Assistant de blé
la source
5
Incroyable. Tu m'épouvantes toujours avec ce que cette langue peut faire! : D
DJMcMayhem
10

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
milles
la source
1
la moisissure n'a pas besoin deL
Maltysen
@Maltysen wow merci, saviez-vous que du code source ou de l'expérience
miles
par expérience, je ne connais pas Jelly, mais j'ai un peu deviné que c'était ce que la moisissure ferait sur un non-numéro, étant donné que Jelly ne fait pas vraiment de surcharge, elle m'a aussi rappelé la
transformation
Mould ne prend en réalité que des iterables, mais il lance en premier les entiers.
Dennis
1
Oui, j’ai traité la moisissure comme un remodelage, c’est pourquoi je lui ai habituellement attribué un numéro. Il y a tellement de petits plaisirs soignés dans Jelly, comme par exemple la façon dont un tableau de chaînes est automatiquement généré sous forme de chaîne concaténée
miles
9

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);
Crypto
la source
J'ai complètement oublié str_pad. joli!
Titus
8

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!

Adnan
la source
6

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é!

Downgoat
la source
Avec le -pdrapeau, vous pouvez économiser 4 octets:$_.reverse!;gsub(/./){$_.reverse!}
Jordanie
@Jordan would't je besoin d' un .chompbien sur la $_? il semble inclure la nouvelle ligne pour le moment
Downgoat
Pas si vous faites quelque chose comme ruby -pe '$_.reverse!;gsub(/./){$_.reverse!}' < file.txtfile.txtest une ligne sans la nouvelle ligne: V Quoi qu'il en soit, si vous décidez de ne pas le faire, vous n'avez pas besoin de parens sur le lambda, donc ça ->smarche
Value Ink
@ValueInk, vous pouvez fournir une entrée sans nouvelle ligne sans fichier si vous la dirigez. Ou vous pouvez même le saisir manuellement, sans appuyer sur Entrée: i.stack.imgur.com/6luxM.png
manatwork
1
Vous n'avez pas besoin de parenthèses autour de l'argument du lambda. De plus, je pense que vous pouvez vous débarrasser de l'un des points d'exclamation:s.gsub(/./){s.reverse!.reverse}
m-chrzan
6

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.

Ton Hospel
la source
Levée de vote pour avoir trouvé une solution prenant moins d'octets qu'une solution intégrée
MilkyWay90
6

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
Conor O'Brien
la source
Vous pouvez économiser un octet en boxant la longueur<@#
miles
Une solution élégante de 8 octets est celle #;@$];|.qui encadre l'initiale et l'inverse, remodèle les cordes encadrées et les rase ensemble
miles le
@ Miles Whoa, c'est plutôt chouette.
Conor O'Brien
5

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?

Titus
la source
1
Vous pourriez utiliser au s[n]?...lieu den<s.length?...
Hedi
1
Vous pouvez également économiser 3 octets en utilisant à la [...s]place des.split``
Huntro
oui 36 octets idéalementf=(s,n=1)=>n==1?s:s+s.reverse(),n-1)
mardi
non récursif f=(s,n=1)=>Array.from({length:n},(_,i)=>i%2?s.reverse():s).join``)qui serait aussi meilleur avec une meilleure fonction pour la plage
caub
@caub: SyntaxError: Unexpected token )JS n'a pas de retour de chaîne natif. SyntaxError: Invalid or unexpected tokenpour votre deuxième suggestion. Dans quel navigateur cela fonctionne-t-il?
Titus
4

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.
El'endia Starman
la source
4

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.

entrez la description de l'image ici

640 Ko
la source
3

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)
DLosc
la source
3

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

michi7x7
la source
2
q s=zip(s>>[s,reverse s])s>>=fst
Damien
3
Ou Pointfree avec la même taille:(>>=fst).(iterate reverse>>=zip)
Damien
3

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
Brad Gilbert b2gills
la source
3

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
Jordan
la source
1
Avec coreutils? C'est de la triche! : P
Christian Rondeau
3

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
Sanchises
la source
J'aime l'utilisation intelligente de td!
DJMcMayhem
@DJMcMayhem Merci! J'avais d' tnq:"abord une évidence , mais tn:"c'est un peu une odeur de code (voir cette astuce de golf Matlab), alors j'ai pensé que cela tnq:pourrait être plus compact, aussi.
Sanchises
3

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.

Lui-meme12794
la source
Je ne sais pas scala, mais pouvez-vous changer i%2==1pour i%2>0?
Citron destructible
@DestructibleWatermelon n'avait pas pensé à ça, oui je peux
Lui-
3

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

Giuseppe
la source
Voici un 24 octets . Même logique générale juste comprimée un peu.
MickyT
@MickyT Je me sentirais mal de prendre un crédit pour 28 octets de golf. Postez-le vous-même!
Giuseppe
3

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!

gastropner
la source
67
ASCII uniquement
@ ASCII-only 68 est possible avec quelques ajustements.
gastropner
: P c'est 67 maintenant lol @gastropner
ASCII seulement
@ ASCII uniquement 66 :-P
gastropner
@ ASCII-only Malheureusement, la version courte ne fonctionne pas dans certains cas.
gastropner
2

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!", ""));
}
Shaun Wild
la source
Cela peut être joué un peu plus: (s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?s:new StringBuffer(s).reverse();return r;};( 88 octets ). De plus, je préciserais qu'il s'agit de Java 8.
Kevin Cruijssen
Na, il est bon de supposer qu'il utilise la dernière version de Java.
Shaun Wild
@KevinCruijssen Java 7 n'est plus supporté (sauf avec de gros $$$). Nous ne devrions pas avoir à spécifier la version de Java. De plus, si vous écrivez en tant que Java 7, la plupart des réponses peuvent être écrites en Java 1.1 ou 1.2. Alors ne devriez-vous pas écrire la version la plus basse avec laquelle cela fonctionne? Si le code dans cette réponse était conforme à Java 7, il serait conforme à Java 1.2, et ... fonctionnerait toujours en Java 8.
Olivier Grégoire
2

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
tourbull
la source
2

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
AdmBorkBork
la source
2

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

Herb Wolfe
la source
1
Bonjour, bienvenue sur PPCG! Tout d’abord, je voudrais recommander de lire des conseils pour jouer au golf en Java . En ce qui concerne votre code, certaines choses peuvent encore être jouées: Vous pouvez supprimer le code public staticavant votre méthode. Vous pouvez supprimer les espaces entre t=new StringBuffer. Vous pouvez supprimer les parenthèses inutiles et les crochets. Et vous pouvez échanger la vérification du module de ==1à <1(ce qui équivaut à ==0des nombres non négatifs). En outre, vous pouvez déplacer le i++jusqu'à la dernière utilisation dans la boucle for.
Kevin Cruijssen
6
Donc, au total, cela devient: void r(String s){for(int i=0;i<s.length();)System.out.print(i++%2<1?s:new StringBuffer(s).reverse()+"");}( 105 octets )
Kevin Cruijssen le
2

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
        )
    )
;
Lait
la source
2

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
Luis Mendo
la source
2

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

Stewie Griffin
la source
2

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.
cadres
la source
S'il vous plaît expliquer certaines de vos connaissances. Aussi peut-être que l'espace avant l'écho peut être amovible, je ne suis pas au courant sur bash cependant
Rohan Jhunjhunwala
@RohanJhunjhunwala Ajout d'une petite explication à la réponse pour peut-être aider à clarifier certaines choses. En outre: lorsque l' omission de la doet des donemots - clés dans une forboucle, vous avez réellement ne besoin que l' espace!
Cadres
+1 semble bon maintenant. J'ai seulement commenté parce que votre code a dessiné un drapeau automatique de faible qualité. Les réponses ne contenant que du code sont automatiquement signalées
Rohan Jhunjhunwala
y=$1;for((;i<${#1};i++)){ printf $y;y=`rev<<<$y`;}... enregistré quelques octets
roblogic
2

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!

Lente
la source
@Shaggy, j'ai essayé de l'utiliser, mais pour ma vie, je n'arrive pas à comprendre. : P Merci beaucoup pour l'exemple, cependant!
Nit
Désolé, le mauvais lien a été posté, il s'agit en fait de 6 octets .
Shaggy
1
@ Shaggy, ça ne me dérangerait pas, et c'est assez différent de la réponse de Nit. Allez-y mec.
Oliver
2

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
Multi
la source
1
vÂ}\J 5 octets est identique à votre code, mais avec les éléments intégrés que vous recherchiez. :)Âest Bifurcate (abréviation de Duplicate & Reverse, qui correspond exactement à ce que vous faites). \ supprime le premier élément de la pile.
Kevin Cruijssen