알파벳에서 문자의 위치로 대체하는 매우 간단한 암호가 있습니다. 예를 들어, abc될 것 1 2 3이 암호에.

이 도전은이 암호에 대한 대안입니다.

도전

ASCII 문자를 입력하고 공백으로 구분 된 문자열을 출력하는 프로그램을 작성하십시오.

• -26통해 정수26

• a통해 편지j

출력은 STDOUT 또는 언어의 가장 가까운 대안을 통해 제공되어야합니다.

명세서

• 대문자는 무시해야합니다. 자본 D예를 들어이 될 것 -4소문자는 동안, d될 것이다 4.

• 숫자는 알파 숫자로 변경해야합니다. 1되고 a, 등등. 입력에서 0은입니다 j.

• 영숫자가 아닌 문자 (공백 제외)는 무시해야합니다.

• 공백은 0입니다.

• 출력의 인접한 공간은 단일 공간으로 축소해야합니다.

  Input: You + Me
  Correct Output: -25 15 21 0 -13 5
  Incorrect Output: -25 15 21 0 0 0 -13 5
  

• 단일 후행 공백 또는 줄 바꾸기가 허용됩니다.

예

Input: programming puzzles
Output: 16 18 15 7 18 1 13 13 9 14 7 0 16 21 26 26 12 5 19

Input: Code Golf
Output: -3 15 4 5 0 -7 15 12 6

Input: Programming Puzzles & Code Golf
Output: -16 18 15 7 18 1 13 13 9 14 7 0 -16 21 26 26 12 5 19 0 -3 15 4 5 0 -7 15 12 6

Input: C0d3 G0lf
Output: -3 j 4 c 0 -7 j 12 6

Input: abc_ABC
Output: 1 2 3 -1 -2 -3

스코어 보드

점수가 보드에 표시 되려면 다음 형식이어야합니다.

# Language, Bytes

취소 선이 문제를 일으키지 않아야합니다.

function getURL(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:getURL(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),useData(answers)}})}function getOwnerName(e){return e.owner.display_name}function useData(e){var s=[];e.forEach(function(e){var a=e.body.replace(/<s>.*<\/s>/,"").replace(/<strike>.*<\/strike>/,"");console.log(a),VALID_HEAD.test(a)&&s.push({user:getOwnerName(e),language:a.match(VALID_HEAD)[1],score:+a.match(VALID_HEAD)[2],link:e.share_link})}),s.sort(function(e,s){var a=e.score,r=s.score;return a-r}),s.forEach(function(e,s){var a=$("#score-template").html();a=a.replace("{{RANK}}",s+1+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SCORE}}",e.score),a=$(a),$("#scores").append(a)})}var QUESTION_ID=58107,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],answer_ids,answers_hash,answer_page=1;getAnswers();var VALID_HEAD=/<h\d>([^\n,]*)[, ]*(\d+).*<\/h\d>/;

body{text-align:left!important}table thead{font-weight:700}table td{padding:10px 0 0 10px}#scores-cont{padding:10px;width:600px}#scores tr td:first-of-type{padding-left:0}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="scores-cont"><h2>Scores</h2><table class="score-table"><thead> <tr><td></td><td>User</td><td>Language</td><td>Score</td></tr></thead> <tbody id="scores"></tbody></table></div><table style="display: none"> <tbody id="score-template"><tr><td>{{RANK}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SCORE}}</td></tr></tbody></table>

CJam, 58 57 54 51 50 49 바이트

그냥 내가 설명을 쓸 때, 나는 다른 50 개 바이트 버전 중 하나가 바이트로 단축 할 수 것으로 나타났습니다 ...

q_el_eu&S-A,s--S%S*{i_32md\2*5-*48md@)A%'a+\?}%S*

여기에서 테스트하십시오.

50 바이트 솔루션 :

q_el_eu&S-A,s--S%S*{_A,s&\i_)A%'a+\32md\2*5-*?}%S*
q_el_eu&S-A,s--S%'`*{i32md:D;(_(2*(D*D3+A%'a+?}%S*
q_el_eu&S-A,s--S%'`*{i32md\(_@_@(2*(*\3+A%'a+?}%S*
q_el_eu&S-A,s--S%'`*{i32md\(_(2*(g@*_z3+A%'a+?}%S*

설명

q         e# Read input.
_el_eu&   e# Intersect a lower-case version with an upper-case version to remove
          e# all letters.
S-        e# Remove spaces from that string.
A,s-      e# Remove digit characters from that string. It now contains all the
          e# the characters from the input we should ignore.
-         e# Remove these characters from the input.
S%S*      e# Split on runs of spaces and join by spaces, collapsing multiple into one.
{         e# Map this block onto each character...
  i_      e#   Convert to character code and make a copy.
  32md    e#   Get divmod 32. Note that digits have character codes 32 + something,
          e#   the upper case letters have character codes 64 + n (where n is the 
          e#   absolute value we want), while lower case letters have codes 96 + n. 
          e#   So the div gives 2 or 3 to distinguish capitalisation (and 1 for digits) 
          e#   and the mod gives the correct absolute value for letters.
          e#   As it happens, the mod also gives 0 for spaces.
  \2*5-   e#   Pull up the div, duplicate, subtract 5. Turns 2 into -1 and 3 into 1. 
          e#   It also turns 1 (digits) into -3.
  *       e#   Multiply the mod by this sign.
          e#   We now have the correct result for everything but digits. Note that
          e#   the absolute value for digits is more than 26, and for everything
          e#   else it's less than 27.
  48md    e#   Get divmod 48. This gives div 0 and mod n for all correct results n.
          e#   For digits it gives div -1 and we don't care about the mod. We'll
          e#   use the div as a truthy/falsy value to select the right result.
  @)A%    e#   Pull up the other copy of the character code, increment 
          e#   (range 49..58), take modulo 10.
          e#   This gives 9 for 0 and n-1 for any other digit n.
  'a+     e#   Add to the character a.
  \?      e#   Select the correct result based on the div 48.
}%
S*        e# Join the resulting values by spaces.

음수 값에 대한 CJam의 모듈러스 거동이 저에게 유용했던 것은 이번이 처음입니다.

자바 스크립트 (ES6) 110 107 133 120 바이트

가져 가라, 나야!

a=>[...a.replace(/[\W_]*?( ?)[\W_]*/g,'$1')].map(x=>(c=x.charCodeAt())<40?0:c<60?'jabcdefghi'[x]:c<91?64-c:c-96).join` `

골프를 할 수있는 더 많은 공간이있을 수 있습니다. 특히 정규식에서는 그렇지 않습니다. 언 골프 버전 :

function f(a) {
  // Replaces each run of bad chars and spaces with
  // a space if it contained one, nothing otherwise:
  a = a.replace(/[\W_]*?( ?)[\W_]*/g, '$1');

  var b = a.split('');
  b = b.map(function(x) {
    var c = x.charCodeAt();
    if (c == 32)     // space
      return 0;
    else if (c < 60) // numbers
      return 'jabcdefghi'.charAt(x);
    else if (c < 91)
      return 64 - c; // uppercase
    else
      return c - 96; // lowercase
  });
  b = b.join(' ');
  return b;
}

제안을 환영합니다!

Pyth, 50 49 바이트

jdm?>d26C+70ddm-xZd26:-z-z=Zs[_rG1dGjk.<UT1)" +"d

여기서 사용해보십시오 .

편집 : 밑줄이 올바르게 처리되도록 재구성 된 문자열 위생. 심지어 바이트도 절약했습니다.

이 프로그램은 입력을 삭제하는 데 사용되는 조회 문자열을 작성합니다. 그런 다음 해당 문자열의 해당 인덱스에 매핑됩니다. 마지막으로 26보다 큰 인덱스는 올바른 ASCII 문자로 변환됩니다.

                                                     Implicit: z=input(), d=' ', ,
                                                       k='', G=[a-z]
                              _rG1                   Reversed, capitalised alphabet
                                  d                  Single space
                                   G                 Lower case alphabet
                                    jk.<UT1          '1234567890'
                            s[             )         Concatenate the 4 previous statements
                          =Z                         Store in Z
                        -z                           Setwise difference of input and above
                                                       (to get all illegal characters)
                      -z                             Setwise difference of input and illegal chars
                     :                      " +"d    Regex replace to lose multiple spaces
              m                                      Map the above over d:
                xZd                                    Get index of d in Z
               -   26                                  Subtract 26
  m                                                  Map the above over d:
   ?>d26                                               If d > 26
        C+70d                                            Convert (d+70) to ASCII
             d                                         Otherwise, select d
jd                                                   Join on spaces and print

\W정규식을 사용한 이전 버전 은 50 바이트입니다.

jdm?>d26C+70ddm-xs[_rG1\ Gjk.<UT1)d26::z"\W"d" +"d

줄리아, 145136 바이트

r=replace;print(join([47<x<58?x+58-10(x>48):x==32?0:cmp(x,96)*(lowercase(x)-96)for x=r(r(readline(),r"[^a-z0-9 ]"i,""),r" +"," ")]," "))

언 골프 드 :

# Read a string from STDIN
input = readline()

# Remove non-alphanumeric characters and replace duplicated spaces
r = replace(replace(input, r"[^a-z0-9 ]"i, ""), r" +", " ")

# Construct an array using comprehension over the replaced input string
A = [47 < x < 58 ? x + 58 - 10(x > 48) : x == 32 ? 0 : cmp(x, 96) * (lowercase(x) - 96) for x = r]

# Join the array elements with spaces
j = join(A, " ")

# Print to STDOUT
print(j)

숫자를 문자로 얻으려면 ASCII 값에 58을 더하고 현재 문자가 0이 아닌 경우 10을 뺍니다. 그러면 0이 j 다른 숫자가 a- 로 매핑됩니다 i.

대문자 제외는 다음을 사용하여 수행됩니다. cmp . 대문자는 -1, 소문자는 1을 반환합니다.

온라인으로 사용해보십시오

펄 5 120 116 113 105 바이트

먼저 원하지 않는 문자와 여분의 공백을 정리하십시오.
그런 다음 각 캐릭터의 아스키 테이블을 내려갑니다.

$_=pop;s/[^\w ]|_//g;s/ +/ /g;map{$n=ord;say$".($n>96?$n-96:$n>64?64-$n:$n>48?chr$n+48:$n>47?j:0)}split//

테스트

$ perl -M5.01 numbers4letters.pl "zZaA _ 190"
 26 -26 1 -1 0 a i j
$ perl -M5.01 numbers4letters.pl "PrOgr4mm1n9 Puz2l3s & C0d3_G0lf!"
-16 18 -15 7 18 d 13 13 a 14 i 0 -16 21 26 b 12 c 19 0 -3 j 4 c -7 j 12 6

C, 142 (138) 135

c,d;main(s){while(c=getchar()+1)d=c|32,c=d-98<26u?s=(d-97)*(c/32*2-5),0:c-48<11u?s='a'+c%10,4:c==33&&s?s=0,0:3,printf("%d \0%c "+c,s);}

언 골프 :

int c,d;
int main(int s)                     // s initially non-zero, meaning spaces are allowed
{
    while(c=getchar()+1)            // getchar until EOF (-1) encountered
    {
        d=c|32;                     // d becomes lowercase c (both incremented by 1)
        if (d-98<26u)               // check for letter
        {
            s=(d-97)*(c/32*2-5);    // print this number and allow subsequent spaces
            c=0;                    // format string will be "%d "
        }
        else if (c-48<11u)          // check for digit
        {
            s='a'+c%10;             // print this letter and allow subsequent spaces
            c=4;                    // format string will be "%c "
        }
        else if (c==33&&s)          // else if space and allowed to output spaces
        {
            s=0;                    // print 0 and disallow subsequent spaces
            c=0;                    // format string will be "%c "
        }
        else
        {
            c=3;                    // format string will be "", prints nothing
        }
        printf("%d \0%c "+c,s);     // final c is treated as index into string literal
    }
}

GCC 4.9.3 및 Clang 3.5.2에서 주어진 테스트를 통과합니다.

> <> (물고기), 219209 바이트

>i:84*=?v:86*1-)?!^:f4*2-(?v:88*)?!v:a9*1+(?v:c8*)?!^:ca*3+  (?v~
>4*(?vov>~86*$:@=?v86*00.  >:86*=?v77*1-+00.>88*-::-$-00.01-*8c<
 >.! ! ! 00~v?( 0:\00. >.!00+6*aa~<>~    92*2!.<2*29<
^7:;?=0:<r0~<
*o73.>n>84

사용해보십시오 여기서

이것은 나의 첫 번째 코드 골프 답변입니다! 마지막으로 코드 골프 챌린지에 사용하고 싶은 언어를 사용할 수있게되었으며, 문자가 자동으로 10 진수로 변환된다는 점에서 완벽한 것처럼 보였습니다.

결과가 더 짧을 것으로 예상했지만 그렇지 않았습니다. 그러나 나는 이것을 너무 많이 골프하지 않았다. 코드가 깨끗하고 이해하기 쉬운 곳이 몇 개 있지만, 공백이 필요한 곳에 있기 때문에 바이트를 저장하지 않습니다. 두 번째 줄의 마지막 비트에 약간의 바이트를 저장하는 방법이있을 수 있습니다. 반대 방향으로 가고 이미 00을 으깬 다음 나중에 더 연주해야합니다

기본적으로 현재 문자가 해당 그룹의 최고 / 최저 값 범위에 있는지 확인하여 현재 문자가 공백, 숫자, 대문자 또는 소문자인지 확인합니다. 그 중 하나가 아닌 경우 폐기됩니다. 그 중 하나에 있으면 문자이면 숫자로 변환되고 숫자이면 문자로 변환됩니다 (또는 문자 aj의 값인 97-106의 숫자). 그런 다음 최상위 값이 28보다 작은 지 확인합니다.이 경우 숫자이고 숫자를 출력합니다. 그렇지 않으면 문자이고 숫자가 나타내는 문자를 출력하고 공백을 출력 한 다음 스택이 비어있을 때까지 반복합니다.

자바 스크립트 (ES6) 108 122 124

@Max 의 의견에서 regexp를 사용하여 편집
Edit2 14 바이트 절약 덕분에 ETHProductions

EcmaScript 6은 화살표 기능 만 사용하므로 Firefox 및 최신 Chrome에서 작동합니다.

아래 스 니펫 테스트

F=
t=>t[R='replace'](/[^\w ]|_/g,'')[R](/ +|./g,c=>((v=parseInt(c,36))>9?c>'Z'?v-9:9-v:'jabcdefghi'[v]||0)+' ')

// Less golfed
U=t=>
  t.replace(/[^\w ]|_/g,'') // remove invalid characters
  .replace(/ +/g,' ') // collapse spaces
  .replace(/./g, c => ( // valid character replacing
    v = parseInt(c,36), // '0'..'9'-> 0..9, 'a'..'z' -> 10..25, ' ' -> NaN
    (
      v > 9 
      ? c > 'Z' ? v-9 : 9-v // manage upper vs lower
      : 'jabcdefghi'[v] || 0 // digits, NaN as an index gives undefined, substituted with 0
    ) + ' ' // separator space
  ))


// TEST
out=x=>O.textContent=x+'\n'+O.textContent;

function go() { out(I.value + ' --> ' + F(I.value) +'\n')}

// test cases, a trailing blank added to the expected output as ...
// "A single trailing space or newline is allowed."

;[
  ['A$b','-1 2 ']
, ['123___abc', 'a b c 1 2 3 ']
, ['You + Me','-25 15 21 0 -13 5 ']
, ['programming puzzles', '16 18 15 7 18 1 13 13 9 14 7 0 16 21 26 26 12 5 19 ']
, ['Code Golf', '-3 15 4 5 0 -7 15 12 6 ']
, ['Programming Puzzles & Code Golf', '-16 18 15 7 18 1 13 13 9 14 7 0 -16 21 26 26 12 5 19 0 -3 15 4 5 0 -7 15 12 6 ']
, ['C0d3 G0lf', '-3 j 4 c 0 -7 j 12 6 ']
].forEach(t=>{ 
  k=t[1],r=F(t[0]), 
  out('Test '+(k==r?'OK':'Fail')+'\nInput:  '+t[0]+'\nResult: '+r+'\nCheck:  '+k+'\n')
})

Custom test: <input id=I><button onclick='go()'>-></button>
<pre id=O></pre>

Pyth, 57 바이트

:jdm@s[r_26Zr1 27Zc<GT1"")xs[_rG1G\ jkr1TZ)dz"0[0 ]+""0 "

라이브 데모 및 테스트 사례.

CJam, 52 바이트

'{,97>:L_eu+A,s(++S+l{1$&},S%S*\26,:)_Wf*+LA<+0+erS*

온라인으로 사용해보십시오

솔루션의 핵심 부분은 CJam er(음역) 연산자를 사용한다는 것 입니다. 연산자에 대한 인수로 모든 문자 목록과 해당 값 목록이 필요합니다.

입력에 대한 사전 처리 단계로서 변환 표의 일부가 아닌 문자 (특수 문자)를 제거하고 반복되는 공백을 단일 공백으로 줄입니다.

설명:

'{,97>  Build list of all lower case letters.
:L      Save it in variable L for later reuse.
_eu+    Add list of upper case letters.
A,s     Build digits "0123456789".
(+      Pop off first digit and append it at the end, to get "1234567890".
+       Add digits to list of characters.
S+      Add a space. List of characters that have values is now complete.
l       Get input.
{1$&},  Filter out all input characters that are not in list.
S%      Split input at spaces.
S*      And re-assemble it with spaces. This reduces multiple spaces to one space.
\       Swap input and character list.
26,     Start building list of values. Start with [0 ... 25].
:)      Use "smilie operator" to increment all values, to get [1 ... 26].
        These are the values for the lower case letters.
_Wf*    Copy the list and negate the values to get [-1 ... -26] for upper case.
+       Concatenate the two lists.
L       Retrieve the list of lower case letters we saved away earlier.
A<      Keep the first 10, which are the values for the digits.
+       Concatenate to list of values.
0+      Add 0 to list, as value for space.
er      Transliterate input string to corresponding values.
S*      Join with spaces for output.

파이썬 2 191 179 177 173 172 168 160 바이트

import re
print" ".join([[[chr(x+48),"j"][x<49],[`[x-96,-x+64][x<96]`,"0"][x<65]][x>57or x<33]for x in map(ord,re.sub(" +"," ",re.sub("[^\w ]|_","",input())))])

테스트

"programming puzzles"
16 18 15 7 18 1 13 13 9 14 7 0 16 21 26 26 12 5 19

"Code Golf"
-3 15 4 5 0 -7 15 12 6

"Programming Puzzles & Code Golf"
-16 18 15 7 18 1 13 13 9 14 7 0 -16 21 26 26 12 5 19 0 -3 15 4 5 0 -7 15 12 6

"C0d3 G0lf"
-3 j 4 c 0 -7 j 12 6

"You + Me"
-25 15 21 0 -13 5

PHP, 116 바이트

while($c=ord(preg_replace(["#[^\w ]|_#","# +#"],["","@"],$argn))[$i++])echo$c<96?jabcdefghi[$c-48]?:64-$c:$c-96," ";

STDIN에서 입력을받습니다. 와 실행-nR .

고장

while($c=ord(preg_replace(["#[^\w ]|_#","# +#"],["","@"],$argn) # sanitize input
    [$i++]))echo            # loop through string and print ...
    $c<96                       # if not lowercase:
        ?jabcdefghi[$c-48]          # digit -> letter
        ?:                          # if that turned out falsy (=empty):
        64-$c                       # uppercase (or former spaces) -> negative (or 0)
    :$c-96                      # else -> positive
," ";                           # append space

@소문자의 공백을 처리하기 위해 백틱으로 대체 할 수 있습니다 .
함께 jabcdefghi0자리에, 당신은 또한 사용할 수 있습니다 :.

Hassium , 1156 바이트

func main() {s = input();c="";for(x=0;x<s.length;x++){c=s[Convert.toNumber(Convert.toString(x))].toString();if (c.toLower()!=c)print(r(c.toLower())*-1);else if(r(c)=="")continue;else print(r(c));print(" ");}}func r(c) {if(c=="a")return 1;else if(c=="b")return 2;else if(c=="c")return 3;else if(c=="d")return 4;else if(c=="e")return 5;else if(c=="f")return 6;else if(c=="g")return 7;else if(c=="h")return 8;else if(c=="i")return 9;else if(c=="j")return 10;else if(c=="k")return 11;else if(c=="l")return 12;else if(c=="m")return 13;else if(c=="n")return 14;else if(c=="o")return 15;else if(c=="p")return 16;else if(c=="q")return 17;else if(c=="r")return 18;else if(c=="s")return 19;else if(c=="t")return 20;else if(c=="u")return 21;else if(c=="v")return 22;else if(c=="w")return 23;else if(c=="x")return 24;else if(c=="y")return 25;else if(c=="z")return 26;else if(c==" ")return 0;else if(c=="1")return "a";else if(c=="2")return "b";else if(c=="3")return "c";else if(c=="4")return "d";else if(c=="5")return "e";else if(c=="6")return "f";else if(c=="7")return "g";else if(c=="8")return "h";else if(c=="9")return "i";else if(c=="0")return "j";else return"";}

매우 긴 답변

젤리 , 32 바이트, 언어 사후 도전

⁶ØB;µ³fi@€
Øaḣ⁵ṙ9
26RµN;;0¢;ị@ÑK

온라인으로 사용해보십시오!

설명

도우미 기능1Ŀ (입력의 각 영숫자 / 공간을 숫자로 변환)

⁶ØB;µ³fi@€
⁶           space
 ØB;        append all digits, uppercase and lowercase letters (in that order)
    µ       set as the new default for missing arguments
     ³      first command-line argument
      f     delete all characters not in {space + alphanumerics}
       i@€  take index of each element within {space + alphanumerics}

도우미 기능2£ (상수 문자열을 반환 “jabcdefghi”)

Øaḣ⁵ṙ9
Øa      lowercase alphabet
  ḣ⁵    take first 10 elements
    ṙ9  rotate 9 elements to the left

주요 프로그램

26RµN;;0¢;ị@ÑK
26R             Range from 1 to 26
   µ            set as default for missing arguments
    N           Minus {each element of the range from 1 to 26}
     ;          with {the range from 1 to 26} appended
      ;0        with a 0 appended
        ¢;      with the result of 2£ prepended
          ị@    index into this using
            Ñ   the result of 1Ŀ
             K  separate by spaces

망막, 74 70 바이트 (비경쟁)

3 행의 선행 공간, 6 행의 후행 공간 및 비어있는 두 번째 라인에 유의하십시오.

[^ \ w] | _

 +
~
.
$ + 
[AZ]
-$ +
T`L`l
[js]
a $ +
[tz]
b $ +
T` ~ ld`dd0-6jl

온라인으로 사용해보십시오!

도전 전에 언어가 만들어졌지만, 내가 사용한 언어 기능 중 일부가 도전 이후에 나온 것으로 생각하여이를 비경쟁이라고 표시했습니다.

자바 7, 257254 바이트

class M{public static void main(String[]a){String r="",x;for(int c:a[0].getBytes()){x=(c>96&c<123?c-96:c>64&c<91?"-"+(c-64):c>48&c<58?(char)(c+48):c==48?"j":c<33?0:"")+"";r+=!x.isEmpty()&&!(r.endsWith("0 ")&x.equals("0"))?x+" ":"";}System.out.print(r);}}

여기에서 시도하십시오.

설명:

class M{                               // Class
  public static void main(String[]a){  //  Required main-method
    String r="",                       //   Result-String
      x;                               //   Temp String
    for(int c:a[0].getBytes()){        //   Loop over the characters of the input-String
      x=(                              //    Set the temp String to:
        c>96&c<123?                    //     If it's a lowercase letter:
          c-96                         //      Set `x` to the 1-indexed alphabetic index
        :c>64&c<91?                    //     Else-if it's a uppercase letter:
          "-"+(c-64)                   //      Set `x` to the 1-indexed alphabetic index as negative
        :c>48&c<58?                    //     Else-if it's a digit 1-9:
          (char)(c+48)                 //      Set `x` to the 1-indexed alphabetic character
        :c==48?                        //     Else if it's a zero:
          "j"                          //      Set `x` to "j"
        :c<33?                         //     Else if it's a space:
          0                            //      Set `x` to "0"
        :                              //     Else:
          ""                           //      Set `x` to an empty String
       )+"";                           //     Required `+""` because `(char)` and `0` aren't Strings
      r+=                              //    Append the result-String with:
        !x.isEmpty()                   //     If `x` has a value
        &&!(r.endsWith("0 ")&x.equals("0"))?
                                       //     and it's not "0" with the previous value also being a zero
          x+" "                        //      Append the value of `x`, plus a space
        :                              //     Else:
          "";                          //      Append nothing
    }                                  //   End of loop
    System.out.print(r);               //   Print the result to STDOUT
  }                                    //  End of main-method
}                                      // End of class

입력 및 출력 예 :

Input:
Programming Puzzles & C0d3 G0lf

Output:
-16 18 15 7 18 1 13 13 9 14 7 0 -16 21 26 26 12 5 19 0 -3 j 4 c 0 -7 j 12 6