Depalindromize cette chaîne!

48

Compte tenu d'un palindrome généré en fonction de ce défi , dépalindromisez-le.

Cas de test

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

Comme il s’agit de dépalindromiser, votre code ne peut pas être un palindrome .

Rappelez-vous que c'est du code-golf , donc le code avec le moins d'octets gagne.

code-golf  restricted-source  palindrome 
— Oliver Ni
source
23
-1 pour la restriction inutile sur votre code n'étant pas un palindrome. Cela n’ajoute rien au défi de l’OMI; dans très peu de langues, cela importerait.
— Rɪᴋᴇʀ
25
+1 pour la restriction. C’est tellement le reflet du défi Paliondrome… et cela ajoute un défi aux esolangs. Je l'aime. Ai-je raison de supposer que la longueur de l'entrée sera toujours inégale?
— Titus
42
La restriction non-palindrome est probablement une blague basée sur le défi précédent. Quelqu'un at-il vraiment un vote négatif basé sur cela?
— Luis Mendo
5
Cela empêche les solutions à un octet. @diynevala +1 pour l'inutile +1.
— Adám
5
Et si la chaîne n'est pas un palindrome pour commencer?
— Xavon_Wrentaile

Réponses:

6

Python 2, 23 octets

Je ne peux pas tester sur mon téléphone, mais cela devrait fonctionner:

lambda s:s[:-~len(s)/2]
— Kade
source
2
Si vous utilisez Android, vous pouvez utiliser QPython à partir de Google Play Store. C'est le meilleur que j'ai trouvé :)
— Yytsi
termux apt-get install python2
— Matt
@ Matt C'est exagéré si tout ce que vous voulez, c'est Python.
— mbomb007
@ Matt ainsi que si vous pouvez trouver apt-getsur votre téléphone, ce n'est probablement pas un téléphone normal.
— Lawful Lazy
@MathManiac termux est installé à partir de Google Play sur tout téléphone Android non rooté. Je ne peux pas avoir beaucoup plus normal que ça.
— Matt
6

Fuzzy Octo Guacamole, 4 octets

2.^/

J'ai passé un certain temps à chercher une langue dans laquelle ce défi est court et me suis rendu compte que j'étais idiot et que ma propre langue faisait de même.

— Rɪᴋᴇʀ
source
5

Cheddar, 22 à 18 octets

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

Tellement simple que je ne pense pas besoin d'explication mais je vais en ajouter une si vous le souhaitez.

Essayez-le en ligne

— Downgoat
source
4

JavaScript (ES6), 32 26 25 octets

1 octet enregistré grâce à Neil:

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

Afficher l'extrait de code

Solutions précédentes
26 octets grâce à Downgoat:

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

32 octets:

s=>s.slice(0,(l=s.length/2)+l%2)
— Hedi
source
1
Vous pouvez raccourcir à tout simplement s=>s.slice(0,s.length/2+1)puisque la longueur sera toujours étrange
— Downgoat
@Downgoat, grâce à vous, j'ai trouvé que pour un octet supplémentaire, la s=>s.slice(0,s.length/2+.5)même longueur pouvait fonctionner.
— Hedi
2
-s.length/2fonctionne pour les longueurs impaires et paires.
— Neil
4

WinDbg, 87 71 octets

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

-16 octets en n'insérant pas la valeur NULL, en passant la longueur à da

L'entrée est transmise via une adresse dans psuedo-register $t0. Par exemple:

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.

Cela fonctionne en remplaçant le caractère du milieu du caractère (ou du milieu à droite si la chaîne a une longueur égale) par un null, puis affiche la chaîne à partir de l'adresse de la mémoire de départ d'origine.

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

Sortie:

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"
— Lait
source
3

Haskell, 27 octets

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

Version Pointfree de

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

qui est également 27 octets.

— nimi
source
3

MATL , 7 à 6 octets

9LQ2/)

Essayez-le en ligne!

Explication

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
source
1
Wow, c'est une façon très soignée de gérer des valeurs complexes comme arguments pour slicing
— miles
@miles Merci! Oui, c'est pratique. L'unité imaginaire fonctionne comme endet les deux points entre les éléments du tableau sont implicites
— Luis Mendo
3

Brachylog , 4 octets

@2tr

Essayez-le en ligne!

Explication

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

Si l'entrée a une longueur impaire, la seconde moitié générée par @2est celle qui est la plus longue, c'est celle à renvoyer (après l'inversion).

— Fataliser
source
3

Perl, 15 octets

Comprend +2 pour -lp

Donnez la chaîne d'entrée sur STDIN:

depal.pl <<< "HelleH"

depal.pl:

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

Ce -ln'est pas vraiment nécessaire si vous entrez le palindrome sans nouvelle ligne finale, mais je l'ai inclus pour être juste envers les autres solutions Perl qui l'utilisent.

— Ton Hospel
source
2

TI-Basic, 14 octets

Fonction standard. Renvoie la chaîne de l'index 1 à l'index (longueur / 2 + 1/2).

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

Langue GameMaker, 59 octets

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

PHP, 40 octets

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

strlen($a)/2est converti en int, l’entrée ayant toujours une longueur impaire, +1suffit à arrondir.

42 octets pour n'importe quelle longueur:

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

pour une longueur inconnue, (1+strlen)/2est moulé à int, arrondi strlen/2.

— Titus
source
Comme l'entrée est définie comme provenant de ce défi ( codegolf.stackexchange.com/questions/98325/… ), sa longueur sera toujours étrange, vous pouvez donc choisir le plus court.
— user59178
2

Dip, 8 octets

H{C'0ÏEI

Explication:

           # 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

Cela pourrait probablement être beaucoup amélioré.

— Oliver Ni
source
2

Perl, 23 + 2 ( -pldrapeau) = 28 25 octets

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

Ungolfed:

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

Merci à @ardnew.

— Denis Ibaev
source
1
vous pouvez économiser 3 caractères en les remplaçant length()pary|||c
— ardnew
2

Befunge , 24 22 octets

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

Essayez-le en ligne!

Befunge n'a pas de type chaîne ou tableau donc tout est fait sur la pile, un caractère à la fois. La première boucle (sur la ligne du haut) compte le nombre de caractères lus (un échange avec moins de 2 éléments dans la pile produit un 0 initial). La seconde (sur la ligne médiane) imprime les caractères tout en effectuant un compte à rebours deux fois plus rapide. En conséquence, seule la dernière moitié de la saisie est imprimée, mais LIFO est donc dans le bon ordre.

Merci à Brian Gradin pour une meilleure version de la première boucle.

— Linus
source
1
Tu m'as battu d'une demi-heure et 7 octets :) befunge.tryitonline.net/…
— Brian Gradin
@ BrianGradin, gentil. maintenant je t'ai battu par 9 octets;)
— Linus
Ah ok. Je vois ce que tu as fait. Je n'ai pas pensé à décompter par deux plutôt que de calculer le nombre réel de caractères à imprimer. Bien fait.
— Brian Gradin
2

Perl, 14 + 3 ( -lFdrapeau) = 19 17 octets

Pour 5.20.0+:

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

Pour 5.10.0+ (19 octets):

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)]);
}

Merci à @simbabque.

— Denis Ibaev
source
2
Vous pouvez enregistrer deux octets, vous ne pas besoin de définir -net -aparce que le -Ffait de façon implicite.
— simbabque
@ Zimbabwe Oui. Mais pour 5.20.0+ seulement.
— Denis Ibaev
2

Brainfuck, 20 octets

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

Essayez-le en ligne.

Cela évite de surcharger l'approche plus simple consistant à consommer l'entrée avant de commencer la boucle principale:

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

Pyth , 8 7 octets

<zh/lz2

Enregistré 1 avec merci à @Steven H

Pas la réponse la plus courte de Pyth (de moitié) mais je fais un effort pour apprendre la langue et ceci est mon premier post l'utilisant. Publié autant pour les commentaires et les réactions que rien. C'est aussi le premier programme Pyth que je dois réellement travailler :)

Maintenant, je dois juste comprendre comment fonctionne la réponse sur 4 octets de @Maltysen :-)

— ElPedro
source
1
Si vous voulez toujours savoir comment fonctionne la réponse de Maltysen, elle csaute l'entrée Qen 2morceaux et prend le premier morceau en utilisant h(qui, grâce à l'implémentation de hachage, saisira également la lettre centrale). En ce qui concerne votre code, vous pouvez remplacer +1par h, la fonction intégrée pour l’incrémentation des nombres.
— Steven H.
Merci pour l'explication et pour l' hindice @Steven H. Il y a tellement d'éléments intégrés que je suppose qu'il faut juste un certain temps pour les trouver tous :)
— ElPedro
1
Aucun problème! Si vous avez besoin d'aide, essayez de me contacter par le dix-neuvième octet.
— Steven H.
2

C, 31 30 octets

Enregistrement d'un octet grâce à Cyoce.

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

Usage:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}
— Karl Napf
source
@KevinCruijssen corrigé
— Karl Napf
Salut, désolé j'ai supprimé mon commentaire. J'avais raison de dire que cela ne fonctionnerait pas, même pour les palindromes. Mais, puisque c'est l'inverse de cet autre défi, il n'y aura pas de test pour les palindromes même. Désolé, vous pouvez annuler votre modification. +1 de moi. :)
— Kevin Cruijssen
2
Eh bien, il a maintenant la même longueur, fonctionne même pour + impair et a l’air plus golfeur. Je suis d'accord avec ça.
— Karl Napf
C'est sans doute une fuite de mémoire :-)
— ShreevatsaR
1
Je pense que vous pouvez supprimer l'espacechar* c
— Cyoce
1

MATLAB / Octave, 20 19 18 16 octets

1 octet sur empruntant une idée de la réponse de Easterly Irk (ajouter 1au lieu de .5)
2 octets à l'aide de @StewieGriffin (parenthèses inutiles)

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

Essayez chez Ideone .

— Luis Mendo
source
@StewieGriffin Merci! Je ne sais pas à quoi je pensais ...
— Luis Mendo
Moi non plus: P Ce n'est pas comme si c'était un "truc" que tu ne connaissais pas ... j'en ai eu quelques-uns aussi :)
— Stewie Griffin
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.