Depalindromize this string!

Question

Given a palindrome generated according to this challenge, depalindromize it.

Test cases

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

As this is about depalindromizing, your code cannot be a palindrome.

Remember, this is code-golf, so the code with the fewest bytes wins.

Answer 1

Julia, 21 15 bytes

x->x[1:end/2+1]

Try it online! (extra code is for printing output)

Answer 2

05AB1E, 3 bytes

2ä¬

Uses the CP-1252 encoding. Try it online!

Answer 3

Python 2, 23 bytes

I am not able to test on my phone, but this should work:

lambda s:s[:-~len(s)/2]

Answer 4

Fuzzy Octo Guacamole, 4 bytes

2.^/

I spent a while searching for a language in which this challenge is short, and realized I was dumb and my own language did that.

Answer 5

05AB1E, 5 bytes

Dg;î£

Try it online!

Explanation:

D      Duplicate
 g;î   Divide length by two and round up
    £  First b letters of a

Answer 6

Cheddar, 22 18 bytes

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

So simple I don't think needs explanation but I'll add one if wanted.

Try it online

Answer 7

Pyth - 4 bytes

hc2Q

Test Suite.

Answer 8

JavaScript (ES6), 32 26 25 bytes

1 byte saved thanks to Neil:

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

f=
  s=>s.slice(0,-s.length/2)
;
console.log(f('abcdedcba'))
console.log(f('johncenanecnhoj'))
console.log(f('ppapapp'))
console.log(f('codegolflogedoc'))

---

Previous solutions
26 bytes thanks to Downgoat:

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

32 bytes:

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

Answer 9

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 by not inserting NULL, instead passing length to da

Input is passed in via an address in psuedo-register $t0. For example:

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.

It works by replacing the right of middle char (or right-middle if the string has even length) with a null and then prints the string from the original starting memory address.

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

Output:

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"

Answer 10

Haskell, 27 bytes

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

Pointfree version of

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

which is also 27 bytes.

Answer 11

MATL, 7 6 bytes

9LQ2/)

Try it online!

Explanation

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]

Answer 12

Jelly, 4 bytes

œs2Ḣ

Try it online!

Explanation

œs2      Split input into 2 chunks of similar lengths. For odd-length input,
         the first chunk is the longest
   Ḣ     Keep the first chunk

Answer 13

V, 12 bytes

Two completely different solutions, both 12 bytes.

ò"Bx$xh|ò"bP

Try it online!

Ó./&ò
MjdGÍî

Try it online!

Answer 14

Brachylog, 4 bytes

@2tr

Try it online!

Explanation

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

If the input has odd length, the second half generated by @2 is the one that is the longest, that is the one we should return (after reversing it).

Answer 15

Java 7, 57 bytes

String c(String s){return s.substring(0,s.length()/2+1);}

Answer 16

Dyalog APL, 9 bytes

⊢↑⍨2÷⍨1+≢

⊢ the argument

↑⍨ truncated at

2÷⍨ half of

1+ one plus

≢ the length

TryAPL online!

Answer 17

Perl, 15 bytes

Includes +2 for -lp

Give input string on STDIN:

depal.pl <<< "HelleH"

depal.pl:

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

The -l is not really needed if you input the palindrome without final newline, but I included it to be fair to the other perl solutions that use it.

Answer 18

PHP, 40 bytes

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

strlen($a)/2 gets cast to int, with the input always having odd length, +1 suffices to round up.

42 bytes for any length:

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

for unknown length, (1+strlen)/2 gets cast to int, rounding up strlen/2.

Answer 19

TI-Basic, 14 bytes

Standard function. Returns string from index 1 to index (length/2 + 1/2).

sub(Ans,1,.5+.5length(Ans

Answer 20

GameMaker Language, 59 bytes

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

Answer 21

C, 31 30 bytes

Saving 1 byte thanks to Cyoce.

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

Usage:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}

Answer 22

Actually, 5 bytes

l½KßH

Try it online!

-1 byte thanks to Sherlock9

Explanation:

l½K@H
l½K    ceil(len(input)/2)
   ßH  first (len(input)//2 + 1) characters of input

Answer 23

Perl, 23 + 2 (-pl flag) = 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 to @ardnew.

Answer 24

Dip, 8 bytes

H{C'0ÏEI

Explanation:

           # 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

This could probably be much improved.

Answer 25

Pyth, 8 7 bytes

<zh/lz2

Saved 1 with thanks to @Steven H

Not the shortest Pyth answer (by half) but I'm making an effort to learn the language and this is my first post using it. Posted as much for comments and feedback as anything. It's also the first Pyth program that I have actually got to work :)

Now I just need to work out how the 4 byte answer from @Maltysen works :-)

Answer 26

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

For 5.20.0+:

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

For 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 to @simbabque.

Answer 27

Befunge, 24 22 bytes

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

Try it online!

---

Befunge has no string or array type so the everything is done on the stack one character at a time. The first loop (on the top line) counts the number of characters read (swapping with less than 2 elements in the stack produces an initial 0). The second (on the middle line) prints characters while counting down twice as fast. As a result only the last half of the input is printed, but LIFO so it's in the correct order.

Thanks to Brian Gradin for a better version of the first loop.

Answer 28

Brainfuck, 20 bytes

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

Try it online.

This saves a byte over the more straightforward approach of consuming the input before starting the main loop:

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

Answer 29

><>, 7 15 bytes

l1+2,[v
 ;!?lo<

Try it here!

This is a full program. To use it simply place the palindrome on the stack, and the result will be outputted to stdout!

Explanation

l       get the stack length
 1+     add one
   2,   divide by two
     [  pop the value, create a new stack of that length

That's the meat of it, ol?!; just outputs until the stack is empty.

*><>, 11 bytes (non-competing)

l5+2,]r{[$.

Try it here! (first line is a program that calls the function, outputs the stack, then exits)

This is a function. To use it simply call it (instruction C) with the palindrome on the stack, and the result will be on the stack! This part is non-competing because *><> is younger than the challenge.

Explanation

l             get the stack length
 5+           add five
   2,         divide by two
     ]        close the stack
      r       reverse the stack
       {      shift the stack left
        [     pop the value on the end, create a new stack of that length
         $    swap the two values on the end of the stack
          .   jump back, with the result on the stack

For ><> coders who might be confused by this, a new stack is created when a function is called, so you can actually call ] right from the start if you're inside a function. The data inside this stack is the x, y coordinate of the ><> when C was called.

Answer 30

Keg, 7 bytes

^(!2/|_

That is easy but really hard to golf.

Explanation

^       # Input in the right order
 (!2/   # Repeat half of length times:
     |_ # Pop the stack

TIO

Answer 31

R, 35 bytes

substr(x<-scan(,''),1,nchar(x)/2+1)

Try it online!

Answer 32

Python 2, 23 bytes

lambda x:x[:len(x)/2+1]

Answer 33

MATLAB / Octave, 20 19 18 16 bytes

1 byte off borrowing an idea from Easterly Irk's answer (add 1 instead of .5)
2 bytes off thanks to @StewieGriffin (unnecessary parentheses)

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

Try it at Ideone.

Answer 34

C# 51 50 bytes

s=>string.Join("",s.Where((_,i)=>i<=s.Count()/2));

It's a lambda, woo!
You can catch it with:

Func<string,string> f=<your lambda here>

it requires the string to be a palindrome.

Answer 35

Pyke, 4 bytes

le>_

Try it here!

l    -    len(input)
 e   -   ^//2
  >  -  input[^:]
   _ - reversed(^)

Answer 36

IBM/Lotus Notes Formula, 21 bytes

@Left(a;@Length(a)/2)

Computed field that takes input from an editable field a. Works because Notes rounds up when an odd number is divided by 2.

Test Cases

Answer 37

Retina, 24 bytes

I basically took this from another answer of mine.

^((.)*?.??)(?<-2>.)*$
$1

Try it online

Answer 38

Racket 48 bytes

(substring s 0(+ 1(floor(/(string-length s)2))))

Ungolfed:

(define (f s)
  (substring s 0 (+ 1
                    (floor
                     (/ (string-length s)
                        2)))))

Testing:

(f "abcdedcba")
(f "johncenanecnhoj")
(f "ppapapp")
(f "codegolflogedoc")

Output:

"abcde"
"johncena"
"ppap"
"codegolf"

Answer 39

CJam, 7 bytes

r_,-2/<

Try it online!

Answer 40

GO, 43 bytes

func(s string)string{return s[:len(s)/2+1]}

Try it online!

Answer 41

Python 2, 22 bytes

lambda _:_[len(_)/2:]

Depalindromizes a given string. Still fails on all the test cases. Weird... ;-)

Answer 42

Python 3.5, 87 Bytes

x=list(input())
for q in range(0,int(round((len(x)/2)-0.1,0))):x.pop()
print(''.join(x))

i'm new to this codegolfing, but it's to be fun. I probably won't win but oh well.

Answer 43

Hexagony, 56 bytes

This is awful, but I just wanted to do it in Hexagony :)

Golfed:

,<_..){/"./..\&..$@....>;{.....'..>"+"+"&"='&'&=}\}=.:(<

In a hexagon:

     , < _ . .
    ) { / " . /
   . . \ & . . $
  @ . . . . > ; {
 . . . . . ' . . >
  " + " + " & " =
   ' & ' & = } \
    } = . : ( <
     . . . . .

Way to many no-ops...

Answer 44

OIL, 61 bytes

5
0
12
0
26
1
26
24
14
div
0
24
1
0
19
8
19
13
27

0
4
0
3

2

This uses the div from the standard library.

Answer 45

Japt, 5 bytes

¯ÒUÊz

Try it here

Answer 46

Ruby, 21 19 bytes

->s{s[0..s.size/2]}

Answer 47

Haskell, 27 bytes

f[x]=[x]
f(a:b)=a:f(init b)

No indexing. Recursively takes from the start and end, keeping letters from the end.

Answer 48

Perl 6, 21 bytes

*.substr(0,1+* div 2)

Expanded:

*\            # Whatever lambda
.substr(
  0,
  1 + * div 2 # Whatever lambda
)

Answer 49

Dyalog APL, 9 bytes

⊢↑⍨2÷⍨1+⍴

Thanks to Adám for saving 4 bytes.

Answer 50

Brain-Flak, 45 bytes

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

Try it online!

42 bytes of code, and +3 for the -c flag which enables ASCII input and output.

Answer 51

Python 3, 28 26 24 bytes

Python 3 strings don't like non-int indexes...

lambda S:S[:len(S)//2+1]

Alternatively, with the same byte count,

lambda S:S[:-~len(S)//2]

Answer 52

Java 7, 57 bytes

String c(String s){return s.substring(0,-~s.length()/2);}

At first I misinterpreted the question and also made code that supported even palindromes (which isn't necessary due to this being the reverse of that other challenge, and therefore there aren't any even palindrome test-cases). So I deleted my answer.
After seeing @KarlNapf's great answer however, I undeleted and edited this. It's the same byte count as the other Java 7 answer, but works for both odd and even length palindromes (although only odd were asked for this challenge).

Ungolfed & test code:

Try it here.

class M{
  static String c(String s){
    return s.substring(0, -~s.length()/2);
  }

  public static void main(String[] a){
    System.out.println(c("abcdedcba"));
    System.out.println(c("abcddcba"));
  }
}

Output:

abcde
abcd

Answer 53

Python 3, 26 bytes

lambda c:c[:(len(c)+1)//2]

This squeezes 2 chars out of the other Python3 answer by replacing the int() with division with //.

Answer 54

R, 59 bytes

Not pretty but it gets the job done.

cat(strsplit(scan(,""),"")[[1]][0:(nchar(x)%/%2)+1],sep="")

Answer 55

GolfSharp, 20 bytes

v=>v.R(0,v.L()/2+1);

Answer 56

PowerShell, 46 36 bytes

Unfortunately there's no PowerShell on Try it Online. Alas, here's my attempt.

$args[0][0..(($args[0].Length-1)/2)]

Answer 57

QBIC, 18 bytes

;?left$$|(A,_lA|/2)

; gets a command line parameter, then we print the left half of it using _l. Works fine for even and odd-length strings.

Answer 58

Lua, 28 bytes

x=...print(x:sub(1,#x//2+1))

Answer 59

Common Lisp, 43

(lambda(s)(subseq s 0(ceiling(length s)2)))

Truly hard to golf without accidentally writing a palindrome, will all those ( matching opposite ).

_{I know, this is not what "palindrome" means.}

Answer 60

Element, 11 bytes

_2:$'[(`)#]

Try it online!

_2:$'[(`)#]
_             take input
 2:           make a second copy
   $          length of string
    '[    ]   FOR loop
     [(`  ]   chop off then print the first character
     [  )#]   chop off then discard the last character

The FOR loop is actually executed about twice as many times as it needs to be, but those extra iterations do not affect the output since it runs out of data to print.

Answer 61

Scala, 21 bytes

a=>a.take(a.size/2+1)

requires an assignment with a type annotation: val f:(Seq[_]=>Seq[_])...

Answer 62

Clojure, 30 bytes

Clojure port of basically every answer here:

#(subs % 0(inc(/(count %)2)))

Should be self explanatory.

Answer 63

Java 8, 33 bytes

Same logic as @Numberknot, but with 24 less bytes due to the use of lambdas. I tried to add this as an update to @Numberknot but with no response therefore I posted this as a separate answer since it's a big difference in bytes between his and my answer.

s->s.substring(0,s.length()/2+1);

Ungolfed version:

interface Func { String foo(String s); }


public class Main
{
    public static void main(String[] args)
    {
        Func s = s->s.substring(0,s.length()/2+1);           
    }
}

Answer 64

C#, 26 bytes

s=>s.Remove(s.Length/2+1);

This removes the end of the string.

Answer 65

R, 35 bytes

Always late to the party.

substr(x<-scan(,""),1,nchar(x)/2+1)

Answer 66

Ruby, 20 bytes

->n{n[0,-~n.size/2]}

anonymous lambda that returns the first half (rounded up) of a string. The -~n is a 1+n with a higher priority than the division by two, so I don't need any parentheses. Unlike the other Ruby solution, this works on strings with even lengths.

Usage:

->n{n[0,-~n.size/2]}["abba"]
->n{n[0,-~n.size/2]}["abcba"]
->n{n[0,-~n.size/2]}["a"]

Returns:

"ab"
"abc"
"a"