Riflessione di stringhe semplice

26

Cominciamo definendo un riflesso di un personaggio in una stringa:

Dato una stringa con lettere alfabetiche minuscole distinte senza spazi come abcdefg, definire un riflesso di una lettera nella stringa ccome spostarla (senza cambiare l'ordine di qualsiasi altra lettera) in una nuova posizione nella stringa in modo che il numero di lettere originariamente a destra di esso è ora il numero di lettere a sinistra di esso.

Quindi, sarebbe un riflesso della lettera cin . Spiegazione: c'erano 4 lettere a destra di e ora, ci sono 4 lettere a sinistra di .abcdefgabdecfgcc

Alcuni altri esempi:

Riflettere il personaggio edentro myfriendformerebbe la stringamyefrind

Riflettere il personaggio adentro axyzformerebbe la stringa xyza.

Riflettere il personaggio bdentro abcformerebbe la stringa abc.

Riflettere il personaggio ddentro dformerebbe la stringa d.

Riflettere il personaggio edentro efformerebbe la stringa fe.

Per ulteriori informazioni o per provare alcuni casi di test, ecco un programma (piuttosto lungo) che ho scritto in C ++.

La sfida

Dato una stringa con lettere minuscole distinte, passa attraverso ciascun carattere in ordine alfabetico e "riflettilo" nella stringa.

Chiarimenti: le lettere nella stringa provengono da a-z, non ci sono spazi, le lettere sono uniche e la stringa è lunga almeno 1 lettera e al massimo 26 lettere.

Esempi

Ingresso: dcba. Uscita: dcba.

Motivo: in primo luogo, riflettere acome è il carattere nella stringa che viene prima dell'alfabeto. Otterrai adcb. Quindi, rifletti bcome viene dopo nell'alfabeto, per ottenere badc. Quindi, rifletti csull'ottenere cbade poi dsull'ottenere dcba.

Ingresso: myface. Uscita: fyecma.

Suggerimento: scorrere le lettere nell'ordine a, c, e, f, m, y.

Ingresso: a. Uscita: a.

Ingresso: acb. Uscita: bac.

Ingresso: cwmfjordbankglyphsvextquiz. Uscita: ieabhqzugdltkfnvpjxsormycw.

punteggio

  • L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
  • È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
  • Sono vietate le scappatoie standard .
  • Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).
  • Accettare ~ 100 ore dopo la pubblicazione.

Vincitore attuale

Mostra snippet di codice

code-golf  string 
— NL628
fonte
2
Qualcuno potrebbe darmi un'idea se questo puzzle va bene? È il mio secondo qui (il mio primo è stato chiuso come off-topic ... whoops). Ho provato a renderlo davvero completo, ma non sono sicuro che mi manchi qualcosa. Mi piacerebbe davvero migliorare e divertirmi con questo SE! Grazie ragazzi: D
— NL628,
6
Questo sembra buono. Potrei dare alcuni esempi più lunghi (in particolare, potrebbe essere utile che la prima sezione degli esempi presenti più di quelli che sembrano casi apparentemente marginali).
— Esolanging Fruit,
1
Richiesta di chiarimento: " le lettere sono uniche " significa che ogni lettera appare una sola volta in input, è corretto?
— GPS
4
Possiamo prendere l'input e l'output in maiuscolo anziché in minuscolo?
— Kevin Cruijssen,
5
@ NL628 A proposito, se vuoi avere un'idea di una sfida prima di pubblicarla qui, quindi pubblicala nella Sandbox .
— Erik the Outgolfer,

Risposte:

8

Brain-Flak , 188 byte

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

Provalo online!

Oltre alle riflessioni descritte nella specifica della sfida, questo codice inverte la stringa esattamente 26 volte. Ciò non ha alcun effetto sull'output 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
fonte
1
Wow, è piuttosto sorprendente. Non riesco nemmeno a capirlo: O +1
— NL628
7

05AB1E , 20 17 byte

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

Provalo online!

Spiegazione

Con l'esempio per la prima iterazione di 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 stringa è circondata da spazi ogni iterazione poiché la divisione sulla prima o sull'ultima lettera della stringa comporterebbe un elenco di lunghezza 1 altrimenti e l'unione non includerebbe quella lettera.

— Emigna
fonte
1
17 byte?! ?? !! AMAZING..yet mnemonic ti sta battendo con un solo byte: P
— NL628
1
Mmmm ... Wow, l'unica cosa che ho potuto vedere è rimuovere il surround con spazi. Sembra strano che non possiamo trovare un'altra alternativa a questo.
— Magic Octopus Urn il
1
@MagicOctopusUrn: è il modo più breve che ho trovato di gestire una divisione del primo o dell'ultimo personaggio. Sembra un sacco di byte solo per quello
— Emigna,
5

Pyth, 18 16 19 16 byte

VSQ=QXx_QN-QNN)Q

Provalo qui

Spiegazione

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.
Wow 16 byte? Voterei, ma purtroppo ho raggiunto il mio limite di voto giornaliero.
— Farà
4

Python 3 , 80 73 byte

Grazie a Esolanging Fruit per avermi ricordato che le funzioni possono tornare modificando il loro argomento. 

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

Provalo online!

Accetta input come un elenco di caratteri.

— Jo King
fonte
3
Wow, ho scritto una risposta anche in C ++ e Python 3. La mia risposta a Python 3 era esattamente doppia rispetto alla tua ... +1
— NL628
3

Retina 0.8.2 , 61 byte

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

Provalo online! Il link include casi di test. Spiegazione:

$
a

Inizia il ciclo alle a.

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

Se l'input contiene la lettera corrente, spostala alla fine, con una stringa di _s che rappresenta la sua posizione originale.

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

Per ogni _mossa la lettera torna indietro di un carattere.

}T`_l`l!`.$

Incrementa la lettera. Dopo zaverlo modificato in a in !modo che non corrisponda a nulla e il ciclo termina.

!

Elimina il !.

— Neil
fonte
3

Java 8, 140 96 92 88 87 85 byte

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

-44 byte creando una porta della risposta Python 2 di @TFeld .
-6 byte grazie a @ OlivierGrégoire .

Modifica l'elenco di input invece di crearne uno nuovo.

Spiegazione:

Provalo 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
— Olivier Grégoire,
1
@ OlivierGrégoire Grazie. E 1 altro in più oltre i soli caratteri alfabetici. :)
— Kevin Cruijssen,
2
Bene, se vai su quella strada, for(char c=9;++c>1;)è meglio ;-)
— Olivier Grégoire
@OlivierGrégoire Ah, certo, charsi avvolge anche come Integer.MAX_VALUE + 1 == Integer.MIN_VALUE.. Intelligente!
— Kevin Cruijssen,
@ OlivierGrégoire sè un ArrayList, quindi indexOfsarà di tipo generico T(che è Characterper questo elenco di input).
— Kevin Cruijssen,
3

JavaScript, 85 80 79 byte

-6 byte grazie a @DanielIndie

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

Provalo online!

— Esolanging Fruit
fonte
questo non "compila" a è una stringa e usi splice
— DanielIndie
@DanielIndie Input dovrebbe essere passato come una matrice di caratteri, proprio come la soluzione Python di Jo King.
— Esolanging Fruit,
— DanielIndie,
non restituisci nulla da quella funzione o
— stampalo
Le funzioni @DanielIndie possono tornare modificando i loro argomenti.
— Esolanging Fruit,
2

Rosso , 96 94 byte

2 byte salvati grazie 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]

Provalo online!

Più leggibile:

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
È possibile salvare 2 byte cambiando find x c replace x c""insert at x i cin find x c insert at replace x c""i cper sbarazzarsi di xe spazio.
— Kevin Cruijssen,
@Kevin Cruijssen Grazie, Kevin, ora è molto meglio!
— Galen Ivanov,
2

R , 73 72 69 byte

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

Provalo online!

Inserisce ed emette un vettore di caratteri.

— Kirill L.
fonte
ew, usando ccome nome variabile? è terribile, anche per il golf del codice!
— Giuseppe,
Beh, posso ovviamente cambiarlo, ma sono davvero sorpreso di vedere che potrebbe disturbare chiunque qui. In realtà tendo a dare la priorità a preservare un certo senso nei nomi delle variabili (come cper char) piuttosto che negli built-in non utilizzati.
— Kirill L.,
bene, quando ho cercato un miglioramento (cosa che non ho fatto) mi sono ritrovato a provare a usare ced è stato terribile quando non sono riuscito a capire cosa stesse succedendo. Di solito uso Ko ko anche Csolo per evitare problemi del genere, ma lo capisco perfettamente. appendè sicuramente lo strumento giusto per il lavoro.
— Giuseppe,
Oh, vedo, mi dispiace, cercherò di evitare di impostare tali "trappole" in futuro.
— Kirill L.,
2

Japt , 23 22 byte

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

Salvato un byte grazie a Oliver .
Provalo online!

— lendine
fonte
1
Ben fatto. È possibile sostituire ,ÉconJ
— Oliver
@Oliver Grazie mille, mi dimentico ancora di usare le variabili predefinite di tanto in tanto, è molto utile.
— Nit
1

Haskell, 87 byte

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

Provalo 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
— Nome del modello
fonte
Perché questo si ferma? Il ripiegamento su un elenco infinito non dovrebbe causare un ciclo infinito? Non dovrebbe essere f s=foldl(#)s['a'..'z']?
— user1472751
1
@ user1472751: ['a'..]non è infinito, perché Charappartiene alla classe Bounded. Un elenco ..]di Boundedvalori si ferma a maxBound. Prova: print [False ..].
— nimi,
1

SNOBOL4 (CSNOBOL4) , 132 128 byte

	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)

Provalo online!

Implementazione semplice dell'algoritmo richiesto. Risparmio di pochi byte passando a una funzione anziché a un programma completo; la spiegazione rimane la stessa, più o meno.

	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

Gelatina ,  12  11 byte

W;ṢḟṁUṣ¥jʋ/

Un collegamento monadico che accetta un elenco di caratteri e restituisce un elenco di caratteri.

Provalo online!

Come?

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 bene, questo praticamente rovina tutto il resto ...
— NL628
1
Beh, penso che sia per Jelly, mi aspetto quasi che Dennis (il creatore di Jelly) ne invii uno più corto!
— Jonathan Allan,
Lol è piuttosto sorprendente: P ma non posso votare b / c Ho usato il mio conteggio dei voti giornaliero..rip
— NL628
1
... Penso che potrebbe esserci un modo per salvare un byte usando ḟ(filtrare) ma non l'ho ancora gestito.
— Jonathan Allan,
1
sembra, nel tempo, è O (n log n) nella lunghezza dell'input poiché utilizza prima Python sortede poi scorre attraverso iterazioni di quelle che sembrano essere operazioni meno complesse (appiattimento, divisione in indici trovati, unione, inversione ). - e Python sortedè O (n log n).
— Jonathan Allan,
1

C (clang) , 164 162 byte

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

Provalo online!

f() prende char-array contenente la stringa di input e la lunghezza di questo array come parametri ed esegue le riflessioni richieste sul posto.

callf() fa bella stampa.

Crediti

-2 byte. @Kevin. Grazie

— GPS
fonte
1
È possibile rimuovere lo spazio in char *se modificarlo i=96in i=9per salvare 2 byte.
— Kevin Cruijssen,
Buona cattura .. non dobbiamo iniziare da a. Grazie
— GPS
— plafoniera dal
1

APL + WIN, 63 byte

Richiede la stringa di input

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

Spiegazione:

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 byte

84 80 byte inclusa la chiamata come 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
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.