怎么把一个字母倒过来？答案

【问题标题】：How to flip a letter upside down?怎么把一个字母倒过来？
【发布时间】：2014-08-13 20:24:51
【问题描述】：

在这里，我试图将一封英文字母颠倒过来作为我的邮件模板。

好吧，我可以手动获取它。我现在做的是手动的

就像

 content.append("ɥ"); //actual h letter.
 content.append("ǝ")// actual e letter.

所以我的问题是，是否有任何技巧/方法/任何线索可以以编程方式做到这一点？

我现在正在做的是

switch(letter) {

case 'e':
   return 'ǝ';
}

这看起来很奇怪，正在寻找提示。感谢您的帮助。

【问题讨论】：

This site 做到了。您可能想查看源代码。它是 javascript，但可以移植到 java :)
你能把它们的 int 值关联起来吗，如果不能，你能不能只创建一个硬编码的地图？
@BackSlash 太奇怪了：P if -else- if.
@JigarJoshi 如果没有选项，肯定会这样做:)
根据您对字符串所做的操作，您还可以将其绘制到 BufferedImage，然后翻转 BufferedImage 本身。哎呀。

标签： java character-encoding char

【解决方案1】：

试试这个脚本，在这里：http://ideone.com/szPg6V

输入：

'所以我的问题是，是否有任何技巧/方法/任何线索可以以编程方式做到这一点？'

输出：

,¿ ʎɐʍ ɔıʇɐɯɯɐɹboɹd uı ʇı op oʇ ǝnןɔ ʎuɐ/poɥʇǝɯ/ʞɔıɹʇ ʎuɐ ǝɹǝɥʇ sı 'ʇɐɹʇ sı uoıʇs

Java 代码：

String normal = "abcdefghijklmnopqrstuvwxyz_,;.?!/\\'";
String split  = "ɐqɔpǝɟbɥıظʞןɯuodbɹsʇnʌʍxʎz‾'؛˙¿¡/\\,";
//maj
normal += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
split  += "∀qϽᗡƎℲƃHIſʞ˥WNOԀὉᴚS⊥∩ΛMXʎZ";
//number
normal += "0123456789";
split  += "0ƖᄅƐㄣϛ9ㄥ86";

String str = "So my question is that , is there any trick/method/any clue to do it in programmatic way ?";
String newstr = ""; 
char letter;
for (int i=0; i< str.length(); i++) {
    letter = str.charAt(i);

    int a = normal.indexOf(letter);
    newstr += (a != -1) ? split.charAt(a) : letter;
}
System.out.println(new StringBuilder(newstr).reverse().toString());

我使用这个工具：http://www.upsidedowntext.com/

【讨论】：

【解决方案2】：

我写了一个代码以编程方式来做，但是代码很慢。

代码计算所有字母形状与翻转字符形状之间的差异，并选择面积最小的那个。

例子：

a ɐ
e ǝ
i ı
o o
u n

代码：

import java.awt.Font;
import java.awt.Shape;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.PathIterator;
import java.awt.geom.Rectangle2D;

class Main {
    private static final Font FONT = new Font(Font.MONOSPACED, Font.PLAIN, 24);

    private static Shape moveToOrigin(Shape s) {
        Rectangle2D r = s.getBounds2D();
        return AffineTransform.getTranslateInstance(-r.getX(), -r.getY())
                .createTransformedShape(s);
    }

    private static Shape flip(Shape s) {
        Rectangle2D r = s.getBounds2D();
        return AffineTransform.getRotateInstance(Math.PI, r.getCenterX(),
                r.getCenterY()).createTransformedShape(s);
    }

    private static double getArea(Shape s) {
        PathIterator path = s.getPathIterator(new AffineTransform());
        double area0 = 0;
        while (!path.isDone()) {
            double area = 0;
            double[] darray = new double[6];
            path.currentSegment(darray);
            double x0 = darray[0], y0 = darray[1];
            double x1 = x0, y1 = y0;
            path.next();
            while (path.currentSegment(darray) != PathIterator.SEG_CLOSE) {
                double x2 = darray[0], y2 = darray[1];
                area += x1 * y2 - y1 * x2;
                x1 = x2;
                y1 = y2;
                path.next();
            }
            path.next();
            area0 += Math.abs((area + x1 * y0 - y1 * x0) / 2);
        }
        return area0;
    }

    public static char findOpposite(char c) {
        FontRenderContext frc = new FontRenderContext(new AffineTransform(),
                true, false);
        GlyphVector gv1 = FONT.createGlyphVector(frc, String.valueOf(c));
        Area area1 = new Area(flip(moveToOrigin(gv1.getOutline())));

        double minDiff = 1.0 / 0.0;
        char bestChar = ' ';
        for (int i = 0; i <= Character.MAX_VALUE; i++) {
            GlyphVector gv2 = FONT.createGlyphVector(frc,
                    String.valueOf((char) i));
            Area area2 = new Area(moveToOrigin(gv2.getOutline()));
            area2.exclusiveOr(area1);

            double diff = getArea(area2);

            if (diff < minDiff) {
                minDiff = diff;
                bestChar = (char) i;
                System.err.println(bestChar + " : " + minDiff);
            }
            if (i % (Character.MAX_VALUE / 100) == 0) {
                System.err.println(i / (Character.MAX_VALUE / 100) + "%");
            }
        }
        return bestChar;
    }

    public static void main(String[] args) {
        System.out.println('a' + " " + findOpposite('a'));
        System.out.println('e' + " " + findOpposite('e'));
        System.out.println('i' + " " + findOpposite('i'));
        System.out.println('o' + " " + findOpposite('o'));
        System.out.println('u' + " " + findOpposite('u'));
    }
}

【讨论】：

【解决方案3】：

如果您不喜欢上面的任何示例，您可以随时使用枚举。通过这种方式，您可以添加您可能想要的其他字符，并将它们各自的等价物颠倒过来。

示例：

//only lower case in this example, but new values can be added
enum upsideDown{
    a('ɐ'),
    b('q'),
    c('ɔ'),
    d('p'),
    e('ə'),
    f('ɟ'),
    g('ƃ'),
    h('ɥ'),
    i('ı'),
    j('ɾ'),
    k('ʞ'),
    l('l'),
    m('ɯ'),
    n('u'),
    o('o'),
    p('d'),
    q('b'),
    r('ɹ'),
    s('s'),
    t('ʇ'),
    u('n'),
    v('ʌ'),
    w('ʍ'),
    x('x'),
    y('ʎ'),
    z('z');
    private char value;

    private upsideDown(char value) {
        this.value = value;
    }
    private char getValue(){
        return value;
    }
};


public static void main(String[] args) {

    String hello = "helloworld";
    StringBuilder str = new StringBuilder(hello.length());
    for (int i = hello.length()-1; i >= 0; i--) {
        str.append(upsideDown.valueOf(String.valueOf(hello.charAt(i))).getValue());
    }
    System.out.println(str.toString());

}

【讨论】：

【解决方案4】：

进行字符替换的最快方法是数组。

创建一个颠倒的字母数组。然后，检查传入的值并找到匹配的值。

Java 允许您通过简单地转换 int x = char a; 来获得字符的整数表示，因此，按道理，您的颠倒 a 将在您的 char 的索引处减去您正在映射的最低 char（通常是小写的 a )。

char[] updown = {'ɐ','q','ɔ','p','ə','ɟ','ƃ','ɥ','ı','ɾ','ʞ','l','ɯ','u','o','d','b','ɹ','s','ʇ','n','ʌ','ʍ','x','ʎ','z'};
//this example uses 26 chars, all lower case;
int a = 'a';
int z = 'z';

String newString = "";
for(int i=0; i<string.length; i++){
    int ch = string.charAt(i);
    if(ch>= a && ch <=z){
        newString = (updown[ch-a]) + newString;
    }
}

这是一个指向 IDEONE 的链接，您可以在其中自己编译和测试。 http://ideone.com/LombFE

【讨论】：

我不想自己写/维护这些字母。并且需要务实地翻转它。
有什么理由不这样做吗？您可以将数组设为常量，然后将其设为 O(1) 中的程序转换的一个条目
大写字母和特殊符号呢？？这就是原因。提供赏金，让我们看看情况如何。如果没有人回答，我当然会给出这个答案，就像我已经投票一样:)
尽我所能，我找不到unicode颠倒的大写字母。有些存在，如 A、E 和 F，但不是完整的字母表。至于特殊字符，思路是一样的。将它们按顺序放入一个数组中，然后当字符在它们的范围内时引用该数组。

【解决方案5】：

如果您正在寻找一种通用的方法来创建颠倒的纯文本，那是没有办法的。

所有这样做的网站，只需替换足够的 unicode 字符，这些字符与原始字符没有任何共同之处，而对于某些网站，他们什么也找不到。没有办法让任何看起来像颠倒的j，所以你可以在其他答案中看到，所谓的“颠倒j”看起来很难看。如果您正在寻找颠倒的ß 或@ 或5，您也找不到任何东西。颠倒文字的网站要么忽略这些符号，要么使用完全不同的东西，要么干脆什么都没做。

Unicode 处理文本的内容，而不是它的方向。

您提到了邮件模板。如果您使用的是 HTML，则可以使用以下 CSS：

.upsidedown {
    -moz-transform: rotate(180deg);
    -webkit-transform: rotate(180deg);
    -ms-transform: rotate(180deg);
    -o-transform: rotate(180deg);
    transform: rotate(180deg);
}

但并非所有邮件客户端都能正确显示。

【讨论】：

【解决方案6】：

我不确定特定于 java 的解决方案，但是看到 java 中的字符串使用 unicode，我在这里检查了 unicode 字符的颠倒对应物：http://www.fileformat.info/convert/text/upside-down-map.htm

看起来没有一个好的程序化方法可以找到这些。不过转换器有很多种，比如这个http://www.fileformat.info/convert/text/upside-down.htm 您可以根据其中一种转换器的输入和输出生成配置文件，并使用这些配置文件来驱动您的倒置字母选择

【讨论】：

感谢雅各布的链接。