हिल्बर्ट वक्र के लिए मैप स्ट्रिंग

27

आइए कुछ स्ट्रिंग्स को 2d स्पेस, फ्रैक्टल स्टाइल में मैप करें। आपका काम एक हिल्बर्ट वक्र की गणना करना और उसके साथ एक स्ट्रिंग रखना है।

हिल्बर्ट वक्र, पुनरावृत्तियों 1 से 8

कार्य

कार्य एकल-लाइन इनपुट स्ट्रिंग को लेना है, और इसे हिल्बर्ट वक्र के साथ बाहर रखना है जिसमें इसे शामिल करने के लिए पर्याप्त बड़ा है, लेकिन कोई बड़ा नहीं है। जितना संभव हो बाइट गिनती बनाने की कोशिश करें; इस है कोड गोल्फ सब के बाद!

शर्तेँ

  • किसी भी अंतराल को व्हाट्सएप से गद्देदार किया जाना चाहिए, लेकिन लाइनों के अंत में पैडिंग की आवश्यकता नहीं है।
  • पंक्ति की शुरुआत शीर्ष-बाएं कोने में होनी चाहिए, और नीचे-बाएं में अंत।
  • आप एक प्रोग्राम या फंक्शन बना सकते हैं।
  • कुछ नए परीक्षण-मामले सामने आ सकते हैं, इसलिए कुछ भी हार्डकोड न करें!

बोनस

नोट: बोनस इस तरह स्टैक होता है: -50% & -20% on 100B= -20% on 50Bया -50% on 80B= 40B।

  • -50% यदि इनपुट एक बहु-पंक्ति स्ट्रिंग है, तो मूल इनपुट बनाने के लिए प्रक्रिया को उल्टा करें। बोनस के लिए परीक्षण के मामले: बस मौजूदा वाले (बोनस परीक्षण मामलों सहित) का उपयोग करें!
  • -20% यदि आप आउटपुट से सभी अनावश्यक व्हाट्सएप को छीन लेते हैं (जैसे एक पंक्ति के अंत में)।
  • -5% यदि आप वैश्विक नाम स्थान को प्रदूषित नहीं करते हैं (आप जानते हैं कि मेरा क्या मतलब है!)

परीक्षण के मामलों

abcdefghijklmn

adef
bchg
 nij
 mlk


The quick brown fox jumps over the lazy dog.

Thn f ju
 ewooxpm
qckr rs 
ui btevo
    hlaz
    e  y
      do
      .g

और व्हॉट्सएप-स्ट्रिपिंग बोनस के लिए:

No  hitespac  her 

Noher

hesc
itpa

लीडरबोर्ड

कोड स्निपेट दिखाएं

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes
code-golf  string  fractal 
— wizzwizz4
स्रोत
अगर कोई कुछ और टेस्टकेस बना सकता है, तो उसकी सराहना की जाएगी।
— wizzwizz4
तो कर्व को वक्र के कोने से दर्शाया जाना चाहिए?
— दोष
No..hitespac..her.जहां डॉट्स स्थान हैं, बोनस के लिए एक बेहतर परीक्षण मामला होगा। (और वर्तमान में, परीक्षण का मामला पीछे छूट रहा है .)
— मार्टिन एंडर
यदि आप एल-सिस्टम दृष्टिकोण ले रहे हैं, तो आप http: // कोडगुल्फ़ / प्रश्न / 48697 / एससीआई-एल-सिस्टम-रेंडरर भी आज़माना चाह सकते हैं । यह आपको अपने उत्तरों को गढ़ने में मदद कर सकता है।
— wizzwizz4

जवाबों:

7

सीजाम, 119 117 113 112 109 * 0.5 * 0.8 = 43.6 बाइट्स

1 बाइट बचाने के लिए डेनिस को धन्यवाद।

यहाँ एक शुरुआत है ...

{+e`W<e~}:F;q_N-,4mLm]0aa{4\#4e!1=f*\:G[zGGW%zW%G].ff+2/{~.+~}%}@:L/\_N&{N/]z:z:~$1f>sS}{4L#' e]f{f=SF}N*N}?F

आगे के परिवर्तनों का परीक्षण करें । व्युत्क्रम परिवर्तन का परीक्षण करें।

मुझे यकीन है कि वक्र उत्पन्न करने का एक छोटा तरीका है ...

व्याख्या

सबसे पहले, मैं एक सरणी के अंत से कुछ तत्व को ट्रिम करने के लिए एक फ़ंक्शन को परिभाषित करता हूं, क्योंकि मुझे कई स्थानों पर इसकी आवश्यकता है। यह ढेर के शीर्ष पर सरणी और तत्व (एक अलग सरणी के अंदर) की अपेक्षा करता है।

{
  +  e# Append the element to the array.
  e` e# Run-length encode.
  W< e# Discard last run.
  e~ e# Run-length decode.
}:F; e# Store in F and discard.

अब अधिकांश कोड आवश्यक हिल्बर्ट वक्र के आकार को निर्धारित करता है और इसे 2D सरणी के रूप में निर्मित करता है जहां तत्व वक्र के साथ सूचक होते हैं। मैं निम्नलिखित अवलोकन के आधार पर इसका निर्माण करता हूं:

2x2 हिल्बर्ट वक्र पर विचार करें:

01
32

4x4 हिल्बर्ट वक्र है:

0345
1276
ed89
fcba

यदि हम प्रत्येक चतुर्थांश से न्यूनतम मान घटाते हैं (और उन्हें दृश्य स्पष्टता के लिए थोड़ा अलग करते हैं), तो हम प्राप्त करते हैं:

03 01
12 32

21 01
30 32

यह पैटर्न किसी भी आकार के लिए होता है। इसका अर्थ है कि हम वर्तमान स्तर से अगले स्तर का निर्माण कर सकते हैं, चार चतुर्भुजों के रूप में उपयोग करके: a) वर्तमान स्तर का पारगमन, b) वर्तमान स्तर स्वयं, c) विरोधी तिरछे के साथ पारगमन, d) फिर से वर्तमान स्तर ही। और फिर हम उन्हें वर्तमान स्तर के क्रमशः 0, 1, 3, 2 गुना आकार देते हैं।

q           e# Read input.
_N-         e# Make a copy and remove all linefeeds.
,4mLm]      e# Take that string's length's logarithm with base 4, rounded up.
            e# This is the Hilbert curve level we need.
0aa         e# Push [[0]] as the level-0 Hilbert curve.
{           e# Store the Hilbert curve level in L. Then for each i from 0 to L-1...
  4\#       e#   Compute 4^i. This is the offset of the four quadrants.
  4e!1=     e#   Get [0 1 3 2] as the second permutation returned by 4e!.
  f*        e#   Multiply each of them by the offset.
  \:G       e#   Swap with the Hilbert curve so far and call it G.
  [         e#   Create an array with...
    z       e#     The transpose of G.
    G       e#     G itself.
    GW%zW%  e#     The anti-diagonal transpose of G.
    G       e#     G itself.
  ]
  .ff+      e#   Add the appropriate offsets to the indices in each of the four quadrants.
  2/        e# Split into a 2x2 grid.
  {         e# Map this onto each pair of quadrants...
    ~       e#   Dump both quadrants on the stack.
    .+      e#   Concatenate them line by line.
    ~       e#   Dump the lines on the stack.
  }%        e# Since this is a map, the lines will automatically be collected in an array.
}@:L/

अंत में, हम इनपुट के उपयुक्त परिवर्तन को लागू करने के लिए सूचकांकों के इस हिल्बर्ट वक्र का उपयोग करते हैं:

\_        e# Swap the curve with the input and make another copy.
N&{       e# If the input contains linefeeds, execute the first block, else the second...
  N/      e#   Split the input into lines. The stack now has a grid of indices and a grid
          e#   of characters.
  ]z:z:~  e#   This is some weird transposition magic which zips up the indices with the
          e#   corresponding characters from both grids, and finally flattens the grid
          e#   into a linear list of index/character pairs. Those cells that don't have
          e#   characters due to trimmed whitespace in the input will be turned into
          e#   arrays containing only an index.
  $       e#   Sort the pairs (which sorts them by indices).
  1f>     e#   Discard the indices.
  s       e#   Flatten the result into a single string.
  S       e#   Leave a space on the stack to be trim trailing spaces later.
}{        e# or...
  4L#     e#   Compute the size of the Hilbert curve.
  ' e]    e#   Pad the input to that size with spaces.
  f{      e#   Map this block over lines of the curve, passing the padding input as an
          e#   additional parameter...
    f=    e#     For each index in the current line, select the appropriate character
          e#     from the padded input.
    SF    e#     Trim spaces from the end of the line.
  }
  N*      e#   Join the lines with linefeed characters.
  N       e#   Leave a linefeed on the stack to be trim trailing linefeeds later.
}?
F         e# We left either a space or a linefeed on stack... trim that character from
          e# the end of the string.
— मार्टिन एंडर
स्रोत
3

पायथन 3, 467 434 423 457 451 426 386 374 342 291 304 * 80% * 95% = 231.04 बाइट्स

जिस तरह से यह काम करता है वह यह है कि मैं एक लिंडेनमायर प्रणाली का उपयोग करके हिल्बर्ट वक्र बनाता हूं और तार के एक सरणी के साथ बाएं, दाएं और आगे के निर्देशों का पालन करता हूं। वहाँ कई तरीके हैं, हालांकि यह बेहतर गोल्फ हो सकता है; विशेष रूप से सशर्त और तार की सरणी बनाने में। (मैंने प्रयास किया [" "*p for i in range(p)]लेकिन तार आइटम असाइनमेंट (जाहिरा तौर पर) का समर्थन नहीं करते हैं। अगर मुझे वह काम मिल सकता है, तो मैं जुड़ने से भी छुटकारा पा सकता हूं,)

संपादित करें: डेनिस के लिए धन्यवाद के साथ कुछ शर्तों को पूरा किया । और मैंने स्ट्रिंग्स की सरणी को नीचे गिरा दिया। और एक नो-बाइट परिवर्तन क्योंकि परिणाम ऊपर के उदाहरणों की तुलना में ट्रांसपोज़ किए गए थे।

संपादित करें: व्हॉट्सएप-स्ट्रिपिंग बोनस को लागू किया।

संपादित करें: छह और बाइट्स के लिए मेरे व्हाट्सएप-स्ट्रिपिंग कोड में एक बग फिक्स्ड

संपादित करें: चूंकि यह उत्तर वैश्विक नामस्थान को प्रदूषित नहीं करता है, मुझे यहां wizzwizz4 के अनुसार, 5% बोनस मिलता है ।

संपादित करें: बदला हुआ कैसे gबढ़ा और घटाया गया है। अब का उपयोग कर eval()और str.translate।

संपादित करें: यह उत्तर अब एक फ़ंक्शन के बजाय एक कार्यक्रम है।

संपादित करें: पिछले गोल्फ से कुछ कीड़े फिक्स्ड।

s=input();m=(len(bin(len(s)-1))-1)//2;t=eval("[' ']*2**m,"*2**m);t[0][0],*s=s;x=y=g=0;b="A";exec("b=b.translate({65:'-BF+AFA+FB-',66:'+AF-BFB-FA+'});"*m)
while s:
 c,*b=b;g+=(c<"-")-(c=="-")
 if"B"<c:x,y=[[x+1-g%4,y],[x,y+g%4-2]][g%2];t[x][y],*s=s
print("\n".join(''.join(i).rstrip()for i in t).rstrip())

Ungolfed:

# hilbert(it) is now implemented in the code with exec("b=b.translate")

def hilbert(it):
    s="A"
    n=""
    for i in range(it):
        for c in s:
            if c == "A":
                n += "-BF+AFA+FB-"
            elif c == "B":
                n += "+AF-BFB-FA+"
            else:
                n += c
        s=n;n=""
    return s

def string_to_hilbert(string):
    length = len(string)
    it = (len(bin(length-1))-1)//2
    hil = hilbert(it)
    pow_2 = 2**it
    # we use eval("[' ']*pow_2,"*pow_2) in the code, but the following is equivalent
    output = [[" "for j in range(pow_2)] for i in range(pow_2)]
    output[0][0] = string[0]
    x = 0
    y = 0
    heading = 0
    while string: # while there are still characters in string
        char, *hil = hil
        if char == "-": heading = heading - 1
        elif char == "+": heading = heading + 1
        elif char == "F":
            if heading % 4 == 3: y += 1
            elif heading % 4 == 2: x -= 1
            elif heading % 4 == 1: y -= 1
            else: x += 1
            output[x][y], *string = string
    array = [''.join(i).rstrip()for i in output]
    array = "\n".join(array).rstrip()
    print(array)
    return
— Sherlock9
स्रोत
5% बोनस के बारे में उत्सुक। क्या पायथन में चर स्वचालित रूप से स्थानीय हैं?
— edc65
@ edc65 मैंने चुनौती लेखक से यहां एक समान बात पूछी : chat.stackexchange.com/transcript/240?m=28529277#28529277 । आशा है कि इससे थोड़ी सहायता मिलेगी। यदि नहीं, तो हम चैट में चर्चा जारी रख सकते हैं।
— शर्लक
2

रूबी, 358 356 344 322 319 * 80% * 95% = 242.44 बाइट्स

यह मेरा पाइथन कोड है जो रूबी को ट्रांसप्लांट किया गया है। मुझे रूबी में और उत्तर लिखना चाहिए। यह गोल्फ के लिए एक सभ्य भाषा है।

संपादित करें: मैं भूल गया कि फ़ंक्शन को इस प्रश्न में नामित करने की आवश्यकता नहीं है।

संपादित करें: चूंकि यह उत्तर वैश्विक नामस्थान को प्रदूषित नहीं करता है, मुझे यहां wizzwizz4 के अनुसार, 5% बोनस मिलता है ।

->s{l=s.size;m=((l-1).bit_length+1)/2;x=2**m;t=(1..x).map{[" "]*x};t[0][0]=s[0];x=y=g=z=0;d=1;b=?A;m.times{b=b.split("").map{|c|c==?A?"-BF+AFA+FB-":c==?B?"+AF-BFB-FA+":c}.join("")};(c=b[z];z+=1;g+=c<?-?1:c==?-?-1:0;(g%2>0?y+=g%4-2:x+=1-g%4;t[x][y]=s[d];d+=1)if c>?B)while d<l;puts (t.map{|i|(i*'').rstrip}*"\n").rstrip}

Ungolfed:

def map_string(string)
  len = string.size
  m = ((len-1).bit_length+1)/2
  pow = 2**m
  output = (1..pow).map{[" "]*pow}
  output[0][0] = s[0]
  x = y = heading = char_index = 0
  chars_in_output = 1
  b = ?A
  m.times do |j|
    a = b.split("").map do |char|
      if char == "A"
        "-BF+AFA+FB-"
      else if char == "B"
        "+AF-BFB-FA+"
      else
        char
      end
    end
    b = a.join("")
  end
  while chars_in_output < len
    char = b[char_index]
    char_index += 1
    if char == "-"
      heading += -1
    else if char == "+"
      heading += 1
    else if char == "F"
      if heading % 2 == 0
        y += heading % 4 - 2
      else
        x += 1 - heading % 4
      end
    end
    output[x][y] = string[char_index]
    char_index += 1
  end
  return (output.map{|i|(i*'').rstrip}*"\n").rstrip
— Sherlock9
स्रोत
क्या यह कोड एक लाइसेंस लाइसेंस के तहत दोहरे लाइसेंस वाला है? मैं एक व्युत्पन्न कार्य का उत्पादन करना चाहूंगा जो GPL के तहत जारी किया गया हो (हालाँकि कोई भी GPL- संगत लाइसेंस इस के साथ काम करेगा)। यह वर्तमान में CC BY-SA 3.0 के तहत जारी किया गया है।
— wizzwizz4
@ wizzwizz4 यहाँ चैट करें: chat.stackexchange.com/rooms/56405/…
— शर्लक
1

जावास्क्रिप्ट (ईएस 6), 227 - 20%: 181.6 बाइट्स

m=>{for(n=1<<((33-Math.clz32(m.length-1))/2),t='',y=0;y<n;y++,t+=`
`)for(x=0;x<n;x++,t+=m[h]||' ')for(u=y,v=x,h=0,s=n;s>>=1;q||(p&&(u=s+~u,v=s+~v),[u,v]=[v,u]))h+=s*s*(3*!!(p=u&s)^!!(q=v&s));return t.replace(/ +$/mg,'').trim()}

5% बोनस प्राप्त करने की कोशिश कर रहा है

m=>{for(var n=1<<((33-Math.clz32(m.length-1))/2),t='',x,y=0;y<n;y++,t+=`
`)for(x=0;x<n;x++,t+=m[h]||' ')for(var p,q,u=y,v=x,h=0,s=n;s>>=1;q||(p&&(u=s+~u,v=s+~v),[u,v]=[v,u]))h+=s*s*(3*!!(p=u&s)^!!(q=v&s));return t.replace(/ +$/mg,'').trim()}

241 * 0.8 * 0.95: 183.16 बड़ा

कम गोल्फ वाला

m=>
{
  // calc the size of the bounding square, clz32 is a bit shorter than ceil(log2()
  n = 1<<( (33-Math.clz32(m.length-1)) / 2); 
  t = '';
  for(y = 0; y < n; y++) 
  {
    for(x = 0 ; x < n; x++)
    {
      // for each position x,y inside the square
      // get the index postion in the hilbert curve
      // see https://en.wikipedia.org/wiki/Hilbert_curve (convert x,y to d)
      for(u=y, v=x, h=0, s=n; s >>= 1; )
      {
        h += s*s*(3 * !!(p = u & s) ^ !!(q = v & s));
        q || (p && (u = s+~u, v = s+~v),[u,v]=[v,u])
      }
      // add char at given index to output  
      t += m[h]||' '; // blank if beyond the length of m
    }
    t += '\n'; // add newline add end line
  }
  return t.replace(/ +$/mg,'').trim() // to get the 20% bonus
}

परीक्षा

F=m=>{for(n=1<<((33-Math.clz32(m.length-1))/2),t='',y=0;y<n;y++,t+=`
`)for(x=0;x<n;x++,t+=m[h]||' ')for(u=y,v=x,h=0,s=n;s>>=1;q||(p&&(u=s+~u,v=s+~v),[u,v]=[v,u]))h+=s*s*(3*!!(p=u&s)^!!(q=v&s));return t.replace(/ +$/mg,'').trim()}

function Test() { O.textContent = F(I.value) }

Test()
#I { width: 90% }
#O { border: 1px solid #ccc}
<input id=I oninput='Test()' value='The quick brown fox jumps over the lazy dog.'>
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
क्या यह var5% बोनस पाने के लिए एस जोड़ने लायक होगा ?
— wizzwizz4
var s,x,y,u,v,t,p,q,n,hनहीं यह @ wizzwizz4 लायक नहीं है
— edc65
आप बस varप्रत्येक के पहले उपयोग से पहले रख सकते हैं ... ओह, यह और भी बुरा है।
— wizzwizz4
@ wizzwizz4 सब सब में, शायद आपके पास एक बिंदु है ... मैं कोशिश कर रहा हूं ... नहीं। बहुत बुरा
— edc65
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.