1.13에서 Minecraft 언어 파일은 단순한 다중 행 키 = 값 형식에서 JSON으로 전환되었습니다 .

도전

JSON 문자열을 반환하는 원래 형식에서 변환하는 프로그램을 작성하십시오. 표준 입력 방법을 사용하여 입력을 가져올 수 있으며 출력은 표준 출력 방법에서 json이어야합니다

원래 형식에는 키 = 값 쌍이있는 행이 포함됩니다 (예 :

tile.dirt.name=Dirt
advMode.nearestPlayer=Use "@p" to target nearest player

build.tooHigh=Height limit for building is %s blocks

key = value를 사용하여 하나의 큰 JSON 객체로 변환해야합니다.

{
    "tile.dirt.name": "Dirt",
    "advMode.nearestPlayer": "Use \"@p\" to target nearest player",
    "build.tooHigh": "Height limit for building is %s blocks"
}

일부 세부 사항

• 올바른 키 / 값 쌍만 포함되어 있으면 유효한 모든 JSON이 허용됩니다. 마인 크래프트가 허용하기 때문에 후행 쉼표가 허용됩니다.
• 탈출해야 할 유일한 것은 따옴표입니다. (1.13 이전에는 언어 파일에 줄 바꿈, 백 슬래시 또는 기타 JSON 중단 항목이 존재하지 않았습니다)
• 빈 줄은 무시해야합니다
• 선은 정확히 하나의 등호를 포함합니다

테스트 사례

입력:

tile.dirt.name=Dirt
advMode.nearestPlayer=Use "@p" to target nearest player

build.tooHigh=Height limit for building is %s blocks

산출:

{
    "tile.dirt.name": "Dirt",
    "advMode.nearestPlayer": "Use \"@p\" to target nearest player",
    "build.tooHigh": "Height limit for building is %s blocks"
}

입력:

translation.test.none=Hello, world!
translation.test.complex=Prefix, %s%2$s again %s and %1$s lastly %s and also %1$s again!
translation.test.escape=%%s %%%s %%%%s %%%%%s
translation.test.invalid=hi %
translation.test.invalid2=hi %  s
translation.test.args=%s %s
translation.test.world=world

산출:

{
  "translation.test.none": "Hello, world!",
  "translation.test.complex": "Prefix, %s%2$s again %s and %1$s lastly %s and also %1$s again!",
  "translation.test.escape": "%%s %%%s %%%%s %%%%%s",
  "translation.test.invalid": "hi %",
  "translation.test.invalid2": "hi %  s",
  "translation.test.args": "%s %s",
  "translation.test.world": "world",
}

입력:

stat.mineBlock=%1$s Mined
stat.craftItem=%1$s Crafted
stat.useItem=%1$s Used
stat.breakItem=%1$s Depleted

산출:

{
    "stat.mineBlock": "%1$s Mined",
    "stat.craftItem": "%1$s Crafted",
    "stat.useItem": "%1$s Used",
    "stat.breakItem": "%1$s Depleted"
}

파이썬 3, 91 77 바이트

OMᗺ 덕분에 -14 바이트

나는 파이썬 사전의 인쇄물이 JSON과 매우 근접 하여이 도전에 대한 매우 경쟁력있는 언어가 될 것이라고 생각했습니다. 그러나 파이썬 사전의 문자열 표현은 파이썬의 내장 JSON 라이브러리를 사용하여 운이 좋았던 JSON과 충분히 다릅니다. JavaScript에서 간결하게 수행 할 수 있다고 확신합니다.

import json
f=lambda x:json.dumps(dict(i.split("=")for i in x.split("\n")if i))

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

편집하다:

Bash + Sed, 68 63 바이트

OMᗺ 및 Night 2 -5 Bytes 덕분에 버그 수정

파이썬 솔루션에 대한 접근 방식과 마찬가지로 텍스트를 객체에 묶지 않고 텍스트를 JSON으로 직접 변환하는 것이 더 바이트 효율적 일 수 있음을 깨달았습니다. 바이트 당 sed는 내가 아는 정규식 대체를위한 가장 강력한 언어입니다.

echo {`echo "$1"|sed 's/"/\\\"/g;s/\(.*\)=\(.*\)/"\1":"\2",/'`}

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

설명

echo {`                                  #  prints the leading curly brace
       echo "$1"|sed                     # feeds the input into sed
       's/"/\\"/g;                       # replaces " with \"
       s/\(.*\)=\(.*\)/"\1":"\2",/'      # surrounds the left and right hand sides of the equals with quotes and joins them with a colon
`}                                       # prints the closing curly brace

Vim, 44 바이트

O{<Esc>:%s/"/\\"/g|%s/\v(.*)\=(.*)/"\1":"\2",
o}

설명:

O{<Esc>                                           Prepend {
       :%s/"/\\"/g                                Escape all "
                  |%s/\v(.*)\=(.*)/"\1":"\2",     Json-ify lines
o}                                                Append }

녹 , 150 바이트

|s:String|s.replace('"',"\\\"").split('\n').filter(|l|l.len()>0).map(|l|format!("\"")+&l.replace('=',"\":\"")+"\",").fold(format!("{{"),|r,n|r+&n)+"}"

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

Java보다 길습니까?

레티 나 0.8.2 , 35 바이트

"
\"
=
": "
G`.
.+
    "$&",
^
{¶
$
¶}

온라인으로 사용해보십시오! and L$`.+대신 사용할 수 있으므로 Retina 1에서 34 바이트가됩니다 . 설명:G`..+

"
\"

따옴표를 탈출하십시오.

=
": "

키 / 값 구분 기호를 수정하십시오. (값에가 포함될 수있는 경우 2 바이트의 비용으로 =사용하십시오 1`=.)

G`.

빈 줄을 제거하십시오.

.+
    "$&",

각 줄을 따옴표로 묶습니다. (내부 따옴표는 이전에 추가되었습니다.)

^
{¶
$
¶}

전체 출력을 {}s로 감 쌉니다 .

껍질 , 22 바이트

문자열 조작은 실제로 Husk의 강점은 아니지만 꽤 잘 수행되었습니다.

`J"{}"J',mȯJ':msx'=fI¶

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

                      ¶  -- split on newlines
                    fI   -- filter by identity (ie. remove empty strings)
         m(        )     -- with each line
                x'=      -- | split on '='
              ms         -- | show each (ie. enclose in quotes and escape quotes)
           J':           -- | join with ':'
      J',                -- join these with ','
`J"{}"                   -- join the string "{}" with the result

루비 , 56 바이트

->x{x.split(?\n).map{|i|i.split(?=)}.to_h.to_json}

-rjson인터프리터 플래그의 경우 +6 바이트

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

펄 5 -nl -M5.010 , 58 54 바이트

BEGIN{say'{'}s'"'\"'g;/=/&&say qq|"$`": "$'",|}{say'}'

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

58 바이트 버전 :

BEGIN{say'{'}s'"'\"'g;s/(.*)=(.*)/"$1": "$2",/;END{say'}'}

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

하스켈 , 75 71 바이트

^{Laikoni 덕분에 -4 바이트 (목록 이해에 do-notation 사용)!}

=한 줄에 여러 개를 사용할 수 있습니다.

f s='{':do{(a,_:b)<-span(/='=')<$>lines s;show a++':':show b++","}++"}"

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

설명

이 용어 span(/='=')<$>lines s는 문자열을 첫 번째로 나누고, =우리를 남겨 둡니다 ("<initial part>","=<remaining line>"). 패턴 일치를 수행하면 (a,_:b)행이 비어 있지 않은 동시에 행간이 제거 =됩니다.

이제 우리는 필요 show둘 a과 b(시세 및 탈출 따옴표로 둘러싸), 어떤 포맷 (DO :및 ,문자) 그리고 마지막으로 묶 {}.

C (gcc) , 243219 바이트

제안에 대한 천장 고양이 덕분에.

나는 상태 머신을 사용하여 세 가지 경우 (개행, 키, 값)를 처리하기로 결정했으며 꽤 잘 나타났습니다. 또한, 나는에 도착 AB는 의 기능을 통해 가을 - 더를 사용 switch하여 매크로 stringizing 연산자!

도전 과제는 필요하지 않았지만 JSON 사양에 따라 \문자를 이스케이프 처리했습니다 . 해당 문자가 입력에 없을 경우 &&c-925 바이트 이상 제거 할 수 있습니다.

#define p(s)printf(#s,c)
#define a(i)case i:
c,s;f(){for(p({);(c=getchar())>0;)switch(s){a(0)if(c<11)break;s++,p(\42);a(1)c==61?s++,p(":"):p(%c);break;a(2)c-34&&c-92?c==10?p(\42\54),s=0:p(%c):p(\\%c);}s-2||p(\42);p(});}

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

원본 제출 : 243 바이트

원래 제출은 제공된 JSON 예제와 같이 불필요한 간격을 유지했습니다.

#define p(s)printf(s,c)
#define a(i)case i:
c,s;f(){for(p("{\n");(c=getchar())>0;)switch(s){a(0)if(c<11)break;s++,p("  \"");a(1)c==61?s++,p("\": \""):p("%c");break;a(2)c-34&&c-39?c==10?p("\",\n"),s=0:p("%c"):p("\\%c");}s==2&&p("\"\n");p("}");}

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

자바 스크립트, 66 63 62 바이트

s=>JSON.stringify(o=/(.+)=(.+)/g,s.replace(o,(_,a,b)=>o[a]=b))

f=
s=>JSON.stringify(o=/(.+)=(.+)/g,s.replace(o,(_,a,b)=>o[a]=b))

console.log(
  f(`tile.dirt.name=Dirt
advMode.nearestPlayer=Use "@p" to target nearest player

build.tooHigh=Height limit for building is %s blocks`)
)

@redundancy 덕분에 -3 바이트

@ l4m2 덕분에 -1 바이트

레티 나 0.8.2 , 43 바이트

¶¶
¶
"
\"
=
": "
m`$|^
"
m`^
    
$
¶}
^
{¶

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

펄 6 , 48 바이트

{to-json %(.lines.grep(?*)>>.split("=",2).flat)}

비어 있지 않은 행에서 정확히 1과 같은 부호를 가정 할 수 있으면 2 바이트가 줄어 듭니다.

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

언 골프 드 :

{                   # An anonymous block, taking 1 string which ends in $_.
    to-json         # Convert a Perl 6 number, string, list or hash to JSON and return it.
    %(              # Force to hash (dictionary)
        .lines      # Break $_ (implicitly assumed) into a list of lines.
        .grep(?*)   # Pick only those that are True (non-empty).
        >>.         # For each element in the list, call the following method ... 
        split("=",2) # ... split the string at =, making at most 2 chunks.
        .flat       # That gives a list of 2-element lists. Flatten it.
    )               # List is converted into the hash like this: { first element => second element, third => fourth, ... }
}                   # Implicitly return

그건 그렇고, to-json컴파일러가 알려 주겠지 만 누가 관심을 가질 지에 따라 루틴은 더 이상 사용되지 않습니다.

파이썬 2 , 81 바이트

lambda s:'{'+re.sub(r'(.*)=(.*)',r'"\1":"\2",',re.sub('"',r'\"',s))+'}'
import re

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

루비, 59 + 5 = 64

필요 -rjson(+5)

->c{Hash[*c.split(?\n).map{|l|l.split ?=}.flatten].to_json}

설명:

->c{                                                      } # anonymous function with param c
    Hash[*                                       ]          # converts ["a", "b", "c", "d"] into {"a": "b", "c": "d"}
          c.split(?\n)                                      # splits c into lines
                      .map{|l|          }                   # map lines so each element represents
                              l.split ?=                    # an array of itself but split by =
                                         .flatten           # merges 2d array to 1d (also gets rid of empty elements for newlines
                                                  .to_json  # converts hash to json

자바 스크립트 (ES6), 66 바이트

s=>`{${s.replace(/"/g,'\\"').replace(/(.*)=(.*)/g,'"$1":"$2",')}}`

한 =줄에 하나만 있다고 가정

스 니펫 테스트

f=s=>`{${s.replace(/"/g,'\\"').replace(/(.*)=(.*)/g,'"$1":"$2",')}}`

<textarea id="i" onkeyup="o.innerText=f(i.value)"></textarea><pre id="o">

V , 30 바이트

O{␛Í"/\\"
ggòeÉ"vyf=Plp$pa,òo}

한 번에 하나의 입력을 예상합니다. TIO 스 니펫은 주어진 모든 테스트 사례를 단일 입력으로 실행합니다.

V의 확장 매핑을 처음 사용하므로 팁을 언제나 환영합니다!

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

설명

O{␛                  # insert { on a new line above
   Í                 # global substitution across all lines
    "/\\"            #   " => \"
gg                   # go to first line
  ò                  # recursively...
   e                 #   forward to end of word; if at end of line, applies to next word below
    É"               #   prepend " to first non-whitespace char
      vy             #   copy current character (i.e. ")
        f=Plp        #   paste " before and after the next =
             $pa,    #   paste " at end of line and append ,
                 ò   # ...end
                  o} # insert } on a new line below

C (gcc) , 172 바이트

#define p(s)printf(#s,c)
c,s;f(){for(p({);~(c=getchar());)s-2?c>10|s&&(s||(s+=p(\42)),c==61?s++,p(":"):p(%c)):c-34&&c-92?c==10?s=!p(\42\54):p(%c):p(\\%c);s-2||p(\42);p(});}

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

@ErikF의 구현을 기반으로하지만 switch/case.

약간 ungolfed 버전

#define p(s)printf(#s,c)
c,s;
f(){
 for(p({);~(c=getchar());)
  s-2?
   c>10|s&&(
    s||
     (s+=p(\42)),
    c==61?
     s++,
     p(":")
    :
     p(%c)
   )
  :
   c-34&&c-92?
    c==10?
     s=!p(\42\54)
    :
     p(%c)
   :
    p(\\%c);
 s-2||p(\42);
 p(});
}

R, 118 바이트

function(s){cat(paste("{",gsub("(.*)=(.*)","\"\\1\":\"\\2\",",gsub("\"","\\\\\"",gsub("\n{2,}","\n",s)),perl=T),"}"))}

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

C (gcc) , 119 바이트

#define p(s)printf(#s,c)
s;f(c){for(p({);~(c=getchar())|s;)c<11?s=s&&!p(",�"):c-61?s++||p(\42),p(\\u%04x):p(":");p(});}

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

PHP, 87 바이트

preg_match_all("/^(.*)=(.*)$/m",$argn,$m);echo json_encode(array_combine($m[1],$m[2]));

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

Windows 줄 바꿈을 위해 \s앞에 삽입하십시오 $/m. \s*줄 바꿈이 확실하지 않은 경우 값에가 포함 된 경우 뒤에
삽입하십시오 .U$/m=

다트 , 142 (114) 108 바이트

f(s)=>"""{${s.replaceAll('"','\\"').replaceAllMapped(RegExp(r'(.*)=(.*)'),(m)=>'"${m[1]}":"${m[2]}",')}}""";

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