Rotação de string - string de saída movendo repetidamente o primeiro caractere para o final

22

O desafio aqui é pegar uma string e produzir todas as suas rotações, movendo repetidamente o primeiro caractere para o final, uma vez por caractere na string, terminando com a string original:

john -> ohnj, hnjo, njoh, john

Você também pode andar de bicicleta na outra direção, movendo caracteres do final:

john -> njoh, hnjo, ohnj, john

Você ainda deve gerar uma rotação por letra, mesmo que a palavra original seja alcançada antes disso:

heehee -> eeheeh, eheehe, heehee, eeheeh, eheehe, heehee

Matrizes de caracteres são permitidas, desde que o resultado funcione como mostrado acima.

A resposta mais curta vence!

code-golf  string 
— I_P_Edwards
fonte
5
Se uma string como heeheeretorna à ordem original em menos ciclos que seu comprimento, paramos por aí? Espero que isso faça uma grande diferença para muitas respostas.
— Xnor
Podemos dar um ciclo na outra direção?
— Xnor
2
Editei a pergunta, incluindo seus esclarecimentos, fique à vontade para alterá-la se não for o que você pretendia.
— Xnor
1
@xnor que parece muito mais claro que o meu post original, muito obrigado!
— I_P_Edwards
1
É permitido inserir / enviar matrizes de caracteres? (A distinção pode ser importante em alguns idiomas.)
— LegionMammal978

Respostas:

4

Japonês, 5 3 bytes

Recebe entrada como uma matriz de caracteres, gera uma matriz de matrizes de caracteres

£=é

Experimente aqui

£=é     :Implicit input of character array U
£       :Map
  é     :  Rotate U one element to the right
 =      :  Reassign to U for next iteration
— Shaggy
fonte
3

brainfuck , 59 bytes

,[>,]<[>>[>]+[<]<[<]>-[[>]>[>]<+[<]<[<]>-]>[.>]>[.>]<[<].<]

Experimente online!

Produz cada sequência separada por bytes nulos.

Explicação:

,[>,]    # Get input
<[       # Start loop over input
  >>[>]       # Go to end of the string
  +           # Set it to one to mark it
  [<]<[<]>    # Move to the beginning of input
  -[[>]>[>]<+[<]<[<]>-]   # Transfer the first character to the end
  >[.>]>[.>]  # Print the rotated string
  <[<].       # Print a nul byte
<]       # Repeat loop while input
— Brincadeira
fonte
3

MATL , 6 5 bytes

tf&+)

1 byte salvo graças a @luis!

Experimente no MATL Online !

Explicação :

    # Implicitly grab input string
t   # Duplicate the input
f   # Create an array [1, ..., N] where N is the number of characters in the input
&+  # Add the transpose of this array to itself to create a 2D array of indices
    #
    #   +   1  2  3  4
    #       ----------
    #   1 | 2  3  4  5
    #   2 | 3  4  5  6
    #   3 | 4  5  6  7
    #   4 | 5  6  7  8
    #
)   # Use this 2D array to index into the original string using periodic indexing
    # Implicitly display the resulting character array
— Suever
fonte
@LuisMendo Clever! Obrigado!
— Suever 12/12/19
3

Wolfram Language (Mathematica) , 35 26 bytes

Partition[#,Tr[1^#],1,-1]&

Experimente online!

Leva uma lista de caracteres como entrada.

Partition(mas não sua variante StringPartitionusada abaixo) tem um quarto argumento opcional para tratar sua entrada como cíclica (e para especificar exatamente como fazê-lo), o que torna essa solução mais simples que a da cadeia anterior - além de não ter 15 caracteres construídos em funções.

Wolfram Language (Mathematica) , 44 bytes

Rest@StringPartition[#<>#,StringLength@#,1]&

Experimente online!

O mesmo, mas recebe uma string como entrada.

Se "john"transforma e "johnjohn", em seguida, pega todas as StringLength["john"]subseqüências de comprimento dessa sequência com o deslocamento 1, produzindo e {"john","ohnj","hnjo","njoh","john"}, em seguida, descarta a primeira delas com Rest.

— Misha Lavrov
fonte
Como matrizes de caracteres são permitidas, Rest@Partition[#~Join~#,Length@#,1]&seriam 36 bytes.
— usar o seguinte
@ LegionMammal978 Thanks! Provavelmente também há uma abordagem mais curta com matrizes de caracteres, embora eu ainda não tenha pensado em nada.
— Misha Lavrov
2

Anexo , 13 bytes

Rotate#{1:#_}

Experimente online!

Explicação

Rotate#{1:#_}
      #          fork(f, g) = ${ f[x, g[x]] }; this forks:
Rotate               rotate's the input by
       {1:#_}        each number from 1 to the length of the input

Alternativas

15 bytes :{_&Rotate!1:#_}

16 bytes :{Rotate[_,1:#_]}

16 bytes :Rotate@Rotations

16 bytes :Rotate#(1&`:@`#)

17 bytes :Rotate#{1+Iota@_}

18 bytes :Rotate#(1&`+@Iota)

19 bytes :Rotate#(Succ=>Iota)

— Conor O'Brien
fonte
2

J , 7 bytes

#\|."{]

Experimente online!

Explicação:

  |."{    - rotate ( "{ is short for "0 1 - rank 0 1 ) 
      ]   - the input
#\        - lenght of the successive prefixes of the input
— Galen Ivanov
fonte
2
Usar "dessa maneira é muito inteligente e requer conhecimento de dicionário do idioma. Existe também um verbo com classificação 1 0?
— Adám
@ Adám eu acho que é "#:. Aprendi isso aqui com Frownyfrog
— Galen Ivanov
2

C (32 bits), 58 51 50 bytes

-1 byte para um número redondo agradável, graças a

i;f(s){for(i=0;i++<printf("%s%.*s\n",s+i,i,s)-2;);}

Experimente online!

Degolf

i;           // "Global" i.
f(s){   // s is pointer to string, which conveniently fits in a 32 bit integer.
    for(i=0; // Initialize i.
        // Increment i and take its complement, and add it to the
        // return value of printf(); which just happens to be strlen(s)+1.
        // ~i + strlen(s) + 1 == strlen(s) + 1 - i - 1, so the last printed
        // string is the original string.
        ~++i + printf("%s%.*s\n",s+i,i,s);
        // The printf prints two strings: first until the terminating \0,
        // the second until a \0 or until i chars have been printed. It also
        // prints a linefeed.
}
Sugerir em ~++i+printf("%s%.*s\n",s+i,i,s)vez dei++<printf("%s%.*s\n",s+i,i,s)-2
— ceilingcat 7/01
@ceilingcat Obrigado, como sempre!
@ceilingcat Você realmente deve ser chamado flooringcat.
1

Carvão , 10 bytes

⮌Ｅθ⭆θ§θ⁻μκ

Experimente online! Link é a versão detalhada do código. Explicação:

  θ         Input string
 Ｅ         Map over characters
    θ       Input string
   ⭆        Map over characters and join
      θ     Input string
     §      Circularly indexed by
       ⁻    Difference between
        μ   Inner index
         κ  Outer index
⮌           Reversed
            Implicitly print each string on its own line

Para girar na direção oposta, substitua Minuspor Plus.

— Neil
fonte
1

Perl 6 , 32 bytes

{m:ex/^(.*)(.+)$/».&{[R~] @$_}}

Experimente online!

m:ex/^(.*)(.+)$/ exhaustively matches o regex dada, dividindo a cadeia de entrada em todos os lugares possíveis, exceto que a segunda substring deve ter pelo menos um caractere - que impede a cadeia de entrada de aparecer duas vezes na saída. Em seguida, cada um dos Matchgrupos de captura dos objetos resultantes é reduzido ( []) a uma única cadeia com R~o operador de concatenação de cadeia reversa.

— Sean
fonte
1

Powershell, 44 bytes

($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}

Script de teste:

$f = {

($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}

}

@(
    ,('john', 'ohnj', 'hnjo', 'njoh', 'john')
    ,('heehee', 'eeheeh', 'eheehe', 'heehee', 'eeheeh', 'eheehe', 'heehee')
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    $result
}

saída:

True
ohnj
hnjo
njoh
john
True
eeheeh
eheehe
heehee
eeheeh
eheehe
heehee
— confuso
fonte
1

Tcl , 80 91 bytes

proc P s {time {puts [set s [string ra $s 1 e][string in $s 0]]} [string le $s]}

Experimente online!

— sergiol
fonte
Reatribuir texto a cada vez salva alguns bytesproc R t {time {puts [set t [string ra $t 1 end][string in $t 0]]} [string len $t]}
— david
Obtive até 80 bytes, graças a @david
— sergiol
1

Lua , 61 bytes

function(s)for i=1,#s do print(s:sub(i+1)..s:sub(1,i))end end

Experimente online!

Divida a sequência em índices sucessivos de um para o comprimento da sequência (indexação baseada em uma), concatene as partes na ordem inversa, imprima.

— ciclaminista
fonte
1

Ruby , 39 bytes

->s{a=s.chars.to_a;a.map{a.rotate!*''}}

Experimente online!

— acornellier
fonte
1
Bem vindo ao site! Não parece que o seu link TIO corresponde à sua resposta. Parece também que sua resposta não se encaixa nos nossos requisitos de entrada / saída. Você pode usar uma função ou STDIN / STDOUT, mas não permitimos reatribuição de variáveis.
— Wheat Wizard
Obrigado Garf. Não tenho certeza de como eu consegui estragar os dois. Deve estar tudo bem agora.
— Acornellier
1

JavaScript, 48 43 36 bytes

-5 bytes cortesia de @Bubbler * -7 bytes cortesia de @Shaggy

Entrada é uma matriz de caracteres e saída é uma matriz de matrizes de caracteres.

s=>s.map(_=>([a,...b]=s,s=[...b,a]))

Experimente online!

— guest271314
fonte
1
— quer
1
— Shaggy
@ Shaggy Essa é uma contagem e entrada de bytes válidas? Não [..."john"]conta como manipulação da string de entrada em uma matriz antes da chamada da função?
— guest271314 8/01
@ guest271314, input é um caractere e output é uma matriz de matrizes de caracteres que são permitidas pela especificação de desafio e pelos nossos padrões de E / S.
— Shaggy
@Shaggy Atualizado. Você pode gentilmente deixar seu comentário acima? Ou seu comentário deve ser incluído na resposta para evitar confusão? Ou não é necessário?
— guest271314 8/01
1

brainfuck , 38 bytes

,[>>,]<<<+>[[.>>]<<[<<]>-[+>.>-].<<+>]

Experimente online!

Com base na idéia do JoKing de usar caracteres nulos como símbolos de espaço. Esse código marca as letras atuais a serem impressas e faz um loop até atingir a extremidade esquerda.

,[>>,]<<    input string with empty cells in between
<+>         set first marker
[           main loop
  [.>>]     print remaining characters
  <<[<<]    return to start
  >-[+>.>-] print until marker (remove marker)
  .         print null
  <<+       set new marker
  >         restart loop with next character to the left
]           stop if there's no character to the left
— Dorian
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.