19

सरल भाग: केवल इनपुट करने योग्य स्ट्रिंग जिसमें केवल मुद्रण योग्य ASCII- वर्ण (स्पेस - टिल्ड) है, को देखते हुए प्रत्येक वर्ण की घटनाओं की संख्या की गणना करें और परिणाम को किसी भी सुविधाजनक प्रारूप पर लौटाएं। एक स्ट्रिंग के लिए परिणाम a%hda7aकी तरह कुछ किया जाना चाहिए: a:3, %:1, h:1, 7:1, d:1। सॉर्टिंग अनावश्यक है, सीमांकक और प्रारूप वैकल्पिक हैं लेकिन यह आसानी से समझा जाना चाहिए कि कौन सी संख्या किस वर्ण से मेल खाती है। आप उन वर्णों को शामिल नहीं करेंगे जो इनपुट स्ट्रिंग a:3, b:0, c:0, d:1, ...में नहीं हैं ( यह ठीक नहीं है)।

असली चुनौती:

अपने कोड के प्रत्येक वर्ण को 8-बिट बाइनरी नंबर (या 16-बिट में यदि आप UTF-16 या इसी तरह का उपयोग कर रहे हैं) में कनवर्ट करें, और प्रत्येक वर्ण को शुरू करें 0।

प्रत्येक वर्ण ( iएन्यूमरेटर) के लिए, i%7-बिट ¹ होना चाहिए 1। बिट्स को दाईं ओर से गिना जाता है। अन्य सभी बिट्स आप जो चाहें कर सकते हैं।

उदाहरण के रूप में निम्नलिखित कोड का उपयोग करते हैं:

[f]-xif)#f

इसे बाइनरी में बदलने से हमें नीचे दी गई सारणी मिलती है। पहले नंबर (का प्रतिनिधित्व करने [के लिए एक है 1कि एक ठीक है 0'th स्थिति में,। दूसरे नंबर (का प्रतिनिधित्व fएक है 11'st स्थिति में है, ताकि एक ठीक भी है। इस तरह जारी रखें, और आप देखेंगे कि ऊपर का कोड मान्य है।

C 76543210 बिट संख्या
- -------- ----------
[०१०११०१ १   ० - ठीक है
f 011001 1 0 1 - ठीक है
] 01011 1 01 2 - ठीक है
- 0010 1 101 3 - ठीक है
x 011 1 1000 4 - ठीक है
i 01 1 01001 5 - ठीक है
f 0 1 100110 6 - ठीक है
) 0010100 1   0 - ठीक है
# 001000 1 1 1 - ठीक है
f 01100 1 10 2 - ठीक है

यदि हम कोड को इसमें बदलते हैं: ]f[-xif)#fतो हमें अनुक्रम की शुरुआत मिलेगी:

C  76543210  Bit number
-  --------  ----------
]  01011101  0   <- OK
f  01100110  1   <- OK
[  01011011  2   <- Not OK
-  00101101  3   <- OK

हम देखते हैं के रूप में, तीसरे चरित्र [एक नहीं है 12 स्थिति (शून्य अनुक्रमित) में है, और इस कोड इसलिए मान्य नहीं है।

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

Input:
This is a string containing some symbols: ".#!".#&/#

Output:
   !  "  #  &  /  :  T  a  b  c  e  g  h  i  l  m  n  o  r  s  t  y  .
7  1  2  3  1  1  1  1  2  1  1  1  2  1  5  1  2  4  3  1  6  2  1  2

कोई भी उचित आउटपुट प्रारूप ठीक है (जो भी आपके लिए सबसे सुविधाजनक है)। आप उदाहरण के लिए हो सकता है: :7, !:1, ":2, #:3, &:1, /:1, T:1, a:2 ...या [ ,7][!,1][",2][#,3][&,1]...। आउटपुट किसी भी मानक तरीके पर है (फ़ंक्शन से वापस, STDOUT आदि के लिए मुद्रित)

¹i मापांक 7।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड ^{रेफरी} जीत जाएगा ।

— स्टीवी ग्रिफिन
स्रोत

6

थोड़ी सहायता करने के लिए, यहाँ उन वर्णों का उपयोग किया जा सकता है जिन्हें आप n%7th स्पॉट> pastie.org/paste/10985263/text

— TidB

@ टीआईडीबी वेबसाइट ऑफलाइन है ??

— रॉड

1

@ हाँ, पास्‍ती को कुछ समस्‍याएं हैं। इसके बजाय

— पास्टबिन का

1

याद रखें कि न्यूलाइन है 00001010। यह उपयोगी भी हो सकता है! :)

— स्टू ग्रिफिन

1

कुछ और सहायता के लिए, यहाँ एक सत्यापन स्क्रिप्ट है जिसका उपयोग आप UTF-8 एन्कोडिंग के लिए कर सकते हैं। उदाहरण की तरह स्ट्रिंग में इनपुट को इनकैप्सुलेट करें।

— AdmBorkBork

6

Pyke, 1 6 बाइट्स

1cn;1c

यहाँ कोशिश करो!

1c     - chunk(size=1, input)
  n;1  - noop. 
     c - count(^)

इस कोड का आधा सिर्फ नो-ऑप्स है ...

00110001 - 1
01100011 - c
01101110 - n
00111011 - ;
00110001 - 1
01100011 - c

— नीला
स्रोत

@EriktheOutgolfer के पास एक वैध बिंदु है। मुझे नहीं लगता कि यह इनपुट प्रारूप वैध है, जब तक कि यह वास्तव में पाइके में एक नियमित स्ट्रिंग नहीं है। चूंकि MATLAB / Octave में यह वैध इनपुट स्ट्रिंग होगा 'abc'==['a','b','c'], इसलिए यह Pyke में भी हो सकता है ...?

— स्टू ग्रिफिन

@StewieGriffin यह नहीं है कि पाइके सामान्य रूप से तारों को कैसे संभालता है। यदि यह ठीक नहीं है, तो मैं इनपुट प्रारूप को स्विच करने के बारे में देख सकता हूं, लेकिन एक चरित्र सूची के रूप में चूक की स्वीकृत सूची के तहत है, हालांकि इस के तहत धोखा के रूप में गिना जा सकता है

— ब्लू

5

1-बाइट के साथ आपकी चुनौती को तोड़ने के लिए क्षमा करें, मुझे नहीं लगता कि आप वास्तव में क्षमा चाहते हैं, और इस चुनौती से नहीं टूटा है :-)

— लुइस मेंडू

2

यह एक चरित्र सूची नहीं है; यह तार की एक सूची है। जबकि वर्ण सूची + 17 / -0 पर हैं , स्ट्रिंग सूची + 2 / -2 पर हैं , इसलिए यह शायद ही कोई डिफ़ॉल्ट डिफ़ॉल्ट है। @StewieGriffin को यह तय करना चाहिए कि यह वैध है या नहीं।

— डेनिस

1

@StewieGriffin बेहतर है?

— ब्लू

6

पायथ, 12 8 7 बाइट्स

^{-1 बाइट @ @ धन्यवाद करने के लिए धन्यवाद}

m+d/Qd{
      { # remove all duplicated elements from the (implicit) input
m       # map each element (d) of the parameter (the set from previous operation)
   /Qd  # count the occurrences of d in Q
 +d     # concatenate with d

बाइनरी प्रतिनिधित्व

0110110 1 मी
001010 1 1 +
01100 1 00 डी
0010 1 111 /
010 1 0001 क्यू
01 1 00100 डी
0 1 111011 {

यहाँ कोशिश करो

— छड़ी
स्रोत

अच्छा! :) उत्पादन 13के लिए 111अजीब लगता है, लेकिन यह गलत समझा नहीं हो सकता (वहाँ किसी भी एक वर्ण नहीं हो सकता 13है कि के 1 बार प्रयोग किया जाता), तो यह पूरी तरह से वैध है!

— स्टीवी ग्रिफिन

4

Befunge-93, 150 बाइट्स

={<{p+}3/}*77\%*7{7:\+{}{1g}+3/*77\%*7{7:}=:_{}{}={}{}{v#{}{}`x1:~
}-}=*}{2*}97}:<$}={$_v#}!:-*84g+3/*77\%*7{7:}=:}:}+}1{}<_{@#
}{}{}={}{}{}={^.},\={<

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

मैंने इसे एक नियमित Befunge प्रोग्राम के रूप में लिखना शुरू किया, जिसे मैंने यथासंभव संभव बनाया। मैंने तब यह सुनिश्चित करने के लिए पैडिंग को जोड़ा कि कार्यक्रम में विभिन्न वर्ण केवल स्वीकृत पदों पर दिखाई दिए। इस पेडिंग ने इस तथ्य पर भरोसा किया कि बेफ्यूज -93 में असमर्थित आदेशों को अनदेखा किया जाता है, इसलिए मुझे केवल अप्रयुक्त पात्रों के अनुक्रम की आवश्यकता होती है जिनके बिट्स आवश्यक पदों के साथ संरेखित होते हैं (मेरे द्वारा उपयोग किया गया अनुक्रम ={}{}{})।

जटिल बिट यह था कि लाइनों के बीच की विभिन्न शाखाओं को सही ढंग से पंक्तिबद्ध करने की आवश्यकता थी (उदाहरण के लिए vएक पंक्ति में तीर, इसके <नीचे तीर के साथ लाइन करने की आवश्यकता होगी )। यह इस तथ्य से और अधिक जटिल था कि पुल कमांड ( #) को इसके आसन्न शाखा तीर से अलग नहीं किया जा सकता था। प्रारंभ में मैंने प्रोग्रामिंग को पैडिंग जनरेट करने की कोशिश की, लेकिन अंत में यह ज्यादातर एक मैनुअल प्रक्रिया थी।

कार्यक्रम के आकार के कारण मैं पूर्ण चरित्र विश्लेषण को सूचीबद्ध नहीं करने जा रहा हूं, लेकिन यह शुरुआत और अंत से एक नमूना है:

= 00111101 0
{ 01111011 1
< 00111100 2
{ 01111011 3
p 01110000 4
+ 00101011 5
} 01111101 6
3 00110011 0
/ 00101111 1
...
{ 01111011 1
^ 01011110 2
. 00101110 3
} 01111101 4
, 00101100 5
\ 01011100 6
= 00111101 0
{ 01111011 1
< 00111100 2

लाइन ब्रेक को एक नई लाइन वर्ण के रूप में माना जाता है, इसलिए या तो स्थिति 1 या 3 में होगा।

— जेम्स होल्डरनेस
स्रोत

3

MATL , 17 बाइट्स

u"G91x@=zD91x@uRD

गिनती प्रदर्शित करता है, फिर संबंधित वर्ण, सभी न्यूलाइन-अलग। सबसे बड़ी कठिनाई है, @जो है 0b01000000; मुझे उम्मीद है कि मुझे इसके बिना करने का एक तरीका मिल सकता है।

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

स्पष्टीकरण:

u"  % Implicit input. Take (u)nique characters and loop (") over them.
G   % Take the input a(G)ain
91x % Filler: push 91, delete immediately.
@   % Push current character of loop
=   % Check for equality with earlier G
z   % Count number of equal characters
D   % Display
91x % More filler!
@   % Get loop character again
uR  % Filler: two NOPs for the single-character @
D   % Display. Implicitly end loop.

MATL, 15 बाइट्स (संदिग्ध आउटपुट)

यदि स्टैक पर केवल दो पंक्ति वैक्टर छोड़ने की अनुमति है ( इस मेटा पोस्ट के अनुसार कार्य-जैसा व्यवहार ), तो हम नीचे उतर सकते हैं

u"G91x@=zv]v!Gu

लेकिन यहां, आउटपुट काफी करीने से ऑर्डर नहीं किया गया है।

— Sanchises
स्रोत

स्टैक को स्पष्ट रूप से कार्यक्रम के अंत में मुद्रित किया जाता है और आउटपुट प्रारूप चुनौती के अनुसार लचीला होता है, इसलिए मुझे दूसरे दृष्टिकोण के साथ कोई समस्या नहीं

— दिखती है

@LuisMendo मुझे यकीन नहीं है। यदि आपके पास 90 अलग-अलग इनपुट वर्ण हैं, तो यह बताना कठिन होगा कि कौन सी कुंजी किस वर्ण की है, इसलिए मुझे लगता है कि मुझे उस एक Sanchises को ना कहना होगा। - Stewie ग्रिफिन 2 घंटे पहले एक प्रस्तावित संकर के जवाब (मायने रखता है अलग-अलग था D'घ, Guकार्यक्रम के अंत में), और मुझे यकीन है कि 15-बाइट संस्करण पर्याप्त अलग है अगर नहीं हूँ।

— सांचेस

@StewieGriffin शायद आप देख सकते हैं कि 15-बाइट संस्करण ( इसे ऑनलाइन आज़माएं! ) ठीक है या नहीं?

— Sanchises

यह सुनिश्चित नहीं है कि स्टीवी को इस पद पर पिंग मिलेगा, बेहतर चुनौती पद का उपयोग करें

— लुइस मेंडो

आपके बारे में नहीं जानते, लेकिन मुझे नहीं लगता कि यह आसानी से समझ में आता है :) मैं 17 बाइट समाधान पसंद करता हूं, लेकिन जवाब में 15 बाइट एक रखने के लिए स्वतंत्र महसूस करता हूं! वैसे उत्तर का अच्छा जवाब :)

— स्टिव ग्रिफ़िन

1

CJam, 14 बाइट्स

q__|_ @sfe=]zp

इसे यहाँ आज़माएँ।

ASCII कोड्स को आवश्यक पैटर्न के अनुकूल बनाने के लिए @और उसके sबाद के स्पेस को फिलर कैरेक्टर में डाला जाता है: स्पेस कुछ नहीं करता है, और sबस एक स्ट्रिंग को स्ट्रिंग में परिवर्तित करता है। इसके अलावा, यह चुनौती कार्य का एक बहुत सरल और सीधा कार्यान्वयन है:

q_ "इनपुट पढ़ें और इसकी एक प्रति बनाएं";
  _ | "प्रतिलिपि में दोहराए गए वर्णों को ध्वस्त करें";
    _ "ढह गई स्ट्रिंग की एक प्रति सहेजें";
      @ "मूल इनपुट स्ट्रिंग को स्टैक के शीर्ष पर खींचें";
       s "(यहाँ कुछ नहीं करता है)";
        fe = "ध्वस्त स्ट्रिंग में प्रत्येक वर्ण के लिए, गिनती ...";
                 "... मूल स्ट्रिंग में यह कई बार होता है";
           ] z "ध्वस्त स्ट्रिंग की सहेजी गई प्रतिलिपि के साथ मायने रखता है";
             पी "परिणाम का स्ट्रिंग प्रतिनिधित्व प्रिंट करें";

इनपुट के लिए foobar123, यह कोड आउटपुट करता है [['f 1] ['o 2] ['b 1] ['a 1] ['r 1] ['1 2] ['2 2] ['3 1]]। यदि बस एक लाइन पर और दूसरी पर संबंधित वर्णों को गिनता है, जैसे कि:

[1 2 1 1 1 2 2 1]
fobar123

एक स्वीकार्य आउटपुट प्रारूप माना जाता है, फिर ]zकुल 12 बाइट्स के लिए दो बाइट्स बचाने के लिए छोड़ा जा सकता है । हां, छोटा कोड अभी भी बिट पैटर्न की आवश्यकता को पूरा करेगा।

Ps। मैंने इस चुनौती के लिए एक साधारण स्रोत कोड चेकर भी लिखा । इनपुट के रूप में कोड की एक पंक्ति को देखते हुए, यह पहले उस रेखा को प्रतिध्वनित करेगा और उसके बाद प्रत्येक वर्ण के साथ उसी पंक्ति को प्रिंट करेगा ( n % 7) -इस ASCII बिट। यदि दूसरी पंक्ति सभी हैं, तो इनपुट मान्य है।

— इल्मरी करोनें
स्रोत

1

जेली , जेली के कोडपेज में 6 बाइट्स

ṢZṢṀŒr

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

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

बाइनरी प्रतिनिधित्व और स्पष्टीकरण:

  76543210 

। 1011011 1    इनपुट के वर्णों को क्रमबद्ध करें
Z 010110 1 0 सूची को स्थानांतरित करें (यह 1D है, इसलिए यह प्रभावी रूप से इसे सूची में लपेटता है)
-10110 1 11 सूची को क्रमबद्ध करें (अ-ऑप, क्योंकि इसमें केवल एक तत्व है)
Element 1100 1 000 सबसे बड़ा (केवल) तत्व लें
Œ 000 1 0011 दो-बाइट कमांड का पहला बाइट
आर 01 1 10010 रन-लंबाई एनकोड

यह देखा जा सकता है कि दूसरे, तीसरे और चौथे वर्ण एक दूसरे को रद्द कर देते हैं और केवल उसी बिट पैटर्न को बनाए रखने के लिए हैं जिनकी हमें आवश्यकता है। Œrहालाँकि यह बहुत सुविधाजनक है, हालाँकि, और प्रोग्राम को पेड करना ताकि हम इसका उपयोग कर सकें, शायद यह हमें एक छोटा प्रोग्राम देता है, जिसमें बिना बिल्ड किए समस्या को हल करने की कोशिश की जाती है।

अक्षरों को गिनें - बिट बाय!

Pyke, 1 6 बाइट्स

पायथ, 12 8 7 बाइट्स

Befunge-93, 150 बाइट्स

MATL , 17 बाइट्स

MATL, 15 बाइट्स (संदिग्ध आउटपुट)

CJam, 14 बाइट्स

जेली , जेली के कोडपेज में 6 बाइट्स