fundo

Atualmente, estou na classe AP Comp Sci A: Java e quero iniciar alguns de meus amigos no golfe de código. Tenho um desafio do curso e gostaria de ver em quantos bytes a comunidade pode fazer esse desafio.

Detalhes do desafio:

Dadas duas seqüências de entrada, a principal e a dinâmica, faça o seguinte:

Se a sequência de pivô for exatamente uma vez como uma substring da sequência principal, a parte da sequência principal que vem antes da sequência de pivô deve ser trocada pela parte que vem depois, preservando a ordem nas subtrações sendo trocadas .

Por exemplo:

Se a sequência dinâmica estiver vazia ou a sequência dinâmica não for encontrada na sequência principal, o programa não precisará ter um comportamento definido.

Se houver mais de uma instância da sequência dinâmica, a divisão deverá ocorrer na primeira e somente na primeira instância da dinâmica.

Exemplos: Dada a sequência principal OneTwoThreeTwoOnee a sequência dinâmica Two, a saída deve ser ThreeTwoOneTwoOne.

Dada a cadeia principal 1Two2Two3Two4e o pivô Two, a saída deve ser 2Two3Two4Two1.

Dada a sequência principal OneTwoThreee a sequência dinâmica "Dois", a saída deve ser ThreeTwoOne. Dada a sequência principal the rabbit is faster than the turtlee a sequência dinâmica

 is faster than 

(observe o espaço único à direita e à direita), a saída deve ser the turtle is faster than the rabbit.

Dada a cadeia principal 1-2-3-4-5-6e o pivô -, a saída deve ser 2-3-4-5-6-1.

Posfácio:

Esta é a minha primeira pergunta sobre código de golfe, portanto, se você tiver sugestões ou críticas construtivas, sinta-se à vontade para dizer isso.

Além disso, meu código para este projeto (escrito em Java porque o curso se concentra nisso) pode ser encontrado abaixo. Se você tiver alguma dica, eu adoraria vê-las. Atualmente, são 363 bytes, mas aposto que vocês podem criar soluções muito melhores e menores.

import java.util.Scanner;interface Main{static<T>void D(T f){System.out.println(f);}static void main(String[]A){Scanner s=new Scanner(System.in);D("Enter the first String:");String a=s.nextLine();D("Enter the pivot String:");String p=s.nextLine();if(p.isEmpty()|!a.contains(p)){D("Error: Pivot String not found.");return;}String w[]=a.split(p,2);D(w[1]+p+w[0]);}}

Nota: O texto para as entradas e para o caso em que a sequência dinâmica não é encontrada é obrigatório para a atribuição original, mas não para este desafio.

Mathematica, 42 bytes

Reverse@StringSplit[##,2]~StringRiffle~#2&

Experimente online!

Gelatina , 6 bytes

œṣṙ1j⁴

Experimente online!

Explicação

œṣṙ1j⁴  Main Link
œṣ      Split around sublists equal to the pivot
  ṙ1    Rotate left by one
    j⁴  Rejoin on the pivot

Python 2 , 37 39 bytes

lambda a,b:b.join(a.split(b,1)[::-1])

Onde aé a sequência principal e ba sequência dinâmica.

Experimente online!

Wolfram Language (Mathematica) , 34 bytes

p#2<>p<>#&@@StringSplit[#,p,2]&

Experimente online!

Uma função ao curry, sem nome, que deve ser chamada com o pivô primeiro e a cadeia principal em segundo. Por exemplo, se você atribuiu a função a um nome f:

f["-"]["1-2-3-4-5-6"]

Ohm v2 , 4 bytes

ïλ⁴j

Experimente online!

Perl 5 , 20 + 2 ( -pl) = 22 bytes

<>=~/$_/;$_="$'$_$`"

Experimente online!

Pega a sequência de pivô na primeira linha e depois a sequência completa na segunda.

Python 2 , 53 44 bytes

graças a ThePlasmaRailgun por alguns bytes

p,m=input()
k=m.split(p,1)
print k[1]+p+k[0]

Experimente online!

Python 2 , 37 bytes

lambda a,b:b.join(a.split(b,1)[::-1])

Experimente online!

C # (compilador Visual C #) , 56 bytes

(m,p)=>(m+p+m).Substring(m.IndexOf(p)+p.Length,m.Length)

Experimente online!

Alice , 18 bytes

/?.?.Qz
\IoI%!oo@/

Experimente online!

Explicação

/...
\...@/

Esta é apenas uma estrutura para o código linear do modo Ordinal (processamento de string). Desdobrando o fluxo de controle em zigue-zague, obtemos:

I.I.!zo?o?%Qo

I.  Read the first string, duplicate it.
I   Read the second string (the pivot).
.!  Store a copy of the pivot on the tape.
z   Drop. Removes everything up to and including the pivot from the first string,
    so we get only the stuff after the pivot.
o   Output that.
?o  Retrieve the pivot from the tape and output it.
?%  Retrieve the pivot again and split the input around (all occurrences of)
    the pivot.
Q   Reverse the stack.
o   Output the top of the stack (i.e. the chunk in front of the first pivot).

SOGL V0.12 , 9 5 bytes

ΘK+,∑

Experimente aqui!

Explicação:

Θ      split the 2nd input on the 1st one
 K     get the 1st element
  +    and add it to the end
   ,∑  join on the 1st input

Retina , 24 23 bytes

tanques para Martin Ender por -1 byte

(.*)¶(.*?)\1(.*)
$3$1$2

Experimente online!

Python 2 , 48 bytes

lambda s,p:p.join(s.split(p)[1:]+s.split(p)[:1])

Experimente online!

Pitão , 8 bytes

jQ.<cEQ1

Experimente aqui!

Explicação

jQ.<cEQ1 - Full program.

    cEQ  - Split the second input by the first input.
  .<   1 - Cyclically rotate by 1 place to the left.
jQ       - Join on the first input.

Carvão vegetal , 13 bytes

≔⪪θηθ⪫Ｅθ§θ⊕κη

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

  θ             First input
   η            Second input
 ⪪              Split
≔   θ           Assign result
      Ｅθ        Map over result
           κ    Current index
          ⊕     Incremented
        §θ      Circularly index into result
     ⪫      η   Join
                Implicitly print

R , 63 58 57 bytes

function(M,P)sub(sub("_",P,"(.+?)(_)(.+)"),"\\3\\2\\1",M)

Experimente online!

M é a string principal, P é o pivô.

resposta da retina dos ovs indicou que eu poderia reparar minha tentativa anterior de uma abordagem regex

(.+)(Pivot string)(.+)

adicionando ?ao primeiro grupo de captura.

Java 8, 47 bytes

x->y->x.replaceAll("(.*?)("+y+")(.*)","$3$2$1")

Experimente online

JavaScript (ES6), 41 40 bytes

(s,p,[a,...r]=s.split(p))=>r.join(p)+p+a

Casos de teste

let f =

(s,p,[a,...r]=s.split(p))=>r.join(p)+p+a

console.log(f('the rabbit is faster than the turtle', ' is faster than '))
console.log(f('1-2-3-4-5-6', '-'))

J , 14 bytes

#@[}.{.@ss|.,~

Como funciona:

O argumento da esquerda é o pivô, o da direita - a string a ser revertida

            ,~   appends the pivot to the string
     {.@ss       finds the positions of the pivot in the string and takes the first one
          |.     rotates the appended string to the left, so that the pivot is at the start
#@[              finds the length of the pivot string (n)
   }.            drops n characters from the begining of the rotated string

Experimente online!

C,  106  100 bytes

i,l;f(s,p)char*s,*p;{l=strlen(p);for(i=0;strncmp(s+i,p,l);++i);printf("%s%s",s+i+l,p);write(1,s,i);}

Experimente online!

SNOBOL4 (CSNOBOL4) , 53 bytes

	P =INPUT
	INPUT ARB . R P REM . L
	OUTPUT =L P R
END

Experimente online!

Recebe a entrada como Pivot, depois Main, separada por uma nova linha.

Este é basicamente o equivalente SNOBOL da minha resposta R .

Perl 6 , 31 bytes

->$_,$b {S/(.*?)$b(.*)/$1$b$0/}

Teste-o

PHP, 62 bytes

<?=![,$s,$p]=$argv,preg_filter("(^(.*)$p(.*)$)U","$2$p$1",$s);

requer PHP 7.1; pode falhar se o pivot contiver caracteres especiais regex ( \+*?[^]$(){}=!<>|:-).
nenhuma alteração se o Pivot estiver vazio, saída vazia se o Pivot não estiver na entrada.
Corra com -n.

versão segura, 77 bytes:

<?=preg_filter("(^(.*)".preg_quote($p=$argv[1])."(.*)$)U","$2$p$1",$argv[2]);

nenhuma alteração se o Pivot estiver vazio, saída vazia se o Pivot não estiver na entrada.
Corra com -n.

versão não regex, 71 bytes:

$a=explode($p=$argv[2],$argv[1]);$a[]=array_shift($a);echo join($p,$a);

emite avisos se o Pivot estiver vazio; nenhuma alteração se o Pivot não estiver na entrada.

Corra com -nr.

Experimente online .

Vermelho , 63 bytes

f: func[p s][rejoin[copy find/tail s p p copy/part s find s p]]

Experimente online!

Rápido , 131 bytes

import Foundation
func f(s:String,d:String){var c=s.components(separatedBy:d);print((c+[c[0]]).suffix(from:1).joined(separator:d))}

Explicação (ungolfed)

import Foundation                     // Import String.components
func f(s:String,d:String){
    var c=s.components(separatedBy:d) // Split the input string by the separator
    print((c+[c[0]])                  // Add the last element of c ([A,B,C] -> [A,B,C,A])
        .suffix(from:1)               // Remove the first element  ([A,B,C,A] -> [B,C,A])
        .joined(separator:d))         // Join with the separator
}

C (gcc) , 76 bytes

f(s,t)char*s,*t;{char*p=strstr(s,t);printf("%s%s%.*s",p+strlen(t),t,p-s,s);}

Experimente online!

C ++ 11, 64 bytes

[s,p,&a]{int f=s.find(p);a=s.substr(f+p.size())+p+s.substr(0,f);}

Um lambda, que captura as strings s, p e a, com a como referência (entrada e saída).

Código de teste

#include <iostream>
#include <string>

std::string Test(std::string s, std::string p) {
    std::string a;
[s,p,&a]{int f=s.find(p);a=s.substr(f+p.size())+p+s.substr(0,f);}();
    return a; 
}

int main() {
    std::string 
        s = "OneTwoThreeTwoOne",
        p = "Two",
        r = "ThreeTwoOneTwoOne";
    auto a = Test(s,p);
    std::cout << ((a==r)?"OK":"Failed") << ": " << a << std::endl; 

    return 0;
}

Limpo , 83 bytes

import StdEnv;f s c=(\p=p takeWhile++[hd s,c:p dropWhile])\g=reverse(tl(g((<>)c)s))

StringNormalmente, um em Limpar é {#Char}- um array sem caixa ( #) Char( {}). Esta função leva em [Char]vez de String, que é uma segunda versão válida de String.

A assinatura completa da função é f :: [.t] .t -> [.t] | [.t <= Char].

Experimente online!

Japonês , 8 7 bytes

£Zg°Y}V

Experimente aqui