Python'un turşu modülü serileştirme için kullanılır, bir kişinin bir nesneyi daha sonra yeniden oluşturulacak şekilde dökmesine izin verir. Bunun için turşu basit bir yığın tabanlı dil kullanır.

İşleri basitleştirmek için, bu dilin küçük bir alt kümesiyle ilgileneceğiz:

(              Push a mark to the stack
S'abc'\n       Push a string to the stack (here with contents 'abc')
l              Pop everything up to the last mark, wrapping all but the mark in a list
t              Pop everything up to the last mark, wrapping all but the mark in a tuple
.              Terminate the virtual machine

Göreviniz dilin bu alt kümesini uygulamaktır. \nBurada gerçek bir yeni satır olduğunu ve yeni satırların aslında dil için önemli olduğunu unutmayın.

Dil-benzeri CJam GolfScript veya aşina, olanlar için (ve l/taynı şekilde Hotel işletmek [ve ]sırasıyla.

Giriş

İşleri basit tutmak için girdi her zaman geçerli olacaktır. Özellikle, girdi hakkında aşağıdakileri varsayabilirsiniz:

• Dizeler yalnızca küçük harfler ve boşluklardan oluşacak [a-z ]ve her zaman tek tırnak kullanacaktır.
• Tüm talimatlar yukarıda belirtildiği gibi yabancı karakterler olmayacaktır. Örneğin, bu, yeni satırların yalnızca dizelerden sonra gerçekleşeceği anlamına gelir.
• Her l/tbirinin (önünde bir eşleşme vardır ve her (birinin önünde bir eşleşme vardır l/t. Ayrıca en az bir tane olacak (.
• Tam olarak bir tane .olacak ve her zaman son karakter olacak.

Komut satırı, STDIN veya işlev bağımsız değişkeni ile girdi alabilirsiniz. İsterseniz çok satırlı bir dize yerine tek satırdan kaçan bir dize kullanabilirsiniz, ancak lütfen cevabınızda bunu belirtin.

Çıktı

Çıktı, son nesnenin bir temsili olmalı, STDOUT'a basılmalı veya dize olarak döndürülmelidir . özellikle:

• Dizeler, aralarında içerik bulunan tek tırnakların açılması ve kapatılması ile temsil edilir, örn S'abc' -> 'abc'. Python'da izin verilse bile, bu meydan okuma için çift tırnak işareti kullanamazsınız.

• Listeler çevrili virgülle ayrılmış unsurları ile temsil edilmektedir [](örneğin, ['a','b','c']küpe çevrili virgülle ayrılmış elemanlarla repsented ise), ()(örneğin ('a','b','c')).

• Alanlar önemli değil, örneğin ('a', 'b', 'c' ).
• Kapatma dirseğinden önce virgül kullanamazsınız. Çoğu dil için işleri kolaylaştırmak ve aynı zamanda Python'da liste / tuple oluşturmayı ve ardından tek öğeli demetin nasıl temsil edildiğini (örneğin bunun için) zorlaştırmak için bunun Python sözdizimi kurallarından bilerek farklı olduğunu unutmayın. meydan okuma, ('a')aksine ihtiyacımız var ('a',)).

Örnekler

Yukarıdaki metin göz korkutucu görünebilir, ancak aşağıdaki örnekler işleri biraz daha açık hale getirmelidir.

(l.

Olası çıktı: []

(t.

Olası çıktı: ()

(S'hello world'
l.

Olası çıktı: ['hello world']

(S'string one'
S'string two'
S'string three'
t.

Olası çıktı: ('string one', 'string two', 'string three')

(S'a'
(S'b'
S'c'
lt.

Olası çıktı: ('a',['b','c'])

((S'a'
S'b'
(lS'c'
t(S'd'
tl.

Olası çıktı: [('a', 'b', [], 'c'), ('d')]

((S'a'
((S'b'
t(S'c'
lS'd'
(((ltlS'e'
S'f'
lS'g'
tl.

Olası çıktı: [('a',[('b'),['c'],'d',[([])],'e','f'],'g')]

kurallar

• Bu kod golf , bu yüzden en az bayt kod kazanır.
• Python turşularıyla çalışmak üzere tasarlanmış hiçbir işleve izin verilmez.

^{Güvenlik notu: Gerçek kodda, yalnızca güvendiğiniz kaynaklardan seçim yapın, yoksa kötü bir cos\nsystem\n(S'rm -rf'\ntR.sürpriz yaşayabilirsiniz}

CJam, 63

q{"Slt 1:T;L ]',*'[\+']+ ]',*'(\+')+ [
 0:T; C+"35/T=S/(C#=~}fC

Çevrimiçi deneyin

Açıklama:

q        read the input
{…}fC    for each character C in the input
  "…"    push that long string, containing code to handle various cases
  35/    split it into (two) parts of length 35
  T=     get the T'th part; T is 1 when parsing a string and 0 otherwise
          (T is initially 0 by default)
  S/     split by space into an array of strings
  (      take out the first item (containing special characters to check)
  C#     find the index of C in that string
  =      get the corresponding string from the array
          (when C is not found, # returns -1 which gets the last array item)
  ~      execute that string

Şimdi çeşitli kod parçaları ile uzun dize. Her bölüm kontrol edilecek birkaç karakter ve ardından her birini işlemek için bir blok ve varsayılan harf içerir.

İlk kısım: Slt 1:T;L ]',*'[\+']+ ]',*'(\+')+ [

Slt      special characters to check
######## first block, corresponding to character 'S'
1:T;     set T=1, causing the next characters to be processed with the 2nd part
L        push an empty string/array, which will be used to collect the string
######## second block, corresponding to character 'l'
]        end array
',*      join with commas
'[\+     prepend a '['
']+      append a ']'
######## third block, corresponding to character 't'
]        end array
',*      join with commas
'(\+     prepend a '('
')+      append a ')'
######## last block, corresponding to other characters (practically, '(' and '.')
[        start array

İkinci kısım: (newline) 0:T; C+

newline  special characters to check (only one)
######## first block, corresponding to newline
0:T;     set T=0, switching back to the first part
######## last block, corresponding to any other character (including apostrophe)
C+       append the character to the collecting string

Perl, 149 bayt

Bunun kötü bir girişim olduğuna dair kötü bir his var, ama işte gidiyor:

$/=$,;$"=",";@s=[];/^\(/?$s[@s]=[]:{$p=/S(.*')/?$1:/l|t/?($l="@{pop@s}")|/l/?"[$l]":"($l)":0,push@{$s[-1]},$p}for<>=~/([(lt]|S.*?\n)/g;print$s[0][0];

Komut dosyası bir dosyaya kaydedilmelidir ve STDIN'den girdi alır.

Açıklama:

# Set the input record separator to undef so that <> reads all lines at
# once
$/=$,;
# Ensure that elements of lists printed in quotes are separated by commas
$"=",";

# The stack. Initialise the bottom element with an empty array
@s=[];

# Tokens are extracted in the for loop a few lines below. Copied here for
# clarity: Read the entire input and iterate over all valid tokens of the
# pickle language
# for <>=~/([(lt]|S.*?\n)/g;
# the token is a mark - push an empty array to the stack
/^\(/ ? $s[@s]=[]
      # token is a string, push it inside the stack top
      : {$p=/S(.*')/ ? $1
                     # otherwise, remove the top and create list or tuple
                     # from it and push it inside the top element
                     : /l|t/ ? ($l="@{pop@s}") | /l/ ? "[$l]"
                                                     : "($l)"
                             : 0 # dummy value
                             # pushing of the string/list/tuple actually
                             # happens here
                             , push@{$s[-1]},$p} 
# read the entire input at once and iterate over all valid tokens
for <>=~/([(lt]|S.*?\n)/g;

# in the end, the bottom element of the stack will be an array with just one
# element which is the string representation of the object
print$s[0][0];

> <>, 88 bayt

^"][">}r]
~rl?!;o11.
^0\!\
 &</\?[1&~?=1l","
 1/\ii:"'"=?v44.
>i9%0$.     >r]i~


 ")("\

Atlar ile eğlenceli! Mod 5'in dahil olduğu 5 ana komut için ASCII kodlarının:

S -> 2
l -> 0
t -> 8
( -> 4
. -> 1

Bu, her işlemin doğrudan doğruya atlanacak olan kendi hattında yapılmasına izin verir. Ayrıca, gerekli dizelere sarmadan önce her dizeyi ve iç içe liste / tupleı ayrı ayrı oluşturmak için yığın yığınını kullanır.

JavaScript (ES6), 199 bayt

s=>(q=x=>(o=[],x.slice(0,-1).map(v=>o=[...o,v.map?q(v):`'${v}'`]),x.pop()<"m"?`[${o}]`:`(${o})`),q(eval(s[r="replace"](/\(/g,"[")[r](/[tl](?![\w ]+'\n)/g,"'$&'],")[r](/S('.+')/g,"$1,").slice(0,-2))))

Geçerli JS koduna dönüştürmek için girdide birkaç normal ifadeyi değiştirir, ardından ayrıştırır.

Snippet'i Test Et

f=
s=>(q=x=>(o=[],x.slice(0,-1).map(v=>o=[...o,v.map?q(v):`'${v}'`]),x.pop()<"m"?`[${o}]`:`(${o})`),q(eval(s[r="replace"](/\(/g,"[")[r](/[tl](?![\w ]*'\n)/g,"'$&'],")[r](/S('.+')/g,"$1,").slice(0,-2))))

<select oninput="I.value=this.selectedIndex?this.value.replace(/\\n/g,'\n'):'';O.innerHTML=this.selectedIndex?f(I.value):''"><option>---Tests---<option>(l.<option>(t.</option><option>(S'hello world'\nl.<option>(S'string one'\nS'string two'\nS'string three'\nt.<option>(S'a'\n(S'b'\nS'c'\nlt.<option>((S'a'\nS'b'\n(lS'c'\nt(S'd'\ntl.<option>((S'a'\n((S'b'\nt(S'c'\nlS'd'\n(((ltlS'e'\nS'f'\nlS'g'\ntl.</select><br>
<textarea rows=10 cols=20 id=I></textarea><br><button onclick="O.innerHTML=f(I.value)">Run</button><br><pre id=O></pre>

Julia + ParserCombinator.jl 306 240

En son revizyon setimle artık saf bir julia çözümünün daha kısa olacağını düşünmüyorum.

using ParserCombinator
v=join
j(t)=v(t,",")
a=Delayed()
s=E"S'"+Star(p".")+Drop(Equal("'\n"))|>x->"'$(v(x))'"
i=Star(a)|E""
l=E"("+i+E"l"|>x->"[$(j(x))]"
t=E"("+i+E"t"|>x->"($(j(x)))"
a.matcher=s|l|t
f(x)=parse_one(x,a+E".")|>first

Bu ilginçti. Kodlanmış kodun oldukça etkili olduğunu düşünüyorum.

• Çıktı biçimlendirme nesilde yapılır
• a l, i, tVe stemelde kuralları cfg vardır
• f her şeyi bir araya getiren işlevdir.
• Drop(Equal("'\n"))sinir bozucu - ideal olarak yazılabilir ki E"\n"ancak Edize makro çıkış sıralarını işlemez.
• İlginç bir şekilde, bu önemsiz bir şekilde dönen veri veri yapılarına dönüştürülebilir, temelde |>s'nin RHS'sindeki dönüşümleri kaldırır tupleve tkural için ekler