द ड्रंकन बिशप

Question

सार्वजनिक कुंजी क्रिप्टोग्राफी में, एक सार्वजनिक कुंजी फिंगरप्रिंट एक लंबी सार्वजनिक कुंजी की पहचान करने के लिए उपयोग किए जाने वाले बाइट्स का एक छोटा अनुक्रम है।

विशेष रूप से SSH में उनका उपयोग यह सत्यापित करने के लिए किया जा सकता है कि एक सर्वर वास्तव में वह सर्वर है जिसके साथ मैं संवाद करने की अपेक्षा कर रहा हूं और मैं एक मानव-मध्य हमले द्वारा लक्षित नहीं हूं।

वे आमतौर पर हेक्साडेसिमल अंकों की एक स्ट्रिंग के रूप में दर्शाए जाते हैं, इसलिए मैं इसकी अपेक्षा फिंगरप्रिंट से तुलना करने के बजाय उबाऊ और थकाऊ हो सकता हूं:

37:e4:6a:2d:48:38:1a:0a:f3:72:6d:d9:17:6b:bd:5e

इसे थोड़ा आसान बनाने के लिए, ओपनएसएसएच ने ASCII कला के रूप में उंगलियों के निशान की कल्पना करने के लिए एक विधि पेश की है, जो इस तरह दिखाई देगी:

+-----------------+
|                 |
|                 |
|          .      |
|     .   o       |
|o . o . S +      |
|.+ + = . B .     |
|o + + o B o E    |
| o .   + . o     |
|         .o      |
+-----------------+

इसके साथ, मैं ASCII कला के किसी न किसी आकार को याद करने की कोशिश कर सकता था और तब (सैद्धांतिक रूप से) इसे पहचान सकता था जब सर्वर का फिंगरप्रिंट बदल गया और छवि अलग दिखती है।

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

से लिया डिर्क में कमी, टोबियास LIMMER, अलेक्जेंडर वॉन Gernler। 2009. शराबी बिशप: ओपनएसएसएच फिंगरप्रिंट विज़ुअलाइज़ेशन एल्गोरिथ्म का विश्लेषण ।

ग्रिड में 17 वर्णों की चौड़ाई और 9 वर्णों की ऊंचाई है। "बिशप" पंक्ति 4 / कॉलम 8 (केंद्र) पर शुरू होता है। प्रत्येक स्थिति को बिशप की प्रारंभिक स्थिति के लिए [x, y], [8,4] के रूप में दर्शाया जा सकता है।

            1111111
  01234567890123456
 +-----------------+
0|                 |
1|                 |
2|                 |
3|                 |
4|        S        |
5|                 |
6|                 |
7|                 |
8|                 |
 +-----------------+

बिशप फिंगरप्रिंट का उपयोग चारों ओर ले जाने के लिए करता है। यह इसे बाइट-वार को बाएं से दाएं और सबसे महत्वपूर्ण बिट से सबसे महत्वपूर्ण बिट तक पढ़ता है:

Fingerprint      37      :       e4      :       6a      :  ...  :       5e
Bits        00 11 01 11  :  11 10 01 00  :  01 10 10 10  :  ...  :  01 01 11 10
             |  |  |  |      |  |  |  |      |  |  |  |              |  |  |  |
Step         4  3  2  1      8  7  6  5     12 11 10  9             64 63 62 61

बिशप निम्नलिखित योजना से आगे बढ़ेगा:

Bits   Direction
-----------------
00     Up/Left
01     Up/Right
10     Down/Left
11     Down/Right

विशेष स्थितियां:

• यदि बिशप एक कोने में है और फिर से कोने में चला जाएगा, तो वह बिल्कुल भी नहीं हिलता। यानी: बिशप है [0,0]और उसका अगला कदम होगा 00। वह पर बनी हुई है[0,0]
• यदि बिशप एक कोने में या एक दीवार पर है और दीवारों में से एक में स्थानांतरित होगा, तो वह क्षैतिज या लंबवत रूप से चलता है। यानी: बिशप है [0,5]और उसका अगला कदम होगा 01। वह बाएं नहीं जा सकता है, इसलिए वह बस ऊपर, को जाता है [0,4]।

प्रत्येक स्थिति इस बात का मूल्य रखती है कि बिशप ने कितनी बार इस क्षेत्र का दौरा किया है:

Value      | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14| 15| 16|
Character  |   | . | o | + | = | * | B | O | X | @ | % | & | # | / | ^ | S | E |

मान 15 (S) और 16 (E) इस मायने में खास हैं कि वे क्रमशः बिशप की शुरुआत और अंत स्थिति को चिह्नित करते हैं और सम्मानजनक स्थिति के वास्तविक मूल्य को अधिलेखित करते हैं।

लक्ष्य

एक प्रोग्राम बनाएं, जो एक अल्फ़ान्यूमेरिक फिंगरप्रिंट इनपुट के रूप में लेता है और उदाहरणों में दिखाए गए अनुसार अपने ASCII कला प्रतिनिधित्व का उत्पादन करता है।

उदाहरण

Input:
16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48

Output:
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+

Input:
b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b

Output:
+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+

Input:
05:1e:1e:c1:ac:b9:d1:1c:6a:60:ce:0f:77:6c:78:47

Output:
+-----------------+
|       o=.       |
|    o  o++E      |
|   + . Ooo.      |
|    + O B..      |
|     = *S.       |
|      o          |
|                 |
|                 |
|                 |
+-----------------+

नियम

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

Comments

क्या हम यह मान सकते हैं कि किसी भी सेल को 14 बार से अधिक नहीं देखा जाएगा?

— मार्टिन एंडर

न्यूनतम कवरेज के कुछ कोने मामले हैं जिनके परिणामस्वरूप कुछ क्षेत्रों को 14 से अधिक बार दौरा किया जा सकता है। 33:33:33:...:33, cc:cc:cc:...:ccइसके लिए उदाहरण होंगे। फ़िंगरप्रिंट आमतौर पर एमडी 5 हैश है, इसलिए यह बहुत संभावना नहीं है कि आपको ऐसा परिणाम मिलेगा। मुझे इनसे निपटने के बारे में कोई विश्वसनीय स्रोत नहीं मिला है, इसलिए अब मैं कहूंगा: मान लें

— पडरोम

Answer 1

पायथ, 125 बाइट्स

Jj*17\-"++"JVc9XXsm@"^ .o+=*BOX@%&#/"hdrS+*U9U17K.u.e@S[0b*8hk)1.b+tNyYNYsm_c4.[08jxsM^.HM16 2d2cz\:,4 8 8ieK17\E76\SjN"||")J

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट-सूट

मैंने कुछ दिन पहले लिखा था, लेकिन इसे पोस्ट नहीं किया, क्योंकि मैं वास्तव में इसके बारे में खुश नहीं था।

स्पष्टीकरण:

मूल विचार निम्नलिखित है। मैं जोड़ी से शुरू करता हूं (4, 8)। प्रत्येक चाल में (m1,m2)मैं से (x, y)जाता हूँ (x-1+2*m1, y-1+2*m2)। यह सुनिश्चित करने के लिए, कि ये निर्देशांक बोर्डर्स के बाहर नहीं जाते हैं, मैं कुछ सूचियाँ बनाऊँगा, उन्हें सॉर्ट करूँगा और बीच का तत्व वापस करूँगा (sorted(0,8,newx)[1], sorted(0,16,newy)[1]):।

मैं सभी पदों पर नजर रखता हूं। इस स्थिति की सूची में मैं सभी संभावित पदों की एक सूची जोड़ता हूं, उन्हें क्रमबद्ध करता हूं और रन-लेंथ-एनकोड करता हूं। जो मुझे प्रत्येक स्थिति के लिए एक नंबर देता है। इस संख्या के साथ मैं कोऑर्क्ट चार्ट चुन सकता हूं, और अंत में प्रारंभ और समाप्ति स्थिति के वर्णों को अधिलेखित कर सकता हूं।

Answer 2

डायलॉग एपीएल (178)

{⎕ML←3⋄F←9 17⍴0⋄5 9{(⍺⌷F)+←1⋄×⍴⍵:(1 1⌈9 17⌊⍺-1 1-2×↑⍵)∇1↓⍵⋄(⍺⌷F)←16⋄F[5;9]←15⋄K⍪(M,' .o+=*BOX@%&#/^SE'[1+F],M←'|')⍪K←'+','+',⍨17⍴'-'}⊃,/{↓⊖4 2⍴⍉(4/2)⊤¯1+⍵⍳⍨⎕D,'abcdef'}¨⍵⊂⍨':'≠⍵}

यह एक फ़ंक्शन है जो स्ट्रिंग को अपने सही तर्क के रूप में लेता है, और एक चरित्र मैट्रिक्स देता है जिसमें ASCII कला प्रतिनिधित्व होता है, जैसे:

      F←{⎕ML←3⋄F←9 17⍴0⋄5 9{(⍺⌷F)+←1⋄×⍴⍵:(1 1⌈9 17⌊⍺-1 1-2×↑⍵)∇1↓⍵⋄(⍺⌷F)←16⋄F[5;9]←15⋄K⍪(M,' .o+=*BOX@%&#/^SE'[1+F],M←'|')⍪K←'+','+',⍨17⍴'-'}⊃,/{↓⊖4 2⍴⍉(4/2)⊤¯1+⍵⍳⍨⎕D,'abcdef'}¨⍵⊂⍨':'≠⍵}


      F '16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48'
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+
      F 'b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b'
+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+

स्पष्टीकरण:

• ⎕ML←3: सेट ⎕MLकरने के लिए 3। यह ⊂स्ट्रिंग्स को विभाजित करने के लिए अधिक उपयोगी बनाता है ।

• F←9 17⍴0: शून्य से 17 बाई 9 का मैट्रिक्स बनाएं। Fप्रतिनिधित्व करता है कि कितनी बार प्रत्येक स्थिति का दौरा किया गया है।

• ⍵⊂⍨':'≠⍵: पात्रों ⍵पर विभाजित :।

• {... }¨: प्रत्येक समूह के लिए:
  • ¯1+⍵⍳⍨⎕D,'abcdef': स्ट्रिंग के प्रत्येक वर्ण का सूचकांक ज्ञात कीजिए '01234567890abcdef'। 1 घटाएँ, क्योंकि एपीएल डिफ़ॉल्ट रूप से 1-अनुक्रमित है।
  • (4/2)⊤: मानों को उनके 4-बिट अभ्यावेदन में परिवर्तित करें (अब 2-बाय -4 मैट्रिक्स होना चाहिए)।
  • ↓⊖4 2⍴⍉: मैट्रिक्स को घुमाएं, तत्वों को 2-बाय -4 मैट्रिक्स को भरने के लिए उपयोग करें, उस मैट्रिक्स को क्षैतिज रूप से मिरर करें, और फिर प्रत्येक पंक्ति को अलग से प्राप्त करें। यह हमें 4 4-बिट वैल्यू देता है जो हमें चाहिए।
• ⊃,/: परिणामी सूचियों को एक साथ मिलाएं, 2-बिट चरणों की सूची दें।
• 5 9{... }: चरणों की सूची दी गई है, और स्थिति की शुरुआत [9,5]:
  • (⍺⌷F)+←1: वर्तमान स्थिति में वृद्धि F।
  • ×⍴⍵:: यदि चरणों की सूची खाली नहीं है:
    • ↑⍵: सूची से पहला कदम उठाएं
    • ⍺-1 1-2×: उस चरण के लिए डेल्टा प्राप्त करें, और इसे वर्तमान स्थिति से घटाएं
    • 1 1⌈9 17⌊: क्षेत्र के भीतर आंदोलन को प्रतिबंधित करें
    • (... )∇1↓⍵: नई स्थिति और बाकी चरणों के साथ जारी रखें
  • यदि यह है खाली:
    • (⍺⌷F)←16: Fअंतिम स्थिति में 16 पर सेट
    • F[5;9]←15: Fप्रारंभ स्थिति में 15 पर सेट करें
    • ' .o+=*BOX@%&#/^SE'[1+F]: संबंधित स्थिति के लिए प्रत्येक स्थिति का नक्शा
    • K⍪(M,... ,M←'|')⍪K←'+','+',⍨17⍴'-': लाइनों में परिणाम लपेट

Answer 3

पर्ल, 300 + 1 (एन) = 301 बाइट्स

perl -ne 'sub b{$b=$_[0]+$_[1];$_[0]=$b<0?0:$b>$_[2]?$_[2]:$b}$v=pack"(H2)*",/\w\w/g;($x,$y)=(8,4);$a[b($y,($_&2)-1,8)*17+b($x,($_&1)*2-1,16)]++for map{vec$v,$_,2}0..63;@a[76,$y*17+$x]=(15,16);$c=" .o+=*BOX@%&#/^SE";print$d="+".("-"x17)."+\n",(map{+"|",(map{substr$c,$_,1}@a[$_*17..($_+1)*17-1]),"|\n"}0..8),$d'

यह जवाब घृणित है, लेकिन यह इस पहेली के लिए भी पहला है, इसलिए यह अभी के लिए करेंगे।

-nSTDIN पर इनपुट की एक लाइन लेने और भरने के लिए $_।

# b($v, -1 or 1, max) modifies $v within 0..max
sub b{$b=$_[0]+$_[1];$_[0]=$b<0?0:$b>$_[2]?$_[2]:$b}

# turn $_ into a binary string
$v=pack"(H2)*",/\w\w/g;

# initialize cursor
($x,$y)=(8,4);

# find an element of single-dimensional buffer @a
$a[
    # y += (bitpair & 2) - 1, within 8
    b($y,($_&2)-1,8) * 17
    # x += (bitpair & 1) * 2 - 1, within 17
  + b($x,($_&1)*2-1,16)
# and increment it
]++
# for each bit pair (in the right order!)
  for map{vec$v,$_,2}0..63;

# overwrite the starting and ending positions
@a[76,$y*17+$x]=(15,16);

# ascii art lookup table
$c=" .o+=*BOX@%&#/^SE";

# output
print
  # the top row, saving it for later
  $d="+".("-"x17)."+\n",
  # each of the eight middle rows
  (map{+
    # converting each character in @a in this row as appropriate
    "|",(map{substr$c,$_,1}@a[$_*17..($_+1)*17-1]),"|\n"
  }0..8),
  # the bottom row
  $d

Answer 4

आर, 465 459 410 393 382 357 बाइट्स

f=function(a){s=strsplit;C=matrix(as.integer(sapply(strtoi(el(s(a,":")),16),intToBits)[1:8,]),2);C[!C]=-1;n=c(17,9);R=array(0,n);w=c(9,5);for(i in 1:64){w=w+C[,i];w[w<1]=1;w[w>n]=n[w>n];x=w[1];y=w[2];R[x,y]=R[x,y]+1};R[]=el(s(" .o+=*BOX@%&#/^",""))[R+1];R[9,5]="S";R[x,y]="E";z="+-----------------+\n";cat(z);for(i in 1:9)cat("|",R[,i],"|\n",sep="");cat(z)}

इंडेंटेशन और न्यूलाइन्स के साथ:

f=function(a){
    s=strsplit
    C=matrix(as.integer(sapply(strtoi(el(s(a,":")),16),intToBits)[1:8,]),2)
    C[!C]=-1
    n=c(17,9)
    R=array(0,n)
    w=c(9,5)
    for(i in 1:64){
        w=w+C[,i]
        w[w<1]=1
        w[w>n]=n[w>n]
        x=w[1]
        y=w[2]
        R[x,y]=R[x,y]+1
    }
    R[]=el(s(" .o+=*BOX@%&#/^",""))[R+1]
    R[9,5]="S"
    R[x,y]="E"
    z="+-----------------+\n"
    cat(z)
    for(i in 1:9)cat("|",R[,i],"|\n",sep="")
    cat(z)
}

उपयोग:

> f("16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48")
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+
> f("37:e4:6a:2d:48:38:1a:0a:f3:72:6d:d9:17:6b:bd:5e")
+-----------------+
|                 |
|                 |
|          .      |
|     .   o       |
|o . o . S +      |
|.+ + = . B .     |
|o + + o B o E    |
| o .   + . o     |
|         .o      |
+-----------------+

Comments

कठबोली आप 'मैट्रिक्स' फ़ंक्शन को एक बार 'मी' के रूप में परिभाषित करके गोल्फ कर सकते हैं? 'फंक्शन' के लिए भी यही?

— चचेरे भाई

मुझे लगता है कि 'कैट' फंक्शन में आपको 'sep =' की जरूरत नहीं है

— CousinCocaine

एसईपी के लिए डिफ़ॉल्ट एक स्थान है, इसलिए मुझे इसे ओवरराइड करने की आवश्यकता है, लेकिन वास्तव में मैं उर्फ ​​मैट्रिक्स कर सकता था।

— प्लेनैपस 12

इसके अलावा, जहाँ तक मुझे पता है, आप उपनाम नहीं कर सकते function।

— प्लेनैपस

Answer 5

सप्तक, 277

d=reshape(rot90(dec2bin(hex2dec(strsplit(input('','s'),':'))))>'0',2,[])*2-1;p=[9;5];for m=1:64 p=[max(min(p(:,1)+d(:,m),[17;9]),1) p];end;A=' .o+=*BOX@%&#/^SE';F=A(sparse(p(2,:),p(1,:),1,9,17)+1);F(5,9)='S';F(p(2,1),p(1,1))='E';[a='+-----------------+';b=['|||||||||']' F b;a]

स्पष्टीकरण:

%// convert the input to binary and rearrange it to be
%//   an array of vectors: [x_displacement; y_displacement]
d=reshape(rot90(dec2bin(hex2dec(strsplit(input('','s'),':'))))>'0',2,[])*2-1;

%// start position array with vector for the start position
p=[9;5];
%// for each move, add displacement, clamping to valid values
for m=1:64 p=[max(min(p(:,1)+d(:,m),[17;9]),1) p];end;

%// alphabet for our fingerprint
A=' .o+=*BOX@%&#/^SE';

%// create a sparse matrix, accumulating values for duplicate
%// positions, and replace counts with symbols
F=A(sparse(p(2,:),p(1,:),1,9,17)+1);

%// correct the start and end symbols and construct the final output
F(5,9)='S';F(p(2,1),p(1,1))='E';
[a='+-----------------+';b=['|||||||||']' F b;a]

नमूना रन:

>> bish
b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b
ans =

+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+

Answer 6

पायथ, 145 143 140

Jm*17]09A,4K8FYcz\:V4AmhtS[0^2d+@,HGdtyv@+_.BiY16*7\0+-4dyN),3 4 X@JGHh@@JGH; X@J4K15 X@JGH16
=Y++\+*17\-\+VJ++\|s@L" .o+=*BOX@%&#/^SE"N\|)Y

इसे ऑनलाइन आज़माएं।

पायथन वास्तव में पुनरावृत्ति के साथ चुनौतियों पर अच्छा नहीं है। मुझे उम्मीद है कि सीजेएम इसे आसानी से हरा देगा।

Answer 7

जावास्क्रिप्ट (ईएस 6) 249 208

संपादित जोड़ा लापता सीमा

किसी भी EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें

B=f=>f.replace(/\w+/g,b=>{for(b=`0x1${b}`;b-1;b>>=2)++g[p=(q=(p=(q=p+~-(b&2)*18)>0&q<162?q:p)+b%2*2-1)%18?q:p]},p=81,z=`+${'-'.repeat(17)}+`,g=Array(162).fill(0))&&g.map((v,q)=>q?q-81?q-p?q%18?' .o+=*BOX@%&#/^'[v]:`|
|`:'E':'S':z+`
|`).join``+`|
`+z

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;['37:e4:6a:2d:48:38:1a:0a:f3:72:6d:d9:17:6b:bd:5e'
,'16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48'
,'b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b'
,'05:1e:1e:c1:ac:b9:d1:1c:6a:60:ce:0f:77:6c:78:47'  
].forEach(t=>console.log(t+'\n'+B(t)+'\n'))


// Less golfed

BB=f=>(
  p = 81,
  g = Array(162).fill(0),
  f.replace(/\w+/g, b => {
    for(b = `0x1${b}`;b != 1; b >>= 2)
      q = p+~-(b&2)*18,
      p = q>0&q<162?q:p,
      p = (q=p+b%2*2-1)%18?q:p,
      ++g[p]
  }),
  g.map((v,q) => q-81?q-p?q%18?' .o+=*BOX@%&#/^'[v]:'\n':'E':'S')
  .join``
)

pre { font-family: menlo,consolas; font-size:13px }

<pre id=O></pre>

Comments

आपका गोल्फ कोड स्वयं भी सीमाओं को प्रिंट करने में सक्षम होना चाहिए। वर्तमान में केवल आपके परीक्षण का मामला ऊपरी और निचली सीमाओं को प्रिंट करता है forEach, ऊर्ध्वाधर सीमाएं अभी भी गायब हैं।

— पद्रोम

@Padarom मैंने आपकी "उचित" टिप्पणी को गलत समझा, यह सोचकर कि सीमा का अनुरोध नहीं किया गया था

— edc65

मेरा अभिप्राय यह है कि इनपुट और आउटपुट का आप किस विधि से उपयोग करते हैं। मेरी क्षमा याचना अगर वह भ्रामक थी, तो मैं इसे संपादित करूँगा

— पडरोम

Answer 8

पायथन, 381 328

-51 धन्यवाद @JonathanFrech को

def h(f):
 s=[f'{int(o,16)>>s&3:02b}'for o in f.split(':')for s in(0,2,4,6)];r=[0]*153;p=76;w=17
 for d in s:r[p]+=1;p+=(-(p%w!=0),p%w!=16)[int(d[1])]+(-w*(p//w!=0),w*(p//w!=8))[int(d[0])]
 r[76]=15;r[p]=16;b='+'+'-'*w+'+';print(b);i=0
 while i<153:print(f"|{''.join(' .o+=*BOX@%&#/^SE'[c]for c in r[i:i+w])}|");i+=w
 print(b)

स्पष्टीकरण के लिए थोड़ा असंतुष्ट:

def h_(f):
 #Alias 17 because it gets used enough times for this to save bytes
 w=17

 #Input parsing
 s=[f'{int(o,16)>>s&3:02b}'for o in f.split(':')for s in(0,2,4,6)]

 #Room setup
 r=[0]*153
 p=76

 #Apply movements
 for d in s:
  r[p]+=1
  p+=(-(p%w!=0),p%w!=16)[int(d[1])]+(-w*(p//w!=0),w*(p//w!=8))[int(d[0])]
 r[76]=15 #Set start position
 r[p]=16 #Set end position

 #Display result
 b='+'+'-'*w+'+'
 print(b)
 i=0
 while i<153:
  print(f"|{''.join(' .o+=*BOX@%&#/^SE'[c]for c in r[i:i+w])}|")
  i+=w
 print(b)

एक लाइन का यह गड़बड़:

r[p]+=1;p+=(-(p%w!=0),p%w!=16)[int(d[1])]+(-w*(p//w!=0),w*(p//w!=8))[int(d[0])]

कार्यात्मक रूप से इसके बराबर है:

if int(d[0]): #Down, Y+
  if p//17!=8:
    p+=17
else: #Up, Y-
  if p//17!=0:
    p-=17
​
if int(d[1]): #Right, X+
  if p%17!=16:
    p+=1
else: #Left, X-
  if p%17!=0:
    p-=1

लेकिन गोल्फ शॉर्टकट की इस शैली में सभी सशर्त घोंसले: (false_value,true_value)[condition] उम्मीद है कि बाकी काफी आत्म-व्याख्यात्मक है

टेस्ट

h('16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48')
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+

h("b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b")
+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+

h("05:1e:1e:c1:ac:b9:d1:1c:6a:60:ce:0f:77:6c:78:47")
+-----------------+
|       o=.       |
|    o  o++E      |
|   + . Ooo.      |
|    + O B..      |
|     = *S.       |
|      o          |
|                 |
|                 |
|                 |
+-----------------+
```

Comments

नमस्कार और पीपीसीजी में आपका स्वागत है। आप एक-अक्षर वाले चर नामों का उपयोग करके और एक पंक्ति में एक एकल-लाइन-फॉर-लूप लगाकर अपने कोड को गोल्फ कर सकते हैं। (1,0)[p%17==16]है +(p%17!=16), या संभवतः भी p%17!=16।

— जोनाथन फ्रीच

इसके अलावा, वहाँ एक शानदार जगह है ] for।

— जोनाथन फ्रेच

मुझे लगता है कि fpहोना चाहिए f।

— जोनाथन फ्रीच

330 बाइट्स ।

— जोनाथन फ्रेच

मैंने क्यों इस्तेमाल किया ~16? आपत्ति का थोड़ा सा भी अपने गोल्फ को चोट नहीं पहुँचा सकते हैं!

— जोनाथन फ्रेच

Answer 9

रूबी 288

->k{w=17
r=[z=?++?-*w+?+]
(0...w*9).each_slice(w).map{|o|r<<?|+o.map{|x|c=76
q=0
k.split(?:).flat_map{|b|(0..7).map{|i|b.to_i(16)[i]}}.each_slice(2){|h,v|v<1?(c>w&&c-=w):c<w*8&&c+=w
c+=h<1?c%w>0?-1:0:c%w<16?1:0
c==x&&q+=1}
x==76?'S':c==x ?'E':' .o+=*BOX@%&#/^'[q]}.join+?|}
(r+[z]).join'
'}

इसे ऑनलाइन आज़माएं: http://ideone.com/QOHAnM

पठनीय संस्करण (एक जिसे मैंने गोल्फ से शुरू किया था) यहां है: http://ideone.com/XR64km

Answer 10

सी - 488

इसे छोटा करने का एक तरीका होना चाहिए ...।

#include<stdio.h>
#define H ++p;h[i]|=(*p-(*p>58?87:48))<<
#define B ((h[j]>>n*2)&3)
#define L puts("+-----------------+")
#define F(m,s)for(m=0;m<s;m++)
int h[16],m[17][9],i,j,n,x=8,y=4;main(w,v)char**v;{char*p=v[1]-1,c[17]={32,46,111,43,61,42,66,79,88,64,37,38,35,47,94,83,69};for(;*p;p++,i++){H 4;H 0;}F(j,16)F(n,4){if(B&1)x+=!(x==16);else x-=!(x==0);if(B&2)y+=!(y==8);else y-=!(y==0);m[x][y]++;}m[8][4]=15;m[x][y]=16;L;F(i,9){printf("|");F(j,17)printf("%c",c[m[j][i]]);puts("|");}L;}

Answer 11

जंग - 509 बाइट्स

fn b(s:&str)->String{let(mut v,mut b)=([[0;11];20],[9,5]);v[19]=[19;11];for i in 0..16{let mut c=usize::from_str_radix(&s[i*3..i*3+2],16).unwrap();for k in 0..4{for j in 0..2{v[j*18][i%9+1]=18;v[i+k][j*10]=[17,3][(i+k+17)%18/17];b[j]=match(if c&(j+1)==j+1{b[j]+1}else{b[j]-1},j,){(0,_)=>1,(18,0)=>17,(10,1)=>9,x@_=>x.0 as usize,}}v[b[0]][b[1]]+=1;c>>=2;}}v[9][5]=15;v[b[0]][b[1]]=16;(0..220).fold("\n".to_string(),|s,i|{format!("{}{}",s," .o+=*BOX@%&#/^SE-|\n".chars().nth(v[i%20][i/20] as usize).unwrap())})}

बड़े लेकिन ... लगभग सी के करीब। जिस तरह से रस्ट स्वचालित रूप से एक दूसरे में नहीं डाली जाती है, उसके कारण कई बाइट्स का उपयोग किया जाता है। लेकिन वहाँ भी शायद सुधार के लिए जगह है .... शायद अन्य समाधानों से कुछ विचारों का उपयोग कर सकता है।

अनगोल्डेड संस्करण ऑनलाइन रस्ट प्लेग्राउंड पर है