Elixir에서, (연결된)리스트는 head 가 무엇이든 될 수있는 형식으로 [head | tail]되어 있으며 tail 은리스트의 나머지리스트이며 , 비어있는리스트는 이것에 대한 유일한 예외입니다.[]

목록도 같이 쓸 수 [1, 2, 3]있는 것은 동일합니다[1 | [2 | [3 | []]]]

당신의 임무는 설명대로 목록을 변환하는 것입니다. 입력은 항상 정규식과 일치하는 숫자 만 포함하는 유효한 목록 (Elixir) \[(\d+(, ?\d+)*)?\]입니다. 공백이 있거나 (쉼표 뒤에 한 칸씩) 공백없이 입력 할 수 있습니다. 출력은 공백이 있거나 없을 수 있습니다 (각 앞뒤에 한 |칸씩).

선행 0이있는 입력의 경우 0없이 또는 함께 출력 할 수 있습니다.

입력과 같이 입력을 문자열로 가져와야합니다 (함수를 쓰는 경우).

예

[] -> []
[5] -> [5 | []]
[1, 7] -> [1 | [7 | []]]
[4, 4, 4] -> [4 | [4 | [4 | []]]]
[10, 333] -> [10 | [333 | []]]

관련 부분에서이 같은, 아니 중복 모드를 추가해야 ]끝에. 또한 Haskell의 답변은 여기의 답변과 다릅니다.

하스켈, 50 바이트

f.read
f(a:b)='[':show(a+0)++'|':f b++"]"
f _="[]"

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

는 +0우리가 숫자의 목록을 다루고있는 하스켈 타입 검사기 노하우를 할 수 있습니다, 그래서 read우리를 위해 입력 문자열을 구문 분석합니다.

파이썬 2 , 50 바이트

r='%s'
for x in input():r%='[%s|%%s]'%x
print r%[]

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

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

s=>eval(s).map(v=>`[${p+=']',v}|`,p='[]').join``+p

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

재귀 버전, 51 바이트

f=(s,[v,...a]=eval(s))=>1/v?`[${v}|${f(s,a)}]`:'[]'

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

망막 , 39 33 32 20 바이트

\b]
,]
+`,(.*)
|[$1]

H.PWiz, ovs, ASCII 전용 및 Neil 덕분에 13 바이트를 절약했습니다.
온라인으로 사용해보십시오!

설명

\b]
,]

빈 목록이 없으면 뒤에 쉼표를 추가하십시오.

+`,(.*)
|[$1]

쉼표가있는 경우을 (를)로 감싸십시오 |[ thing ].

펄 5 -pl , 31 28 바이트

s/\d\K]/,]/;$\=']'x s/,/|[/g

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

어떻게?

-p                    # (command line) Implicit input/output via $_ and $\
s/\d\K]/,]/;          # insert a comma at the end if the list is not empty
$\=']'x s/,/|[/g      # At the end of the run, output as many ']' as there are
                      # commas in the input.  Replace the commas with "|["

엘릭서 , 111 85 바이트

f=fn[h|t],f->"[#{h}|#{f.(t,f)}]"
[],_->"[]"
h,f->f.(elem(Code.eval_string(h),0),f)end

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

나는 전에 엘릭서를 사용한 적이 없다. 문자열과 자신에 대한 참조를 가져 와서 문자열을 반환하는 함수를 정의합니다.

실론 , 113 바이트

String p(String s)=>s.split(" ,[]".contains).select((x)=>!x.empty).reversed.fold("[]")((t,h)=>"[``h`` | ``t``]");

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

그 내용은 다음과 같습니다.

// define a function p mapping Strings to Strings.
String p(String s) =>
    // we split the string at all characters which are brackets, comma or space.
    s.split(" ,[]".contains)    // → {String+}, e.g.  { "", "1", "7", "" }
    // That iterable contains empty strings, so let's remove them.
    // Using `select` instead of `filter` makes the result a sequential instead of
    // an Iterable.
     .select((x)=>!x.empty)    // → [String*], e.g.   [1, 7]
    // now invert the order.
    // (This needs a Sequential (or at least a List) instead of an Iterable.)
     .reversed                 // → [String*], e.g.   [7, 1]
    // Now iterate over the list, starting with "[]", and apply a function
    // to each element with the intermediate result.
     .fold("[]")                       // → String(String(String, String))
    //    This function takes the intermediate result `t` (for tail) and an element
    //    `h` (for head), and puts them together into brackets, with a " | " in the
    //    middle. This uses String interpolation, I could have used `"+` and `+"`
    //    instead for the same length.
          ((t,h)=>"[``h`` | ``t``]");  // → String

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

(현재 삭제 된) 주석에서 ovs가 지적한 바와 같이 : 질문에 표시된 입력 및 출력에 "공백 없음"옵션을 선택하면 3 바이트를 더 안전하게 확보 할 수 있습니다 (공백이있는 명백한 바이트).

입력을 구문 분석 할 필요는 없지만 시퀀스를 입력으로 얻을 수있는 경우 훨씬 짧아집니다 (69 바이트).

String p(Object[]s)=>s.reversed.fold("[]")((t,h)=>"[``h`` | ``t``]");

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

파이썬 3 , 65 바이트

lambda k:"["+''.join(f"{u}|["for u in eval(k))+-~len(eval(k))*"]"

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

입력이 대신 목록이 될 수있는 경우 :

파이썬 3 , 53 바이트

lambda k:"["+''.join(f"{u}|["for u in k)+-~len(k)*"]"

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

SNOBOL4 (CSNOBOL4) , 114 바이트

	I =INPUT
S	N =N + 1	
	I SPAN(1234567890) . L REM . I	:F(O)
	O =O '[' L ' | '	:(S)
O	OUTPUT =O '[' DUPL(']',N)
END

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

	I =INPUT				;* read input
S	N =N + 1				;* counter for number of elements (including empty list)
	I SPAN(1234567890) . L REM . I	:F(O)	;* get value matching \d until none left
	O =O '[' L ' | '	:(S)		;* build output string
O	OUTPUT =O '[' DUPL(']',N)		;* print O concatenated with a '[' and N copies of ']'
END

Stax , 19 바이트

É▲²:WlÖ└%ï╪☺╒▓"We↨Φ

실행 및 디버깅

내 첫 스탁스 포스트, 아마 최적이 아닙니다.

포장을 풀고 댓글을 달았습니다 :

U,                      Put -1 under input
  {                     Block
   i                      Push loop index, needed later
    '[a$'|++              Wrap the element in "[...|"
            m           Map
             '[+        Add another "["
                s2+     Get the latest loop index + 2
                   ']*+ Add that many "]"

이것을 실행하고 디버그하십시오

껍질 , 22 바이트

+:'[J"|[":msr¹₁*₁Lr
"]

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

Befunge-98 (PyFunge) , 22 21 바이트

'[,1;@j,]';#$&." |",,

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

출력에 이상한 제한이 없다면 우리는 18에서 이것을 할 수 있습니다.

'[,1;@j,]';#$&.'|,

재미있는 사실, 이것은 기술적으로 파이썬에서 아무것도하지 않는 프로그램입니다.

루비 -p , 39 바이트

전체 프로그램 :

$_[$&]="|[#$2]"while/(,|\d\K(?=]))(.*)/

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

루비 , 48 45 바이트

재귀 함수 :

f=->s{(s[/,|\d\K(?=])/]&&="|[")&&f[s+=?]]||s}

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

아르 자형 , 84 71 69 바이트

function(x){while(x<(x=sub('(,|\\d\\K(?=]))(.+)','|[\\2]',x,,T)))1;x}

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

• @KirillL 덕분에 -15 바이트

양성자 , 57 바이트

k=>"["+''.join(str(u)+"|["for u:(e=eval(k)))+-~len(e)*"]"

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

젤리 , 19 바이트

ŒV©;€⁾|[”[;µ®L‘”]ẋṭ

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

Erik의 솔루션에 대한 비재 귀적 대안 .

젤리 , 18 바이트

ŒVḢ,ŒṘÇ”|;ƲƊ¹¡⁾[]j

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

젤리 , 18 바이트

ŒVµ⁾[]jj⁾|[ṫ3;”]ṁ$

결과를 인쇄하는 전체 프로그램 (모나 딕 링크로 문자 목록을 허용하지만 문자 및 정수 목록을 리턴 함)

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

어떻게?

ŒVµ⁾[]jj⁾|[ṫ3;”]ṁ$ - Main link: list of characters  e.g. "[10,333]"
ŒV                 - evaluate as Python code              [10,333]
  µ                - start a new monadic chain, call that X
   ⁾[]             - list of characters                   ['[',']']
      j            - join with X                          ['[',10,333,']']
        ⁾|[        - list of characters                   ['|','[']
       j           - join                                 ['[','|','[',10,'|','[',333,'|','[',']']
           ṫ3      - tail from index three                ['[',10,'|','[',333,'|','[',']']
                 $ - last two links as a monad (f(X)):
              ”]   -   character                          ']'
                ṁ  -   mould like X                       [']',']'] (here 2 because X is 2 long)
             ;     - concatenate                          ['[',10,'|','[',333,'|','[',']',']',']']
                   - implicit (and smashing) print        [10|[333|[]]]

자바 10, 107 바이트

s->{var r="[]";for(var i:s.replaceAll("[\\[\\]]","").split(","))r="["+i+"|"+r+"]";return s.length()<3?s:r;}

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

설명:

s->{                       // Method with String as both parameter and return-type
  var r="[]";              //  Result-String, starting at "[]"
  for(var i:s.replaceAll("[\\[\\]]","") 
                           //  Removing trailing "[" and leading "]"
             .split(","))  //  Loop over the items
    r="["+i+"|"+r+"]";     //   Create the result-String `r`
  return s.length()<3?     //  If the input was "[]"
          s                //   Return the input as result
         :                 //  Else:
          r;}              //   Return `r` as result

표준 ML , 71 바이트

fun p[_]="]|[]]"|p(#","::r)="|["^p r^"]"|p(d::r)=str d^p r;p o explode;

온라인으로 사용해보십시오! 공백없이 형식을 사용합니다. 예를 들어 it "[10,333,4]"수율"[10|[333|[4]|[]]]]" .

언 골프

fun p [_]       = "]|[]]"          (* if there is only one char left we are at the end *)
  | p (#","::r) = "|[" ^ p r ^ "]" (* a ',' in the input is replaced by "|[" and an closing "]" is added to the end *)
  | p (d::r)    = str d ^ p r      (* all other chars (the digits and the initial '[') are converted to a string and concatenated to recursive result *)

val f = p o explode  (* convert string into list of chars and apply function p *)

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

R , 140 136 바이트

주세페의 조언에 따라 4 바이트 줄였습니다.

function(l,x=unlist(strsplit(substr(l,2,nchar(l)-1),", ")))paste(c("[",paste0(c(x,"]"),collapse=" | ["),rep("]",length(x))),collapse="")

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

R , 108 바이트

function(l)Reduce(function(x,y)paste0("[",x,"|",y,"]"),eval(parse(t=sub("]",")",sub("\\[","c(",l)))),"[]",T)

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

이전보다 더 나은 R 솔루션을 찾는 데 거의 1 년이 걸렸습니다 Reduce. 공백이없는 출력, 공백이 있거나없는 입력이 가능합니다.

파이썬 2 , 63 바이트

lambda s:'['+'|['.join(map(str,eval(s))+[']'])+']'*len(eval(s))

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

sed + -E, 46 바이트

:
s/\[([0-9]+)(, ?([^]]*)|())\]/[\1 | [\3]]/
t

상당히 간단한 접근법. 두 번째 줄은를 [\d+, ...]로 변경합니다 [\d | [...]]. 대체가 성공한 경우 세 번째 줄은 첫 번째 줄로 건너 뜁니다. 대체는 실패 할 때까지 반복 된 다음 프로그램이 종료됩니다. sed -E -f filename.sedstdin을 통해 입력을 전달 하여로 실행하십시오 .

빨강 , 110 바이트

func[s][if s ="[]"[return s]replace append/dup replace/all b: copy s",""|[""]"(length? b)- length? s"]""|[]]"]

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

ungolfed 버전에 대한 설명 :

f: func[s][                      
    if s = "[]" [return s]                    ; if the list is empty, return it    
    b: copy s                                 ; save a copy of the input in b 
    replace/all b "," "|["                    ; replace every "," with "|["  
    append/dup b "]" (length? b) - length? s  ; append as many "]" as there were ","
    replace b "]" "|[]]"                      ; replace the first "]" with "|[]]"     
]                                             ; the last value is returned implicitly

빨간색 은 쉽게 읽을 수 있으므로 위의 주석을 추가해야한다고 의심합니다. :)

펄 6 , 38 바이트

{'['~S:g/\s|.<($/\|\[/~']'x$_+1}o&EVAL

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