Reflexão de corda simples

26

Vamos começar definindo um reflexo de um caractere em uma string:

Dada uma sequência com letras alfabéticas minúsculas distintas e sem espaços, como abcdefg, defina um reflexo de uma letra na sequência ccomo movendo-a (sem alterar a ordem de qualquer outra letra) para um novo local na sequência, de forma que o número de letras originalmente agora à direita está o número de letras à esquerda.

Assim, um reflexo da letra cem abcdefgseria abdecfg. Explicação: havia 4 letras à direita de ce agora, existem 4 letras à esquerda de c.

Mais alguns exemplos:

Refletindo o caráter eem myfriendformariam a stringmyefrind

Refletindo o caráter aem axyzformariam a corda xyza.

Refletindo o caráter bem abcformariam a corda abc.

Refletindo o caráter dem dformariam a corda d.

Refletindo o caráter eem efformariam a corda fe.

Para obter mais informações ou experimentar alguns casos de teste, aqui está um programa (um tanto longo) que escrevi em C ++.

O desafio

Dada uma sequência com letras minúsculas distintas, passe por cada caractere alfabeticamente e "reflita" na sequência.

Esclarecimentos: As letras da string são de a-z, não há espaços, as letras são exclusivas e a string tem pelo menos 1 letra e no máximo 26 letras.

Exemplos

Entrada: dcba. Saída: dcba.

Motivo: primeiro, reflita o acaractere da string que aparece mais cedo no alfabeto. Você receberá adcb. Em seguida, reflita o bque vem a seguir no alfabeto, para obter badc. Em seguida, reflita o cque obter cbade, em seguida, o dque obter dcba.

Entrada: myface. Saída: fyecma.

Dica: Percorra as letras na ordem a, c, e, f, m, y.

Entrada: a. Saída: a.

Entrada: acb. Saída: bac.

Entrada: cwmfjordbankglyphsvextquiz. Saída: ieabhqzugdltkfnvpjxsormycw.

Pontuação

  • A entrada e saída podem ser fornecidas por qualquer método conveniente .
  • Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
  • As brechas padrão são proibidas.
  • Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.
  • Aceitando ~ 100 horas após a postagem.

Vencedor Atual

Mostrar snippet de código

code-golf string NL628
fonte
2
Alguém poderia me dar uma idéia sobre se esse quebra-cabeça está bom? É o meu segundo aqui (o meu primeiro foi fechado como fora de tópico ... gritos). Tentei torná-lo realmente completo, mas não tenho certeza se estou perdendo alguma coisa. Eu realmente gostaria de melhorar e me divertir neste SE! Obrigado rapazes: D
NL628
6
Este parece ser bom. Eu posso dar alguns exemplos mais longos (em particular, pode ser bom que a primeira seção de exemplos apresente mais do que aparentemente são casos extremos).
Esolanging Fruit
1
Pedido de esclarecimento: " as letras são únicas " significa que cada letra ocorre apenas uma vez na entrada, está correto?
GPS
4
Podemos pegar a entrada e a saída em maiúsculas em vez de minúsculas?
Kevin Cruijssen
5
@ NL628 A propósito, se você quiser obter informações sobre um desafio antes de publicá-lo aqui, publique-o na Sandbox .
Erik the Outgolfer

Respostas:

8

Flacidez Cerebral , 188 bytes

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

Experimente online!

Além das reflexões descritas na especificação do desafio, esse código também inverte a sequência exatamente 26 vezes. Isso não afeta a saída 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
fonte
1
Uau, isso é incrível. Eu nem consigo entender: O +1
NL628 20/0418
7

05AB1E , 20 17 bytes

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

Experimente online!

Explicação

Por exemplo, para a primeira iteração 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'

A cadeia é cercada por espaços a cada iteração, pois a divisão na primeira ou na última letra da cadeia resultaria em uma lista de comprimento 1 caso contrário, e a mesclagem não incluiria essa letra.

Emigna
fonte
1
17 bytes?! ?? !! INCRÍVEL .. ainda que mnemônico esteja vencendo você por apenas um byte: P
NL628:
1
Mmmm ... Uau, a única coisa que eu pude ver foi remover o ambiente com espaços. Parece estranho que não possamos encontrar outra alternativa para isso.
Urna de polvo mágico
1
@MagicOctopusUrn: É a maneira mais curta que eu encontrei de lidar com uma divisão do primeiro ou do último caractere. Ele se sente como um monte de bytes apenas para que embora
Emigna
5

Pitão, 18 16 19 16 bytes

VSQ=QXx_QN-QNN)Q

Experimente aqui

Explicação

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.

fonte
Uau 16 bytes? Gostaria de votar, mas infelizmente atingi meu limite diário de votos. Vai fazer em 6 horas: P
NL628 20/0418
4

Python 3 , 80 73 bytes

Agradeço ao Esolanging Fruit por me lembrar que as funções podem retornar modificando seu argumento. 

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

Experimente online!

Recebe a entrada como uma lista de caracteres.

Brincadeira
fonte
3
Uau, eu escrevi uma resposta em C ++ e Python 3 também. Minha resposta do Python 3 foi exatamente o dobro do tempo da sua ... +1
NL628 20/0418
3

Retina 0.8.2 , 61 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

$
a

Inicie o loop em a.

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

Se a entrada contiver a letra atual, mova-a para o final, com uma sequência de _s representando sua posição original.

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

Para cada _movimento, a letra retorna um caractere.

}T`_l`l!`.$

Incremente a letra. Depois de zalterá-lo para um, !para que não corresponda a nada e o loop termina.

!

Exclua o !.

Neil
fonte
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 criando uma porta da resposta Python 2 do @TFeld .
-6 bytes graças a @ OlivierGrégoire .

Modifica a lista de entrada em vez de criar uma nova.

Explicação:

Experimente online.

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
fonte
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 Obrigado. E mais 1 repetindo mais do que apenas os caracteres do alfabeto. :)
Kevin Cruijssen
2
Bem, se você ir por esse caminho, for(char c=9;++c>1;)é melhor ;-)
Olivier Grégoire
@ OlivierGrégoire Ah, claro, chartambém envolve como Integer.MAX_VALUE + 1 == Integer.MIN_VALUE.. Inteligente!
Kevin Cruijssen
@ OlivierGrégoire sé um ArrayList, portanto indexOfserá do tipo genérico T(que é Characterpara esta lista de entrada).
Kevin Cruijssen
3

JavaScript, 85 80 79 bytes

-6 bytes graças a @DanielIndie

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

Experimente online!

Esolanging Fruit
fonte
isto não "compilação" um é uma cadeia e você usa emenda
DanielIndie
A entrada @DanielIndie deve ser transmitida como uma matriz de caracteres, assim como a solução Python de Jo King.
Esolanging Fruit
80 bytes
DanielIndie
Você não retornar nada do que função, ou imprimi-lo
DanielIndie
As funções @DanielIndie podem retornar modificando seus argumentos.
Esolanging Fruit
2

Ruby , 51 bytes

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

Experimente online!

Toma uma matriz de caracteres

Retorna modificando a entrada

Asone Tuhid
fonte
2

Vermelho , 96 94 bytes

2 bytes economizados graças 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]

Experimente online!

Mais legível:

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
fonte
1
Você pode salvar 2 bytes mudando find x c replace x c""insert at x i cpara find x c insert at replace x c""i cpara se livrar de um xespaço.
Kevin Cruijssen
@ Kevin Cruijssen Obrigado, Kevin, está muito melhor agora!
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}

Experimente online!

Insere e gera um vetor de caracteres.

Kirill L.
fonte
ew, usando ccomo um nome de variável? isso é horrível, mesmo para o código de golfe!
Giuseppe
Bem, eu posso obviamente mudar isso, mas estou realmente surpreso ao ver que isso poderia incomodar alguém aqui. Na verdade, costumo dar prioridade à preservação de algum sentido em nomes de variáveis ​​(como cpara char), em vez de embutidos não utilizados.
precisa
bem, ao procurar uma melhoria (o que eu não fiz), me vi tentando usar c, e foi horrível quando não consegui entender o que estava acontecendo. Normalmente, uso Kou kmesmo Capenas para evitar problemas como esse, mas entendo totalmente. appendé a ferramenta certa para o trabalho.
Giuseppe
Ah, entendo, desculpe por isso, tentarei evitar definir essas "armadilhas" no futuro.
Kirill L.
2

Perl 5 -p , 37 bytes

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

Experimente online!

Ton Hospel
fonte
2

Japonês , 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.

Salvo um byte graças a Oliver .
Experimente online!

Nit
fonte
1
Agradável. Você pode substituir ,ÉporJ
Oliver
@ Oliver Muito obrigado, ainda me esqueço de usar as variáveis ​​padrão de vez em quando, isso é muito ú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'..]

Experimente online!

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
fonte
Por que isso pára? A dobragem de uma lista infinita não deve causar um loop infinito? Não deveria ser f s=foldl(#)s['a'..'z']?
usar o seguinte comando
1
@ user1472751: ['a'..]não é infinito, porque Charpertence à classe Bounded. Uma lista com ..]dos Boundedvalores pára maxBound. Tente: print [False ..].
N20 /
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)

Experimente online!

Implementação direta do algoritmo necessário. Economizou alguns bytes alternando para uma função em vez de um programa completo; a explicação permanece a mesma, mais ou 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
fonte
1

Geléia ,  12  11 bytes

W;ṢḟṁUṣ¥jʋ/

Um link monádico que aceita uma lista de caracteres e retorna uma lista de caracteres.

Experimente online!

Quão?

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
fonte
Ok bem este praticamente destroços tudo o resto ...
NL628
1
Bem, eu acho que é para isso que Jelly é - eu meio que espero que Dennis (criador de Jelly) envie um menor!
Jonathan Allan
Lol que é bastante surpreendente: P mas não posso upvote b / c eu usei o meu voto count..rip diária
NL628
1
... Acho que pode haver uma maneira de salvar um byte usando ḟ(filtrar), mas ainda não o consegui.
Jonathan Allan
1
parece, no tempo, é O (n log n) no comprimento da entrada, uma vez que primeiro usa o Python sortede depois executa n iterações do que parecem ser operações menos complexas (achatamento, divisão nos índices encontrados, união, reversão ) - e o Python sortedé O (n log n).
Jonathan Allan
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++;}

Experimente online!

f() toma o array de caracteres contendo a string de entrada e o comprimento desse array como parâmetros e executa as reflexões necessárias.

callf() faz bonita impressão.

Créditos

-2 bytes. @Kevin. obrigado

GPS
fonte
1
Você pode remover o espaço em char *se mudança i=96para i=9para salvar 2 bytes.
Kevin Cruijssen
Boa captura .. não precisamos começar a. Obrigado
GPS
144 bytes
tetocat 23/11
1

APL + WIN, 63 bytes

Solicita a sequência de entrada

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

Explicação:

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

Perl , 74 70 bytes

84 80 bytes, incluindo invocação 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
fonte