Inverta duas seções de uma corda em torno de um pivô

17

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.

code-golf  string 
— ThePlasmaRailgun
fonte
Qual é a saída esperada para pivot='-'e main='1-2-3-4-5-6'? A maioria dos envios gera 2-3-4-5-6-1isso, mas, pelo que entendi, o desafio deve ser 2-1-3-4-5-6.
— ovs
Ele só deve dividir a sequência no primeiro pivô. O resultado pretendido deve ser 2-3-4-5-6-1.
— ThePlasmaRailgun
3
A propósito, você pode usar a caixa de areia da próxima vez.
— Erik the Outgolfer
Eu acho que a ênfase "ao preservar a ordem dentro das ditas subtrações sendo trocadas" apenas a tornou mais confusa. Eu já entendo dessa maneira, mas as palavras o tornaram confuso se é isso que você quis dizer.
— precisa saber é o seguinte

Respostas:

6

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
— HyperNeutrino
fonte
Uau, alguma chance de uma explicação? Isso é fenomenal!
— ThePlasmaRailgun
@ThePlasmaRailgun Na verdade, não é tão fenomenal: P - Jelly possui built-ins úteis: œṣé "dividir x em torno de sublistas iguais a y ", ṙ1gira o array um lugar para a esquerda e j⁴se junta à segunda entrada.
— Mr. Xcoder
@ThePlasmaRailgun Adicionando explicação agora. Mas para Jelly isso não é mesmo xD extremamente impressionante
— HyperNeutrino
Agradável. Eu amo isso.
— ThePlasmaRailgun
6

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!

— wnnmaw
fonte
2
Mude split(b)para split(b,1)para especificar que você deseja dividir apenas na primeira ocorrência.
— precisa saber é
@ovs, editado para trabalhar no terceiro caso de teste
— wnnmaw 8/17/17
@ypetlion, eu não sabia que splitaceitava mais argumentos, obrigado!
— Wnnmaw
4

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!

— ovs
fonte
A saída no seu caso de teste com o pivô "Dois" e a sequência "1Two2Two3Two4" deve ser "2Two3Two4Two1". Ele deve ser dividido apenas nos primeiros "Dois", deixando a matriz ["1", "2Two3Two4Two"]. Então você pode apenas print k[1]+p+k[0]. Isso deve ter um comportamento pretendido.
— ThePlasmaRailgun
Fixo. Também vou adicionar um exemplo de caso de teste para mostrar às pessoas como deve ser.
— ThePlasmaRailgun
@ThePlasmaRailgun da próxima vez que você quiser melhorar uma resposta, deixe um comentário e deixe o op editá-lo.
— ovs
@ThePlasmaRailgun obrigado pelo seu esclarecimento
— ovs
A segunda e a terceira linhas passam k,j=m.split(p,1);print j,p,ka 38 bytes.
— precisa saber é
4

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).
— Martin Ender
fonte
2

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.
— Mr. Xcoder
fonte
2

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
— Neil
fonte
2

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.

— Giuseppe
fonte
2

JavaScript (ES6), 41 40 bytes

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

Casos de teste

Mostrar snippet de código

— Arnauld
fonte
2

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!

— Galen Ivanov
fonte
0

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 .

— Titus
fonte
0

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
}
— Herman L
fonte
0

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;
}
— Surt
fonte
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!

— Furioso
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.