ถอดรหัสเป็นโมฆะ


25

รายการโมฆะคือรายการที่ไม่มีระดับมีวัตถุที่ไม่ใช่รายการใด ๆ หรือถ้าคุณต้องการคำจำกัดความซ้ำ

  • รายการว่างเปล่าเป็นโมฆะ

  • รายการที่มีเพียงรายการโมฆะอื่น ๆ ที่เป็นโมฆะ

รายการโมฆะทั้งหมดมีความลึก จำกัด

นี่คือตัวอย่างของรายการโมฆะ (ใช้ไวยากรณ์ของหลาม):

[]
[[]]
[[],[]]
[[[]]]
[[[]],[]]
[[],[[]]]

นี่คือตัวอย่างของสิ่งที่ไม่ใช่รายการโมฆะ:

["a"]
[[...]]
[1]
2
[[],([],[])]

งาน

เขียนสองฟังก์ชั่นแยกกัน (หรือโปรแกรมหากคุณต้องการ) หนึ่งควรใช้จำนวนเต็มบวก (คุณอาจรวมศูนย์ถ้าคุณต้องการ) เป็นอาร์กิวเมนต์และส่งกลับรายการโมฆะอื่น ๆ ควรใช้รายการโมฆะและกลับเป็นจำนวนเต็ม ฟังก์ชันทั้งสองนี้ควรเป็นค่าผกผันของกันและกัน นั่นคือถ้าคุณผ่านการส่งออกของfเข้าgที่คุณควรจะได้รับการป้อนข้อมูลเดิมเป็นผลมาจากการf gนี่หมายความว่าการแมปจะต้องเป็น 1: 1 นั่นคือสำหรับทุก ๆ จำนวนเต็มอาจมีเพียงหนึ่งรายการโมฆะที่gให้จำนวนเต็มนั้นและสำหรับรายการโมฆะทุกรายการควรมีจำนวนเต็มหนึ่งค่าที่fให้รายการโมฆะนั้น

คุณกำลังสร้าง Bijection เป็นหลัก

คุณอาจเลือกที่จะใช้การแทนค่าสตริงของรายการโมฆะ (มีหรือไม่มีเครื่องหมายจุลภาคและเว้นวรรค) แทนประเภทรายการเนทีฟของภาษาของคุณ

เกณฑ์การให้คะแนน

คะแนนของคุณจะเป็นความยาวของทั้งสองฟังก์ชั่นของคุณด้วยกัน นี่คือดังนั้นคุณควรตั้งเป้าหมายที่จะลดยอดรวมนี้


2
มีความเกี่ยวข้องกันมาก: codegolf.stackexchange.com/questions/94540/build-a-nest/…
Lemon ที่ถูกทำลายได้

1
คำถามนี้ถามถึงสองฟังก์ชั่นในขณะที่ซ้ำกันเพียงถามสำหรับครึ่งแรก
เอียนมิลเลอร์

3
หนู ฉันเกือบโพสต์คำตอบที่ดีที่สุดที่ฉันเขียนไว้และมันก็ไม่ผ่านเกณฑ์สำหรับความท้าทายอื่น ๆ
Caleb Kleveter

2
@IanMiller ฉันจะบอกว่าความท้าทายอื่นมีแนวทางที่แตกต่างกันสำหรับการเข้ารหัสแล้วอันนี้ทำ
Caleb Kleveter

1
บางทีมันอาจจะสมเหตุสมผลกว่าที่คำถามนี้จะเป็นแค่ตัวถอดรหัส? เนื่องจากมีคำถามเกี่ยวกับโปรแกรมเปลี่ยนไฟล์

คำตอบ:


7

Pyth, 27 + 29 = 56 ไบต์

f:

L?bol`NS{sm[d+d]Y]d)ytb]Y@y

ชุดทดสอบ

g:

L?bol`NS{sm[d+d]Y]d)ytb]Yxyl`

ชุดทดสอบ

ระบบนี้เป็นระบบที่ง่ายมาก: ฉันสร้างรายการเป็นไปได้ทั้งหมดไม่เกินจำนวนที่แน่นอนของ['s จากนั้นฉันเรียงลำดับตามรายการที่ฉันยังไม่ได้สร้าง ทั้งหมดนี้ทำโดยฟังก์ชันyซึ่งเหมือนกันในทั้งสองโปรแกรม มันถูกเขียนเป็น

L?bol`NS{sm[d+d]Y]d)ytb]Y

จากนั้นฉันสร้างดัชนีลงในรายการนี้สำหรับ fgและค้นหาผ่านมัน

จำนวนรายการที่ฉันสร้างถูกเลือกให้มีขนาดใหญ่พอที่ฉันได้สร้างรายการที่เป็นไปได้ทั้งหมดซึ่งจะปรากฏที่หรือก่อนตำแหน่งที่ต้องการในรายการที่เรียงไม่สิ้นสุด

โปรแกรมอนุญาต / คืนค่า 0 เป็นตัวเลือก


5

Python 2 , 96 ไบต์

ลองออนไลน์! เพื่อทดสอบ bijection

f=lambda l:len(l)and f(l[0])*2+1<<f(l[1:])

รับรายการเป็นโมฆะเป็นจำนวนเต็มไม่เป็นลบ 42 ไบต์

g=lambda n:n*[g]and[g(n/(n&-n)/2)]+g(len(bin(n&-n))-3)

ใช้จำนวนเต็มที่ไม่เป็นลบเพื่อโมฆะรายการ 54 ไบต์ ความพยายามแบบเรียกซ้ำอีกครั้งให้ความยาวเท่ากัน

g=lambda n,i=0:n*[g]and[g(n/2,i+1),[g(n/2)]+g(i)][n%2]

1

Java 7, 725 ไบต์

f(int)( 325 ไบต์ ):

String f(int i){String s="";for(int j=0,e=0;e<i;e+=v(s))s=Integer.toBinaryString(j++);return"["+s.replace("1","[").replace("0","]")+"]";}int v(String s){for(;!s.isEmpty();s=s.replaceFirst("1","").replaceFirst("0",""))if(s.replace("1","").length()!=s.replace("0","").length()|s.charAt(0)<49|s.endsWith("1"))return 0;return 1;}

g(String)( 75 + 325 ไบต์ ):

int g(String s){int r=0;for(String i="10";!i.equals(s);i=f(++r));return r;}

เนื่องจาก method gใช้วิธีfการคำนวณผลลัพธ์ของมันโดยการวนลูปในรายการ void ที่เป็นไปได้จนกว่าจะพบหนึ่งเท่ากับหนึ่งอินพุตที่ไบต์fจะถูกนับสองครั้ง (เนื่องจากทั้งสองวิธีควรจะสามารถทำงานได้

คำอธิบาย:

โดยทั่วไปแล้วเมธอดจะfวนรอบสตริงการแทนค่าสตริงจำนวนเต็มของไบนารีทั้งหมดและเพิ่มตัวนับทุกครั้งที่พบค่าที่ถูกต้อง binary-Strings ที่ถูกต้องสำหรับความท้าทายนี้ปฏิบัติตามกฎต่อไปนี้: พวกเขาเริ่มต้นด้วย1, และจบด้วย0; พวกเขามีจำนวนเท่ากับ 1 และ 0 และทุกครั้งที่คุณลบแรก1และ0ตรวจสอบสิ่งที่เหลืออีกครั้งกฎทั้งสองนี้ยังคงมีผลอยู่ หลังจากตัวนับเท่ากับอินพุตมันจะแปลงนั้น binary-String เป็น String void-list โดยแทนที่ทั้งหมด1ด้วย[และทั้งหมด0ด้วย]กับ

สำหรับเมธอดg: เราเริ่มต้นด้วย"[]"(แทนโมฆะรายการ0) จากนั้นใช้วิธีการต่อไปfในขณะที่เพิ่มจำนวนเต็มจนกระทั่งมันตรงกับอินพุต - สตริง

String f(int i){         // Method `f` with integer parameter and String return-type
  String s="";           //  Start with an empty String
  for(int j=0,e=0;e<i;   //  Loop as long as `e` does not equal the input
      e+=v(s))           //    And append increase integer `e` if String `s` is valid
    s=Integer.toBinaryString(j++);
                         //   Change `s` to the next byte-String of integer `j`
                         //  End of loop (implicit / single-line body)
  return"["+             //  Return the result String encapsulated in "[" and "]"
    s.replace("1","[").replace("0","]")+"]";
                         //  after we've replaced all 1s with "[" and all 0s with "]"
}                        // End of method `f`

int v(String s){         // Separate method with String parameter and integer return-type
  for(;!s.isEmpty();     //  Loop as long as String `s` isn't empty
      s=s.replaceFirst("1","").replaceFirst("0",""))
                         //    After each iteration: Remove the first "1" and "0"
    if(s.replace("1","").length()!=s.replace("0","").length()
                         //   If there isn't an equal amount of 1s and 0s
       |s.charAt(0)<49   //   or the String doesn't start with a 1
       |s.endsWith("1")) //   or the String doesn't end with a 0
      return 0;          //    Return 0 (String is not valid)
                         //  End of loop (implicit / single-line body)
  return 1;              //  Return 1 (String is valid)
}                        // End of separate method

int g(String s){         // Method `g` with String parameter and integer return-type
  int r=0;               // Result integer
  for(String i="[]";!i.equals(s);
                         //  Loop as long as `i` does not equal the input String
      i=f(++r));         //   After each iteration: Set `i` to the next String in line
  return r;              //  Return the result integer
}                        // End of method `g`

ตัวอย่างกรณีอินพุทและเอาท์พุท:

ลองที่นี่ (หมายเหตุ: ค่อนข้างช้าสำหรับกรณีทดสอบสองสามครั้งล่าสุดใช้เวลาประมาณ 10-15 วินาทีสำหรับทุกกรณี)

0   <-> []
1   <-> [[]]
2   <-> [[][]]
3   <-> [[[]]]
4   <-> [[][][]]
5   <-> [[][[]]]
6   <-> [[[]][]]
7   <-> [[[][]]]
8   <-> [[[[]]]]
9   <-> [[][][][]]
10  <-> [[][][[]]]
11  <-> [[][[]][]]
12  <-> [[][[][]]]
13  <-> [[][[[]]]]
14  <-> [[[]][][]]
50  <-> [[[][[[]]]]]
383 <-> [[[][]][[[][]]]]

1
ฉันไม่คิดว่า[][]เป็นรายการ บางทีฉันอาจเข้าใจผิดว่า Java ทำสิ่งใด เพิ่ม[...]รอบพวกเขาทั้งหมดและมี 0 แผนที่[]ควรทำเคล็ดลับ
ข้าวสาลีตัวช่วยสร้าง

@WheatWizard อาโทรดี จะพยายามแก้ไขสิ่งนี้ ฉันยังมีไบต์ไม่เพียงพอ ; P
Kevin Cruijssen

@Weateat ตัวช่วยสร้างตกลงตอนนี้ควรได้รับการแก้ไขแล้ว ความท้าทายที่ยาก แต่สนุก btw ก่อนที่ฉันจะเข้าใจว่าคุณหมายถึงอะไรและใช้เวลานานกว่านั้นในการเขียนคำตอบนี้ แต่ก็สนุกดี :)
Kevin Cruijssen



0

Python 3 - ลงชื่อ / abs, 73 ไบต์

f=lambda n:[[[]]*(n<0),[[]]*abs(n)]
g=lambda l:[-1,1][not l[0]]*len(l[1])

ลองออนไลน์!

การนำไปปฏิบัติใช้โดยตรงรองรับตัวเลขติดลบ

จำนวนเต็มiถูกเข้ารหัส[sign(i), abs(i)]โดยที่sign(i)=[] if i > 0 else [[]]และabs(i)=[[]] * iเช่นรายการของรายการที่ว่างเปล่าที่มีความยาว abs (i)

Python 3 - ไบนารี, 126 ไบต์

นี่เป็นรุ่นที่ซับซ้อนมากขึ้น (และอีกต่อไป ... ) ซึ่งค่าสัมบูรณ์ถูกเข้ารหัสในการแสดงรายการแบบไบนารี

f=lambda n:[[[]]*(n<0),[[[]]*int(i)for i in f"{n:+b}"[1:]]]
g=lambda l:[-1,1][not l[0]]*int(''.join(map(str,map(len,l[1]))),2)

ลองออนไลน์!


1
ใช้ไม่ได้กับรายการโมฆะที่ซับซ้อนมากขึ้นลองออนไลน์!
Jitse

อ๊ะฉันก็พลาดไปว่าควรจะมีการแมปสำหรับรายการโมฆะทุกรายการ ... คุณพูดถูก
movatica

0

Stax , 33 ไบต์ทั้งหมด

โปรแกรมเหล่านี้เป็นของกันและกัน พวกมันแปลงไปเป็นและจากรายการโมฆะทั้งหมดและจำนวนเต็มที่ไม่เป็นลบทั้งหมดดังนั้นที่มี 0 ดูเหมือนว่ามันอาจจะเป็นฟังก์ชั่นที่มีชื่อเสียงจากพีชคณิตบางชนิดที่ฉันไม่รู้ เพื่อที่จะหุ้มหัวฉันก่อนอื่นฉันใช้โปรแกรมเป็นฟังก์ชั่นในหลาม

def convert_to_void(n):
    lst = []
    while n > 0:
        n -= 1
        choices = len(lst) + 1
        choice = n % choices
        cutpoint = len(lst) - choice
        n //= choices
        newgroup = lst[cutpoint:]
        del lst[cutpoint:]
        lst.append(newgroup)
    return lst

def convert_from_void(lst):
    n = 0
    while lst != []:
        newgroup = lst.pop()
        n *= len(lst) + len(newgroup) + 1
        n += len(newgroup) + 1
        lst.extend(newgroup)
    return n

โปรแกรม stax มีพฤติกรรมเดียวกัน

จำนวนเต็มไม่ลบ→รายการเป็นโมฆะ 15 ไบต์

ƒâ₧~└3BI─¿-rÅ;ì

เรียกใช้และแก้ไขข้อบกพร่อง

รายการโมฆะ→จำนวนเต็มไม่ลบ 18 ไบต์

Çäê[!σ`c↑Ö§░NR╥ç=Æ

เรียกใช้และแก้ไขข้อบกพร่อง

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.