Reflexión de cuerda simple

26

Comencemos definiendo un reflejo de un personaje en una cadena:

Dada una cadena con letras alfabéticas en minúsculas distintas sin espacios como abcdefg, defina un reflejo de una letra en la cadena ccomo moviéndola (sin cambiar el orden de ninguna otra letra) a un nuevo lugar en la cadena de manera que el número de letras originalmente a la derecha está el número de letras a la izquierda.

Por lo tanto, un reflejo de la letra cen abcdefgsería abdecfg. Explicación: había 4 letras a la derecha de cy ahora, hay 4 letras a la izquierda de c.

Algunos ejemplos más:

Reflejar el carácter een myfriendformaría la cadenamyefrind

Reflejar el carácter aen axyzformaría la cadena xyza.

Reflejar el carácter ben abcformaría la cadena abc.

Reflejar el carácter den dformaría la cadena d.

Reflejar el carácter een efformaría la cadena fe.

Para obtener más información o probar algunos casos de prueba, aquí hay un programa (algo largo) que escribí en C ++.

El reto

Dada una cadena con letras minúsculas distintas, revise cada carácter alfabéticamente y "refleje" en la cadena.

Aclaraciones: las letras de la cadena son de a-z, no hay espacios, las letras son únicas y la cadena tiene al menos 1 letra de largo y como máximo 26 letras de largo.

Ejemplos

Entrada: dcba. Salida: dcba.

Motivo: Primero, refleje el acarácter de la cadena que aparece más temprano en el alfabeto. Lo conseguirás adcb. Luego, refleje bcomo viene a continuación en el alfabeto, para obtener badc. Luego, refleje el cpara obtener cbad, y luego el dpara obtener dcba.

Entrada: myface. Salida: fyecma.

Sugerencia: revisa las letras en el orden a, c, e, f, m, y.

Entrada: a. Salida: a.

Entrada: acb. Salida: bac.

Entrada: cwmfjordbankglyphsvextquiz. Salida: ieabhqzugdltkfnvpjxsormycw.

Tanteo

  • La entrada y salida se pueden dar por cualquier método conveniente .
  • Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
  • Las lagunas estándar están prohibidas.
  • Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).
  • Aceptando ~ 100 horas después de la publicación.

Ganador actual

Mostrar fragmento de código

code-golf string NL628
fuente
2
¿Alguien podría darme una idea de si este rompecabezas está bien? Es mi segundo aquí (el primero fue cerrado como fuera de tema ... whoops). Traté de hacerlo realmente completo, pero no estoy seguro de si me falta algo. ¡Realmente me gustaría mejorar y divertirme en este SE! Gracias chicos: D
NL628
66
Esto luce bien. Podría dar algunos ejemplos más largos (en particular, podría ser bueno que la primera sección de ejemplos presente más de lo que aparentemente son casos extremos).
Esolanging Fruit
1
Solicitud de aclaración: " las letras son únicas " significa que cada letra aparece solo una vez en la entrada, ¿es correcto?
GPS
44
¿Podemos tomar la entrada y salida en mayúsculas en lugar de minúsculas?
Kevin Cruijssen
55
@ NL628 Por cierto, si desea obtener información sobre un desafío antes de publicarlo aquí, publíquelo en el Sandbox .
Erik the Outgolfer

Respuestas:

8

Brain-Flak , 188 bytes

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

Pruébalo en línea!

Además de las reflexiones descritas en la especificación de desafío, este código también invierte la cadena exactamente 26 veces. Esto no tiene ningún efecto en el resultado final.

# 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
fuente
1
Wow, eso es bastante asombroso. Ni siquiera puedo entenderlo: O +1
NL628
7

05AB1E , 20 17 bytes

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

Pruébalo en línea!

Explicación

Con ejemplo para la primera iteración 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 cadena está rodeada de espacios en cada iteración, ya que la división en la primera o última letra de la cadena daría como resultado una lista de longitud 1 de lo contrario y la fusión no incluiría esa letra.

Emigna
fuente
1
17 bytes?! ?? !! INCREÍBLE ... aún mnemónico te está ganando por un solo byte: P
NL628
1
Mmmm ... Wow, lo único que pude ver es quitar el entorno con espacios Parece extraño que no podamos encontrar otra alternativa a eso.
Urna mágica de pulpo
1
@MagicOctopusUrn: es la forma más corta que he encontrado de manejar una división del primer o último personaje. Sin embargo, parece una gran cantidad de bytes solo para eso
Emigna el
5

Pyth, 18 16 19 16 bytes

VSQ=QXx_QN-QNN)Q

Pruébalo aquí

Explicación

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.

fuente
Wow 16 bytes? Votaría, pero lamentablemente he alcanzado mi límite diario de votación. Lo haré en 6 horas: P
NL628
4

Python 3 , 80 73 bytes

Gracias a Esolanging Fruit por recordarme que las funciones pueden regresar modificando su argumento. 

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

Pruébalo en línea!

Toma la entrada como una lista de caracteres.

Jo King
fuente
3
Wow, también escribí una respuesta en C ++ y Python 3. Mi respuesta de Python 3 fue exactamente el doble que la suya ... +1
NL628
3

Retina 0.8.2 , 61 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

$
a

Comience el ciclo a las a.

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

Si la entrada contiene la letra actual, muévala al final, con una cadena de _s que represente su posición original.

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

Por cada _movimiento, la letra retrocede un carácter.

}T`_l`l!`.$

Incrementa la letra. Después de zcambiarlo a a !para que no coincida con nada y el ciclo termina.

!

Eliminar el !.

Neil
fuente
3

Java 8, 140 96 92 88 87 85 bytes

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

-44 bytes creando un puerto de respuesta de Python 2 de @TFeld .
-6 bytes gracias a @ OlivierGrégoire .

Modifica la lista de entrada en lugar de crear una nueva.

Explicación:

Pruébalo en línea.

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
fuente
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 Gracias. Y 1 más recorriendo más que solo los caracteres del alfabeto. :)
Kevin Cruijssen
2
Bueno, si vas por ese camino, for(char c=9;++c>1;)es mejor ;-)
Olivier Grégoire
@ OlivierGrégoire Ah, por supuesto, chartambién se envuelve como Integer.MAX_VALUE + 1 == Integer.MIN_VALUE.. ¡Inteligente!
Kevin Cruijssen
@ OlivierGrégoire ses una ArrayList, por indexOflo que será de tipo genérico T(que es Characterpara esta lista de entrada).
Kevin Cruijssen
3

JavaScript, 85 80 79 bytes

-6 bytes gracias a @DanielIndie

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

Pruébalo en línea!

Fruta Esolanging
fuente
esto no "compila" a es una cadena y usa empalme
DanielIndie
@DanielIndie La entrada se debe pasar como una matriz de caracteres, al igual que la solución Python de Jo King.
Esolanging Fruit
80 bytes
DanielIndie
no devuelve nada de esa función, ni lo imprime
DanielIndie
@DanielIndie Las funciones pueden regresar modificando sus argumentos.
Esolanging Fruit
2

Ruby , 51 bytes

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

Pruébalo en línea!

Toma una variedad de caracteres

Devuelve modificando la entrada

Asone Tuhid
fuente
2

Rojo , 96 94 bytes

2 bytes guardados gracias a 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]

Pruébalo en línea!

Más legible:

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
fuente
1
Puede guardar 2 bytes cambiando find x c replace x c""insert at x i ca find x c insert at replace x c""i cpara deshacerse de un xy espacio.
Kevin Cruijssen
@Kevin Cruijssen Gracias, Kevin, ¡ahora está mucho mejor!
Galen Ivanov
2

R , 73 72 69 bytes

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

Pruébalo en línea!

Entradas y salidas de un vector de caracteres.

Kirill L.
fuente
ew, utilizando ccomo nombre de variable? eso es horrible, incluso para el golf de código!
Giuseppe
Bueno, obviamente puedo cambiarlo, pero estoy realmente sorprendido de ver que podría molestar a cualquiera aquí. De hecho, tiendo a dar prioridad a preservar algo de sentido en los nombres de variables (como cfor char) en lugar de los elementos integrados no utilizados.
Kirill L.
bueno, cuando buscaba una mejora (que no lo hice) me encontré tratando de usar c, y fue horrible cuando no pude entender lo que estaba sucediendo. Normalmente uso Ko kincluso Csolo para evitar problemas como ese, pero lo entiendo totalmente. appendDefinitivamente es la herramienta adecuada para el trabajo.
Giuseppe
Ah, ya veo, lo siento, trataré de evitar establecer tales "trampas" en el futuro.
Kirill L.
2

Japt , 23 22 bytes

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

Guardado un byte gracias a Oliver .
Pruébalo en línea!

Liendre
fuente
1
Buena esa. Puede reemplazar ,ÉconJ
Oliver
@ Oliver Muchas gracias, todavía me olvido de usar las variables predeterminadas de vez en cuando, eso es muy útil.
Nit
1

Haskell, 87 bytes

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'..]

Pruébalo en línea!

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
fuente
¿Por qué se detiene esto? ¿No debería doblarse sobre una lista infinita causar un bucle infinito? ¿No debería ser f s=foldl(#)s['a'..'z']?
user1472751
1
@ user1472751: ['a'..]no es infinito, porque Charpertenece a la clase Bounded. Una lista con ..]de Boundedvalores se detiene en maxBound. Proveedores: print [False ..].
nimi
1

SNOBOL4 (CSNOBOL4) , 132 128 bytes

	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)

Pruébalo en línea!

Implementación directa del algoritmo requerido. Ahorró unos pocos bytes al cambiar a una función en lugar de un programa completo; La explicación sigue siendo la misma, más o menos.

	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
fuente
1

Jalea ,  12  11 bytes

W;ṢḟṁUṣ¥jʋ/

Un enlace monádico que acepta una lista de caracteres y devuelve una lista de caracteres.

Pruébalo en línea!

¿Cómo?

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
fuente
Ok, bueno, este prácticamente arruina todo lo demás ...
NL628
1
Bueno, creo que para eso está Jelly: ¡casi espero que Dennis (el creador de Jelly) envíe uno más corto!
Jonathan Allan el
Jajaja, eso es bastante sorprendente: P pero no puedo votar a favor c / c Usé mi conteo de votos diario ... rasgón
NL628
1
... Creo que puede haber una manera de guardar un byte mediante el uso de ḟ(filtrar) pero aún no lo he logrado.
Jonathan Allan el
1
Parece que, en el tiempo, es O (n log n) en la longitud de la entrada, ya que primero usa Python sortedy luego ejecuta n iteraciones de lo que parecen ser operaciones menos complejas (aplanamiento, división en índices encontrados, unión, inversión) ) - y Python sortedes O (n log n).
Jonathan Allan el
1

C (clang) , 164 162 bytes

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

Pruébalo en línea!

f() toma la matriz de caracteres que contiene la cadena de entrada y la longitud de esta matriz como parámetros y realiza las reflexiones requeridas en su lugar.

callf() hace una bonita impresión.

Créditos

-2 bytes. @Kevin. Gracias

GPS
fuente
1
Puede eliminar el espacio en char *sy cambiar i=96a i=9para guardar 2 bytes.
Kevin Cruijssen
Buena captura ... no necesitamos comenzar a. Gracias
GPS
144 bytes
ceilingcat el
1

APL + WIN, 63 bytes

Solicita cadena de entrada

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

Explicación:

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
fuente
1

Perl , 74 70 bytes

84 80 bytes incluyendo invocación como filtro 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
fuente