文字列を降順の数値に変換する関数

Question

表題のような関数をjavaで作成したいと考えています。
文字列xに対して降順となる数値もしくは文字列aを返す関数です。
f(x) = a
ただし、文字列xがx2>x1(x2.compareTo(x1)>0)のとき、aは降順、つまり、a2<a1となる数値か、もしくは、a2.compareTo(a1)<0となるような文字列を求めたいです。

例えば、以下になるような数値もしくは文字列を返す関数です。
f("1") = 10 だとすると、f("2") = 9
f("a") = 5 だとすると、f("b") = 4

右辺は順序が降順になっていれば自由な値で構いません。

これは、入力値を関数内でソートするようなものではなく、関数は複数回呼ばれますが、その値が結果的に降順になるというものです。

例えば、xがlongの最大値よりも小さい数字の場合、関数は以下のように書けます。
java.lang.Long.MAX_VALUE-Long.parseLong(x)
これを、xが文字列の場合でも求めたいのです。

そもそもの要件として、昇順しかソートできないKVSで降順を実現するために、降順用に項目を１つ追加し、降順の値を格納してそれをKVSの機能で昇順ソートすることで降順を実現したいというものです。

ヒントをもらって実装してみましたがダメでした。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class DescTest {

	public static void main(String[] args) {
//		String[] src = {"a", "b", "A", "abc", "def", "ab", "abcd", "あいうえお", "かきくけこ"};
		String[] src = {"a", "b", "c", "d", "e", "f", "g", "h", "i"};
		Map<Integer,String> dist = new HashMap<Integer,String>();

		for(int i=0;i<src.length;i++) {
			dist.put(i, DescTest.decKey(src[i]));
//			dist.put(i, src[i]);
		}
		
		List<Map.Entry<Integer,String>> entries = 
	              new ArrayList<Map.Entry<Integer,String>>(dist.entrySet());
	        Collections.sort(entries, new Comparator<Map.Entry<Integer,String>>() {
	 
	            @Override
	            public int compare(
	                  Entry<Integer,String> entry1, Entry<Integer,String> entry2) {
	                return (entry1.getValue()).compareTo(entry2.getValue());
	            }
	        });
	        
        for (Entry<Integer,String> s : entries) {
            System.out.println("s.getKey() : " + s.getKey());
            System.out.println("s.getValue() : " + src[s.getKey()]);
        }
	}

	public static String decKey(String s) {
	    char[] c = s.toCharArray();
	    int v = c[0];
//	    System.out.print("c="+v+" ");
	    for(int i = 0; i < c.length; i++) {
	        c[i] = (char)(65535 - c[i]);
	    }
	    return c.toString();
	}
	
}

結果（降順にならない）

s.getValue() : b
s.getKey() : 4
s.getValue() : e
s.getKey() : 8
s.getValue() : i
s.getKey() : 6
s.getValue() : g
s.getKey() : 0
s.getValue() : a
s.getKey() : 7
s.getValue() : h
s.getKey() : 3
s.getValue() : d
s.getKey() : 2
s.getValue() : c
s.getKey() : 5
s.getValue() : f

よろしくお願いします。

Comments

[maisumakun]

使う文字列の範囲は決まっていますか？

[stakezaki]

範囲を決めないと多分作れないと思うので、xの文字数の最大の長さは固定として構いません。

[maisumakun]

返り値の型をlongまでで考えると、あらゆる文字列を処理して矛盾しないようにするには「4文字」以下しか処理できませんが、それで問題ないでしょうか。

[stakezaki]

いえ、それでは困りますので、戻り値の型はStringを希望します。

[maisumakun]

では逆に、Comparableを返す、という形では対応できないでしょうか。

[stakezaki]

Comparableが返ってきた場合に、どのように降順の値を求めればいいかわからないです（これまで入力された値をすべて入れて実行するのは不可能なので）

[maisumakun]

そもそもの要件として、「得られた値をどのように使いたい」のかを聞き忘れていましたね。

[stakezaki]

すみません、質問に追記いたしました。

[stakezaki]

文字列を数値化して最大値から引き算すればいいような気はしていますが、どのように実装すればいいのか。。

[stakezaki]

少しわかってきたので自己解決に書きました。実装方法はまだです。

Answer 1

例えば、xがlongの最大値よりも小さい数字の場合、関数は以下のように書けます。

java.lang.Long.MAX_VALUE-Long.parseLong(x)
これを、xが文字列の場合でも求めたいのです。

ということであればUnicodeに変換すれば良いのではないでしょうか？

BMPの範囲内であれば4桁の16進数を用いてU+0000～U+FFFFで表せるので、FFFF-その文字のUnicodeで求められると思います。

例）文字がaの場合
文字「a」はUnicodeでは「U+0061」の為、FFFF-0061を計算する

尚、サロゲートペアを含めて考える必要がある場合には第16面の最大値であるU+10FFFFを用いれば良いかと思います。

文字列をUnicodeに変換するには以下のコードで可能です。

public static String toUnicode(String str)
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < str.length(); i++) {
        sb.append(String.format("\u%04X", Character.codePointAt(str, i)));
    }
    String unicode = sb.toString();
    return unicode;
}

このメソッドに「a」を通すと、返り値は「\u0061」となるので、
あとは\uを除いた「0061」を取得し、16進数で計算する部分を加えればよいはずです。

Comments

[stakezaki]

おっしゃるように、サロゲートペアまで考慮するとこの方法になるかと思います。ありがとうございます。

Answer 2

全部ひっくり返せばいいんでない？

public static String decKey(String s) {
    char[] c = s.toCharArray();
    for(int i = 0; i < c.length; i++) {
        c[i] = (char)(65535 - c[i]);
    }
    return new String(c);
}

ごめんなさい、肝心の返り値を書いていませんでした。なお、この方法だと「a」「ab」のような「一方が他方より長いだけ」の順番が逆にならないのでご注意を。

てっきりJavaでのソートができない、あるいは何か別の固有の機能でソートするのかと思っていましたが、Javaプログラム上での並び替えができるなら簡単に済みます。
(entry1とentry2が逆になっているのがポイント)

            Collections.sort(entries, new Comparator<Map.Entry<Integer,String>>() {

                @Override
                public int compare(
                      Entry<Integer,String> entry1, Entry<Integer,String> entry2) {
                    return (entry2.getValue()).compareTo(entry1.getValue());
                }
            });

なお、Java8以降であればyukkuriさんの回答のようなstaticメソッドでのComparatorが使えて便利です。

Comments

[stakezaki]

もしかしたら最大桁数で合わせないといけないかもしれませんが、こちらでいけるかもしれません。参考にさせていただきます。

[stakezaki]

やってみましたが降順にはなりませんでした。（質問文に試したコードを追加しています）

[stakezaki]

質問文のコードは計算結果の検証のためにソートを使っておりますが、Javaプログラム上での並び替えはできません。

[stakezaki]

最初に教えていただいたコードを少し修正したらできました。ありがとうございます。

Answer 3

以下で解決しました。(サロゲートペアはとりあえず無視しています）

    public static String decKey(String s) {
        char[] c = s.toCharArray();
        String result = "";
        for(int i = 0; i < c.length; i++) {
            result += (char)(65535 - c[i]);
        }
        return result;
    }

検証用プログラム

package jp.reflexworks.atom.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class DescTest {

    public static void main(String[] args) {
        String[] src = {"a", "b", "A", "abc", "def", "ab", "abcd", "あいうえお", "かきくけこ"};
//        String[] src = {"a", "b", "c", "d", "e", "f", "g", "h", "i"};
        Map<Integer,String> dist = new HashMap<Integer,String>();

        for(int i=0;i<src.length;i++) {
            dist.put(i, DescTest.decKey(src[i]));
        }

        List<Map.Entry<Integer,String>> entries = 
                  new ArrayList<Map.Entry<Integer,String>>(dist.entrySet());
            Collections.sort(entries, new Comparator<Map.Entry<Integer,String>>() {

                @Override
                public int compare(
                      Entry<Integer,String> entry1, Entry<Integer,String> entry2) {
                    return (entry1.getValue()).compareTo(entry2.getValue());
                }
            });

        for (Entry<Integer,String> s : entries) {
            System.out.println("s.getKey() : " + s.getKey());
            System.out.println("s.getValue() : " + src[s.getKey()]);
        }
    }

    public static String decKey(String s) {
        char[] c = s.toCharArray();
        String result = "";
        for(int i = 0; i < c.length; i++) {
            result += (char)(65535 - c[i]);
        }
        return result;
    }

}

実行結果

s.getKey() : 8
s.getValue() : かきくけこ
s.getKey() : 7
s.getValue() : あいうえお
s.getKey() : 4
s.getValue() : def
s.getKey() : 1
s.getValue() : b
s.getKey() : 0
s.getValue() : a
s.getKey() : 5
s.getValue() : ab
s.getKey() : 3
s.getValue() : abc
s.getKey() : 6
s.getValue() : abcd
s.getKey() : 2
s.getValue() : A

Answer 4

自己解決とまではいきませんが、文字列の大小比較をもう少し詳しく調べてみる（チェリー本の補足として）をヒントに、文字列をbyte配列として計算すればよさそうというのがわかってきました。

例えば、最大３文字として、
入力値 : ABCのbyte配列 => [65, 66, 67] を最大値[FF,FF,FF]から引いたものを降順の値とすることで解決できそうです。

Answer 5

こういう感じでしょうか。

import java.util.Arrays;
import java.util.Comparator;

// main関数省略

Integer arrayup[] = {3, 2, 1, 5, 4};   // 昇順用
Integer arraydown = arrayup;

Arrays.sort(arrayup, Comparator.naturalOrder()); // 昇順になる

Arrays.sort(arraydown, Comparator.reverseOrder()); // 降順になる

int count = 0;    // 使用する arrayup の位置
System.out.println( "f(\"" + arrayup[ count ] + "\") = " + arraydown[ arrayup.length - count - 1 ] );

###コメントによる追記
あまりメモリを気にしないなら、

int c = 1;   // 入力値 c番目
int max = 400; // 最大値  // これと上はコマンドラインで持ってきて変換したと想定

Integer arrayup = new Integer[ max ];
for( int l = 0; l < max - 1; l++ ){
    arrayup[ l ] = l;
}

// 降順にするなどは上の回答を参照してください。

(すいません。わたしには1 -> 400 みたいにする式が出てきませんでした。その式を使うと
もっと効率化できるはずです。)

質問の追記による追記

ここまで式が出ているのなら、文字列から変換すればいいのでは？

String atai = "21";

long l = Long.parceLong( atai );

質問者自身の回答を見させていただいて

例えば、最大３文字として、

入力値 : ABCのbyte配列 => [65, 66, 67] を最大値[FF,FF,FF]から引いたものを降順の値とすることで解決できそうです。

ということなので、このような感じでしょうか。

/**
 * 降順にソートします。
 *
 * @param by 変換する Byte 配列(長さはどれでもいいはず)
 *
 * @return 変換後の Byte[ by.length ]
 */
public Byte[] sort( Byte[] by )
{
    Byte base = by;    // 念の為コピー
    for( int  l = 0; l < base.length; l++ ){
        base[ l ] = FF - base[ l ];
    }
    return base;   // もしかしたら変数自体変更で void でいける？
}

蛇足:そろそろ長くなってきたから回答分けようかなぁ...

Comments

[stakezaki]

説明不足ですみません。入力値の最大文字数は固定で構いませんが、入力値自体は固定ではなく、都度入力されると考えてください。関数内部にすべての入力値を保持することもできません。

[yukkuri]

コマンドライン変数を、Integer もしくは int に変換すればいいかと。あと、最大文字数は固定で入力値は可変だと、安全性に問題がある気がしますが、まあifでどうにかなるか。というもんなのでだいじょうぶでしたすいません。

[yukkuri]

回答に追記しました。

[stakezaki]

まだ意図が伝わっていない感じです。入力値を関数内でソートするようなものではなく、関数は複数回呼ばれますが、その値が結果的に降順になるというものです。

[stakezaki]

質問欄に数値の場合の例を追記しました。

[cateye]

>関数内部にすべての入力値を保持することもできません。・・・は、前回返した最大と最小は保持できると考えていいのですか？

[stakezaki]

前回返した最大と最小も保持できないとお考えください。

[yukkuri]

上のを見た限り、関数に保持できない->クラスには保持できる、ということになりますが、多分それもなしなんですよね？

[cateye]

比較対象がなくてどうやって大小を見つけるんでしょうか？？；

[stakezaki]

比較対象は入力の文字コードの値になります。相対的に大小を計算するには文字コードの値をひっくり返すしかないと思っています。

[cateye]

ごめん、頭悪いので教えて欲しいんですが、前回の文字コードって保持できるんですか？

[stakezaki]

保持はできないですね

[yukkuri]

もうここに追記でいいや。
Stringならcharに変換できる(charAt())なので、FF-charAt()で解決できませんか？
(私は頭悪いので100%は理解できてない)

[stakezaki]

charはFFFFが最大なのでFFFF-charAt()で解決できます。解決したコードを記入しました。ありがとうございました。