7-सेगमेंट डिस्प्ले का उपयोग करके शब्द प्रदर्शित करें

Question

मेरी पहली प्रोग्रामिंग पहेलियाँ और कोड गोल्फ सात-स्लेश डिस्प्ले है । यहां मेरा पहला चैलेंज है, जो 7-सेगमेंट डिस्प्ले पर आधारित है।

मैं अक्सर संख्याओं के अलावा, एक साधारण 7 सेगमेंट डिस्प्ले का उपयोग करके किस तरह के पत्र प्रदर्शित कर सकता हूं, इसके बारे में सोचता हूं। बहुत सारे पत्र प्रदर्शित किए जा सकते हैं। वास्तव में, सभी लेकिन K, M, V, W, X अक्षर एक एकल 7-खंड प्रदर्शन का उपयोग करके प्रदर्शित किए जा सकते हैं। ऐसा इसलिए है क्योंकि आप या तो निचले मामले या किसी पत्र के ऊपरी मामले को प्रदर्शित कर सकते हैं। जैसे

"abcdef" के रूप में प्रदर्शित किया जा सकता है

 _     _     _  _
!_!!_ !   _!!_ !_ 
! !!_!!_ !_!!_ !  

ध्यान दें कि प्रत्येक वर्ण एक 3x3 मैट्रिक्स से बना !और है _।

बेशक, 7-खंड प्रदर्शन संख्या और प्रतीकों को प्रदर्शित करने के लिए इस्तेमाल किया जा सकता है:

 _     _  _  _           _  _     _    
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!

कुछ पत्रों में ऊपरी और निचले दोनों मामले हो सकते हैं:

 _                 _          
!   _ !_!!_   !   ! ! _ ! !   
!_ !_ ! !! !  !  !!_!!_!!_!!_!

यहाँ वर्णों का पूरा सेट दिया गया है:

 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  

 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_ 

ध्यान दें कि एक सफेद स्थान ( ), एक डैश ( -) और एक प्रश्न चिह्न ( ?) हैं। पत्र I, Oऔर Zसंख्या के रूप में ही कर रहे हैं 1, 0और 2क्रमशः।

इस चुनौती में, आप ऊपर 7-खंड प्रदर्शन प्रारूप का उपयोग करके स्ट्रिंग प्रदर्शित करने के लिए एक प्रोग्राम या फ़ंक्शन लिखेंगे।

नियम

1. आप एक कार्यक्रम या एक समारोह लिख सकते हैं

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

3. आपके प्रोग्राम या फ़ंक्शन को STDIN या एक पैरामीटर के रूप में इनपुट लेना चाहिए। और एक स्ट्रिंग को STDOUT या एक स्ट्रिंग के रूप में 3 लाइनों में अग्रणी स्थान के बिना आउटपुट करता है, लेकिन न्यूलाइन के साथ समाप्त कर दिया जाता है। CHIOUठीक से ऊपरी / निचले मामले को संभालें ।

4. आप वैकल्पिक रूप से सफेद स्थानों को पीछे छोड़ते हुए प्रिंट कर सकते हैं

5. आपको ऊपर दिए गए प्रारूप का पालन करना चाहिए। अपने 7-खंड प्रदर्शन बनाने के लिए अंडरस्कोर _और विस्मयादिबोधक चिह्न का उपयोग करना !।

6. आपको सफेद स्थान ( ), डैश ( -) और प्रश्न चिह्न ( ?) का समर्थन करना चाहिए

7. यदि स्ट्रिंग में असमर्थित वर्ण (k, m, v, w, x) है, तो एक एकल त्रुटि वर्ण (3 क्षितिज रेखा, उदाहरण देखें) प्रदर्शित होता है। 5 असमर्थित वर्णों के अलावा, आप मान सकते हैं कि इनपुट केवल समर्थित वर्ण सेट से बना है।

8. मैंने lभ्रम के कारण लोअरकेस एल ( ) के लिए एक पत्र नहीं चुना है, लेकिन अगर आप इतने इच्छुक हैं, तो आप इसे 1दाईं या बाईं ओर प्रदर्शित कर सकते हैं ।

उदाहरण

$./a.out Start
 _     _    
!_ !_ !_! _ !_
 _!!_ ! !!  !_
$./a.out "7-seg dIsplay"
 _     _  _  _           _  _     _ 
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!
$./a.out "0123456789 chiou-?"
 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !
$./a.out "ABCDEFGHIJLNOPQRSTUZ"
 _     _     _  _  _                 _  _  _     _        _
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! ! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "abcdefghijlnopqrstuz"
 _           _  _  _                    _  _     _        _
!_!!_  _  _!!_ !_ !  !_      !!   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "Bad Form"
 _
 _
 _
$./a.out "Hello"
    _       
!_!!_ !  !   _
! !!_ !_ !_ !_!
$./a.out "World"
 _
 _
 _

Comments

हां, आप मान सकते हैं कि कोई असमर्थित प्रतीक नहीं है। मेरा इरादा यह सुनिश्चित करना है कि जिन तारों को k, m, v, w, xप्रदर्शित नहीं किया गया है।

— कुछ उपयोगकर्ता

संबंधित: codegolf.stackexchange.com/questions/9266/…

— DavidC

मुझे लगता है कि आपने \rलाइन फीड (एलएफ) के साथ कैरिज रिटर्न (सीआर ) को भ्रमित किया है \n। * निक्स एलएफ का उपयोग करता है और विंडोज सीआरएलएफ का उपयोग करता है। केवल कुछ विरासत प्रणालियां ही सीआर का उपयोग करती हैं। अधिक जानकारी यहां: en.wikipedia.org/wiki/Newline

— विनी जूल

आपका "8" चरित्र एक बार लगता है "|" विस्मयादिबोधक चिह्न के बजाय "!"। क्या यह इरादा है?

— coredump

@, आप बिल्कुल सही हैं। जब मैंने इसे लिखा तो मैं इसे देखने के लिए बहुत आलसी था।

— कुछ उपयोगकर्ता

Answer 1

CJam, 123 114 112 110 बाइट्स

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"^A^W^G;^Þ¯     ^Þ^Û9³·^É¿»
^@
^P
^Ü^Ò½7¦^_¶´§=   ^O^V&5^U¯¼¹^T³6/"=i2b9Ue[3/"!_!"f.{S?}.+}/N*

उपरोक्त कार्यवाहक संकेतन का उपयोग करता है, क्योंकि कोड में अनपेक्षित वर्ण हैं। उनमें से एक अशक्त बाइट ( ^@) है, जिसका अर्थ है कि यह कोड केवल कमांड लाइन से निष्पादित किया जा सकता है।

केवल दो और बाइट्स (कुल 112 के लिए ) की कीमत पर, हम इसे ठीक कर सकते हैं।

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"AWG{ÞïIÞÛyó÷Éÿû
@
P
ÜÒýwæ_öôç}IOVfuUïüùTóvo"=i448+2b1>3/"!_!"f.{S?}.+}/N*

इस समय, सभी वर्ण मुद्रण योग्य हैं। CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

उदाहरण चलाते हैं

$ LANG=en_US
$ xxd -ps -r > 7seg.cjam <<< 51715f6575223b3d4b4d565758223a5426224022403f22202d6368696f752254657265757b69220117073b9eaf099e9b39b3b789bfbb0a000a100a9c92bd37a61fb6b4a73d090f16263515afbcb914b3362f223d6932623955655b332f22215f2122662e7b533f7d2e2b7d2f4e2a
$ wc -c 7seg.cjam 
110 7seg.cjam
$ echo -n '0123456789 chiou-?' | cjam 7seg.cjam; echo
 _     _  _     _  _  _  _  _                       _ 
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  
$ echo -n 'ABCDEFGHIJLNOPQRSTUYZ' | cjam 7seg.cjam; echo
 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_ 
$ echo -n 'World' | cjam 7seg.cjam; echo
 _ 
 _ 
 _

आइडिया (मुद्रण योग्य संस्करण)

प्रत्येक चरित्र को 9-खंड प्रदर्शन पर दिखाया जा सकता है

!_!
!_!
!_!

रिक्त स्थान के साथ इसके कुछ पात्रों के पात्रों को बदलकर।

हम प्रत्येक दिखाए गए खंड को प्रतिस्थापित करके पूर्णांक में एक विशिष्ट चरित्र को बदल सकते हैं, प्राकृतिक रीडिंग ऑर्डर में, 1 के साथ , प्रत्येक को 0 के साथ खंड नहीं दिखाया गया है और परिणाम द्विआधारी अंकों पर विचार कर रहा है।

पहले और तीसरे खंड को कभी नहीं दिखाया जाता है, इसलिए यह पूर्णांक [0,64] और [128,192) में पूर्णांक उत्पन्न करेगा ।

हम इनमें से प्रत्येक पूर्णांक को एक बाइट के रूप में एन्कोड कर सकते हैं, लेकिन उनमें से आधे का परिणाम अनपेक्षित वर्णों में होगा। इस प्रकार, हम चरित्र के लिए कास्टिंग करने से पहले प्रत्येक पूर्णांक में 64 जोड़ते हैं , जिससे यह सुनिश्चित होता है कि कोड बिंदु [64,128) और [192,256] श्रेणी में हैं ।

इन दो श्रेणियों में एकमात्र अनुचित वर्ण DEL (कोड बिंदु 127) है, जो निम्नलिखित, अप्रयुक्त प्रदर्शन कॉन्फ़िगरेशन से मेल खाता है:

!_!
!_!

हम प्रत्येक कोड बिंदु पर 448 == 512 - 64 जोड़कर उपरोक्त एन्कोडिंग को उलट सकते हैं , बेस 2 में परिवर्तित कर सकते हैं और पहले बाइनरी अंक को हटा सकते हैं।

उन सभी को इन ASCII वर्णों के साथ इन एन्कोडेड सीगमेट्स को जोड़ने का एक कुशल तरीका खोजने के लिए छोड़ दिया गया है।

हम के पात्रों के नक्शे हैं " -chiou"के पात्रों को ";=KMVWX"अपरकेस में और पूरे इनपुट कन्वर्ट, हम बस के बीच सभी पात्रों के लिए एन्कोडिंग स्टोर कर सकते हैं 0(कोड बिंदु 48) और Z, (कोड बिंदु 90) 43 की एक श्रृंखला दे रही है।

अरेज इंडेक्सिंग सीजेएम में मॉड्यूलर है, इसलिए यदि Aलंबाई 43 की एक स्ट्रिंग है A86=, A43=और A0=सभी समान परिणाम देते हैं। कोड बिंदु 86 के साथ वर्ण है V, इसलिए हम क्रम में वी - जेड और 0 - यू के एन्कोड किए गए खंडों को संग्रहीत करते हैं ।

वास्तविक कोड में, हम साइन इन को "खराब फॉर्म" वर्ण के रूप में चुनते हैं, स्ट्रिंग के साथ पूरे इनपुट को प्रतिस्थापित करते हैं "@"यदि इसमें एक निषिद्ध पत्र होता है और ऊपर से चरणों को उल्टा करता है।

कोड (मुद्रण योग्य संस्करण)

Q            e# Push an empty array for posterior concatenation.
q            e# Read from STDIN.
_eu          e# Copy the input and convert is to uppercase.
";=KMVWX":T& e# Intersect the result with with T := ";=KMVWX".
"@"@?        e# Select "@" if truthy and the input if falsy.
" -chiou"Ter e# Perform transliteration.
eu           e# Convert everything to uppercase.
{            e# For each character in the modified input:
  i          e#   Push its code point.
  "…"=       e#   Select the corresponding character from the string.
  i448+      e#   Push that character's code point and add 448.
  2b1>       e#   Convert to base 2 and discard the first digit.
  3/         e#   Group into triplets of digits (rows).
  "!_!"      e#   Push that string.
  f.{        e#   For each group of digits:
    S?       e#     Select the corresponding char of "!_!" for 1 and " " for 0.
  }          e#
  .+         e#   Concatenate along the rows with the previous results.
}/           e#
N*           e# Join, separating by linefeeds.

Answer 2

पर्ल, 475 469 424 390 280 272 बाइट्स

$_=<>;die" -
"x3if/[kmvwx]/i;y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);$i.=$z&1?' _ ':$"x3;$m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");$p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}print"$i
$m
$p
"

टिप्पणियों के साथ बहु-पंक्ति:

$_=<>;   # accept input
die" -   # check for invalid chars
"x3if/[kmvwx]/i;
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)   # loop over each character
    # lookup character from string using transliteration and convert to
    # number using ord() for bit checking:
    {$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);
    $i.=$z&1?' _ ':$"x3;    # first row
    $m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");   # second row
    $p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}    # third row
# print result:
print"$i
$m
$p
"

खंडों को एन्कोडिंग करने वाले बिट पैटर्न एक स्ट्रिंग में संग्रहीत किए जाते हैं ( अंतरिक्ष के लिए उपयोग \xऔर उपयोग करने वाले 3 अनपेक्षित वर्णों से बचकर \0) और पर्ल ट्रांसलिटरेशन ऑपरेटर का उपयोग करके इनपुट वर्णों में मैप किया जाता है।

7 खंडों में से 5 के लिए, एक बिटवाइज और एक अंतरिक्ष या खंड चरित्र के उत्पादन के लिए टर्नरी ऑपरेटर के साथ प्रयोग किया जाता है। नीचे के दो खंडों (बिटसेट में 2 और 4 से एन्कोडेड) के लिए, 2 बाइट्स को बचाने के लिए 8 वर्ण स्ट्रिंग में एक विकल्प लुकअप का उपयोग किया जाता है।

अपने पर्ल गोल्फिंग सुझावों के लिए डोम हेस्टिंग्स को धन्यवाद।

पुराना संस्करण (पैटर्न को सांकेतिक शब्दों में बदलना के लिए), 390 बाइट्स:

$_=<>;if(/[kmvwx]/i){print" -\n"x3;exit}y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   ');$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').($z=~/[adhijopquyz\?0-4789]/?'!':' ');$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').($z=~/[b-egjklostuw-z0235689]/?'_':' ').($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')}print"$i\n$m\n$p\n"

टिप्पणियों के साथ बहु-पंक्ति:

$_=<>;   # accept input
if(/[kmvwx]/i){print" -\n"x3;exit}   # check for invalid chars
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)
{$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   '); # first row
$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').
($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').
($z=~/[adhijopquyz\?0-4789]/?'!':' '); # second row
$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').
($z=~/[b-egjklostuw-z0235689]/?'_':' ').
($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')} # third row
print"$i\n$m\n$p\n" # print result

स्ट्रिंग को रीडगेक्स का उपयोग करके अमान्य वर्णों के लिए पढ़ा और जांचा जाता है, यदि कोई पाया जाता है तो बाहर निकलता है। फिर अनुमत लोअरकेस वर्णों को अमान्य वर्णों के लिए प्रतिस्थापित किया जाता है और पूरे स्ट्रिंग को लोअरकेस में बदल दिया जाता है।

पंक्तियों को एक बार में उत्पन्न किया जाता है, जिसमें पहली पंक्ति में 1 खंड प्रति अक्षर और अन्य दो पर 3 होते हैं। प्रत्येक पंक्ति के लिए, स्ट्रिंग को एक बार में एक वर्ण संसाधित किया जाता है और यदि यह जाँचने के लिए वर्ण प्रत्येक खंड के लिए एक regex के साथ मेल खाता है! या _ प्रदर्शित किया जाना चाहिए। रेगेक्स का उपयोग करने का मतलब है कि उन पात्रों के लिए जहां सेगमेंट सेट नहीं है, इसे सेट करने के लिए प्रति सेगमेंट प्रति शून्य बिट्स लेता है या नहीं, और इसके लिए जहां यह है वह औसतन 8 बिट्स से थोड़ा कम लेता है क्योंकि रेगेक्स कैरेक्टर रेंज हो सकती है उपयोग किया गया। तो यह सेट में प्रति सेगमेंट प्रति खंड लगभग 3 या 4 बिट्स या लगभग 21-24 बिट्स प्रति कैरेक्टर पर काम करता है।

यह लाइन-रैपिंग को हैंडल नहीं करता है।

Comments

हे @samgak, और अधिक पर्ल प्यार देखने के लिए खुश! मैंने कुछ चीजों पर ध्यान दिया जो आपको कुछ बाइट्स से दूर करने में मदद कर सकती हैं और उन्हें साझा करना चाहती हैं! इस में कमी करने के लिए आप पर्ल के कुछ जादुई चर का उपयोग कर सकते हैं; ' 'के साथ प्रतिस्थापित किया जा सकता है $"और ' 'यह $"x3कुछ हद तक दूर \nहो सकता है , आपके एस कुछ और छुटकारा पाने के लिए शाब्दिक नए समाचार हो सकते हैं। आपके शुरुआती निकास को डाई का उपयोग करके भी छोटा किया जा सकता है, ताकि यह if(/[kmvwx]/i){print" -\n"x3;exit}बन जाए die" - "x3if(/[kmvwx]/i)। थोड़े और अधिक फ्रॉडिंग के साथ आप कोष्ठक से बचने के लिए लूप को फिर से व्यवस्थित कर सकते हैं और आपको $zकुछ और बचाने की आवश्यकता नहीं होनी चाहिए !

— डोम हेस्टिंग्स

मुझे आशा है कि आप नाराज नहीं होंगे, लेकिन मैंने अधिक, gist.github.com/dom111/e651b5de8c7e7fc9a6cf को कम करने पर एक नज़र डाली थी । नीचे 323 करने के लिए!

— डोम हेस्टिंग्स

@DomHastings कोई अपराध नहीं लिया, महान गोल्फ युक्तियाँ के लिए धन्यवाद! मैंने अपने संपादित उत्तर में उनमें से कई का उपयोग किया है, जो कि मैंने खंड पैटर्न के लिए regexes के बजाय बिटकॉइन एन्कोडिंग का उपयोग करने के लिए बदल दिया है। दुर्भाग्य से $ z वापस आ गया है, और मैं यह पता नहीं लगा सकता कि इससे कैसे छुटकारा पाया जाए। इसके अलावा, $_=lc<>काम नहीं करता है, क्योंकि तब कोड ऊपरी और निचले CHIOU के बीच भेदभाव नहीं कर सकता है

— Samgak

Answer 3

आम लिस्प, 488 416

(lambda(z)(dotimes(r 3)(map()(lambda(c)(do((i 0(+ 17 i))n)((or(and(> i 901)(setf n 146))(=(char-code c)(ldb(byte 8 9)(setf n(ldb(byte 17 i)#36RIL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02)))))(loop for v from(* 3 r)for d across"!_!"do(format t"~:[ ~;~A~]"(logbitp v n)d)))))z)(terpri)))

उदाहरण

"abcdefg'hijklnopqrstuz"प्रिंट के साथ :

 _           _  _  _  _           _           _  _     _        _ 
!_!!_  _  _!!_ !_ !   _ !_   !  ! _ !   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_! _ ! !  !!_! _ !_ ! !!_!!    !!   _!!_ !_!!_ 

टिप्पणियों

आधार संख्या 36 में वर्ण और उनके अभ्यावेदन इस संख्या में कूटबद्ध हैं:

IL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02

इस अंक के द्विआधारी प्रतिनिधित्व को 17 बिट्स के समूहों में विभाजित किया गया है।

उदाहरण के लिए, 17 बिट्स का अंतिम समूह है 110000111101010, जो दो भागों में विघटित होता है:

1. 110000चरित्र के चार-कोड 0

2. 111101010, ड्राइंग का एक एन्कोडिंग, सबसे अच्छा प्रतिनिधित्व इस प्रकार है:

   010 (bits 0-2)         _ 
   101 (bits 3-5)   =>   ! !
   111 (bits 6-8)        !_!
   

   पहले और आखिरी "कॉलम" में बिट्स !वर्णों के लिए हैं, वर्ण के लिए मध्य कॉलम में _हैं। जब आवश्यक हो, एक चरित्र के अपरकेस और डाउनकेस संस्करण दोनों को संग्रहीत किया जाता है।

फ़ंक्शन इनपुट स्ट्रिंग पर तीन बार पुनरावृत्त करता है, आउटपुट की प्रत्येक पंक्ति के लिए एक, तालिका में एक मिलान चरित्र (या 146, उर्फ ​​तीन बार के लिए चूक) के लिए खोज करता है, और वर्तमान पंक्ति में प्रतिनिधित्व प्रिंट करता है।

Comments

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

— कुछ उपयोगकर्ता

मैं 'चरित्र को अपडेट करूंगा और प्रश्न को संपादित करूंगा Kक्योंकि वास्तव में, मैंने Kइनपुट स्ट्रिंग ("... jlKn ...") में गलत स्थान पर रखा है ; ;-) आप केवल ट्रिपल बार (त्रुटि) देख सकते हैं एल के बाद यह ध्यान देने के लिए धन्यवाद।

— coredump

Answer 4

जावास्क्रिप्ट (ईएस 6), 380 352 324 बाइट्स

( नोट: कोड कैरट नोटेशन का उपयोग करता है, क्योंकि इसमें कुछ अनपेक्षित वर्ण हैं। मूल कोड प्राप्त करने के लिए, यहां क्लिक करें और कच्चे डेटा का चयन करें। और नहीं, hसीजेएम प्रोग्राम नहीं है;)

d=s=>{a=' ',u=n=>r>>n&1?'!':a,v=n=>r>>n&1?'_':a,g='ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz0123456789-? ÿ',h='{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)^??^BK^0^G',x=y=z='';for(i=0;i<s.length;x+=a+v(0)+a,y+=u(4)+v(1)+u(3),z+=u(6)+v(2)+u(5)){q=g.indexOf(s[i++]);if(q<0)return d`ÿ`;r=h.charCodeAt(q)}return x+`
${y}
`+z}

के रूप में d("7-seg display")या समान कहा जाता है । फ़ायरफ़ॉक्स 40 में काम करता है, लेकिन अन्य ब्राउज़रों में नहीं हो सकता है। किसी कारण से, HTML / JS स्निपेट नॉन-प्रिंटबल को नहीं बचाता है, लेकिन आप यहां से कच्चे डेटा को कॉपी-पेस्ट कर सकते हैं ।

Ungolfed:

( नोट: g और hमैच के लिए रिक्त स्थान के साथ गद्देदार दिया है 8, -, ÿऔर spaceउनकी संगत यूनिकोड मूल्यों के साथ।)

d = function (s) {
  t = function (n) { return Math.floor(n) % 2; };
  g = 'ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz012345679? 8      -      ÿ      space ';
  h = '{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)?K \u007f \u0002 \u0007 \u0000';
  x = y = z = '';
  for(var i = 0; i < s.length; i++) {
    q = g.indexOf(s.charAt(i));
    if (q < 0)          // if g does not contain the character
      return d('ÿ');    // ÿ is equivalent to the error character, '\u0007'
    r = h.charCodeAt(q);
    x += ' ' + (r % 2 === 1 ? '_' : ' ') + ' ';
    y += (t(r / 16) === 1 ? '!' : ' ') + (t(r / 2) === 1 ? '_' : ' ') + (t(r / 8) === 1 ? '!' : ' ');
    z += (t(r / 64) === 1 ? '!' : ' ') + (t(r / 4) === 1 ? '_' : ' ') + (t(r / 32) === 1 ? '!' : ' ');
  }
  return x + '\n' + y + '\n' + z;
}

स्पष्टीकरण:

मैंने तुरंत देखा कि 7 खंड, 0/ 1बिट्स में परिवर्तित हो गए , पहले 128 यूनिकोड वर्णों के साथ अच्छी तरह से चला जाएगा। इस विचार के साथ समस्या यह है कि इन वर्णों में से 1/4 गैर-मुद्रण योग्य नियंत्रण वर्ण हैं। मेरे कोड में उनका उपयोग करने से यह अविश्वसनीय रूप से गन्दा लगेगा (या अविश्वसनीय रूप से बुद्धिमान; मैंने तय नहीं किया है कि कौन सा)। बाकी कोड को सरल रखते हुए इसे हल करने के लिए, मैं इस विचार के साथ आया:

के अपवाद के साथ -, स्थान , और त्रुटि , दोनों में से कोई भी कम ऊर्ध्वाधर खंडों को याद नहीं कर रहा था। तो सुनिश्चित करें कि उन सभी पात्रों के बीच रहने लगा बनाने के लिए 0020और 007f, मैं बस मैप किया गया 64 और 32 , इन क्षेत्रों के लिए बिट्स की तरह तो:

     1
    ---
16 |   | 8
  2 ---
64 |   | 32
    ---
     4

अन्य 5 खंडों की संख्या बहुत महत्वपूर्ण नहीं है; उन्हें किसी अन्य तरीके से व्यवस्थित किया जा सकता था और अभी भी सभी समान वर्ण "इन-सीमा" हैं।

एक उदाहरण के रूप में, यहाँ ए का एन्कोडेड संस्करण है :

     1
    ---
16 |   | 8
  2 ---
64 |   | 32

Dec: 64 + 32 + 16 + 8 + 2 + 1 = 123
Hex: 40 + 20 + 10 + 8 + 2 + 1 = 7B = u+007B = {

फिर मैंने प्रत्येक 7-सेग वर्ण के एन्कोडेड संस्करण को भर दिया h। हालाँकि, 8परिणामी 007f( हटाए गए नियंत्रण कोड; निरंतर कोई फर्क नहीं पड़ता कि सेगमेंट की व्यवस्था कैसे की जाती है), अंतरिक्ष के परिणामस्वरूप 0000( शून्य कोड; भी स्थिर), -परिणामस्वरूप 0002और त्रुटि हुई 0007। मैं सही स्थिति में प्रतिलिपि चिपकाया कच्चे बाइट्स के लिए 8, -और त्रुटि ; अंतरिक्ष आसानी से हासिल किया गया था \0।

इस सभी एन्कोडिंग के बाद, मुझे केवल इतना करना था कि इसे स्ट्रिंग को डीकोड करने के लिए इस्तेमाल किया जाए और इसे 7-सेग पठनीय प्रारूप में आउटपुट किया जाए। मैं एक प्रयोग के लिए लूप और तीन चर ( x, y, और zस्ट्रिंग में प्रत्येक चरित्र के माध्यम से जाने के लिए और उत्पादन के लिए अपनी 7-SEG बराबर जोड़ने के लिए, प्रत्येक एक आउटपुट लाइन के अनुरूप)। मैंने त्रुटि चरित्र के ÿलिए चुना क्योंकि AFAIK, यह किसी भी कीबोर्ड पर नहीं है, और यह सीमा में अंतिम चरित्र है । शायद मैं मजाकिया और चुना हुआ हो सकता है (ग्रीक अक्षर xi) इसके बजाय ....;)u+0000-u+00ffΞ

संपादित करें 1: सहेजी गयी बनाने मिनी कार्यों से अंतरिक्ष का एक समूह निर्धारित करने के लिए !, _या की जरूरत है।

संपादित करें 2: जब से मैंने इस पोस्ट को देखा है, तब से मैंने जो ट्रिक्स सीखे हैं, उनका उपयोग करके एक गुच्छा अधिक स्थान बचाया।

हमेशा की तरह, सुझावों की बहुत सराहना की जाती है!