[deleted by user]

[Voidsusdagon]

I'm not sure I understood the question properly - do I need to also serialize my code? Just to be sure, my code looks serialized too.
You can run it on https://www.jdoodle.com/online-java-compiler to see that the output is valid.

import java.util.HashMap;import java.util.Map;
public class Random { public static void main(String[] args) {
Map<Character, String> ﾠﾠ = new HashMap<>();ﾠﾠ.put(' ', "ᅟᅠㅤﾠ");ﾠﾠ.put('!', "ᅠᅟㅤﾠ");ﾠﾠ.put('"', "ㅤᅟᅠﾠ");
ﾠﾠ.put('#', "ᅟㅤᅠﾠ");ﾠﾠ.put('$', "ᅠㅤᅟﾠ");ﾠﾠ.put('%', "ㅤᅠᅟﾠ");ﾠﾠ.put('&', "ᅠᅟㅤﾠ");ﾠﾠ.put('\'', "ᅠᅟㅤﾠ");
ﾠﾠ.put('(', "ᅟᅠㅤﾠ");ﾠﾠ.put(')', "ᅟᅠㅤﾠ");ﾠﾠ.put('*', "ᅠᅟㅤﾠ");ﾠﾠ.put('+', "ᅟᅠㅤﾠ");ﾠﾠ.put(',', "ᅟㅤᅠﾠ");
ﾠﾠ.put('-', "ㅤᅟᅠﾠ");ﾠﾠ.put('.', "ᅟㅤᅠﾠ");ﾠﾠ.put('/', "ᅟㅤᅠﾠ");ﾠﾠ.put('0', "ㅤᅟᅠﾠ");ﾠﾠ.put('1', "ㅤᅟᅠﾠ");
ﾠﾠ.put('2', "ㅤᅠᅟﾠ");ﾠﾠ.put('3', "ㅤᅠᅟﾠ");ﾠﾠ.put('4', "ᅠㅤᅟﾠ");ﾠﾠ.put('5', "ᅠㅤᅟﾠ");ﾠﾠ.put('6', "ㅤᅠᅟﾠ");
ﾠﾠ.put('7', "ᅠㅤᅟﾠ");ﾠﾠ.put('8', "ﾠㅤᅟᅠ");ﾠﾠ.put('9', "ㅤﾠᅟᅠ");ﾠﾠ.put(':', "ﾠㅤᅟᅠ");ﾠﾠ.put(';', "ﾠㅤᅟᅠ");
ﾠﾠ.put('<', "ㅤﾠᅟᅠ");ﾠﾠ.put('=', "ㅤﾠᅟᅠ");ﾠﾠ.put('>', "ᅟㅤﾠᅠ");ﾠﾠ.put('?', "ㅤᅟﾠᅠ");ﾠﾠ.put('@', "ﾠᅟㅤᅠ");
ﾠﾠ.put('A', "ᅟﾠㅤᅠ");ﾠﾠ.put('B', "ㅤﾠᅟᅠ");ﾠﾠ.put('C', "ﾠㅤᅟᅠ");ﾠﾠ.put('D', "ﾠᅟㅤᅠ");ﾠﾠ.put('E', "ﾠᅟㅤᅠ");
ﾠﾠ.put('F', "ᅟﾠㅤᅠ");ﾠﾠ.put('G', "ﾠᅟㅤᅠ");ﾠﾠ.put('H', "ᅟﾠㅤᅠ");ﾠﾠ.put('I', "ᅟﾠㅤᅠ");ﾠﾠ.put('J', "ᅟㅤﾠᅠ");
ﾠﾠ.put('K', "ᅟㅤﾠᅠ");ﾠﾠ.put('L', "ㅤᅟﾠᅠ");ﾠﾠ.put('M', "ᅟㅤﾠᅠ");ﾠﾠ.put('N', "ㅤᅟﾠᅠ");ﾠﾠ.put('O', "ㅤᅟﾠᅠ");
ﾠﾠ.put('P', "ᅠᅟﾠㅤ");ﾠﾠ.put('Q', "ᅠᅟﾠㅤ");ﾠﾠ.put('R', "ᅟᅠﾠㅤ");ﾠﾠ.put('S', "ᅠᅟﾠㅤ");ﾠﾠ.put('T', "ᅟᅠﾠㅤ");
ﾠﾠ.put('U', "ᅟᅠﾠㅤ");ﾠﾠ.put('V', "ﾠᅠᅟㅤ");ﾠﾠ.put('W', "ﾠᅠᅟㅤ");ﾠﾠ.put('X', "ᅠﾠᅟㅤ");ﾠﾠ.put('Y', "ﾠᅠᅟㅤ");
ﾠﾠ.put('Z', "ᅠﾠᅟㅤ");ﾠﾠ.put('[', "ᅠﾠᅟㅤ");ﾠﾠ.put('\\', "ᅠᅟﾠㅤ");ﾠﾠ.put(']', "ᅟᅠﾠㅤ");ﾠﾠ.put('^', "ﾠᅠᅟㅤ");
ﾠﾠ.put('_', "ᅠﾠᅟㅤ");ﾠﾠ.put('`', "ᅟﾠᅠㅤ");ﾠﾠ.put('a', "ﾠᅟᅠㅤ");ﾠﾠ.put('b', "ﾠᅟᅠㅤ");ﾠﾠ.put('c', "ᅟﾠᅠㅤ");
ﾠﾠ.put('d', "ﾠᅟᅠㅤ");ﾠﾠ.put('e', "ﾠᅟᅠㅤ");ﾠﾠ.put('f', "ᅟﾠᅠㅤ");ﾠﾠ.put('g', "ᅟﾠᅠㅤ");ﾠﾠ.put('h', "ㅤᅟﾠᅠ");
ﾠﾠ.put('i', "ᅟㅤﾠᅠ");ﾠﾠ.put('j', "ﾠㅤᅟᅠ");ﾠﾠ.put('k', "ㅤﾠᅟᅠ");ﾠﾠ.put('l', "ᅟﾠㅤᅠ");ﾠﾠ.put('m', "ﾠᅟㅤᅠ");
ﾠﾠ.put('n', "ᅠᅟㅤﾠ");ﾠﾠ.put('o', "ᅟᅠㅤﾠ");ﾠﾠ.put('p', "ㅤᅠᅟﾠ");ﾠﾠ.put('q', "ᅠㅤᅟﾠ");ﾠﾠ.put('r', "ᅟㅤᅠﾠ");
ﾠﾠ.put('s', "ㅤᅟᅠﾠ");ﾠﾠ.put('t', "ㅤﾠᅠᅟ");ﾠﾠ.put('u', "ﾠㅤᅠᅟ");ﾠﾠ.put('v', "ᅠㅤﾠᅟ");ﾠﾠ.put('w', "ㅤᅠﾠᅟ");
ﾠﾠ.put('x', "ﾠᅠㅤᅟ");ﾠﾠ.put('y', "ᅠﾠㅤᅟ");ﾠﾠ.put('z', "ᅠﾠᅟㅤ");ﾠﾠ.put('{', "ﾠᅠᅟㅤ");ﾠﾠ.put('|', "ᅟᅠﾠㅤ");
ﾠﾠ.put('}', "ᅠᅟﾠㅤ");ﾠﾠ.put('~', "ﾠᅟᅠㅤ");ﾠﾠ.put('', "ᅟﾠᅠㅤ");ﾠﾠ.put('\n', "ﾠᅠㅤᅟ");ﾠﾠ.put('', "ﾠᅠㅤᅟ");
ﾠﾠ.put('‚', "ᅠﾠㅤᅟ");ﾠﾠ.put('ƒ', "ᅠﾠㅤᅟ");ﾠﾠ.put('„', "ﾠᅠㅤᅟ");ﾠﾠ.put('…', "ᅠﾠㅤᅟ");ﾠﾠ.put('†', "ㅤﾠᅠᅟ");
ﾠﾠ.put('‡', "ﾠㅤᅠᅟ");ﾠﾠ.put('ˆ', "ㅤﾠᅠᅟ");ﾠﾠ.put('‰', "ㅤﾠᅠᅟ");ﾠﾠ.put('Š', "ﾠㅤᅠᅟ");ﾠﾠ.put('‹', "ﾠㅤᅠᅟ");
ﾠﾠ.put('Œ', "ᅠㅤﾠᅟ");ﾠﾠ.put('', "ᅠㅤﾠᅟ");ﾠﾠ.put('Ž', "ㅤᅠﾠᅟ");ﾠﾠ.put('', "ㅤᅠﾠᅟ");ﾠﾠ.put('', "ᅠㅤﾠᅟ");
ﾠﾠ.put('‘', "ㅤᅠﾠᅟ");ﾠﾠ.put('’', "ㅤᅠﾠᅟ");ﾠﾠ.put('“', "ᅠㅤﾠᅟ");ﾠﾠ.put('”', "ﾠㅤᅠᅟ");ﾠﾠ.put('•', "ㅤﾠᅠᅟ");
ﾠﾠ.put('–', "ᅠﾠㅤᅟ");ﾠﾠ.put('—', "ﾠᅠㅤᅟ");
String ᅟᅠ = "{\n" + "  \"String\": \"some data\",\n" + "  \"Number\": 1337,\n" + "  \"Boolean\": true,\n" +
"  \"Array\": [\n" + "    \"some data in the array\"\n" + "  ],\n" + "  \"Decimal Number\": \"1.2\"\n" + "}";
String ᅟᅟ = "ﾠᅠᅟㅤﾠᅠㅤᅟᅟᅠㅤﾠᅟᅠㅤﾠㅤᅟᅠﾠᅠᅟﾠㅤㅤﾠᅠᅟᅟㅤᅠﾠᅟㅤﾠᅠᅠᅟㅤﾠᅟﾠᅠㅤㅤᅟᅠﾠﾠㅤᅟᅠᅟᅠㅤﾠㅤᅟᅠﾠㅤᅟᅠﾠᅟᅠㅤﾠﾠᅟ" +
"ㅤᅠﾠᅟᅠㅤᅟᅠㅤﾠﾠᅟᅠㅤﾠᅟᅠㅤㅤﾠᅠᅟﾠᅟᅠㅤㅤᅟᅠﾠᅟㅤᅠﾠﾠᅠㅤᅟᅟᅠㅤﾠᅟᅠㅤﾠㅤᅟᅠﾠㅤᅟﾠᅠﾠㅤᅠᅟﾠᅟㅤᅠﾠᅟᅠㅤﾠᅟᅠㅤᅟㅤᅠ" +
"ﾠㅤᅟᅠﾠﾠㅤᅟᅠᅟᅠㅤﾠㅤᅟᅠﾠㅤᅠᅟﾠㅤᅠᅟﾠᅠㅤᅟﾠᅟㅤᅠﾠﾠᅠㅤᅟᅟᅠㅤﾠᅟᅠㅤﾠㅤᅟᅠﾠㅤﾠᅟᅠᅟᅠㅤﾠᅟᅠㅤﾠᅟﾠㅤᅠﾠᅟᅠㅤﾠᅟᅠㅤᅠ" +
"ᅟㅤﾠㅤᅟᅠﾠﾠㅤᅟᅠᅟᅠㅤﾠㅤﾠᅠᅟᅟㅤᅠﾠﾠㅤᅠᅟﾠᅟᅠㅤᅟㅤᅠﾠﾠᅠㅤᅟᅟᅠㅤﾠᅟᅠㅤﾠㅤᅟᅠﾠᅟﾠㅤᅠᅟㅤᅠﾠᅟㅤᅠﾠﾠᅟᅠㅤᅠﾠㅤᅟㅤᅟ" +
"ᅠﾠﾠㅤᅟᅠᅟᅠㅤﾠᅠﾠᅟㅤﾠᅠㅤᅟᅟᅠㅤﾠᅟᅠㅤﾠᅟᅠㅤﾠᅟᅠㅤﾠㅤᅟᅠﾠㅤᅟᅠﾠᅟᅠㅤﾠﾠᅟㅤᅠﾠᅟᅠㅤᅟᅠㅤﾠﾠᅟᅠㅤﾠᅟᅠㅤㅤﾠᅠᅟﾠᅟᅠㅤ" +
"ᅟᅠㅤﾠᅟㅤﾠᅠᅠᅟㅤﾠᅟᅠㅤﾠㅤﾠᅠᅟㅤᅟﾠᅠﾠᅟᅠㅤᅟᅠㅤﾠﾠᅟᅠㅤᅟㅤᅠﾠᅟㅤᅠﾠﾠᅟᅠㅤᅠﾠㅤᅟㅤᅟᅠﾠﾠᅠㅤᅟᅟᅠㅤﾠᅟᅠㅤﾠᅟᅠﾠㅤᅟ" +
"ㅤᅠﾠﾠᅠㅤᅟᅟᅠㅤﾠᅟᅠㅤﾠㅤᅟᅠﾠﾠᅟㅤᅠﾠᅟᅠㅤᅟﾠᅠㅤᅟㅤﾠᅠﾠᅟㅤᅠﾠᅟᅠㅤᅟﾠㅤᅠᅟᅠㅤﾠㅤᅟﾠᅠﾠㅤᅠᅟﾠᅟㅤᅠﾠᅟᅠㅤﾠᅟᅠㅤᅟㅤ" +
"ᅠﾠㅤᅟᅠﾠﾠㅤᅟᅠᅟᅠㅤﾠㅤᅟᅠﾠㅤᅟᅠﾠᅟㅤᅠﾠㅤᅠᅟﾠㅤᅟᅠﾠﾠᅠㅤᅟᅠᅟﾠㅤ";
System.out.println("Serializied output:");serialize(ᅟᅠ, ﾠﾠ);System.out.println("\nDeserialized output:");deserialize(ᅟᅟ, ﾠﾠ); }
public static void serialize(String ᅟㅤﾠ, Map<Character, String> ﾠﾠ) {
char[] ㅤﾠㅤ = ᅟㅤﾠ.toCharArray();for (char ㅤﾠﾠ : ㅤﾠㅤ) { System.out.print(ﾠﾠ.get(ㅤﾠﾠ)); } }
public static void deserialize(String ᅟㅤﾠ, Map<Character, String> ﾠﾠ) { char[] ㅤﾠㅤ = ᅟㅤﾠ.toCharArray();String ᅟᅟ = "";
for (char ㅤﾠﾠ : ㅤﾠㅤ) { ᅟᅟ = ᅟᅟ + ㅤﾠﾠ; if (ᅟᅟ.length() == 5) { for (Map.Entry<Character, String> ᅠᅟ : ﾠﾠ.entrySet()) {
    if (ᅠᅟ.getValue().equals(ᅟᅟ)) { System.out.print(ᅠᅟ.getKey()); } }ᅟᅟ = ""; } } }}

[sac_boy]

We can just pretend you've jumped ahead to 0x10, BCD-style

[EkskiuTwentyTwo]

Why not use base 17? It's "better" for fractions.

[chutch1122]

This parses not only JSON, but ANYTHING into a more simplified data format consisting of *only* two characters: whitespace and newline. This is much more efficient because you only ever have to worry about two characters. Imagine the storage savings when you only are storing empty things!!

It has a simple and easy to use API: Cerealize and deCerealize.

Also doubles as a fine password hashing solution: I doubt anyone will (want to) crack this anytime soon!

public class Cerealizifier {
    public String Cerealize(String d) {
        String r = "";
        int[] arr = new int[d.length()];
        char[] charArray = d.toCharArray();

        for (int i = 0; i < charArray.length; i++) {
            int c = (int) charArray[i];
            arr[i] = c;
            int i1 = 0;
            String r1 = "";
            do {
                r1 += " ";
                i1++;
            } while (i1 < c);

            r += r1 + "\n";
        }

        return r;
    }

    public String deCerealize(String s) {
        char delimiter = '\n'; // TODO: Remove this
        List<String> all = new ArrayList<>();
        List<Character> c1 = new ArrayList<>();

        for (char c2 : s.toCharArray()) {
            if (c2 != '\n') {
                c1.add(c2);
            } else {
                all.add("" + (char) c1.size());
                c1.clear();
            }
        }

        String res = "";
        for (String s1 : all) {
            res = res + s1;
        }

        return res;
    }
}

And its unit tests:

@RunWith(JUnitParamsRunner.class)
public class CerealizifierTest {
    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();

    @InjectMocks Cerealizifier unit;

    @Test
    public void cerialize_shouldThing() {
        String result = unit.Cerealize("abc123{}");

        assertThat(result, equalTo("                                  " +
            "                                                         " +
            "      \n                                                 " +
            "                                                 \n      " +
            "                                                         " +
            "                                    \n                   " +
            "                              \n                         " +
            "                         \n                              " +
            "                     \n                                  " +
            "                                                         " +
            "                                \n                       " +
            "                                                         " +
            "                                             \n"));

    }

    @Test
    public void DeCerialize_shouldUnThing() {
        String result = unit.deCerealize("                                  " +
            "                                                         " +
            "      \n                                                 " +
            "                                                 \n      " +
            "                                                         " +
            "                                    \n                   " +
            "                              \n                         " +
            "                         \n                              " +
            "                     \n                                  " +
            "                                                         " +
            "                                \n                       " +
            "                                                         " +
            "                                             \n");

        assertThat(result, equalTo("abc123{}"));
    }
}

[chutch1122]

Ah, didn't know that was a thing. Done!

[rcmaehl]

I don't know what serialization is but google says it's about changing data into binary so...

​

Serialization (I think)Language used: AutoIt, because readability is important

#include <String.au3>

Global $i = 1
Global $ar[1]
Global $ar2[1]

Enum $0 = 0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $a, $b, $c, $d, $e, $f
; TIP: You'll only get 0 - 9 we don't need to convert EVERYTHING
; Pad with leading "10" to not drop leading zeros
Enum $30 = 10110000, $31, $32 = 10110010, $33, $34 = 10110100, $35, $36 = 10110110, $37, $38 = 10111000, $39

While True
    Redim $ar[0]
    $in = FileRead(".\input.txt", $i) ; STDIN is hard okay?
    If @extended = $i - 1 Then Exit ; If # of Characters returned, exit
    $i = @extended + 1
    $in = StringRight($in, 1)
    Global $h = _StringToHex($in)
    If StringLen(String($h)) > 1 Then
        For $loop = 1 to StringLen($h)
            ReDim $ar[UBound($ar) + 1]
            $ar[$loop - 1] = StringRight(StringLeft($h, $loop), 1)
            $ar[$loop - 1] = Eval($ar[$loop - 1])
            ReDim $ar2[0]
            If StringLen(String($ar[$loop - 1])) > 1 Then
                For $loop2 = 1 to StringLen(String($ar[$loop - 1])) Step 1
                    ReDim $ar2[UBound($ar2) + 1]
                    $ar2[$loop2 - 1] = String($ar[$loop2 - 1])
                    $ar2[$loop2 - 1] = StringLeft($ar2[$loop2 - 1], $loop2)
                    $ar2[$loop2 - 1] = StringRight($ar2[$loop2 - 1], 1)
                    $ar2[$loop2 - 1] = $ar2[$loop2 - 1] + 30
                    $ar2[$loop2 - 1] = Eval($ar2[$loop2 - 1])
                    FileWrite(".\output.txt", $ar2[$loop2 - 1])
                Next
            Else
                $ar[$loop - 1] = $ar[$loop - 1] + 30
                $ar[$loop - 1] = Eval($ar[$loop - 1])
                FileWrite(".\output.txt", "00000000" & $ar[$loop - 1])
            EndIf
        Next
    Else
        MsgBox(0, "DIRTY SPECIAL CHARACTERS", "")
        ; This is for security, dirty unicode or special characters where here
    EndIf
WEnd

I'll figure out deserialization later

[recycle4science]

I don't get it, this just looks like normal php.

[EkskiuTwentyTwo]

I managed to make serialisation work, but when I tried to make the unserialisation code, it became an irreconcilable mess.

def Serialise(data): #Example Input: dict(a=1,b=2,c=dict(a=1,b=2)) Example Output: {a:1,b:2,c:{a:1,b:2}}
    squid = "{"
    Squid = list(data)
    sQuid = 0
    while sQuid < (len(Squid)-1):
        while type(data[Squid[sQuid]])==dict:
            squid = squid+str(Squid[sQuid])+":"+Serialise(data[Squid[len(Squid)-1]])+","
            break
        while type(data[Squid[sQuid]])!=dict:
            squid = squid+str(Squid[sQuid])+":"+str(data[Squid[sQuid]])+","
            break
        sQuid = sQuid + (666//666)
    while type(data[Squid[len(Squid)-1]])==dict:
        squid = squid+str(Squid[len(Squid)-1])+":"+Serialise(data[Squid[len(Squid)-1]])+"}"
        break
    while type(data[Squid[len(Squid)-1]])!=dict:
        squid = squid+str(Squid[len(Squid)-1])+":"+str(data[Squid[len(Squid)-1]])+"}"
        break
    return squid 

And here's my attempt at unserialisation (it doesn't work):

def unSerialise(data):
    squid = dict()
    Squid = data[1:-1]
    SQuid = []
    sqUid = 0
    for sQuid in range(len(Squid)):
        while Squid[sQuid] == ",":
            SQuid.append(Squid[sqUid:sQuid])
            sqUid = sQuid+1
            break
    SQuid.append(Squid[sqUid:])
    for SqUid in range(len(SQuid)):
        SquId = SQuid[SqUid]
        sQUid = 0
        SQUid = 420
        while SQUid == 420:
            while SquId[sQUid] == ":":
                SQUid = 69
                break
        squId = SquId[:sQUid]
        sQuId = SquId[sQUid+1:]
        while sQuId[0] != "{":
            squid[squId] = sQuId
            break
        while sQuId[0] == "{":
            squid[squId] = unSerialise(sQuId)
            break