वर्णमाला गाइड

निर्देशों की एक सरणी को देखते हुए, जहाँ दिशाएँ निम्नानुसार परिभाषित की गई हैं:

NW  N  NE
W   .   E
SW  S  SE

या अनुक्रमणिका के रूप में (आप ऊपर के तारों के बजाय निर्देशों के लिए इन सूचकांकों का उपयोग कर सकते हैं):

0 1 2
3 . 4
5 6 7

आप किसी भी प्रारूप का चयन कर सकते हैं, दोनों को चुनौती देना आवश्यक नहीं है। इसी वर्णमाला स्ट्रिंग उत्पन्न करें जो खींची गई पथ का प्रतिनिधित्व करती है, ए के साथ शुरू दिशाओं की संख्या कभी भी 25 से अधिक नहीं होगी, जिसका अर्थ है कि यह कभी भी अतीत में नहीं जा सकता है Z, इसलिए आपको इस परिदृश्य को संभालने की आवश्यकता नहीं है। कोई अन्य इनपुट प्रारूप तब तक स्वीकार नहीं किए जाएंगे जब तक कि आप यह नहीं बता सकते कि भाषा प्रारूप के कारण ये प्रारूप काम क्यों नहीं करते। यह मौखिक रूप से काम करने वाले उदाहरण का उपयोग करके समझाने में आसान है।

तो, एक त्वरित उदाहरण को देखने देता है:

[E,SE,N,S,S,S,NW,W,N] or [4,7,1,6,6,6,0,3,1]

हमेशा ए से शुरू करें।

पूर्व से बी पर जाएं।

A-B

जाओ दक्षिण पूर्व से सी।

A-B 
   \
    C

उत्तर से D पर जाएं।

A-B D
   \|
    C

C से ओवर राइटिंग करते हुए दक्षिण की ओर वापस जाएं।

A-B D
   \|
    E

F और G. दोनों के लिए 2 चक्रों के लिए दक्षिण को जारी रखें।

A-B D
   \|
    E
    |
    F
    |
    G

गो वेस्ट टू एच।

A-B D
   \|
    E
    |
  H F
   \|
    G

वेस्ट टू आई।

A-B D
   \|
    E
    |
I-H F
   \|
    G

बिंदु J पर उत्तर की ओर अंत।

A-B D
   \|
J   E
|   |
I-H F
   \|
    G

आपके द्वारा दिया गया अंतिम मान अंतिम ग्राफ़ को दाईं ओर, ऊपर से नीचे तक पढ़ने के लिए है:

ABD
JE
IHF
G

जिसके परिणामस्वरूप:

ABDJEIHFG

यह कोड-गोल्फ है , सबसे कम बाइट-काउंट जीतता है।

code-golf alphabet

— जादू ऑक्टोपस Urn
स्रोत

1

MATL , 64 58 57 50 46 40 37 36 35 30 बाइट्स

O'!":<TUV '59-G)hYsIH$6#u64+c!

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

O           % Push the number 0 to the stack
'!":<TUV '  % String literal
59-         % Converts this string literal into [-26 -25 -1 1 25 26 27 -27]. These
            % are deltas for the linear indexes into the matrix corresponding to each
            % of the directions. Note that the -27 is at the end since a 0 index wraps
            % around to the end
i)          % Grab the input and use it to index into the delta array 
h           % Horizontally concatenate this with the 0 (our starting point)
Ys          % Take the cumulative sum to get the absolute linear index (location) of
            % each successive letter
IH$6#u      % Find the index of the last (sorted) occurrence of each location
64+         % Add 64 to this index to create ASCII codes
c!          % Convert to character, transpose, and display

— Suever
स्रोत

1

अरे वाह! मुझे लगा कि मेंडू ने ऐसा किया है! अच्छा :)। आमतौर पर वह मेरे मैट्रिक्स प्रश्नों को जीतता है, इस भाषा का उपयोग करके किसी और को देखने के लिए अच्छा है। मैं नाइट लीअर करने की कोशिश कर रहा हूं।

— मैजिक ऑक्टोपस Urn

12

जावास्क्रिप्ट (ईएस 6), 108 107 94 87 बाइट्स

टाइटस के लिए धन्यवाद, एक शानदार 13 बाइट्स सहेजे गए!
7 और बाइट्स को बचाया, edc65 के लिए धन्यवाद!

let f =

a=>[i=9,...a].map(d=>r[p+=(d+=d>3)*9-d%3*8-28]=(++i).toString(36),r=[],p=646)&&r.join``

console.log(f([4,7,1,6,6,6,0,3,1]));

स्निपेट का विस्तार करें

यह काम किस प्रकार करता है

सूत्र निम्नलिखित ऑफ़सेट में (d += d > 3) * 9 - d % 3 * 8 - 28दिशाओं का अनुवाद 0..7करता है:

0   1   2       -28 -27 -26
3   x   4  -->   -1  x   +1
5   6   7       +26 +27 +28

हम सूचक pको एक-आयामी सरणी में स्थानांतरित करने के लिए rऔर परिणामी पदों पर पत्र लिखने के लिए इन ऑफसेट का उपयोग करते हैं ।

हम शुरुआती अक्षर 'a' को सम्मिलित करने के लिए [i = 9, ...a]केवल उस पर पुनरावृति करते हैं a। क्योंकि हम एक ही समय में इनिशियलाइज़ iकरते हैं 9, इसलिए हम 54 की एक विशेष ऑफसेट (इसके लिए उपरोक्त सूत्र का परिणाम d = 9) पेश करते हैं। पहले पुनरावृत्ति के बाद, pबराबर होता है 646 + 54 = 700, जो नॉर्थ-वेस्ट में 25 चालों तक समर्थन करने के लिए सिर्फ पर्याप्त स्थान छोड़ता है 25 * -28 = -700:। इसीलिए pइसे इनिशियलाइज़ किया जाता है 646।

फिर हमें केवल अपनी अंतिम स्ट्रिंग प्राप्त करने के लिए सरणी में शामिल होना होगा। अक्षरों के बीच में अपरिभाषित मूल्यों को केवल अनदेखा किया जाता है join()।

— Arnauld
स्रोत

d+=d>3,p+=d*9-d%3*8-2811 बाइट्स बचाता है।

— टाइटस

@ धन्यवाद धन्यवाद, अच्छी जगह! (अब मैं iसरणी परिभाषा में 2 और बाइट्स की बचत कर सकता हूं )

— अरनॉल्ड

जैसा कि ओपी ने कहा कि लोअरकेस की अनुमति है, शायद आप 9 से शुरू होने वाले 7 बाइट्स को बचा सकते हैं और उपयोग कर रहे हैं (++i).toString(36)(फिर भी अपने गणित को समझने की कोशिश नहीं कर रहे हैं, लेकिन यह काम करने लगता है)

— edc65

@ edc65 धिक्कार है। धन्यवाद!

— अरनौलद

5

ऑक्टेव, 145 138 131 123 105 103 90 87 85 बाइट्स

@(a){[~,k]=unique(cumsum([1 fix((z=a+(a>3))/3);1 mod(z,3)]'-1),'rows');[k'+64 '']}{2}

यह ऑनलाइन की कोशिश करो

के लिए धन्यवाद Suever 2 बचाया बाइट!

पिछला उत्तर 103 बाइट्स:

@(a)[nonzeros(accumarray(cumsum([1 fix((z=a+(a>3))/3);1 mod(z,3)]'-1)+30,65:nnz(++a)+65,[],@max)')' '']

यह ऑनलाइन की कोशिश करो!

पहले 145 बाइट्स ट्राई करें

@(a){[x y]=find(~impad(1,1,1));c=cumsum([0 0;([y x]-2)(++a,:)]);c=c-min(c)+1;n=nnz(a);[nonzeros(sparse(c(:,1),c(:,2),65:n+65,'unique')')' '']}{5}

कुछ स्पष्टीकरण

@(a){
    [x y]=find([1 0 1]|[1;0;1]);                            %generate 2d coordinates corresponding to 1d input indices
    XY = [y x]-2;
    c=cumsum([0 0;XY(++a,:)]);                              %cumulative sum of coordinates to find position of characters
    c=c-min(c)+1;n=nnz(a);
    [nonzeros(sparse(c(:,1),c(:,2),65:n+65,'unique')')' ''] %using sparse matrix to place characters at specified positions
    }{5}

— rahnema1
स्रोत

1

मेरा मानना है कि जब से आपको imageअपने बाईटाउन के पैकेज वाले हिस्से की जरूरत है , इमेज पैकेज लोड करना होगाpkg load image

— स्वेवर

धन्यवाद, पैकेज ठीक से स्थापित है, तो लोड करने की कोई जरूरत आप में यह परीक्षण कर सकते हैं सप्टक ऑनलाइन

— rahnema1

मेरा मानना है कि केवल इसलिए कि ऑक्टेव ऑनलाइन pkg load *शुरुआत में कहता है । ideone.com एक बेहतर विकल्प हो सकता है

— Suever

पैकेज इस तरह से स्थापित किया जाना चाहिए pkg install -auto image-1.0.0.tar.gzताकि यह स्वचालित रूप से लोड हो सके कृपया मैनुअल देखें

— rahnema1

ठीक है तो शायद यह ठीक है। मैं यहां से पहले जो कुछ देख रहा था, मैं उससे दूर जा रहा था ।

— Suever

5

MATLAB, 87 85 बाइट्स

लुइस मेंडो की बदौलत 2 बाइट्स बचाए

function a=f(s);i='()*BD\]^'-67;[~,a]=unique([0 cumsum(i(s+1))],'last');a=[a'+64,''];

— gnovice
स्रोत

'%&''?AYZ['-64अच्छी चाल ... वास्तव में 66 बाइट्स अगर आप ऑक्टेव में फिर से लिखते हैं

— rahnema1

4

PHP, 93 बाइट्स

कोडोस जॉनसन के जवाब जैसे एकल सरणी पर काम करना ।
लेकिन इसके और भी कई विचार हैं जो मैंने अपने दम पर पोस्ट किए हैं।

for($r=[$c=A];""<$d=$argv[++$i];)$r[$p+=($d+=$d>3)*9-$d%3*8-28]=++$c;ksort($r);echo join($r);

कमांड लाइन तर्कों से संख्या लेता है। साथ चलाना -nr।

कर्सर ले जाना

प्रारंभिक गणना:

$d+=$d>3;           // if $d>3, add 1
$p+= ($d/3-1|0)*26  // add/subtract 26 for line change
    +$d%3-1;        // add/substract 1 for column change

गोल्फ:

$d+=$d>3;$p+=($d/3-1|0)*27+$d%3-1;          // +0: multiple of 3 instead of 26
$d+=$d>3;$p+=($d/3|0)*27-27+$d%3-1;         // +1: distribute `line-1`
$d+=$d>3;$p+=($d/3)*27-$d%3/3*27-27+$d%3-1; // +8: distribute `|0`
$d+=$d>3;$p+=$d*9-$d%3*9-27+$d%3-1;         // -8: `/3*27` -> `*9`
$d+=$d>3;$p+=$d*9-$d%3*8-28;                // -7: combine duplicates

असाइनमेंट को मर्ज करने से कुछ भी नहीं बचता है, लेकिन पठनीयता में सुधार होता है:

for(init;input loop;$p=$d...)$d+=$d>3;
for(init;input loop;)$p=($d+=$d>3)...;

टूट - फूट

for($r=[$c=A];                  // init result, init letter
    ""<$d=$argv[++$i];)         // loop through command line arguments
    $r[
        $p+=($d+=$d>3)*9-$d%3*8-28  // move cursor
    ]=++$c;                         // increment letter, plot
ksort($r);                      // sort result by index
echo join($r);                  // print result

— टाइटस
स्रोत

3

पायथन 2, 180 178 176 बाइट्स

def f(d,a=[[""]*26 for _ in[1]*26],x=0,y=0,j=66):
 a[0][0]="A"
 for i in d:y+=(i>4)-(i<3);x+=(`i`in'247')-(`i`in'035');a[y][x]=chr(j);j+=1
 return"".join("".join(i)for i in a)

— OVS
स्रोत

2

PHP, 121 बाइट्स

$r[0]=chr(65);for(;($n=$argv[1][$i])!=null;)$r[$c+=[-27,-26,-25,-1,1,25,26,27][$n]]=chr($i+++66);ksort($r);echo join($r);

यह -rध्वज के साथ कमांड लाइन में चलता है और एक तर्क के रूप में सूचकांकों का एक चार्ट (स्ट्रिंग) लेता है।

— कोडोस जॉनसन
स्रोत

आप 5 आसान बाइट बचा सकते ""<$n=$argv[1][$i]हैं($n=$argv[1][$i])!=null

— टाइटस

1

आर, 160 बाइट्स

a=scan()
e=f=26
x=matrix(0,51,51)
x[e,f]="A"
for(i in a){g=function(q)grepl(q,i)
T=T+1
f=f-g("N")+g("S")
e=e-g("W")+g("E")
x[e,f]=LETTERS[T]}
cat(x[x>0],sep="")

— ixodesbeta
स्रोत