Rotazione stringa - stringa di output che sposta ripetutamente il primo carattere alla fine

22

La sfida qui è prendere una stringa e produrre tutte le sue rotazioni, spostando ripetutamente il primo carattere alla fine, una volta per carattere nella stringa, terminando con la stringa originale:

john -> ohnj, hnjo, njoh, john

Puoi anche spostarti nell'altra direzione, spostando i caratteri dalla fine:

john -> njoh, hnjo, ohnj, john

Dovresti comunque generare una rotazione per lettera anche se la parola originale viene raggiunta prima di ciò:

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

Le matrici di caratteri sono consentite, purché il risultato funzioni come mostrato sopra.

Vince la risposta più breve!

code-golf string

— I_P_Edwards
fonte

5

Se una stringa come heeheeritorna all'ordine originale in meno cicli della sua lunghezza, ci fermiamo qui? Mi aspetto che ciò farebbe una grande differenza per molte risposte.

— xnor

Possiamo pedalare nella direzione opposta?

— xnor

2

Ho modificato la domanda includendo i tuoi chiarimenti, sentiti libero di cambiarla se non è quello che volevi.

— xnor

1

@xnor che sembra molto più chiaro del mio post originale, grazie mille!

— I_P_Edwards,

1

Ci è consentito inserire / emettere array di caratteri? (La distinzione può essere importante in alcune lingue.)

— LegionMammal978

Risposte:

7

Gelatina , 2 byte

ṙJ

Un collegamento monadico che accetta un elenco di caratteri che produce un elenco di elenchi di caratteri

Provalo online! (il piè di pagina viene stampato chiamando il collegamento e unendosi con i caratteri di nuova riga)

— Jonathan Allan
fonte

8

Haskell, 27 byte

scanl(\(a:b)_->b++[a])=<<id

Provalo online!

— Nome del modello
fonte

6

APL (Dyalog Unicode) , 6 byte ^SBCS

⍳∘≢⌽¨⊂

Provalo online!

⍳ gli indici

∘ di

≢ il conteggio

⌽¨ ogni ruota (a sinistra)

⊂ l'intera stringa

— Adamo
fonte

6

Python 2 , 38 byte

s=input()
for c in s:s=s[1:]+c;print s

Provalo online!

— XNOR
fonte

Python 3 ha solo 9 byte in più.

— wizzwizz4,

1

@ wizzwizz4 Dove hai preso 9? Python

— 3-39

@ pizzapants184 Ho dimenticato che le stringhe erano immutabili; hai ragione; è solo 1 byte in più.

— wizzwizz4,

6

JavaScript (ES6), 37 32 byte

Restituisce una matrice di stringhe.

s=>[...s].map(c=>s=s.slice(1)+c)

Provalo online!

— Arnauld
fonte

4

Japt, 5 3 byte

Accetta input come array di caratteri, genera un array di array di caratteri

£=é

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

— ispido
fonte

3

05AB1E , 3 byte

ā._

Provalo online!

— Okx
fonte

3

Brainfuck , 59 byte

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

Provalo online!

Emette ciascuna stringa separata da byte null.

Spiegazione:

,[>,]    # 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

— Jo King
fonte

3

MATL , 6 5 byte

tf&+)

1 byte salvato grazie a @luis!

Provalo su MATL Online !

Spiegazione :

    # 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! Grazie!

— Suever,

3

Wolfram Language (Mathematica) , 35 26 byte

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

Provalo online!

Accetta un elenco di caratteri come input.

Partition(ma non la sua variante StringPartitionutilizzata sotto) presenta un quarto argomento opzionale per trattare il suo ingresso ciclico (e per specificare esattamente come farlo), che rende questa soluzione più semplice della stringa di un - oltre a non avere alcun 15 caratteri built -in funzioni.

Wolfram Language (Mathematica) , 44 byte

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

Provalo online!

Lo stesso, ma accetta una stringa come input.

Si trasforma "john"in "johnjohn", quindi prende tutte le StringLength["john"]sottostringhe di lunghezza di questa stringa con offset 1, producendo {"john","ohnj","hnjo","njoh","john"}, quindi rilascia la prima di queste con Rest.

— Misha Lavrov
fonte

Poiché gli array di caratteri sono consentiti, Rest@Partition[#~Join~#,Length@#,1]&sarebbero 36 byte.

— LegionMammal978,

@ LegionMammal978 Grazie! Probabilmente c'è anche un approccio più breve con gli array di personaggi, anche se non ho ancora pensato a nulla.

— Misha Lavrov,

2

Attache , 13 byte

Rotate#{1:#_}

Provalo online!

Spiegazione

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

alternative

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

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

16 byte :Rotate@Rotations

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

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

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

19 byte :Rotate#(Succ=>Iota)

— Conor O'Brien
fonte

2

J , 7 byte

#\|."{]

Provalo online!

Spiegazione:

  |."{    - rotate ( "{ is short for "0 1 - rank 0 1 ) 
      ]   - the input
#\        - lenght of the successive prefixes of the input

— Galen Ivanov
fonte

2

Usare "così è molto intelligente e richiede una conoscenza del dizionario della lingua. Esiste anche un verbo con rango 1 0?

— Adám,

@ Adám Penso di si "#:. L'ho imparato qui da Frownyfrog

— Galen Ivanov il

2

R , 58 byte

function(s,`[`=substring)paste0(s[n<-nchar(s):1],s[1,n-1])

Provalo online!

— digEmAll
fonte

2

C # (compilatore interattivo Visual C #) , 34 byte

x=>x.Select(c=>x=x.Substring(1)+c)

Provalo online!

— dana
fonte

2

C (32 bit), 58 51 50 byte

-1 byte per un bel numero tondo grazie a ceilingcat

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

Provalo 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.
}

Suggerisci ~++i+printf("%s%.*s\n",s+i,i,s)invece dii++<printf("%s%.*s\n",s+i,i,s)-2

— ceilingcat

@ceilingcat Grazie, come sempre!

@ceilingcat Dovresti davvero essere chiamato flooringcat.

1

Carbone , 10 byte

⮌Ｅθ⭆θ§θ⁻μκ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  θ         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

Per ruotare nella direzione opposta, sostituire Minuscon Plus.

— Neil
fonte

1

Rosso , 49 43 byte

func[s][forall s[print move head s tail s]]

Provalo online!

— Galen Ivanov
fonte

1

Python 2 , 54 48 byte

lambda i:[i[x:]+i[:x]for x in range(1,len(i)+1)]

Provalo online!

Ben battuto da Xnor ma pubblicato comunque come approccio alternativo.

— ElPedro
fonte

1

Perl 6 , 32 byte

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

Provalo online!

m:ex/^(.*)(.+)$/ exarresta in modo mavido il regex dato, suddividendo la stringa di input in ogni posizione possibile, tranne per il fatto che la seconda sottostringa deve avere almeno un carattere - che impedisce alla stringa di input di apparire due volte nell'output. Quindi ciascuno dei Matchgruppi di acquisizione degli oggetti risultanti viene ridotto ( []) in una singola stringa con R~l'operatore di concatenazione di stringhe inverse.

— Sean
fonte

1

Pushy , 4 byte

L:{"

Provalo online!

L:    \ Length of the string times do:
  {   \    Cyclically shift left once
   "  \    Print

— FlipTack
fonte

1

V , 8 byte

ýñx$pÙñd

Provalo online!

hexdump:

00000000: fdf1 7824 70d9 f164                      ..x$p..d

— DJMcMayhem
fonte

ýñx$pÙñddà 8 rimuovendo la necessità di H tio.run/##K/v///DewxsrVAoOzzy8MeX/f6/8jDwA

— Kritixi Lithos

@Cowsquack Ancora meglio:ý<M-->ñx$pÙ

— DJMcMayhem

Questo non ripete l'ultima riga?

— Kritixi Lithos il

1

Powershell, 44 byte

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

Script di prova:

$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
}

produzione:

True
ohnj
hnjo
njoh
john
True
eeheeh
eheehe
heehee
eeheeh
eheehe
heehee

— Mazzy
fonte

1

Tcl , 80 91 byte

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

Provalo online!

— sergiol
fonte

Riassegna il testo ogni volta che salva alcuni byteproc R t {time {puts [set t [string ra $t 1 end][string in $t 0]]} [string len $t]}

— David

È arrivato a 80 byte, grazie a @david

— sergiol il

1

SNOBOL4 (CSNOBOL4) , 82 byte

	S =INPUT
T	X =X + 1
	S LEN(1) . L REM . R
	OUTPUT =S =R L LE(X,SIZE(S))	:S(T)
END

Provalo online!

— Giuseppe
fonte

1

Lua , 61 byte

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

Provalo online!

Dividi la stringa in indici successivi da uno alla lunghezza della stringa (indicizzazione a base singola), concatena i pezzi nell'ordine inverso, stampa.

— cyclaminist
fonte

1

Rubino , 39 byte

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

Provalo online!

— acornellier
fonte

1

Benvenuti nel sito! Non sembra che il tuo link TIO corrisponda alla tua risposta. Sembra anche che la tua risposta non si adatti ai nostri requisiti di input / output. Puoi utilizzare una funzione o STDIN / STDOUT ma non consentiamo la riassegnazione variabile.

— Wheat Wizard

Grazie Garf. Non sono sicuro di come sono riuscito a rovinare entrambi. Ora dovrebbe andare tutto bene.

— Acornellier,

1

JavaScript, 48 43 36 byte

-5 byte per gentile concessione di @Bubbler * -7 byte per gentile concessione di @Shaggy

L'input è un array di caratteri e l'output è un array di array di caratteri.

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

Provalo online!

— guest271314
fonte

1

43 byte .

— Bubbler

1

36 byte

— Shaggy

@Shaggy È un conteggio e una voce di byte validi? Non [..."john"]conta come manipolazione della stringa di input in un array prima della chiamata della funzione?

— ospite271314

@ guest271314, l'input è un carattere e l'output è una matrice di array di caratteri consentiti dalle specifiche della sfida e dalle impostazioni predefinite I / O.

— Shaggy

@Shaggy Aggiornato. Puoi gentilmente lasciare il tuo commento sopra? O il tuo commento dovrebbe essere incluso nella risposta per evitare confusione? O non è né necessario?

— ospite271314

1

Lisp comune, 88 byte

(lambda(x)(loop for s from 1 to(length x)do(format t"~a~a "(subseq x s)(subseq x 0 s))))

Provalo online!

— Renzo
fonte

1

MBASIC , 69 66 byte

-3 byte, grazie a Ørjan Johansen

1 INPUT S$:L=LEN(S$):FOR I=1 TO L:S$=MID$(S$+S$,2,L):PRINT S$:NEXT

— wooshinyobject
fonte

Ho il sospetto che tu possa accorciarlo 1 INPUT S$:L=LEN(S$):FOR I=1 TO L:S$=MID$(S$+S$,2,L):PRINT S$:NEXT.

— Ørjan Johansen,

@ Ørjan Johansen Molto bello, grazie.

— wooshinyobject

1

Brainfuck , 38 byte

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

Provalo online!

Basato sull'idea di JoKing di usare caratteri null come simboli di spazio. Questo codice contrassegna le lettere correnti da stampare e scorre fino a raggiungere l'estremità sinistra.

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.