Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
Given a word, decide if it is an ambigram.
When rotated:
b > q
d > p
l > l
n > u
o > o
p > d
q > b
s > s
u > n
x > x
z > z
Assume only lowercase letters as input.
Test input:
this,
another,
lll,
lol,
dad,
dab,
dap,
wow,
ooi,
lollpopdodllol,
Ones That Should Return Truthy Values:
lll,
lol,
lollpopdodllol,
Note that input and output can be taken in any format (except for Standard Loopholes).
flip-text, 34 bytes[ dup flip-text "ʃ""l"replace = ]
Factor has a vocabulary for ʇxǝʇ ᵷuᴉddᴉʃɟ, but for some reason it turns l into ʃ, so I have to change it back.
-1 byte thanks to Kyle G
lambda s:[i*(i in b'losxz')or b'dbq0pnu0'[i%8]for i in s][::-1]==[*s]
Accepts a bytes object as input.
[... for i in s] Build an array mapping each letter i of s to...
i*(i in b'losxz') ... i, if i is one of the letters that should remain unchanged, or...
b'dbq0pnu0'[i%8] ... its rotation. Since the rotatable letters have unique code points mod 8, we can use that to index into a string of possible rotations. Note that multiple letters may map to a given letter (e.g. u and e both map to n), but that's fine since only the rotatable letters will form a reversible map (e.g. b->q->b)
[...][::-1]==[*s] Reverse the new array and compare to the original string, unpacked into an array.
ord(i)%8 and the string unpacking ([*s])
\$\endgroup\$
Jun 2 at 14:37
bytes or bytearray object instead of a string
\$\endgroup\$
θ⟲Ｔ⁴≔⪫ＫＡωη⎚⁼θΦη№bdlnopqsuxzι
Try it online! Link is to verbose version of code. Explanation:
θ
Print the input string to the canvas.
⟲Ｔ⁴
Rotate the canvas by 180°, transforming the characters as required.
≔⪫ＫＡωη
Read the transformed rotated string back from the canvas.
⎚
Clear the canvas.
⁼θΦη№bdlnopqsuxzι
Compare the two strings, and check that all of the letters in the string were valid. (This check costs half of the byte-count, ugh.)
ka«ƛG₈₀2ǔvȯF±ɾF)ǍrT«ĿṘ⁼
Try it online or verify all test cases.
ka«×¢₇}Ẇ₇]↲βjEβ&ɾṗµ«ĿṘ⁼
ka # Push the lowercase alphabet
«×¢₇}Ẇ₇]↲βjEβ&ɾṗµ« # Push compressed string "bqapaaaaaaalauodbasanaaxaz"
Ŀ # Transliterate the (implicit) input from the lowercase alphabet to that
Ṙ # Reverse
⁼ # Is it equal to the (implicit) input?
A port of Kevin's 05AB1E answer is 23 bytes as well:
Ḃ«ƛ≠ȧ‹«:£ḂĿka¥«g₴Ṡ«JFF=
z in your compressed string.
\$\endgroup\$
Jun 2 at 8:21
Saved 1 byte thanks to @Shaggy
Returns \$0\$ or \$1\$.
s=>[...s].map(c=>o=S[S.search(c)^1]+o,S=o='bqdpnulloossxxzz')|o==s+S
Edit: Thanks to ceilingcat for shortening the code to 172 171 bytes by using some nifty tricks!
Hello, first time posting code golf here! Criticism is welcome. :)
d[]={[98]=81,0,80,[108]=76,0,85,79,68,68,0,83,0,78,0,0,88,0,90};main(c,v)int**v;{for(char*s,*e;--c;s>e&&puts(v[c]))for(e=index(s=v[c],0);s<e--&d[*e]-*s+d[*s]+64==*e;)s++;}
Try it online (with explanation)
Explanation:
/**
* Thanks to ceilingcat for shortening the code to 171 bytes by using some nifty tricks!
*/
/**
* Stores the flipped equvilent of a character in upper case ASCII
* (sorry to anyone using EBCDIC) where the index is the character (lower case)
* and the value is the flipped equivalent of the character.
* The reason I used upper case is because writing many ['b'] = 'q' is more
* expensive (space-wise) than writing [66] = 81 and converting them each time
* (by adding or subtracting 32).
*/
d[]={[98]=81,0,80,[108]=76,0,85,79,68,68,0,83,0,78,0,0,88,0,90};
main(c,v)int**v;{
// Prints string if the 2 pointers crossed the middle which would
// mean the second loop never exited (is a palindrome) at the end.
for(char*s,*e;--c;s>e&&puts(v[c]))
// 'e=index(s=v[c],0)' gets the pointers for the first and last
// character of the string.
// Exits the loop when character '*s' is not equal to flipped character '*e' and
// vice versa or the 2 pointers cross at the middle of the string.
for(e=index(s=v[c],0);s<e--&d[*e]-*s+d[*s]+64==*e;)
s++;
}
:=~&(:~|~:tr&"pq#{?p*9}lpuodbpspnppxpp"&[*?a..?z]*'')
Just learning J-uby so this definitely is terrible.
Edit: I knew it. -95 bytes thanks to Steffan
\(s)all(chartr("a-y","AqCpE-KlMuodbRsTnVWxY",s)==rev(s))Takes input as a vector of characters.
Translates all characters from the dictionary in the question to their counterparts and all others to uppercase equivalents (comparison is case sensitive in R, so those will break the equality).
regex), 65 bytes^(([losxz])((?1)\2|)|b(?1)q|q(?1)b|d(?1)p|p(?1)d|n(?1)u|u(?1)n|)$
Try it online! - Perl
Try it online! - PCRE2
Try it online! - Boost
This is a straight port of my Perl/PCRE2/Boost answer to Numbers with Rotational Symmetry.
^ # Assert this is the start of the string
( # Define (?1) recursive subroutine call
([losxz]) # \2 = match a char that is its own rotation
((?1)\2|) # Optionally match (?1) followed by \2
|
b(?1)q
|
q(?1)b
|
d(?1)p
|
p(?1)d
|
n(?1)u
|
u(?1)n
|
# Match an empty string at the center of an even-length string
)
$ # Assert this is the end of the string
(This works in the latest version of Pythonregex, but not the one on TIO, and ATO doesn't have it installed.)
If there just one more matched pair of distinct characters, e.g. a↔e, another method would win by 3 bytes:
^(([losxz])((?1)\2|)|a(?1)e|e(?1)a|b(?1)q|q(?1)b|d(?1)p|p(?1)d|n(?1)u|u(?1)n|)$
^((?=([losxz]|a.*e|e.*a|b.*q|q.*b|d.*p|p.*d|n.*u|u.*n)(?<=(.))).((?1)\3|)|)$
But instead it loses by 1 byte:
^(([losxz])((?1)\2|)|b(?1)q|q(?1)b|d(?1)p|p(?1)d|n(?1)u|u(?1)n|)$
^((?=([losxz]|b.*q|q.*b|d.*p|p.*d|n.*u|u.*n)(?<=(.))).((?1)\3|)|)$
^((?=([losxz]|b.*q|q.*b|d.*p|p.*d|n.*u|u.*n)(?<=(.))).(\g<1>\k<3+0>|)|)$
In this port, unlike the Perl/PCRE2/Boost version, the alternative method wins by 5 bytes:
^(([losxz])(\g<1>\k<2+0>|)|b\g<1>q|q\g<1>b|d\g<1>p|p\g<1>d|n\g<1>u|u\g<1>n|)$
^((?=([losxz]|b.*q|q.*b|d.*p|p.*d|n.*u|u.*n)(?<=(.))).(\g<1>\k<3+0>|)|)$
^((?=([losxz]|b.*q|d.*p|n.*u|p.*d|q.*b|u.*n)(?<=(.))).?)+(?<-3>\3)*(?(3)^)$
This is a straight port of my .NET answer to Numbers with Rotational Symmetry.
^((?=([losxz]|b.*q|q.*b|d.*p|p.*d|n.*u|u.*n)(?<=(.))).?(?=.*(\3(?(4)\4))))*\4?$
Try it online! - Perl
Try it online! - PCRE1
Try it online! - PCRE2
Try it online! - .NET
^((?=([losxz]|b.*q|q.*b|d.*p|p.*d|n.*u|u.*n)(?<=(.))).?(?=.*(\3(\6\4|(?!\6))())))*\4?$
Try it online! - Perl
Try it online! - PCRE1
Try it online! - PCRE2
Try it online! - Java
Try it online! - .NET
regex), 90 bytes^(l(?1)l|o(?1)o|s(?1)s|x(?1)x|z(?1)z||b(?1)q|q(?1)b|d(?1)p|p(?1)d|n(?1)u|u(?1)n|[losxz]?)$
Try it online! - Perl
Try it online! - PCRE2
Try it online! - Python import regex
Unlike in Numbers with Rotational Symmetry, this comes in last place here. However, it's only with the old version of the mrab-regex Python module on TIO that this is needed. The 65 byte regex works in its latest version.
-7 bytes thanks to OVS
Prompts for text
t≡⌽'qpluodbsnxz '['bdlnopqsuxz'⍳t←,⎕]
≡, but ∧/t=⌽ ... should work?
\$\endgroup\$
Â.•1⋃•©Â‡A®.•(ÖÆ•«ммQ
Try it online or verify all test cases.
A port of @Steffan's Vyxal answer is 23 bytes as well:
ÂA.•1ηλ¥nô[˜ζÕPζeí=Ω•‡Q
Try it online or verify all test cases.
Explanation:
 # Bifurcate the (implicit) input-string, short for Duplicate & Reverse
.•1⋃• # Push the compressed string "bdunpq"
© # Store it in variable `®` (without popping)
 # Bifurcate it
‡ # Transliterate all "bdunpq" to "qpnudb"
A # Push the lowercase alphabet
® # Push string `®`
.•(ÖÆ•« # Append compressed string "losxz"
м # Remove all those characters from the alphabet: "acefghijkmrtvwy"
м # Remove all those characters from the modified input
Q # Check if it's equal to the input-string
# (after which the result is output implicitly)
 # Bifurcate the (implicit) input-string, short for Duplicate & Reverse
A # Push the lowercase alphabet "abcdefghijklmnopqrstuvwxyz"
.•1ηλ¥nô[˜ζÕPζeí=Ω•
# Push the compressed string "bqapaaaaaaalauodbasanaaxaz"
‡ # Transliterate the alphabet to these characters
Q # Check if it's equal to the input-string
# (after which the result is output implicitly)
See this 05AB1E tip of mine (section How to compress strings not part of the dictionary?) to understand why .•1⋃• is "bdunpq"; .•(ÖÆ• is "losxz"; and .•1ηλ¥nô[˜ζÕPζeí=Ω• is "bqapaaaaaaalauodbasanaaxaz".
s->Vecrev(s)==[Vec("`q`p```````l`uodb`s`n``x`z")[i-96]|i<-Vecsmall(s)]I never was very good at golf...
#include "string.h"
#include "stdio.h"
char z[8][2] = {{'b','q'},{'d','p'},{'n','u'},{'l','l'},{'o','o'},{'s','s'},{'x','x'},{'z','z'},};
void main(int argc, char *argv[])
{
int n = argc-1;
for (int x = 1; x <= n; x++){
int p = 0;
int l = strlen(argv[x]);
char r[l+1];
for (int i = l; i > 0; i--){
char c = argv[x][i-1];
int v = 0;
for (int a = 0; a < 8; a++){
if (c == z[a][0]){
c = z[a][1];
v = 1;
} else if (c == z[a][1]){
c = z[a][0];
v = 1;
}
}
if (!v) {p = 1;}
r[l-i] = c;
}
r[strlen(argv[x])+1] = '\0';
printf("%d\n", memcmp(r, argv[x], l) == 0 && p == 0);
}
}
Original, much more readable version:
#include "string.h"
#include "stdio.h"
char letters_to_rotate[8][2] = {
{'b', 'q'},
{'d', 'p'},
{'n', 'u'},
{'l', 'l'},
{'o', 'o'},
{'s', 's'},
{'x', 'x'},
{'z', 'z'},
};
void main(int argc, char *argv[])
{
int num_inputs = argc-1;
for (int x = 1; x <= num_inputs; x++){
int invalid_char_present = 0;
int inputlength = strlen(argv[x]);
char rotated[inputlength+1];
for (int i = inputlength; i > 0; i--){
char c = argv[x][i-1];
int valid_char = 0;
for (int a = 0; a < 8; a++){
if (c == letters_to_rotate[a][0]){
c = letters_to_rotate[a][1];
valid_char = 1;
}
else if (c == letters_to_rotate[a][1]){
c = letters_to_rotate[a][0];
valid_char = 1;
}
}
if (!valid_char) {invalid_char_present = 1;}
rotated[inputlength-i] = c;
}
rotated[strlen(argv[x])+1] = '\0';
if (memcmp(rotated, argv[x], inputlength) == 0 && invalid_char_present == 0){
printf("%s: True\n", argv[x]);
} else {
printf("%s: False\n", argv[x]);
}
}
}
for loop stuff.
\$\endgroup\$
Jun 3 at 0:01
let m="bqdpnulloossxxzz";let f=|s:&str|!s.chars().zip(s.chars().rev()).any(|(a,b)|m.find(a).or(Some(99))!=m.rfind(b).map(|x|x^1));
I'm pretty new to golfing so I hope I did it alright.
I'm still pretty unhappy with how verbose the code to fix the options is.
Returns 1 when palindrome, otherwise 0
PRINT IIF(translate(@,'bqdpnu','qbpdun')<>reverse(@)or
@ like'%[^qbpdunolsxz]%',0,1)
o=reverse(translate(o,'bdlnopqsuxzacefghijkmnrstuvwy','qpluodbsnxz'))
Tested with
with w as (
select column_value o
from
ku$_vcnt(
'this',
'another',
'lll',
'lol',
'dad',
'dab',
'dap',
'wow',
'ooi',
'lollpopdodllol'
))
select o from w
where
o=reverse(translate(o,'bdlnopqsuxzacefghijkmnrstuvwy','qpluodbsnxz'));
f()(a=bdlnopqsuxz;[ "`echo $1|tr $a qpluodbsnxz|tr -dc $a|rev`" = $1 ])
Using a more compact tr command as inspired by pajonk's answer:
f()([ "`echo $1|tr a-y AqCpE-KlMuodbRsTnVWxY|rev`" = $1 ])
!(($s=$args)|?{'dbqspn x z l uo'[$_%16]-$s[--$i]})
The script assumes an input does not contains space chars. I guess It is good constraint for a word.
The script takes a splatted string and performs double check for each symbol from the string.
The algorithm for the hash string dbqspn x z l uo is: Place an ambigram char at the position (ASCII % 16).
| Source char | ASCII | % 16 | Ambigram char |
|---|---|---|---|
| p | 112 | 0 | d |
| q | 113 | 1 | b |
| b | 98 | 2 | q |
| s | 115 | 3 | s |
| d | 100 | 4 | p |
| u | 117 | 5 | n |
| x | 120 | 8 | x |
| z | 122 | 10 | z |
| l | 108 | 12 | l |
| n | 110 | 14 | u |
| o | 111 | 15 | o |
$
¶$`
T`b\dl-qsuxzl`q\p\l_u\o\dbsnxz_`^.+
+`(.)¶\1
¶
^¶$
Try it online! Link includes test cases. Explanation:
$
¶$`
Duplicate the input.
T`b\dl-qsuxzl`q\p\l_u\o\dbsnxz_`^.+
Individually rotate the characters of the first copy, but delete characters that aren't rotatable. (d, l, o and p need to be quoted when not used as part of a range.)
+`(.)¶\1
¶
Compare the last character of the first copy with the first character of the second, removing both if they are equal. Repeat until either they don't match or there aren't any left.
^¶$
If there aren't any left then the original input was a rotational palindrome.
{x~|v(|v:"lnopqsxzxsbdoul")?x}
I took the shortest ambigram which contained all the possible characters and made it into a lookup string: locate where each character of the input is in the string, and then take one character from the reversed version to construct the rotated character. Finally, reverse it and compare against the original input.
s=>s==[...s].map(x=>'losxz'.includes(x)?x:(r='budpnq')[5-r.indexOf(x)]).reverse().join``
