Réflexion de chaîne simple

26

Commençons par définir le reflet d'un caractère dans une chaîne:

Étant donné une chaîne avec des lettres alphabétiques minuscules distinctes sans espaces tels que abcdefg, définissez le reflet d'une lettre dans la chaîne ccomme la déplaçant (sans changer l'ordre d'une autre lettre) vers un nouvel emplacement dans la chaîne tel que le nombre de lettres à l'origine à sa droite se trouve maintenant le nombre de lettres à sa gauche.

Ainsi, un reflet de la lettre cen abcdefgserait abdecfg. Explication: il y avait 4 lettres à droite de cet maintenant, il y a 4 lettres à gauche de c.

Quelques exemples supplémentaires:

Compte tenu du caractère een myfriendformerait la chaînemyefrind

Compte tenu du caractère aen axyzformerait la chaîne xyza.

Compte tenu du caractère ben abcformerait la chaîne abc.

Compte tenu du caractère den dformerait la chaîne d.

Compte tenu du caractère een efformerait la chaîne fe.

Pour plus d'informations ou pour essayer quelques cas de test, voici un programme (un peu long) que j'ai écrit en C ++.

Le défi

Étant donné une chaîne avec des lettres minuscules distinctes, parcourez chaque caractère par ordre alphabétique et "réfléchissez" la chaîne.

Précisions: les lettres de la chaîne proviennent de a-z, il n'y a pas d'espaces, les lettres sont uniques et la chaîne a au moins 1 lettre et au plus 26 lettres.

Exemples

Entrée: dcba. Sortie: dcba.

Raison: Tout d'abord, reflétez le acar c'est le caractère de la chaîne qui apparaît le plus tôt dans l'alphabet. Vous obtiendrez adcb. Ensuite, reflétez le bcomme il vient ensuite dans l'alphabet, pour obtenir badc. Ensuite, réfléchissez à cpour obtenir cbad, puis à dpour obtenir dcba.

Entrée: myface. Sortie: fyecma.

Astuce: Parcourez les lettres dans l'ordre a, c, e, f, m, y.

Entrée: a. Sortie: a.

Entrée: acb. Sortie: bac.

Entrée: cwmfjordbankglyphsvextquiz. Sortie: ieabhqzugdltkfnvpjxsormycw.

Notation

  • L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
  • Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
  • Les failles standard sont interdites.
  • Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.
  • Accepter ~ 100 heures après la publication.

Gagnant actuel

Afficher l'extrait de code

code-golf string NL628
la source
2
Quelqu'un pourrait-il me dire si ce puzzle va bien? C'est mon deuxième ici (mon premier a été fermé comme hors sujet ... whoops). J'ai essayé de le rendre vraiment complet, mais je ne sais pas si je manque quelque chose. J'aimerais vraiment m'améliorer et m'amuser sur cette SE! Merci les gars: D
NL628
6
Cela semble bon. Je pourrais donner quelques exemples plus longs (en particulier, il pourrait être bon que la première section d'exemples présente plus que ce qui sont des cas apparemment marginaux).
Esolanging Fruit
1
Demande de clarification: " les lettres sont uniques " signifie que chaque lettre n'apparaît qu'une seule fois en entrée, est-ce exact?
GPS
4
Pouvons-nous prendre l'entrée et la sortie en majuscules au lieu de minuscules?
Kevin Cruijssen
5
@ NL628 Soit dit en passant, si vous voulez avoir un aperçu d'un défi avant de le publier ici, postez-le dans le bac à sable .
Erik the Outgolfer

Réponses:

8

Brain-Flak , 188 octets

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

Essayez-le en ligne!

En plus des réflexions décrites dans la spécification de défi, ce code inverse également la chaîne exactement 26 fois. Cela n'a aucun effet sur la sortie finale.

# Push 26
<>((((()()()){}){}()){})

# Do 26 times:
{(({}[()])<

  # Subtract 122 from counter to get negative lowercase letter
  ({}[(((((()()()()()){}){}){})()){}{}])

  # For each character in string:
  <>{

    # Keep a copy of pivot letter on the third stack
    <>(({})<

    # Move next letter to other stack and compare to pivot
    ({}<>({}<>))

    # If letters are equal:
    ((){[()](<{}>)}{}){

      # Keep current letter separate from this transformation
      {}(<({}<

      # While keeping a copy of current stack height:
      ([]<

        # Move all letters to one stack
        <>{({}<>)<>}<>

      >)

      # Move a number of letters equal to old stack height back
      {({}[()]<({}<>)<>>)}{}

      >)>)

    }{}>)<>

  }

  # Destroy pivot letter
  <>{}<>

>)}

# Switch stack for output
<>
Nitrodon
la source
1
Wow, c'est assez étonnant. Je ne peux même pas le comprendre: O +1
NL628
7

05AB1E , 20 17 octets

{vð.øy¡€á€gsJ£yý

Essayez-le en ligne!

Explication

Avec un exemple pour la première itération de myface

{v                  # for each char y in sorted input
  ð.ø               # surround current string with spaces
                    # STACK: ' myface '
     y¡             # split at current letter
                    # STACK: [' myf', 'ce ']
       ۇ           # remove non-letters
                    # STACK: ['myf','ce']
         €g        # get the length of each string in the pair, reversed
                    # STACK: ['myf','ce'], [2,3]
            sJ      # join the pair back to a string
              £     # split into 2 pieces of the calculated sizes
                    # STACK: ['my','fce']
               yý   # join on the current char y
                    # STACK: 'myafce'

La chaîne est entourée d'espaces à chaque itération car le fractionnement sur la première ou la dernière lettre de la chaîne entraînerait sinon une liste de longueur 1 et la fusion n'inclurait pas cette lettre.

Emigna
la source
1
17 octets?! ?? !! AMAZING..yet mnemonic vous bat d'un seul octet: P
NL628
1
Mmmm ... Wow, la seule chose que j'ai pu voir est de supprimer le surround avec des espaces. Semble étrange, nous ne pouvons pas trouver une autre alternative à cela.
Magic Octopus Urn
1
@MagicOctopusUrn: C'est le moyen le plus court que j'ai trouvé pour gérer une division du premier ou du dernier caractère. Cela ressemble à beaucoup d'octets juste pour cela
Emigna
5

Pyth, 18 16 19 16 octets

VSQ=QXx_QN-QNN)Q

Essayez-le ici

Explication

VSQ=QXx_QN-QNN)Q
VSQ           )       For each character (N) in the sorted input (Q)...
          -QN         ... remove the character from Q...
      x_QN            ... get the reflected position...
     X       N        ... insert N...
   =Q                 ... and save the result into Q.
               Q      Output the final result.

la source
Wow 16 octets? Je voterais favorablement, mais malheureusement, j'ai atteint ma limite de vote quotidienne.
Fera
4

Python 3 , 80 73 octets

Merci à Esolanging Fruit de m'avoir rappelé que les fonctions peuvent revenir en modifiant leur argument. 

lambda x:[x.insert(len(x)+~x.index(i),x.remove(i)or i)for i in sorted(x)]

Essayez-le en ligne!

Prend la saisie sous forme de liste de caractères.

Jo King
la source
3
Wow, j'ai aussi écrit une réponse en C ++ et Python 3. Ma réponse Python 3 était exactement deux fois plus longue que la vôtre ... +1
NL628
3

Retina 0.8.2 , 61 octets

$
a
{`(.)(.*)\1$
$2$.`$*_$1$1
+`(.)_(_*.)
$2$1
}T`_l`l!`.$
!

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

$
a

Commencez la boucle à a.

{`(.)(.*)\1$
$2$.`$*_$1$1

Si l'entrée contient la lettre actuelle, déplacez-la à la fin, avec une chaîne de _s représentant sa position d'origine.

+`(.)_(_*.)
$2$1

Pour chaque _mouvement, la lettre recule d'un caractère.

}T`_l`l!`.$

Incrémentez la lettre. Après l'avoir zchangé en a !pour qu'il ne corresponde à rien et la boucle se termine.

!

Supprimez le !.

Neil
la source
3

Java 8, 140 96 92 88 87 85 octets

s->{for(char c=9;++c>0;){int i=s.indexOf(c);if(i>=0)s.add(s.size()+~i,s.remove(i));}}

-44 octets créant un port de réponse Python 2 @TFeld .
-6 octets grâce à @ OlivierGrégoire .

Modifie la liste d'entrée au lieu d'en créer une nouvelle.

Explication:

Essayez-le en ligne.

s->{                     // Method with ArrayList<Character> parameter and no return-type
  for(char c=9;++c>0;){  //  Loop over all characters known
                         //  (except for the first 9 unprintables)
    int i=s.indexOf(c);  //   Index of the character, or -1 of it isn't present
    if(i>=0)             //   If the current character is present in the List
      s.add(s.size()+~i,s.remove(i));}}
                         //    Change the position of this character to index `l-i-1`,
                         //    (where `l` is the size of the input-List)
Kevin Cruijssen
la source
1
s->{for(char c=96;++c<123;){int i=s.indexOf(c);if(i>=0)s.add(s.size()+~i,s.remove(i));}}
Olivier Grégoire
1
@ OlivierGrégoire Merci. Et 1 boucle supplémentaire sur plus que les seuls caractères de l'alphabet. :)
Kevin Cruijssen
2
Eh bien, si vous allez sur cette route, for(char c=9;++c>1;)c'est mieux ;-)
Olivier Grégoire
@ OlivierGrégoire Ah bien sûr, chars'enroule aussi comme Integer.MAX_VALUE + 1 == Integer.MIN_VALUE.. Smart!
Kevin Cruijssen
@ OlivierGrégoire sest un ArrayList, il indexOfsera donc de type générique T(qui est Characterpour cette liste d'entrée).
Kevin Cruijssen
3

JavaScript, 85 80 79 octets

-6 octets grâce à @DanielIndie

a=>[...a].sort().map(i=>a.splice(s=a.indexOf(i),1)&&a.splice(a.length-s,0,i))&&a

Essayez-le en ligne!

Esolanging Fruit
la source
cela ne "compile" pas une chaîne et vous utilisez une épissure
DanielIndie
@DanielIndie L'entrée doit être passée sous forme de tableau de caractères, tout comme la solution Python de Jo King.
Esolanging Fruit
80 octets
DanielIndie
vous ne retournez rien de cette fonction, ou ne l'imprimez pas
DanielIndie
@DanielIndie Les fonctions peuvent revenir en modifiant leurs arguments.
Esolanging Fruit
2

Rubis , 51 octets

->s{s.sort.map{|c|s.insert~s.index(c),s.delete(c)}}

Essayez-le en ligne!

Prend un tableau de caractères

Renvoie en modifiant l'entrée

Asone Tuhid
la source
2

Rouge , 96 94 octets

2 octets économisés grâce à Kevin Cruijssen 

func[x][foreach c sort copy x[i:(length? x)+ 1 - index? find x c insert at replace x c""i c]x]

Essayez-le en ligne!

Plus lisible:

f: func[x][
    foreach c sort copy x[                  ; for each symbol in the sorted input
       i: (length? x) + 1 - index? find x c ; find its index and reflect it 
       insert at replace x c "" i c         ; remove it by replacing it with an empty char 
                                            ; and insert the symbol at its new index   
    ]
    x                                       ; return the transformed string
]
Galen Ivanov
la source
1
Vous pouvez économiser 2 octets en changeant find x c replace x c""insert at x i cpour find x c insert at replace x c""i csupprimer un xespace et.
Kevin Cruijssen
@Kevin Cruijssen Merci, Kevin, c'est beaucoup mieux maintenant!
Galen Ivanov
2

R , 73 72 69 octets

function(s){for(x in sort(s))s=append(s[x!=s],x,match(x,rev(s))-1);s}

Essayez-le en ligne!

Entre et sort un vecteur de caractères.

Kirill L.
la source
ew, en utilisant ccomme nom de variable? c'est affreux, même pour le golf de code!
Giuseppe
Eh bien, je peux évidemment le changer, mais je suis vraiment surpris de voir que cela pourrait déranger quiconque ici. En fait, j'ai tendance à donner la priorité à la préservation d'un certain sens dans les noms de variables (comme cpour char) plutôt que dans les intégrés intégrés.
Kirill L.
eh bien, quand je cherchais une amélioration (ce que je n'ai pas fait), je me suis retrouvé à essayer d'utiliser c, et c'était horrible quand je ne pouvais pas comprendre ce qui se passait. J'utilise généralement Kou kou même Cjuste pour éviter des problèmes comme ça, mais je comprends parfaitement. appendest sans aucun doute le bon outil pour le travail.
Giuseppe
Oh, je vois, désolé, j'essaierai d'éviter de mettre de tels "pièges" à l'avenir.
Kirill L.
2

Perl 5 -p , 37 octets

#!/usr/bin/perl -p
for$a(a..z){s/$a//&&s/.{@{-}}$/$a$&/}

Essayez-le en ligne!

Ton Hospel
la source
2

Japt , 23 22 octets

¬n rÈ+S kY iYJ-XbY)x}U
¬n                     // Split the input into chars and sort it.
   r                }U // Then reduce the result with initial value of the input.
    È+S                // Append a space for replacing edge cases and
        kY             // remove the current char from the string.
           iY          // Insert it back
             J-XbY     // at the calculated index,
                  )x   // and remove the unnecessary space once we're done.

Enregistré un octet grâce à Oliver .
Essayez-le en ligne!

Lente
la source
1
Joli. Vous pouvez remplacer ,ÉparJ
Oliver
@Oliver Merci beaucoup, j'oublie toujours d'utiliser les variables par défaut de temps en temps, c'est très pratique.
Nit
1

Haskell, 87 octets

s#c|(h,_:t)<-span(/=c)s,(v,w)<-splitAt(length t)$h++t=v++c:w|1<2=s
f s=foldl(#)s['a'..]

Essayez-le en ligne!

f s=foldl(#)s['a'..]         -- fold the function '#' into all characters from 'a'
                              -- with the starting value of the input string s
s#c=                          -- in each step (s: result so far, c: next char)
   (h,_:t)<-span(/=c)s        -- let 'h' be the substring before 'c' and
                              -- 't' the substring after 'c'. the pattern match
                              -- fails if there's no 'c' in 's'
   (v,w)<-splitAt(length t)$h++t
                              -- split the string 'h++t' at index length of t
   =v++c:w                    -- return 'v' followed by 'c' followed by 'w'
   |1<2=s                     -- if there's no 'c' in 's', return 's' unchanged
nimi
la source
Pourquoi cela s'arrête-t-il? Le pliage d'une liste infinie ne devrait-il pas provoquer une boucle infinie? N'est-ce pas f s=foldl(#)s['a'..'z']?
user1472751
1
@ user1472751: ['a'..]n'est pas infini, car Charappartient à la classe Bounded. Une liste ..]de Boundedvaleurs s'arrête à maxBound. Essayez: print [False ..].
nimi
1

SNOBOL4 (CSNOBOL4) , 132 128 octets

	DEFINE('I(I)')
I	U =&LCASE
N	U LEN(1) . K REM . U	:F(RETURN)
	I ARB @S K	:F(N)
	I K =
	I ARB . L RPOS(S) REM . R
	I =L K R	:(N)

Essayez-le en ligne!

Implémentation simple de l'algorithme requis. Enregistré quelques octets en passant à une fonction plutôt qu'à un programme complet; l'explication reste plus ou moins la même.

	I =INPUT			;* read input
	U =&LCASE			;* alias for lowercase letters (it started out as uppercase)
N	U LEN(1) . K REM . U	:F(O)	;* set K to the next lowercase letter, and when empty, goto O
	I ARB @S K	:F(N)		;* set S to the number of letters before K, or goto N
	I K =				;* remove K
	I ARB . L RPOS(S) REM . R	;* set R to the last S characters of I and L to the others
	I =L K R	:(N)		;* recombine the string and goto N
O	OUTPUT =I			;* print new string
END
Giuseppe
la source
1

Gelée ,  12  11 octets

W;ṢḟṁUṣ¥jʋ/

Un lien monadique acceptant une liste de caractères et renvoyant une liste de caractères.

Essayez-le en ligne!

Comment?

W;ṢḟṁUṣ¥jʋ/ - Link: list of characters V  e.g. "myface"  ...i.e. ['m','y','f','a','c','e']
W           - wrap V in a list                 ["myface"]
  Ṣ         - sort V                           ['a','c','e','f','m','y']
 ;          - concatenate                      ["myface",'a','c','e','f','m','y']
          / - reduce with:
         ʋ  -   last four links as a dyad:
            -   (i.e. start with "myface" on the left and 'a' on the right 
            -         2nd iteration has that result on the left and 'c' on the right
            -         and so-forth)            e.g. left = myface, right = 'a'
   ḟ        -     filter out (right from left)      "myfce"
       ¥    -     last two links as a dyad:
     U      -       upend left                      "ecafym"
      ṣ     -       split at occurrences of right   ["ec","fym"]
    ṁ       -     mould (ḟ(x,y)) like (Uṣ¥(x,y))    ["my","fce"] 
         j  -   join with right                   "myafce"
Jonathan Allan
la source
Ok bien celui-ci détruit à peu près tout le reste ...
NL628
1
Eh bien, je pense que c'est à ça que sert Jelly - je m'attends à moitié à ce que Dennis (le créateur de Jelly) en soumette un plus court!
Jonathan Allan
Lol c'est assez étonnant: P mais je ne peux pas voter contre b / c J'ai utilisé mon décompte quotidien des votes..rip
NL628
1
... Je pense qu'il peut y avoir un moyen de sauvegarder un octet en utilisant ḟ(filtrer) mais je ne l'ai pas encore réussi.
Jonathan Allan
1
ressemble, dans le temps, à O (n log n) dans la longueur de l'entrée, car il utilise d'abord Python sortedet parcourt ensuite n itérations de ce qui semble être des opérations moins complexes (aplatissement, fractionnement aux indices trouvés, jointure, inversion ). - et Python sortedest O (n log n).
Jonathan Allan
1

C (clang) , 164 162 octets

y,n,a,b,c,p,i;f(char*s,l){for(i=0;p=0,++i<123;p<l&&(y=s[p],n=l+~p,a=p+1,b=p,n<p&&(a=n,b=n+1),c=l+~(2*(n<p?n:p)),memmove(s+b,s+a,c),s[n]=y))while(s[p]^i&&p<l)p++;}

Essayez-le en ligne!

f() prend en charge le tableau de caractères contenant la chaîne d'entrée et la longueur de ce tableau et effectue les réflexions requises en place.

callf() fait de jolies impressions.

Crédits

-2 octets. @Kevin. Merci

GPS
la source
1
Vous pouvez supprimer l'espace à char *set le changement i=96à i=9d'économiser 2 octets.
Kevin Cruijssen
Bonne prise .. nous n'avons pas besoin de commencer a. Merci
GPS
144 octets
Plafond
1

APL + WIN, 63 octets

Demande la chaîne d'entrée

l←s[⍋⎕av⍳s←,⎕]⋄⍎∊(⍴s)⍴⊂'s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l⋄l←1↓l⋄'⋄s

Explication:

l←s[⍋⎕av⍳s←,⎕] sort characters into alphabetical order

⍎∊(⍴s)⍴⊂'....' create an implicit loop for each character

s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l do the relection for first character in l

l←1↓l drop the first character in l

s display the result

⋄ statement separator
Graham
la source
1

Perl , 74 70 octets

84 80 octets, y compris l'invocation en tant que filtre Unix

for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}

$ echo -e 'dcba\nmyface\na\nacb\ncwmfjordbankglyphsvextquiz' |
> perl -pE'for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}'
dcba
fyecma
a
bac
ieabhqzugdltkfnvpjxsormycw
Hynek -Pichi- Vychodil
la source