Despalindromize essa sequência!

48

Dado um palíndromo gerado de acordo com esse desafio , despalindromize-o.

Casos de teste

abcdedcba -> abcde
johncenanecnhoj -> johncena
ppapapp -> ppap
codegolflogedoc -> codegolf

Como se trata de despalindromização, seu código não pode ser um palíndromo .

Lembre-se, isso é código-golfe , portanto o código com o menor número de bytes vence.

code-golf  restricted-source  palindrome 
— Oliver Ni
fonte
23
-1 para a restrição inútil do seu código não ser um palíndromo. Isso não acrescenta nada ao desafio da OMI, em pouquíssimos idiomas isso importaria.
— Rɪᴋᴇʀ
25
+1 para a restrição. É um espelho do desafio do paliondrome ... e está adicionando um desafio aos esolangs. Eu gosto disso. Estou correto no pressuposto de que a entrada sempre terá um comprimento desigual?
— Titus
42
A restrição não palíndromo é provavelmente uma piada baseada no desafio anterior. Alguém realmente votou com base nisso?
— Luis Mendo
5
Evita soluções de byte único. @diynevala +1 pelo +1 desnecessário.
— Adám 03/11/19
5
E se a string não for um palíndromo, para começar?
— Xavon_Wrentaile

Respostas:

6

Python 2, 23 bytes

Não consigo testar no meu telefone, mas isso deve funcionar:

lambda s:s[:-~len(s)/2]
— Kade
fonte
2
Se você estiver executando no Android, poderá usar o QPython na loja do Google Play. É o melhor que eu encontrei :)
— Yytsi
termux apt-get install python2
— Matt
@ Matt Isso é um exagero, se tudo o que você quer é Python.
— mbomb007
@Matt, bem como se você pode encontrar apt-getno seu telefone, provavelmente não é um telefone normal.
— Legal preguiçoso
O @MathManiac termux é instalado no Google Play em qualquer telefone Android sem raiz. Não pode ficar muito mais normal que isso.
— Matt
6

Fuzzy Octo Guacamole, 4 bytes

2.^/

Passei um tempo procurando por um idioma em que esse desafio fosse curto, e percebi que era burro e meu próprio idioma fez isso.

— Rɪᴋᴇʀ
fonte
5

Queijo Cheddar, 22 18 bytes

@.head($0.len/2+1)

Tão simples que acho que não precisa de explicação, mas adicionarei uma, se desejado.

Experimente online

— Downgoat
fonte
4

JavaScript (ES6), 32 26 25 bytes

1 byte economizado graças a Neil:

s=>s.slice(0,-s.length/2)

Mostrar snippet de código

Soluções anteriores
26 bytes graças ao Downgoat:

s=>s.slice(0,s.length/2+1)

32 bytes:

s=>s.slice(0,(l=s.length/2)+l%2)
— Hedi
fonte
11
Você pode encurtar para apenas s=>s.slice(0,s.length/2+1)Desde comprimento será sempre estranha
— Downgoat
@ Downgoat, graças a você, descobri que, por mais um byte, s=>s.slice(0,s.length/2+.5)também funcionaria por um comprimento igual.
— Hedi
2
-s.length/2funciona para comprimentos pares e ímpares.
— Neil
4

WinDbg, 87 71 bytes

db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2

-16 bytes, não inserindo NULL, passando o comprimento para da

A entrada é passada através de um endereço no psuedo-register $t0. Por exemplo:

eza 2000000 "abcdedcba"       * Write string "abcdedcba" into memory at 0x02000000
r $t0 = 33554432              * Set $t0 = 0x02000000
* Edit: Something got messed up in my WinDB session, of course r $t0 = 2000000 should work
* not that crazy 33554432.

Ele funciona substituindo o direito do meio do caractere (ou o meio-direito, se a string tiver um comprimento uniforme) por um nulo e, em seguida, imprime a string a partir do endereço de memória inicial original.

db $t0 L1;                                   * Set $p = memory-at($t0)
.for (r $t1 = @$t0; @$p; r $t1 = @$t1 + 1)   * Set $t1 = $t0 and increment until $p == 0
{
    db $t1 L1                                * Set $p = memory-at($t1)
};
da $t0 L(@$t1-@$t0)/2                        * Print half the string

Resultado:

0:000> eza 2000000 "abcdeedcba"
0:000> r $t0 = 33554432
0:000> db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2
02000000  61                                               a
02000000  61                                               a
02000001  62                                               b
02000002  63                                               c
02000003  64                                               d
02000004  65                                               e
02000005  65                                               e
02000006  64                                               d
02000007  63                                               c
02000008  62                                               b
02000009  61                                               a
0200000a  00                                               .
02000000  "abcde"
— leite
fonte
3

Haskell, 27 bytes

take=<<succ.(`div`2).length

Versão sem ponto de

\x->take(div(length x)2+1)x

que também tem 27 bytes.

— nimi
fonte
3

MATL , 7 6 bytes

9LQ2/)

Experimente online!

Explicação

9L       % Push array [1, 1j]
  Q      % Add 1: transforms into [2, 1+1j]
   2/    % Divide by 2: transforms into [1, 0.5+0.5j]
     )   % Apply as index into implicit input. The array [1, 0.5+0.5j] used as an index
         % is interpreted as [1:0.5+end*0.5]
— Luis Mendo
fonte
11
Uau, isso é uma maneira muito elegante de lidar com valores complexos como argumentos para cortar
— milhas
@miles Obrigado! Sim, é útil. A unidade imaginária funciona como end, e dois pontos entre os elementos de matriz estão implícitos
— Luis Mendo
3

Braquilog , 4 bytes

@2tr

Experimente online!

Explicação

@2        Split in half
  t       Take the second half
   r      Reverse it

Se a entrada tiver um comprimento ímpar, a segunda metade gerada por @2é a mais longa, que é a que devemos retornar (depois de revertê-la).

— Fatalizar
fonte
3

Perl, 15 bytes

Inclui +2 para -lp

Dê uma string de entrada no STDIN:

depal.pl <<< "HelleH"

depal.pl:

#!/usr/bin/perl -lp
s/../chop/reg

A -lnão é realmente necessário, se você inserir o palíndromo sem nova linha final, mas eu incluí-lo para ser justo com as outras soluções perl que o utilizam.

— Ton Hospel
fonte
2

TI-Basic, 14 bytes

Função padrão. Retorna a string do índice 1 para o índice (comprimento / 2 + 1/2).

sub(Ans,1,.5+.5length(Ans
— Timtech
fonte
2

Idioma do GameMaker, 59 bytes

a=argument0 return string_copy(a,1,ceil(string_length(a)/2)
— Timtech
fonte
2

PHP, 40 bytes

<?=substr($a=$argv[1],0,1+strlen($a)/2);

strlen($a)/2é convertido para int, com a entrada sempre tendo um comprimento ímpar, +1é suficiente para arredondar para cima.

42 bytes para qualquer comprimento:

<?=substr($a=$argv[1],0,(1+strlen($a))/2);

por comprimento desconhecido, (1+strlen)/2é convertido em int, arredondando para cima strlen/2.

— Titus
fonte
Como a entrada é definida como proveniente desse desafio ( codegolf.stackexchange.com/questions/98325/… ), seu comprimento sempre será ímpar, portanto, você pode simplesmente continuar com o menor.
— user59178
2

Mergulho, 8 bytes

H{C'0ÏEI

Explicação:

           # Implicit input
 H         # Push length of input
  {        # Add 1
   C       # Divide by 2
    '      # Convert to int
     0Ï    # Get string back
       E   # Push prefixes of string
        I  # Push prefixes[a]
           # Implicit print

Provavelmente isso poderia ser muito melhorado.

— Oliver Ni
fonte
2

Perl, 23 + 2 ( -plsinalizador) = 28 25 bytes

perl -ple '$_=substr$_,0,1+y///c/2'

Ungolfed:

while (<>) {             # -p flag
    chomp($_)            # -l flag
    $_ = substr($_, 0, 1 + length($_) / 2);
    print($_, "\n")      # -pl flag
}

Thanx para @ardnew.

— Denis Ibaev
fonte
11
você pode salvar 3 caracteres substituindo length()pory|||c
— ardnew
2

Befunge , 24 22 bytes

~:0`!#v_\1+
0:-2,\_@#`

Experimente online!

Como o Befunge não tem tipo de string ou array, tudo é feito na pilha, um caractere de cada vez. O primeiro loop (na linha superior) conta o número de caracteres lidos (trocar com menos de 2 elementos na pilha produz um 0 inicial). O segundo (na linha do meio) imprime caracteres enquanto conta em contagem regressiva duas vezes mais rápido. Como resultado, apenas a última metade da entrada é impressa, mas o LIFO está na ordem correta.

Agradecemos a Brian Gradin por uma versão melhor do primeiro loop.

— Linus
fonte
11
Você me bater por meia hora e 7 bytes :) befunge.tryitonline.net/...
— Brian Gradin
@BrianGradin, nice. agora eu batida já vencê-lo por 9 bytes;)
— Linus
Ah ok. Eu vejo o que você fez. Não me ocorreu contagem regressiva por dois, em vez de calcular o número real de caracteres a serem impressos. Bem feito.
— Brian Gradin
2

Perl, 14 + 3 ( -lFsinalizador) = 19 17 bytes

Para 5.20.0+:

perl -lF -E 'say@F[0..@F/2]'

Para 5.10.0+ (19 bytes):

perl -nlaF -E 'say@F[0..@F/2]'

Ungolfed:

while (<>) {             # -n flag (implicitly sets by -F in 5.20.0+)
    chomp($_)            # -l flag
    @F = split('', $_);  # -aF flag (implicitly sets by -F in 5.20.0+)
    say(@F[0 .. (scalar(@F) / 2)]);
}

Thanx para @simbabque.

— Denis Ibaev
fonte
2
Você pode salvar dois bytes, não precisa definir -ne -aporque o -Ffaz implicitamente.
— simbabque
@simbabque Sim. Mas apenas para 5.20.0+.
— Denis Ibaev 04/11
2

Brainfuck, 20 bytes

,
[
  [>,]
  <[<]
  >.,>[>]
  <<
]

Experimente online.

Isso economiza um byte na abordagem mais direta de consumir a entrada antes de iniciar o loop principal:

,[>,]
<
[
  [<]
  >.,>[>]
  <,<
]
— Mitch Schwartz
fonte
2

Pitão , 8 7 bytes

<zh/lz2

Guardado 1 com graças a @Steven H

Não é a resposta mais curta do Pyth (pela metade), mas estou fazendo um esforço para aprender o idioma e este é o meu primeiro post usando-o. Postado tanto por comentários e feedback como qualquer coisa. É também o primeiro programa Pyth que eu realmente tenho que trabalhar :)

Agora só preciso descobrir como funciona a resposta de 4 bytes do @Maltysen :-)

— ElPedro
fonte
11
Se você ainda deseja saber como a resposta de Maltysen funciona, ela divide ca entrada Qem 2pedaços e pega a primeira parte usando h(que, graças à implementação de chop, também pega a letra central). Quanto ao seu código, você poderia substituir +1com h, o built-in para incrementar números.
— 7116 Steven H.
Obrigado pela explicação e para o hdica @ Steven H. Há tantas built-ins eu acho que só leva algum tempo para encontrá-los todos :)
— ElPedro
11
Sem problemas! Se você precisar de ajuda, tente me enviar um ping no décimo nono byte.
— 7116 Steven H.
2

C, 31 30 bytes

Economizando 1 byte graças ao Cyoce.

f(char*c){c[-~strlen(c)/2]=0;}

Uso:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}
— Karl Napf
fonte
@KevinCruijssen fixado
— Karl Napf
Oi, desculpe, eu excluí meu comentário. Eu estava certo ao dizer que não funcionaria nem para palíndromos. Mas, como esse é o inverso desse outro desafio, não haverá casos de teste para nem mesmo os palíndromos. Desculpe por isso, você pode desfazer sua alteração. +1 de mim. :)
— Kevin Cruijssen
2
Bem, agora tem o mesmo comprimento, funciona para pares + ímpares e parece mais golfista. Eu estou bem com isso.
— 194 Karl Napf
Este é sem dúvida um vazamento de memória :-)
— ShreevatsaR
11
Eu acho que você pode remover o espaço emchar* c
— Cyoce 13/12/16
1

MATLAB / Oitava, 20 19 18 16 bytes

1 byte emprestado de uma ideia da resposta de Easterly Irk (adicione em 1vez de .5)
2 bytes de desconto graças a @StewieGriffin (parênteses desnecessários)

@(x)x(1:end/2+1)

Experimente em Ideone .

— Luis Mendo
fonte
@StewieGriffin Thanks! Eu não sei o que eu estava pensando ...
— Luis Mendo
Nem eu: P Não é como se fosse um "truque" que você não sabia sobre ... Eu tive alguns deles também :)
— Stewie Griffin
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.