सात स्लेश डिस्प्ले


99

एक प्रोग्राम लिखें जो अंकों के गैर-रिक्त स्ट्रिंग में 9 के माध्यम से 0 लेता है और प्रिंट करता है कि उन्हें स्लैश ( , ) का उपयोग करके सात-खंड प्रदर्शन पर कैसे दिखाया जाएगा ।/\

ये सटीक अंक आकार हैं:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

जब एक अंक एक दूसरे के बाद होता है, तो वे तिरछे और दाहिने ओर जंजीर होते हैं, जिसके बीच में एक विकर्ण स्थान होता है। इसलिए, उदाहरण के लिए, 203यह बन जाएगा:

    /\
     /\
  /\  /
  \ \
/\ \/
 / 
 \/

ध्यान दें कि 1चरित्र दूसरों की तरह ही उतनी ही जगह लेता है। प्रदर्शन की दो पंक्तियाँ 1प्रदर्शन के दाईं ओर हैं, बाईं ओर नहीं।

तो 159114यह बन जाएगा:

           \
          \/\
         \
          \
       \
        \
    /\
    \/\
  /   /
  \/\
 \  /
  \

जब तक अंक एक दूसरे के संबंध में सही स्थिति में न हों, तब तक आउटपुट में अग्रणी / अनुगामी न्यूलाइन्स या स्पेस की कोई भी राशि और संयोजन हो सकता है।

तो 159114, यह भी मान्य होगा:



          \        
         \/\     
        \
         \
      \    
       \          
   /\     
   \/\
 /   /
 \/\         
\  /
 \    


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

9 के माध्यम से अंक 0 में से कोई भी गैर-रिक्त स्ट्रिंग काम करना चाहिए, एकल अंक तार (जैसे सहित 8) और पहले शून्य तार (जैसे में 007, शून्य है मुद्रित करने के लिए की जरूरत है)।

बाइट्स में सबसे छोटा कोड जीतता है।


41
पूरी तरह से अपमानजनक: यह भयानक लग रहा है!
मार्टिज़न

4
यह वास्तव में वास्तव में अच्छा है। हालांकि, मुझे यकीन नहीं है कि कोल्मोगोरोव-जटिलता इस सवाल के लिए उपयुक्त है - मैंने सोचा था कि एक निरंतर आउटपुट की आवश्यकता है?
अलेक्जेंडर-ब्रेट

1
@ अलेक्जेंडर-ब्रेट iirc कि मूल इरादा था, हालांकि, हाल ही में इसका उपयोग उन समस्याओं के लिए किया गया है जहां कोड के अधिकांश शायद ही हार्डकोडिंग होने जा रहे हैं।
अंडरग्राउंडोरेल

यह मुझे जाना पसंद है ... वाह! बस वाह!
Renae Lider

प्रश्न: क्या हमें गैर-अंकीय वर्णों वाले खाली तारों या तारों को संभालने की आवश्यकता है?
फ्रेडरिक

जवाबों:


9

सीजाम, 77 71 70 69 63 62 बाइट्स

r_,5*_Sa*a*\{~"÷Ðëúܾ¿ðÿþ"=i2bS"\/"4*W<+.*3/..e>2fm>2m>}/Wf%N*

सभी वर्ण मुद्रण योग्य हैं, इसलिए कॉपी और पेस्ट ठीक काम करना चाहिए।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

हम अंकों की संख्या का परीक्षण करके शुरू n इनपुट में और रिक्त स्थान काफी बड़ा उत्पादन को कवर करने के एक वर्ग धक्का। कार्यान्वयन में, यह वर्ग एक-वर्ण स्ट्रिंग्स के दो-आयामी सरणी के रूप में एन्कोड किया जाएगा।

लंबाई 2n + 1 का एक वर्ग सिर्फ सही होगा (यानी, कोई आसपास का व्हाट्सएप) एक सीधा कार्यान्वयन के लिए नहीं, लेकिन हम लंबाई 5n में से एक का उपयोग करेंगे बाइट्स के एक जोड़े को बचाने के लिए से । शुक्र है, आसपास के व्हाट्सएप की अनुमति है।

यदि हम 8 के सात स्लैश प्रतिनिधित्व की रेखाओं को उल्टा करते हैं , तो हम निम्नलिखित प्राप्त करते हैं:

 \/
\/\
/\

सभी अंकों का प्रतिनिधित्व 8-बिट पूर्णांक के रूप में एन्कोड किया जा सकता है, जहां i th बिट 0 है यदि i th वर्ण को एक स्थान के साथ प्रतिस्थापित किया जाना चाहिए। अंक 0 से 9 के लिए , परिणामी पूर्णांक हैं

247 208 235 250 220 190 191 240 255 254

जो निम्नलिखित ISO-8559-1 अक्षरों के अनुरूप है:

÷Ðëúܾ¿ðÿþ

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

अब, हम वर्टिकल के अधिकतम स्ट्रिंग्स की गणना करते हैं जो वर्ग का प्रतिनिधित्व करते हैं और स्ट्रिंग्स जो अंक का प्रतिनिधित्व करते हैं। तार /और \स्ट्रिंग से भी बड़ा कर रहे हैं  , ताकि वे वर्ग में रिक्त स्थान की जगह लेगा। खाली स्ट्रिंग, हालांकि, स्ट्रिंग से छोटी है  , इसलिए अंक प्रतिनिधित्व में खाली तार वर्ग में रिक्त स्थान को संरक्षित करेंगे।

अब हम वर्ग के उचित भाग में निम्नलिखित अंक प्रतिनिधित्व को रखने के लिए दो इकाइयों द्वारा पंक्तियों और स्तंभों को घुमाते हैं और इनपुट में शेष अंकों के लिए प्रक्रिया को दोहराते हैं।

अंत में, हम प्रत्येक पंक्ति को उल्टा करते हैं और अलग-अलग पंक्तियों के बीच एक लाइनफ़ीड सम्मिलित करते हैं।

कोड

r_,      e# Read a token from STDIN and push the length of a copy.
5*_      e# Multiply the length by 5 and push a copy.
Sa*      e# Repeat the array [" "] that many times.
a*       e# Repeat the array [[" " ... " "]] that many times.
\{       e# For each character C in the input:
  ~      e#   Push eval(C), i.e., the digit the character represents.

  "÷Ðëúܾ¿ðÿþ"

         e#   Push the encodings of all 10 seven slash representations.

  =      e#   Select the proper one.
  i2b    e#   Push the resulting characters code point in base 2, i.e., its bits.
  S      e#   Push " ".
  "\/"4* e#   Push "\/\/\/\/".
  +W<    e#   Concatenate and eliminate the last character.
  .*     e#   Vectorized repetition.

         e#   For the digit 5, e.g., we have [1 0 1 1 1 1 1 0] and  " \/\/\/\" on
         e#   the stack, so .* yields [" " "" "/" "\" "/" "\" "/" ""].

  3/     e#   Divide the representation into chunks of length 3, i.e., its lines.
  ..e>   e#   Compute the twofold vectorized maximum, as explained above.
  2fm>   e#   Rotate each line to characters to the right.
  2m>    e#   Rotate the lines two units down.
}/
Wf%      e# Reverse each line.
N*       e# Place linefeeds between them.

अंतिम घुमाव आउटपुट को गड़बड़ कर देगा अगर वर्ग की लंबाई 2n + 3 से छोटी थी । सभी सकारात्मक पूर्णांकों n के लिए 5n 5 2n + 3 के बाद से , वर्ग इसे रोकने के लिए काफी बड़ा है।


क्या यहां आपके कोड का आधार 64 संस्करण पोस्ट करना समझदारी होगी?
TRGG

1
+1, लेकिन ईमानदार होने के लिए, मैं CJam एट अल की उम्मीद कर रहा था। यह एक बाहर बैठना होगा: पी
प्रथम

@प्रिमो: मुझे पाइथ और गणित के सवालों के बारे में भी ऐसा ही लगता है। : P मैं पार्टी के लिए थोड़ा लेट हूँ क्योंकि मुझे Rearranging Words द्वारा nerd-sniped मिला है । आज सुबह तक यह संपादित नहीं हुआ था कि मुझे यह प्रश्न याद था।
डेनिस

@ डेनिस की चुनौतियाँ बहुत तेज़ गति से जाती हैं, जितना वे करते थे। मैं अभी भी दो सप्ताह पहले से एक पर काम कर रहा हूं: पी
प्रिमो

1
मैं हमेशा सीजेम को इस उम्मीद के साथ देखता हूं कि इसकी सबसे कम बाइट गिनती होगी। मुझे अभी तक निराश नहीं होना है।
इंजीनियर टोस्ट

25

पायथन 3, 189 183 174 बाइट्स

s="a%sa"%input()
while s[1:]:b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")];S=len(s)*"  ";print(S+a+b,c+d+"\n"+S+e+f+g);*s,_=s

संपीड़न मुझे ठीक लगता है, लेकिन मुझे सात चर खोदने के अच्छे तरीके के साथ आने में परेशानी हो रही है ...

शुक्र है कि व्हाट्सएप के नियमों पर कल्पना काफी हद तक शांत है, क्योंकि व्हाट्सएप पर बहुत सारे प्रमुख / अनुगामी हैं।

विस्तारित:

s="a%sa"%input()
while s[1:]:
  b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "
                 for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")]
  S=len(s)*"  "
  print(S+a+b,c+d+"\n"+S+e+f+g)
  *s,_=s

व्याख्या

चरों द्वारा दर्शाए गए खंड स्थिति निम्न हैं:

    ab               /\
    efg               /\
  ab cd            /\  /
  efg              \ \
ab cd            /\ \/
efg               /
 cd               \/

प्रत्येक खंड को एक एकल 2-बाइट यूनिकोड चरित्र द्वारा एन्कोड किया गया है। उदाहरण के लिए, ϻसांकेतिक शब्दों में बदलना gहै:

bin(ord("ϻ")) = bin(1019) = "0b1111111011"
                               ^^^^^^^^^^
                               9876543210

वास्तव में, 2सात-खंड प्रदर्शन के निचले-दाएं खंड का उपयोग न करने के लिए एकमात्र अंक है।


19

सी, 1098 345 323 319 बाइट्स

पहला दूसरा तीसरा प्रयास। अंत में स्क्रीन बफ़र को कुछ बाइट्स को बचाने के लिए खाई का फैसला किया। यह कार्यक्रम अंकों का एक पैरामीटर लेता है और अंकों को 7-खंड प्रारूप में प्रिंट करता है।

पहली बार प्रतिभागी। सिर्फ मनोरंजन के लिए। नेक बनो।

a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977},i,j,k,n,m;char*c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
main(w,char**v){f(i,n=strlen(v[1]))f(k,(m=n-i-1)?2:3){f(j,m*2)P(32);f(w,3)Q(m,k,w);if(!k&&i)f(w,2)Q(m+1,2,w+1);P(10);}}

विस्तारित, चेतावनी मुक्त:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977};
char *c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
int main(int w, char **v)
{
    int i,j,k,n,m;
    f(i,n=strlen(v[1])) {
        m=n-i-1;
        f(k,m?2:3) {
            f(j,m*2) P(32);
            f(w,3) Q(m,k,w);
            if (!k&&i) f(w,2) Q(m+1,2,w+1);
            P(10);
        }
    }
}

पश्चिम में सबसे तेज बंदूक। मैं अब मेरा कंप्रेस कर रहा हूं।
एलेक्सी बर्डिन

15
अरे! कोड गोल्फ में आपका स्वागत है। इस चुनौती का उद्देश्य आपके कोड को यथासंभव कम करना है, इसलिए आपको रिक्त स्थान, स्टेटमेंट को निकालने आदि के संबंध में कुछ अनुकूलन करना चाहिए, और फिर भाषा के साथ अपने पोस्ट के शीर्ष पर अपनी बाइट गिनती की रिपोर्ट करें। महान पहली पोस्ट हालांकि! संदर्भ के लिए, आपकी प्रारंभिक पोस्ट 1,098 बाइट्स लंबी है।
केड

धन्यवाद। बस भाषा और बाइट काउंट जोड़ा। मेरे मूल में भी टिप्पणियाँ और उपयोग हैं। :)
कुछ उपयोगकर्ता

युक्ति: सभी चर नामों को एकल वर्णों में बदलें। इसके अलावा, आप 'के लिए' (i = 0; i <अंक 'का उपयोग करते हैं, शायद इसे एक मैक्रो के साथ बदलें?
जोशपब्रॉन

यहाँ अच्छा काम है। अपने स्कोर को और अधिक प्रतिस्पर्धी बनाने के लिए, आप सी में गोल्फ के लिए हमारे सुझावों पर एक नज़र डाल सकते हैं ।
एलेक्स ए।

14

जावास्क्रिप्ट, 192 178 167 162 बाइट्स

f=x=>{n=b="\n";for(k in x)for(i=0;i<8;)b+=("î\xA0Öô¸|~àþü".charCodeAt(x[k])>>i++&1?i%2?"/":"\\":" ")+(i%3?"":n+"  ".repeat(k));return b.split(n).reverse().join(n)}

उपयोग: f("1337");वापस आ जाएगी

      /\
        \
    /\   
     /\
  /\  /
   /\
 \  /
  \

यह ES6 की सुविधाओं का उपयोग करता है और अर्धविराम और कोष्ठक और इस तरह के चूक के कारण कुछ कार्यान्वयन पर निर्भर व्यवहार हो सकता है, लेकिन यह फ़ायरफ़ॉक्स में काम करता है।

विस्तारित:

f=x=>
{
    n = b = "\n";

    for (k in x)
        for (i=0; i<8;)
            b += ("î\xA0Öô¸|~àþü".charCodeAt(x[k]) >> i++ & 1? i%2? "/" : "\\" : " ") + (i%3? "" : n+"  ".repeat(k));

    return b.split(n).reverse().join(n)
}

स्पष्टीकरण:

lएक सरणी है जिसमें 10 एकल बाइट वर्ण होते हैं जो प्रत्येक अंक के आकार के अनुरूप होते हैं। उदाहरण के लिए, अंक 0 वर्ण द्वारा दर्शाया गया है î:

/\        11
\ \  -->  101  --> 11 101 110 = î
 \/       011

इनपुट वर्णों को कुंजी के रूप में उपयोग किया जाता है जो उनके आकार को समकक्षों का प्रतिनिधित्व करते हुए पकड़ते हैं, जो कि बिट द्वारा थोड़ा सा पढ़ा जाता है।


2
कर रहे हैं ==0और ==1इससे पहले कि वास्तव में आवश्यक ?। Int को js में बूलियन नहीं माना जाता है? @ रीग्रेट
एलेक्सी

1
@ रीग्रेट: "w\x05k/\x1D>~\x07\x7F?"प्रत्येक वर्ण बिटवाइड के साथ उलटा हो जाता है "\xee\xa0\xd6\xf4\xb8|~\xe0\xfe\xfc", इनमें से प्रत्येक प्रिंट करने योग्य होता है। यह 8 और बाइट्स देता है। हालांकि, पर्याप्त नहीं ...
एलेक्सी बर्डिन

1
आप कोष्ठक को हटाकर 2 बाइट्स निकाल f=(x)=>{}सकते हैं - केवल एक तर्क के साथ उनकी आवश्यकता नहीं है।
शिमोनस्टर

आप बिलकुल सही कह रहे हैं, @Alexey। मैं उसे बदल दूंगा।
रेग

क्या यह काम करता है? मुझे चंचल पात्रों के साथ 6 और पंक्तियाँ मिलती हैं।
edc65

10

पर्ल - 103 बाइट्स

#!perl -n
print$i+$%2?U^(u,$i--%2?v9:z)[$i<4+$%2&vec$_,4*$-3-$i,1]:$/.!($i=$--)
while$+=2*y/0-9/wPkz\\>?p~/

उपरोक्त में 6 अनपेक्षित वर्ण हैं (स्रोत को Ideone में डाउनलोड किया जा सकता है ), और निम्नलिखित के बराबर है:

#!perl -n
print$i+$^F%2?U^(u,$i--%2?v9:z)[$i<4+$^F%2&vec$_,4*$^F-3-$i,1]:$/.!($i=$^F--)
while$^F+=2*y/0-9/wPkz\\>?p\177~/

प्रत्येक ^Fको शाब्दिक वर्ण 6 (ACK) द्वारा प्रतिस्थापित किया जा सकता है, और \177चरित्र 127 (DEL) द्वारा प्रतिस्थापित किया जा सकता है ।

शेबंग को 1 के रूप में गिना जाता है, दूसरी न्यूलाइन असमान है। इनपुट स्टड से लिया गया है।


नमूना उपयोग

$ echo 0123 | perl seven-slash.pl

      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

$ echo 456789 | perl seven-slash.pl

          /\
          \/\
        /\  /
        \/\
      /\ \/
        \
    /
    \/\
  /  \/
  \/\
 \  /
\/\

व्याख्या

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

   /\           56 
   \/\          234
 /\ \/   ->   56 01
 \/\          234 
  \/           01

आउटपुट 3 और 5 स्लैश के बीच वैकल्पिक होता है, ताकि बिट अगले अंक 56में फैल जाए 01। बिट 7का उपयोग नहीं किया गया है।


8

सी #, 360 355 331 बाइट्स

हाय, कोड-गोल्फ में पहला प्रयास। आशा है कि यह C # -entry के लिए बहुत बुरा स्कोर नहीं करता है।

string p(string n){var l=new string[n.Length*2+1];var i=l.Length-1;for(;i>0;){var x=@"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0]-48)*7,7);for(var j=i-3;j>=0;){l[j--]+="  ";}l[i--]+=" "+x[5]+x[6];l[i--]+=""+x[2]+x[3]+x[4];l[i]+=""+x[0]+x[1];n=n.Remove(0, 1);}return string.Join("\n",l);}

उपयोग: p("159114");वापस आ जाएगी

          \
         \/\
        \
         \
      \
       \
   /\
   \/\
 /   /
 \/\
\  /
 \

विस्तारित:

string p(string n)
    {
        var l = new string[n.Length * 2 + 1];
        var i = l.Length - 1;
        for (; i > 0; )
        {
            var x = @"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0] - 48) * 7, 7);

            for (var j = i - 3; j >= 0; )
            {
                l[j--] += "  ";
            }
            l[i--] += " " + x[5] + x[6];
            l[i--] += "" + x[2] + x[3] + x[4];
            l[i] += "" + x[0] + x[1];

            n = n.Remove(0, 1);
        }

        return string.Join("\n", l);
    }

1
मुझे पता है कि यह लगभग तीन साल हो गया है, लेकिन आप 30 बाइट्स गोल्फ कर सकते हैं: इसे ऑनलाइन आज़माएं। 301 बाइट्स । हालांकि अच्छा जवाब, मेरी ओर से +1।
केविन क्रूज़सेन

ठंडा। बेझिझक इसे अपने स्वयं के उत्तर के रूप में पोस्ट करें :)
Shion

1
नहीं, यह आपका कोड है। मैंने बस फॉर-लूप ब्रैकेट्स को हटाकर और वैरिएबल के संयोजन से थोड़ा छोटा किया। और लंबोदर का उपयोग करके बदल रहा string s(string n)है n=>। आह ठीक है, आप चाहें तो इसे ऐसे ही छोड़ सकते हैं। :) मैंने आपको जावा क्रेडिट करने के लिए एक पोर्ट बनाया है लेकिन आपको। ;)
केविन क्रूज़सेन

4

अजगर 2, 317 298 278 273.15

def f(s):
    r=range;n=len(s)*2;l=[[' ']*-~n for x in r(-~n)]
    for x in r(0,n,2):
        for i,[d,y,c]in enumerate(zip('0112012','1021012',r'\\\\///')):l[n-2-x+int(y)][x+int(d)]=[' ',c][('%7s'%(bin(ord('}(7/jO_,\x7fo'[map(int,s)[x/2]])))[2:])[i]=='1']
    for x in l:print''.join(x)

मैंने गिनती करते समय 4-रिक्त स्थान को टैब माना।
असम्बद्ध और पठनीय:

def f(s):
    r=['1111101','0101000','0110111','0101111','1101010','1001111','1011111','0101100','1111111','1101111']
    ''.join(map(lambda x:chr(eval('0b'+x)),r))
    n=len(s)*2
    l=[[' ']*(n+1) for x in xrange(n+1)]
    shifts=[(0,1,'\\'),(1,0,'\\'),(1,2,'\\'),(2,1,'\\'),(0,0,'/'),(1,1,'/'),(2,2,'/')]
    for x in xrange(0,n,2):
        y=n-2-x
        for i,[dx,dy,c] in enumerate(shifts):
            l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' '
    return '\n'.join(''.join(x) for x in l)

अरे! शानदार उत्तर, लेकिन आप इसे थोड़ा छोटा करने के लिए कुछ बदलाव भी कर सकते हैं। बदलने l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' 'के लिए l[y+dy][x+dx]=[' ',c][r[map(int,s)[x/2]][i]=='1']5 बाइट्स की बचत होती है, बदल रहा है return '\n'.join(''.join(x) for x in l)करने के लिए print'\n'.join(''.join(x)for x in l)3 बाइट्स, प्लस कुछ और परिवर्तन सहेजता है। यहाँ एक Gist का लिंक दिया गया है जहाँ मुझे बाइट की गिनती ५०
केड

6
केल्विन उस स्कोर से बहुत खुश होता।
क्रिस्टियन लुपस्कू

3
आपका जवाब वास्तव में 272 बाइट्स है, लेकिन आप एक और बचा सकते हैं क्योंकि एक स्थान एक टैब से कम है। देखें यहाँ । आपके पास वैसे भी 273.15 बाइट्स कैसे हो सकते हैं?
mbomb007

1
273.15 बाइट्स का अर्थ है @AlexeyBurdin ने डिजिटल प्लेटफॉर्म पर एनालॉग कंप्यूटिंग का पता लगाया। दुनिया में आपने विज्ञान के बजाय इसे यहां क्यों प्रकाशित किया? ;-)
hBy2Py

1
इसका मतलब केवल यह है कि समाधान निरपेक्ष शून्य पर जमे हुए है, अर्थात मैं उस चीज़ पर ध्यान केंद्रित नहीं करना चाहता जो पहले ही खो चुकी है । :)
एलेक्सी बर्डिन

3

केडीबी (क्यू), १ 136२ १३६ बाइट्स

{d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;
 -1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}

व्याख्या

1) dसभी अंकों के आकृतियों के साथ नक्शा बनाएं ।

2) अतिरिक्त शून्य के साथ मैट्रिक्स को पैड करें और उन्हें एक साथ जोड़ें। यानी "01"

0           0 0 0 2 0   
0           0 0 0 0 2
1 2 0 0 0 + 0 0 0 0 0
2 0 2 0 0   0
0 2 1 0 0   0

3) मैप " /\"और प्रिंट के लिए इंडेक्स का उपयोग करें -1

परीक्षा

q){d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;-1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}"0123456789"
                  /\
                  \/\
                /\  /
                \/\
              /\ \/
                \
            /
            \/\
          /  \/
          \/\
         \  /
        \/\
      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

मुझे यकीन है कि यह छोटा हो सकता है !!

शुक्रिया @hjk


1
एकमात्र कमी जिसे मैंने देखा (-6) के 1 2 0 2 1 2 0 2 1साथ बदलना है (9#1 2 0 2)
hjk

1
ओह, और कार्यों के enlistसाथ प्रतिस्थापित करना 1#, इसलिए यह एक और -5 है।
hjk

1
तुम एक सितारे हो! मैं अपडेट करूंगा! लेकिन खिचड़ी जगह नहीं है enlistक्योंकि count[a 0]#0परमाणु नहीं है :(
WooiKent ली

आह अजीब यह मेरे लिए काम किया, हालांकि ... एक quirk होना चाहिए। ;)
hjk

1
वास्तव में, सूची प्लस परमाणु वैसे भी परमाणु को सही लंबाई तक बढ़ाएगा! आपने मुझे ऐसा तंत्र याद दिलाया! : डी
वूइकेंट ली

2

पिप, 122 + 1 = 123 बाइट्स

-nझंडे का उपयोग करता है । कमांड-लाइन तर्क के माध्यम से इनपुट लेता है।

l:$.(J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Ma)z:2*#ap:sXz+2RLz+2Fi,5Fj,z{c:[4-ii]//2+j(pc@0c@1):(lij)}RVp

UTF-8 स्ट्रिंग के पात्रों में निम्नलिखित कोड बिंदु हैं 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089:।

थोड़ा अपराजित:

t:[120022001 222022202 122012021 122012201 220012202 120212201 120212001 122022202 120012001 120012201]
l:$.({J"\/ "@^t@a.2<>2}Ma)
z:2*#a+2
p:sXzRLz
Fi,5
 Fj,2*#a {
  x:i//2+j
  y:(4-i)//2+j
  p@y@x:l@i@j
 }
P RVp

मूल रणनीति यह है कि प्रत्येक संख्या के घटक वर्णों को खोजें और फिर उन्हें उचित रूप से तिरछा करें। उदाहरण के लिए 8, हम चाहते हैं कि यह (डॉट्स द्वारा दर्शाया गया स्थान):

/.
\\
/.
\\
/.

जो इस में बदल जाएगा:

 .  
/\. 
\/\.
 \/ 

इस रणनीति की अच्छी विशेषता यह है कि कई पूर्व-तिरछी संख्याओं को बस एक-दूसरे के साथ जोड़ा जा सकता है।

अब, हम /.\\/.\\/.बेस 3 में एनकोड कर सकते हैं 1200120012। फिर हम इसे दशमलव में परिवर्तित कर सकते हैं और इसे UTF-8 कोड बिंदु के रूप में मान सकते हैं।

J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maनिम्नलिखित प्रक्रिया द्वारा अभिव्यक्ति को पूर्व-तिरछा डेटा मिलता है:

                            Ma   Map this lambda function to each character in input:
        (A_TB3M"...")            Create list of the code points of each character in UTF-8
                                   string, converted to base 3
                     @_          Index into that list using the input character
                       .2        Concatenate 2 to the end of the base-3 value (all of the
                                   pre-skewed number grids end in 2, i.e. space)
       ^                         Split the number into a list of its digits
 "\/ "@                          Index into this string with those digits, giving a list
                                   of slashes & spaces
J                                Join the list together into a string
                         <>2     Group string two characters at a time

एक बार जब हमने इन तारों को अगल-बगल इस्तेमाल कर लिया है $., तब हम रिक्त स्थान (2 * n + 2 वर्ग) का एक ग्रिड बनाते हैं , पूर्व तिरछी ग्रिड के माध्यम से लूप बनाते हैं , और बाद में तिरछे ग्रिड के साथ संबंधित रिक्त स्थान को बदलते हैं उपयुक्त पात्र। इसे होते हुए देखने के लिए, प्रत्येक चरण को प्रिंट करने के लिए कोड को संशोधित कर सकता है और उपयोगकर्ता इनपुट के लिए रुक सकता है:

प्रक्रिया में एल्गोरिदम

ग्रिड वास्तव में उल्टा बनाया गया है, क्योंकि यह गणित को आसान बनाता है।

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

पिप पर अधिक


2

ब्रेनफक - 719 बाइट्स

केवल ऐतिहासिक संदर्भ के लिए, डैनियल बी क्रिस्टोफनी को श्रेय दिया जाता है। मुझे यकीन नहीं है कि यह कब बनाया गया था, लेकिन यह इंटरनेट आर्काइव से 9 मई, 2003 तक उपलब्ध है।

के लिए आउटपुट 9समस्या वर्णन की तुलना में अलग है।

>>>>+>+++>+++>>>>>+++[
  >,+>++++[>++++<-]>[<<[-[->]]>[<]>-]<<[
    >+>+>>+>+[<<<<]<+>>[+<]<[>]>+[[>>>]>>+[<<<<]>-]+<+>>>-[
      <<+[>]>>+<<<+<+<--------[
        <<-<<+[>]>+<<-<<-[
          <<<+<-[>>]<-<-<<<-<----[
            <<<->>>>+<-[
              <<<+[>]>+<<+<-<-[
                <<+<-<+[>>]<+<<<<+<-[
                  <<-[>]>>-<<<-<-<-[
                    <<<+<-[>>]<+<<<+<+<-[
                      <<<<+[>]<-<<-[
                        <<+[>]>>-<<<<-<-[
                          >>>>>+<-<<<+<-[
                            >>+<<-[
                              <<-<-[>]>+<<-<-<-[
                                <<+<+[>]<+<+<-[
                                  >>-<-<-[
                                    <<-[>]<+<++++[<-------->-]++<[
                                      <<+[>]>>-<-<<<<-[
                                        <<-<<->>>>-[
                                          <<<<+[>]>+<<<<-[
                                            <<+<<-[>>]<+<<<<<-[
                                              >>>>-<<<-<-
  ]]]]]]]]]]]]]]]]]]]]]]>[>[[[<<<<]>+>>[>>>>>]<-]<]>>>+>>>>>>>+>]<
]<[-]<<<<<<<++<+++<+++[
  [>]>>>>>>++++++++[<<++++>++++++>-]<-<<[-[<+>>.<-]]<<<<[
    -[-[>+<-]>]>>>>>[.[>]]<<[<+>-]>>>[<<++[<+>--]>>-]
    <<[->+<[<++>-]]<<<[<+>-]<<<<
  ]>>+>>>--[<+>---]<.>>[[-]<<]<
]
[Enter a number using ()-./0123456789abcdef and space, and hit return.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/]

2
मैं शायद 2002 में लिखा था इंटरनेट का संग्रह कहते हैं पानू Kalliokoski अगस्त 2002 में उसकी brainfuck भंडार में जोड़ा के रूप में 9 के लिए, मुझे लगता है कि मैं के दूसरे संस्करण से पैटर्न का इस्तेमाल किया माइक्रोप्रोसेसर और Interfacing , पेज 4.
डैनियल Cristofani

1

पर्ल, 270 बाइट्स

मुझे वास्तव में इस पर अपना समय बर्बाद नहीं करना चाहिए था।

$e="\\";$g=" ";$_=reverse<>;$l=length;push@a,(119,18,107,91,30,93,125,19,127,95)[$1]while/(.)/g;for($i=0;$i<=$l;$i++){$j=2*($l-$i);$b=$a[$i];$c=$i&&$a[$i-1];print" "x$j,$b&1?"/":$g,$b&2?$e:$g,$g,$c&32?$e:$g,$c&64?"/":$g,"
"," "x$j,$b&4?$e:$g,$b&8?"/":$g,$b&16?$e:$g,"
"}

4 बाइट बचाने के लिए के [$1]while/(.)/gसाथ बदलें [$_]for/./g। 9 बाइट बचाने के लिए के for($i=0;$i<=$l;$i++)साथ बदलें for$i(0..$l)
जूल

1

जावास्क्रिप्ट ( ईएस 6 ), 191 206

परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ।

F=m=>(
  a='    \\/  /\\/\\ /  /\\  \\\\ \\'.match(/.../g),
  o=f='',r=' ',
  [for(d of m)(
    n=1e3+'¯B\x91ÿ$ê\x86A\x87ë'.charCodeAt(d)+'', // here there are 3 valid characters tha the evil stackoverflow editor just erase off, so I had to put them as hex escape
    o='\n'+f+' '+a[n[2]]+'\n'+r+a[n[1]]+o,
    r=f+a[n[3]],
    f+='  ')],
  r+o
)


//TEST

go=_=>O.innerHTML =(v=I.value)+'\n'+F(v)

go()
<input id=I value='0123456789'><button onclick='go()'>-></button>
<pre id=O></pre>


0

जावा 8, 341 बाइट्स

n->{int i=n.length*2,j=i+1,k=0,t;String l[]=new String[j],x;for(;j-->0;l[j]="");for(;i>0;l[i--]+=" "+x.substring(5,7),l[i--]+=x.substring(2,5),l[i]+=x.substring(0,2))for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\').substring(t=(n[k++]-48)*7,t+7),j=i-2;j-->0;)l[j]+="  ";return"".join("\n",l);}

पोर्ट ऑफ @ शियन के सी # .NET का उत्तर है , इसलिए उसे भी सुनिश्चित करें!

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

स्पष्टीकरण:

n->{                       // Method with character-array parameter and String return-type
  int i=n.length*2,        //  Two times the length of the input array
      j=i+1,               //  Index integer, starting at `i+1`
      k=0,t;               //  Temp integers
  String l[]=new String[j],//  String-array for the rows, default filled with `null`
         x;                //  Temp-String
  for(;j-->0;l[j]="");     //  Replace all `null` with empty Strings
  for(;i>0                 //  Loop `i` downwards in the range [`n.length*2`, 0)
      ;                    //   After every iteration:
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         " "               //     A space
         +x.substring(5,7),//     And the 6th and 7th characters of temp-String `x`
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         x.substring(2,5), //     The 3rd, 4th and 5th characters of temp-String `x`
       l[i]+=              //    Append the row at index `i` with:
         x.substring(0,2)) //     The 1st and 2nd characters of the temp-String `x`
    for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\')
                           //   String containing all digit-parts
          .substring(t=(n[k++]-48)*7,t+7),
                           //   and take the substring of 7 characters at index
                           //   `n[k]` as integer multiplied by 7
        j=i-2;j-->0;)      //   Inner loop `j` in the range (`i`-2, 0]
      l[j]+="  ";          //    And append the rows at index `j` with two spaces
  return"".join("\n",l);}  //  Return the rows delimited with new-lines
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.