Given a palindrome generated according to this challenge, depalindromize it.
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.
I am not able to test on my phone, but this should work:
lambda s:s[:-~len(s)/2]
apt-get on your phone, it's probably not a normal phone.
\$\endgroup\$
Commented
Nov 6, 2016 at 0:04
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.
Dg;î£
Explanation:
D Duplicate
g;î Divide length by two and round up
£ First b letters of a
@.head($0.len/2+1)
So simple I don't think needs explanation but I'll add one if wanted.
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)
s=>s.slice(0,s.length/2+1) Since length will always be odd
\$\endgroup\$
s=>s.slice(0,s.length/2+.5) would work for even length too.
\$\endgroup\$
-s.length/2 works for both odd and even lengths.
\$\endgroup\$
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"
take=<<succ.(`div`2).length
Pointfree version of
\x->take(div(length x)2+1)x
which is also 27 bytes.
9LQ2/)
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]
end, and colons between the array elements are implicit
\$\endgroup\$
Commented
Nov 3, 2016 at 1:01
œs2Ḣ
œs2 Split input into 2 chunks of similar lengths. For odd-length input,
the first chunk is the longest
Ḣ Keep the first chunk
@2tr
@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).
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.
String c(String s){return s.substring(0,s.length()/2+1);}
} (so it's 57 bytes).
\$\endgroup\$
Commented
Nov 3, 2016 at 9:09
Standard function. Returns string from index 1 to index (length/2 + 1/2).
sub(Ans,1,.5+.5length(Ans
a=argument0 return string_copy(a,1,ceil(string_length(a)/2)
<?=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.
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.
-pl flag) = 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.
length() with y|||c
\$\endgroup\$
~:0`!#v_\1+
0:-2,\_@#`
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.
-lF flag) = 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.
-n and -a because -F does so implicitly.
\$\endgroup\$
Commented
Nov 4, 2016 at 12:05
,
[
[>,]
<[<]
>.,>[>]
<<
]
This saves a byte over the more straightforward approach of consuming the input before starting the main loop:
,[>,]
<
[
[<]
>.,>[>]
<,<
]
<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 :-)
chops the input Q into 2 pieces and takes the first piece using h (which, thanks to the implementation of chop, will grab the center letter as well). As for your code, you could replace +1 with h, the built-in for incrementing numbers.
\$\endgroup\$
Commented
Nov 7, 2016 at 10:08
h hint @Steven H. There are so many built-ins I guess it just takes some time to find them all :)
\$\endgroup\$
l½KßH
-1 byte thanks to Sherlock9
Explanation:
l½K@H
l½K ceil(len(input)/2)
ßH first (len(input)//2 + 1) characters of input
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);
}
char* c
\$\endgroup\$
lambda x:x[:len(x)/2+1]
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)