62

मैंने हाल ही में एक नई भाषा बनाई है जिसका नाम है ;#("अर्धविराम हैश") जिसमें केवल दो कमांड हैं:

; संचायक में एक जोड़ें

#127 से संचयकर्ता modulo, ASCII चरित्र और एक नई रेखा के बिना आउटपुट में कनवर्ट करें । इसके बाद, संचायक को 0. पर रीसेट करें, हाँ, 127 सही है।

किसी अन्य चरित्र की अनदेखी की जाती है। यह संचायक पर कोई प्रभाव नहीं पड़ता है और कुछ भी नहीं करना चाहिए।

आपका काम इस शक्तिशाली भाषा के लिए दुभाषिया बनाना है!

यह या तो एक पूर्ण कार्यक्रम या एक फ़ंक्शन होना चाहिए जो एक ;#प्रोग्राम को इनपुट के रूप में ले जाएगा और सही आउटपुट का उत्पादन करेगा।

उदाहरण

Output: Hello, World!
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Output: ;#
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Output: 2d{ (unprintable characters here; should have 4 `\000` bytes between the `d` and the `{` and 3 after the `{`)
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o

Output: Fizz Buzz output
Program: link below

Output: !
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

फिज बज़ 100 तक

code-golf interpreter

— केर्ड सिक्काहिरिंग
स्रोत

1

क्या यह स्वीकार्य है यदि कोई दुभाषिया इनपुट के अंत में अपने निष्पादन को समाप्त नहीं करता है, लेकिन इसके बजाय अतिरिक्त उत्पादन का उत्पादन किए बिना अनिश्चित काल तक लूप करता रहता है?

— सिंह

5

दूसरा उदाहरण मुझे एक कार्यक्रम के बारे में आश्चर्यचकित करता है कि एक कार्यक्रम का उत्पादन करने के लिए सांकेतिक शब्दों में बदलना ... पुनरावर्ती संकलन!

— frarugi87

@ लियो हाँ यह ठीक है

— caird coinheringaahing

1

@iamnotmaynard सेमीकोलन हैश

— 17'17 को caird coinheringaahing

2

शायद विंक हैश कहना आसान होगा

— जेम्स वाल्डबी - jwpat7

20

पायथन 3 , 69 68 बाइट्स

-बेटेवहाइडग्राउंड के लिए -1 बाइट

i=0
for c in input():
 i+=c==';'
 if'#'==c:print(end=chr(i%127));i=0

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

— OVS
स्रोत

1

आप एक बाइट को उल्टा करके बचा सकते हैं if। इसे ऑनलाइन आज़माएं!

— गेहूं जादूगर

17

जावास्क्रिप्ट (ईएस 6), 76 82 80 बाइट्स

s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)

डेमो

कोड स्निपेट दिखाएं

let f =

s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)

console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))

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

पुनरावर्ती संस्करण, 82 77 बाइट्स

नील को धन्यवाद देकर 5 बाइट्स बचाए

यह फ़िज़ बज़ उदाहरण जैसे बड़े इनपुट के लिए क्रैश होने की संभावना है।

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""

— Arnauld
स्रोत

मुझे लगता है कि f(s,a+(c==';'))आपके पुनरावर्ती संस्करण से तीन बाइट्स दस्तक दे सकते हैं।

— नील

@ नील यह वास्तव में 5 बाइट्स बचाता है। :-)

— Arnauld

मैं अब वास्तव में मूर्खतापूर्ण महसूस करता हूं। मेरे पास मूल रूप से एक छोटी गाड़ी संस्करण था, और बग को ठीक करने के लिए 2 बाइट्स घटाया गया था। लेकिन मैंने गर्भपात कर दिया था और छोटी गाड़ी के संस्करण ने वास्तव में 7 बाइट्स बचाए ...

— नील

12

रेटिना , 336 63 67 65 66 62 59 बाइट्स

T`;#-ÿ`¯_
;{127}|;+$

(^|¯)
¯
+T`-~`_-`[^¯]
T\`¯`

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

काल्पनिक भागने के सिंटैक्स का उपयोग कर पठनीय संस्करण :

T`;#\x01-ÿ`\x01¯_
;{127}|;+$

(^|¯)\x01\x01
¯\x02
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
T\`¯`

NUL बाइट्स को प्रिंट नहीं करता है, क्योंकि TIO उन्हें सोर्स कोड में अनुमति नहीं देता है। इसके अलावा अंत में एक अतिरिक्त newline प्रिंट करता है, लेकिन मुझे लगता है कि यह अन्यथा नहीं कर सकता। अनुगामी न्यूलाइन ने @Leo को धन्यवाद को दबा दिया ।

-273 (!) @ETHproductions के लिए धन्यवाद बाइट्स ।

-2 बाइट्स थैंक्स टू @ovs ।

-3 बाइट्स @Neil की बदौलत । उनके अद्भुत 34-बाइट समाधान की जाँच करें ।

— eush77
स्रोत

1

ओह मेरे शब्द। लेकिन क्या आप एक हजार बाइट्स नहीं बचा सकते हैं +T`\x01-~`_\x03-\x7f`[^\x01¯]\x01? (एकल वर्णों के रूप में

— unprintables

@ETHproductions बेशक आप कर सकते हैं। धन्यवाद! :)

— eush77

1

वर्तमान में अंतिम पत्र हमेशा आउटपुट में होता है, भले ही #इनपुट में कोई अनुगामी न हो । आप करने के लिए अपने दूसरे चरण को बदलकर इसे ठीक कर सकते हैं(;{127}|;+$)

— OVS

1

क्या आपको तीसरी पंक्ति पर + `की आवश्यकता है? जैसा कि आप पूरे मैच को हटाते हैं, दूसरे पुनरावृत्ति में बदलने के लिए कुछ भी नहीं होना चाहिए।

— ओव्स

1

मुझे लगता है कि मैं इसे 34 बाइट्स में कर सकता हूं: T`;#\x01-ÿ`\x80\x7F_ \x80+$(खाली लाइन) \+T`\x7Fo`\x01-\x80_`\x80[^\x80](हेक्साडेसिमल का उपयोग करके unprintables का प्रतिनिधित्व करने के लिए पलायन)। आउटपुट nulls के बजाय \ x7F।

— नील

12

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

s->{int i=0;for(byte b:s.getBytes()){if(b==59)i++;if(b==35){System.out.print((char)(i%127));i=0;}}};

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

— मास
स्रोत

3

साइट पर आपका स्वागत है! :)

— DJMcMayhem

मैंने आपके लिए FizzBuzz उदाहरण के साथ एक ऑनलाइन दुभाषिया के लिए एक लिंक जोड़ा (लिंक पाठ एक टिप्पणी में फिट होने के लिए बहुत लंबा था)

— जोनाथन एलन

जावा अपने कार्यक्रमों के लिए UTF-16 का उपयोग करता है । तो, ये 100 बाइट नहीं बल्कि 100 अक्षर हैं ।

— गेरोल्ड ब्रोसर

5

@GeroldBroser यूनिकोड एक वर्ण सेट है: UTF-8 और UTF-16 उस वर्ण सेट के दो एन्कोडिंग हैं । ASCII स्रोत जावा प्रोग्राम के रूप में पूरी तरह से मान्य है, और मेरे पास बहुत सारे जावा स्रोत फ़ाइलें हैं जो ASCII में एन्कोडेड हैं (जो कि UTF-8 भी मान्य है, इसलिए एक यूनिकोड एन्कोडिंग भी है)।

1

पूरी तरह से गोल्फ, 81 बाइट्स के लिए एक के रूप में Consumer<char[]>:s->{char i=0;for(int b:s){if(b==59)i++;if(b==35){System.out.print(i%=127);i=0;}}}

— ओलिवियर

11

जाप , 18 बाइट्स

®è'; %# d}'# ë ¯J

इसके बाद एक unprintable \ x7f char है %#। इसे ऑनलाइन टेस्ट करें!

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

®   è'; %#   d}'# ë ¯  J
mZ{Zè'; %127 d}'# ë s0,J
                         // Implicit: operate on input string
mZ{           }'#        // Split the input at '#'s, and map each item Z to
   Zè';                  //   the number of semicolons in Z,
        %127             //   mod 127,
             d           //   turned into a character.
m              '#        // Rejoin the list on '#'. At this point the Hello, World! example
                         // would be "H#e#l#l#o#,# #W#o#r#l#d#!#" plus an null byte.
                  ë      // Take every other character. Eliminates the unnecessary '#'s. 
                    ¯J   // Slice off the trailing byte (could be anything if there are
                         // semicolons after the last '#').
                         // Implicit: output result of last expression

— ETHproductions
स्रोत

1

डी'ओह, जवाब की जाँच करनी चाहिए थी! केवल इस पर कुछ समय बिताया है ताकि आप पा सकें कि मुझे पंच मारना है। q'# ®è'; u# dÃ¬¯Jउसी स्कोर के लिए भी काम करता है।

— झबरा

11

पायथन , 65 बाइट्स

यह इस पहले के जवाब का एक गोल्फ है ।

lambda t:''.join(chr(x.count(';')%127)for x in t.split('#')[:-1])

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

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

व्याख्या

यह एक बहुत सीधा सा जवाब है जो हम निर्धारित करते हैं कि ;प्रत्येक के बीच कितने s हैं #और chrmod 127 को प्रिंट करते हैं । केवल एक चीज जो थोड़ी अजीब हो सकती है वह है [:-1]। हमें अंतिम समूह को छोड़ने की आवश्यकता है क्योंकि इसके #बाद कोई नहीं होगा ।

उदाहरण के लिए

;;#;;;;#;;;;;#;;;

में विभाजित किया जाएगा

[';;',';;;;',';;;;;',';;;']

लेकिन हम अंतिम नहीं चाहते हैं ;;;क्योंकि #मूल्य को प्रिंट करने के लिए इसके बाद कोई नहीं है ।

— गेहूं का जादूगर
स्रोत

1

मैं एक टीआईओ लिंक में सभी परीक्षण प्राप्त करने की कोशिश में व्यस्त था। सिवाय chr के लिए chr था tऔर x।

— जोनाथन एलन

9

> <> , 35 बाइट्स

>i:0(?;:'#'=?v';'=?0
^   [0o%'␡'l~<

इसे ऑनलाइन आज़माएं! ␡0x7F, ^?या "हटाएं" से बदलें ।

मुख्य घेरा

>i:0(?;:'#'=?v      
^            <

यह इनपुट का एक वर्ण लेता है ( i), यह जाँचता है कि क्या यह शून्य से कम यानी ईओएफ ( :0() है और यदि यह है तो प्रोग्राम समाप्त कर देता है ?;। अन्यथा, जांचें कि क्या इनपुट #( :'#'=) के बराबर है । यदि यह है, शाखा नीचे और लूप ( ?v... ^ ... <) को पुनरारंभ करें ।

काउंटर तर्क

              ';'=?0

जांचें कि इनपुट इनपुट ;( ';'=) के बराबर है या नहीं । यदि यह है, तो धक्का 0। नहीं तो कुछ न करें। यह मुख्य लूप को पुनरारंभ करता है।

मुद्रण तर्क

>       '#'=?v      
^   [0o%'␡'l~<

जब इनपुट वर्ण होता है #, तो स्टैक से इनपुट पॉप करें ( ~), स्टैक पर सदस्यों की संख्या प्राप्त करें ( l), 127 ( '␡') पुश करें , और मापांक ( %) लें। फिर, इसे एक चरित्र के रूप में आउटपुट करें ( o) और एक नया स्टैक शुरू करें ( [0)। यह काउंटर को "शून्य" करता है। फिर, लूप पुनरारंभ होता है।

— कोनोर ओ ब्रायन
स्रोत

3

गरीब> <>। यह दुखद है :0(:(

— caird coinheringaahing

9

पायथन 3, 69 बाइट्स

बेहतर हुआ, @heat विज़ार्ड, @Uriel को धन्यवाद

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))

— MrGeek
स्रोत

3

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यहाँ उद्देश्य कोड को यथासंभव कम (बाइट्स में) बनाना है, इसलिए आपको बाइट काउंट को हेडर में शामिल करना होगा :)।

— अदनान

समझाने के लिए धन्यवाद, पता नहीं था। मैं उस पर काम करूंगा।

— MrGeek

2

आप :s के बाद स्पेस हटा सकते हैं ।

— पावेल

1

मैं 74 बाइट्स गिनता हूं। tio.run/nexus/…

— डेनिस

2

इसके अलावा, ';'==cएक स्थान बचाता है, लेकिन ifबयानों का उपयोग न करना भी कम होगा।

— डेनिस

9

रोड़ा , 44 39 38 बाइट्स

5 बाइट्स @fergusq की बदौलत बच गए

{(_/`#`)|{|d|d~="[^;]",""chr #d%127}_}

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

अनाम फ़ंक्शन जो स्ट्रीम से इनपुट लेता है।

यदि अन्य पात्रों को नजरअंदाज नहीं करना है, तो मुझे यह मिलता है:

रोड़ा , 20 बाइट्स

{(_/`#`)|chr #_%127}

— क्रिक्टी लिथोस
स्रोत

8

रूबी, 41 35 34 अक्षर

( 40 34 33 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प)

gsub(/.*?#/){putc$&.count ?;%127}

करने के लिए धन्यवाद:

(6 वर्णों) के putcसाथ स्पष्ट रूपांतरण की आवश्यकता नहीं करने का सुझाव देने के लिए जॉर्डन.chr
अनावश्यक कोष्ठक (1 वर्ण) खोजने के लिए किरिल एल।

नमूना रन:

bash-4.4$ ruby -ne 'gsub(/.*?#/){putc$&.count ?;%127}' < '2d{.;#' | od -tad1
0000000    2  etb    d  nul  nul  nul  nul    {  nul  nul  nul
          50   23  100    0    0    0    0  123    0    0    0
0000013

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

— आदमी काम पर है
स्रोत

रवींद्र। हालांकि मैंने अपने शुरुआती वर्षों में सी किया, मैं पूरी तरह से भूल गया putc()। धन्यवाद, @ जोर्डन

— मैनटवर्क

1

मेरे खुद के आश्चर्य के लिए, आप वास्तव में एक बाइट

— Kirill L.

अच्छा कैच, @KirillL।, धन्यवाद।

— manatwork

7

05AB1E , 16 15 14 बाइट्स

कोड:

'#¡¨ʒ';¢127%ç?

व्याख्या:

'#¡              # Split on hashtags
   ¨             # Remove the last element
    ʒ            # For each element (actually a hacky way, since this is a filter)
     ';¢         #   Count the number of occurences of ';'
        127%     #   Modulo by 127
            ç    #   Convert to char
             ?   #   Pop and print without a newline

05AB1E -encoding का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

7

जेली , 13 बाइट्स

ṣ”#Ṗċ€”;%127Ọ

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

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

ṣ”#Ṗċ€”;%127Ọ  Main link. Argument: s (string)

ṣ”#            Split s at hashes.
   Ṗ           Pop; remove the last chunk.
    ċ€”;       Count the semicola in each chunk.
        %127   Take the counts modulo 127.
            Ọ  Unordinal; cast integers to characters.

— डेनिस
स्रोत

1

यह शब्द semicolaमौजूद नहीं है semicolons।

— आउटगोल्फ

@EriktheOutgolfer en.m.wiktionary.org/wiki/semicola

— डेनिस

हम्म, अजीब शब्द।

— आउटगोल्फ

@EriktheOutgolfer विक्षनरी पर कोई व्यक्ति शायद लैटिन बहुवचन को अंग्रेजी में मान्य बनाने की कोशिश कर रहा था , लेकिन कोला और अर्धविराम वर्तनी का आरोप लगाया जाना चाहिए।

— कोयूर

7

MS-DOS पर x86 मशीन कोड - 29 बाइट्स

00000000  31 d2 b4 01 cd 21 73 01  c3 3c 3b 75 06 42 80 fa  |1....!s..<;u.B..|
00000010  7f 74 ed 3c 23 75 eb b4  02 cd 21 eb e3           |.t.<#u....!..|
0000001d

टिप्पणी विधानसभा:

bits 16
org 100h

start:
    xor dx,dx       ; reset dx (used as accumulator)
readch:
    mov ah,1
    int 21h         ; read character
    jnc semicolon
    ret             ; quit if EOF
semicolon:
    cmp al,';'      ; is it a semicolon?
    jne hash        ; if not, skip to next check
    inc dx          ; increment accumulator
    cmp dl,127      ; if we get to 127, reset it; this saves us the
    je start        ; hassle to perform the modulo when handling #
hash:
    cmp al,'#'      ; is it a hash?
    jne readch      ; if not, skip back to character read
    mov ah,2        ; print dl (it was choosen as accumulator exactly
    int 21h         ; because it's the easiest register to print)
    jmp start       ; reset the accumulator and go on reading

— माटेओ इटालिया
स्रोत

6

05AB1E , 25 21 19 बाइट्स

-2 बाइट्स अदनान को धन्यवाद

Îvy';Q+y'#Qi127%ç?0

व्याख्या:

Î                       Initialise stack with 0 and then push input
 v                      For each character
  y';Q+                 If equal to ';', then increment top of stack
       y'#Qi            If equal to '#', then
            127%        Modulo top of stack with 127
                ç       Convert to character
                 ?      Print without newline
                  0     Push a 0 to initialise the stack for the next print

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

— Okx
स्रोत

1

मुझे लगता है कि आप की जगह ले सकता i>}से +।

— अदनान

6

रेटिना , 34 बाइट्स

T`;#-ÿ`_
\+T`o`-_`[^]|$

इसे ऑनलाइन आज़माएं! टेस्ट केस शामिल है। संपादित करें: @MartinEnder की कुछ मदद से 2 बाइट्स सहेजे गए। नोट: कोड में unprintables शामिल हैं, और &#x;कोड का उपयोग करने से गलत परिणाम उत्पन्न होते हैं क्योंकि ब्राउज़र ISO-8859-1 के बजाय Windows-1252 का उपयोग करता है। स्पष्टीकरण: पहली पंक्ति इनपुट को साफ: ;करने के लिए बदल गया है \x80, #के लिए \x7F(कारण TIO सीमाओं) और बाकी सब कुछ नष्ट कर दिया है। फिर जब भी हम देखते हैं \x80कि एक दूसरे से पहले नहीं है \x80, हम इसे हटा देते हैं और किसी भी अगले चरित्र के कोड को बढ़ाते हैं। यह तब तक पुनरावृत्त होता है जब तक कि अधिक \x80वर्ण शेष न हों। मूल कोड जो अशक्त बाइट्स का समर्थन करता है, मूल रूप से अप्रतिबंधित बाइट्स से 1 को घटाता है, पहली पंक्ति को छोड़कर जहां \xFFअनसोल्ड है और \x7Fबन जाता है\x00। पठनीयता के लिए पलायन के साथ:

T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$

— नील
स्रोत

आप अंतिम चरण के साथ अंतिम दो चरणों को जोड़कर एक बाइट बचा सकते हैं \x80([^\x80]|$)।

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

@MartinEnder धन्यवाद! अनायास, \s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?केवल एक बाइट भी बचाता है।

— नील

आह, लेकिन [^\x80]|\x80$दो बाइट्स बचाता है, मुझे लगता है।

— नील

आह अच्छा, पिछले एक काम करता है। मैंने भी नकारात्मक रूप देखने की कोशिश की थी, लेकिन sयह कष्टप्रद है।

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

6

आर, 97 90 86 84 बाइट्स

एक समारोह:

function(s)for(i in utf8ToInt(s)){F=F+(i==59);if(i==35){cat(intToUtf8(F%%127));F=0}}

जब आर शुरू होता है, तो Fइसे FALSE(संख्यात्मक 0) के रूप में परिभाषित किया जाता है ।

Ungolfed:

function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }

— स्वेन होहेंस्टीन
स्रोत

यह R + pryr नहीं होना चाहिए?

— L3viathan

@ L3viathan चूंकि pryrR पैकेज है, यह अभी भी R कोड है।

— स्वेन होइनस्टीन

यह आर कोड है, लेकिन इसके लिए एक अतिरिक्त पुस्तकालय की स्थापना की आवश्यकता है।

— L3viathan

@ L3viathan क्या आपको लगता है कि मेरा उत्तर अमान्य है? क्या मुझे अतिरिक्त पैकेज का उपयोग करने से बचना चाहिए?

— स्वेन होइनस्टीन

2

@BLT कोई अंतर नहीं है। मेरी राय में चुनौती से पहले बनाए गए अतिरिक्त पैकेजों का उपयोग करना कोई समस्या नहीं है । यह सभी भाषाओं के लिए सही है। पायथन में आपको importR में उपयोग करना होगा जबकि आप ::सीधे पैकेज में फ़ंक्शन का उपयोग कर सकते हैं । आप अक्सर यहां अतिरिक्त पैकेजों का उपयोग देख सकते हैं (जैसे, पायथन और जावा के लिए)। हालाँकि, मैंने अपनी पूर्व पोस्ट बदल दी क्योंकि मैं चर्चा में शामिल नहीं होना चाहता।

— स्वेन होइनस्टीन

5

पायथन, 82 बाइट्स

lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])

— Uriel
स्रोत

1

@WheatWizard जब से आप पहले से ही इसे एक जवाब के रूप में पोस्ट करते हैं, मेरा मानना है कि मेरे लिए सही कार्रवाई अपडेट के बजाय इसे अपडेट करना होगी

— यूरिल

4

सादा टीएक्स, 156 बाइट्स

\newcount\a\def\;{\advance\a by 1\ifnum\a=127\a=0\fi}\def\#{\message{\the\a}\a=0}\catcode`;=13\catcode35=13\let;=\;\let#=\#\loop\read16 to\>\>\iftrue\repeat

पठनीय

\newcount\a

\def\;{
  \advance\a by 1
  \ifnum \a=127 \a=0 \fi
}
\def\#{
  \message{\the\a}
  \a=0
}

\catcode`;=13
\catcode35=13

\let;=\;
\let#=\#

\loop
  \read16 to \> \>
  \iftrue \repeat

— Uriel
स्रोत

क्या यह पात्रों को प्रतीकात्मक रूप से मुद्रित कर सकता है?

— eush77

4

सी (जीसीसी) , 58 बाइट्स

a;f(char*s){a+=*s^35?*s==59:-putchar(a%127);a=*s&&f(s+1);}

इसे ऑनलाइन आज़माएं! (संकेत: इसे ढहाने के लिए : पाद क्लिक करें ।)

— डेनिस
स्रोत

4

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

$_=chr(y%;%%%127)x/#/

perl -043pe( perl -eमानक के रूप में 4 बाइट्स के रूप में गिना जाता है) के साथ चलाएं ।

स्पष्टीकरण: -043लाइन-टर्मिनेटर को #(ASCII 043) सेट करता है । -pइनपुट "लाइनों" (वास्तव में # -delimited स्ट्रिंग्स, अब) पर पुनरावृत्तियों। प्रत्येक "लाइन" में y%;%%संख्या की गणना करता है ;। x/#/यह सुनिश्चित करता है कि हम उन प्रोग्रामों के लिए एक अतिरिक्त वर्ण प्रिंट नहीं करते हैं जो # (तीसरे टेस्टकेस की तरह) समाप्त नहीं होते हैं। %127स्पष्ट रूप से स्पष्ट होना चाहिए। $_=सामान्य बायलरप्लेट है।

— साँवला
स्रोत

एक को प्रभावित करना, हालांकि गड़बड़ है: इसके लिए ;;#;;;# 2 के बजाय # 5 आउटपुट देता है।

— मैनटवर्क

आपको यह परिणाम कैसे मिला? मेरी मशीन पर echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxdसही ढंग से आउटपुट 00000000: 02। यदि आपने छोड़ दिया है 043, या एक कोडपेज का उपयोग कर रहे हैं जहां #ASCII 043 नहीं है, तो यह आपके परिणाम की व्याख्या करेगा।

— ग्रिम

1

उफ़। क्षमा करें, मेरे परीक्षण में एक टाइपो था। आपका कोड पूरी तरह से काम करता है।

— मैनटवर्क

4

सीजेएम, 27 बाइट्स

0q{";#"#") 127%co0 "S/=~}%;

व्याख्या:

0                            e# Push 0
 q                           e# Push the input
  {                          e# For each character in the input:
   ";#"#                     e#   Index of character in ";#", -1 if not found
        ") 127%co0 "S/       e#   Push this string, split on spaces
                      =      e#   Array access (-1 is the last element)
                       ~     e#   Execute as CJam code. ")" increments the accumulator,
                             e#     and "127%co0" preforms modulo by 127, converts to character, pops and outputs, and then pushes 0.
                        }%   e# End for
                          ;  e# Delete the accumulator

वैकल्पिक समाधान, 18 बाइट्स

q'#/);{';e=127%c}%

व्याख्या:

q                   e# Read the whole input
 '#/                e# Split on '#'
    );              e# Delete the last element
      {             e# For each element:
       ';e=         e#   Count number of ';' in string
           127%     e#   Modulo by 127
               c    e#   Convert to character code
                }%  e# End for

— फल तोड़ना
स्रोत

व्यावसायिक बिल्ली जो अमान्य वर्णों को अनदेखा नहीं करती है।

— एगलैंगिंग फ्रूट

आपको ;संचायक को हटाने की आवश्यकता क्यों है ?

— केयर्ड सिक्काहिंगाहिंग

@RandomUser तो यह अंत में स्ट्रिंग के साथ आउटपुट प्राप्त नहीं करता है।

— ETHproductions

4

एफ #, 79 91 93 बाइट्स

let rec r a=function|[]->()|';'::t->r(a+1)t|'#'::t->printf"%c"(char(a%127));r 0 t|_::y->r a y

Ungolfed

let rec run acc = function
    | [] -> ()
    | ';'::xs ->
        run (acc + 1) xs
    | '#'::xs ->
        printf "%c" (char(acc % 127))
        run 0 xs
    | x::xs -> run acc xs

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

संपादित करें: ';' जैसा '#'। इसे बदल दिया ताकि यह अमान्य वर्णों को अनदेखा कर दे।

विकल्प

एफ #, 107 104 बाइट्स

let r i=
 let a=ref 0
 [for c in i do c|>function|';'->a:=!a+1|'#'->printf"%c"(!a%127|>char);a:=0|_->()]

संदर्भ सेल का उपयोग 3 बाइट्स बचाता है

Ungolfed

let run i =
    let a = ref 0;
    [for c in i do
        match c with
        | ';' -> a := !a + 1
        | '#' ->
            printf "%c" (char(!a % 127))
            a := 0
        |_->()
    ]

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

— ब्रूनर
स्रोत

4

प्रसंस्करण .js (खानकैमी संस्करण), 118 बाइट्स

var n="",a=0;for(var i=0;i<n.length;i++){if(n[i]===";"){a++;}if(n[i]==="#"){println(String.fromCharCode(a%127));a=0;}}

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

जैसा कि उपयोग किए गए प्रसंस्करण के संस्करण में कोई इनपुट विधि नहीं है इनपुट n में रखा गया है।

— क्रिस्टोफर
स्रोत

आप तकनीकी रूप से अपनी स्वयं की इनपुट पद्धति को बना सकते हैं keyTyped=function(){ ... }: P

— ETHproductions

@ETHproductions यह घृणा का एक रूप है।

— क्रिस्टोफर

@RandomUser याय! मैंने यह कर दिया है! मैं प्रसंस्करण में जवाब देना पसंद करता हूं (मेरे उत्तरों की जांच करें)

— क्रिस्टोफर

2

@RandomUser न केवल 1000 प्रतिनिधि .. बल्कि 2 ^ 10 प्रतिनिधि (͜ʖ ° ͡) °)

ओह @Midnightas हाँ

— क्रिस्टोफर

4

भूलभुलैया , 61 47 बाइट्स

_36},)@
;    {
; 42_-
"#-  1
_ ; 72
_ ) %
"""".

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

व्याख्या

कोड निष्पादन शीर्ष बाएं कोने में शुरू होता है और पहला अर्धविराम स्टैक से एक निहित शून्य को हटाता है और दाईं ओर जारी रहता है।

संतरा

_36स्टैक पर 36 को धक्का देता है। यह इनपुट की तुलना करने के लिए है#
} स्टैक के शीर्ष को द्वितीयक स्टैक में ले जाता है
, स्टैक पर वर्ण के पूर्णांक मान को धकेलता है
)स्टैक को बढ़ाता है (यदि यह इनपुट का अंत है, तो इससे स्टैक 0 हो जाएगा और प्रोग्राम का प्रवाह आगे @निकल जाएगा)
{ प्राथमिक स्टैक के शीर्ष पर द्वितीयक स्टैक का शीर्ष ले जाता है
-पॉप वाई, पॉप एक्स, पुश एक्स - वाई। यह इनपुट #(ascii में 35) के साथ तुलना करने के लिए है । यदि इनपुट था #, तो कोड बैंगनी अनुभाग के लिए जारी रहेगा (क्योंकि स्टैक के शीर्ष 0 है आईपी उस दिशा में जारी है जो पहले चल रहा था), अन्यथा यह हरे रंग के अनुभाग में जारी रहेगा।

बैंगनी

127 स्टैक करने के लिए 127 धक्का
% पॉप x, पॉप y, x% y पुश करें
. एक चरित्र के रूप में स्टैक (संचायक) और आउटपुट के शीर्ष पर पॉप करें

यहां से ग्रे कोड हमें प्रोग्राम के ऊपरी बाएं कोने में ले जाता है, जिसमें स्टैक पर कुछ भी नहीं है।

हरा

_24 स्टैक पर 24 धक्का
-पॉप x, पॉप y, xy पुश करें। 24 अंतर है #और ;इसलिए यह जांचता है कि क्या इनपुट था ;। यदि यह था ;कोड सीधे की ओर जारी है )। अन्यथा यह #स्टैक की ऊंचाई को धक्का देगा (हमेशा एक सकारात्मक संख्या, प्रोग्राम को अगले चौराहे पर दाएं मुड़ने के लिए मजबूर करता है और कोड को याद करता है जो संचायक को बढ़ाता है)
; ढेर के ऊपर छोड़ दें
) स्टैक के शीर्ष में वृद्धि जो या तो एक अंतर्निहित शून्य है या यह उत्पादन के लिए संचयकर्ता के रूप में पहले से वृद्धि की गई शून्य अभिनय है

यहां से ग्रे कोड हमें प्रोग्राम के शीर्ष बाएं कोने में ले जाता है, जिसमें केवल संचयकर्ता होता है।

धूसर

उद्धरण नो-ऑप्स हैं, _स्टैक के लिए 0 को धक्का ;देता है , और स्टैक के शीर्ष को जोड़ता है। यह सब सही तरीके से नियंत्रण-प्रवाह को बाध्य करने और ढेर के ऊपर से अतिरिक्त कुछ भी छोड़ने के लिए बस कोड है।

— रॉबर्ट हिकमैन
स्रोत

जिज्ञासा से बाहर, आपने स्पष्टीकरण छवि कैसे उत्पन्न की? क्या आपने इसे खुद बनाया है?

— स्टेफनोच

2

@Stefnotch, मैंने प्रत्येक कैरेक्टर के बीच टैब लगाने के लिए एक टेक्स्ट एडिटर का उपयोग किया और फिर कोड को Microsoft Excel में पेस्ट किया जिसने प्रत्येक कैरेक्टर को अपने सेल में डाल दिया। मैंने उन्हें समान चौड़ाई और ऊंचाई देने के लिए सभी कोशिकाओं का चयन किया। फिर मैंने रंगों और सीमाओं को समायोजित किया और स्क्रीनशॉट लिया।

— रॉबर्ट हिकमैन

3

MATL , 29 बाइट्स

';#'&mXz!"@o?T}vn127\c&YD]]vx

इनपुट एकल उद्धरण में संलग्न एक स्ट्रिंग है।

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

FizzBuzz कार्यक्रम ऑनलाइन दुभाषियों के लिए बहुत लंबा है; इस gif में ऑफ़लाइन काम करते देखें:

व्याख्या

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

';#'       % Push this string
&m         % Input string (implicit). Pushes row vector array of the same size with 
           % entries 1, 2 or 0 for chars equal to ';', '#' or others, respectively
Xz         % Remove zeros. Gives a column vector
!          % Transpose into a row vector
"          % For each entry
  @        %   Push current entry
  o?       %   If odd
    T      %     Push true. This increases the accumulator (number of stack elements)
  }        %   Else
    v      %     Concatenate stack into a column vector
    n      %     Number of elements
    127\   %     Modulo 127
    c      %     Convert to char
    &YD    %     Display immediately without newline
  ]        %   End
]          % End
vx         % Concatenate stack and delete. This avoids implicit display

— लुइस मेंडो
स्रोत

3

ऐलिस , 22 बाइट्स

I!?';-n+?h$'@u%?'#-n$O

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

व्याख्या

हम ढेर का केवल एक ही काउंटर पर रखते हैं कि ;हमने कितने का सामना किया है। जब स्टैक खाली होता है (उदाहरण के लिए कार्यक्रम की शुरुआत में) तो यह एक 0 होता है।

I!?';-n+?h$'@u%?'#-n$O
I                      Push codepoint of next char from input
 !?                    store it on the tape and reload it right away
   ';-n+               add 1 to the counter if this char is a semicolon,
                       0 otherwise
        ?h$'           If the input char was -1 (EOF) execute the next command,
                       otherwise push its codepoint
            @          Terminate the program (or push 64)
             u         Set all bits up to the most significant as equal to 1
                       this turns 64 (1000000b) into 127 (1111111b)
              %        Compute modulo
               ?       reload the input char from the tape
                '#-n$O if it is a hash, pop the counter and print
                       the corresponding character
                       wrap back to the start of the line

इस कार्यक्रम का एक छोटा, लेकिन गैर-समाप्ति वाला संस्करण यहां पाया जा सकता है ।

— सिंह
स्रोत

यहां

— '15:00 पर caird coinheringaahing

खराब फॉर्मेटिंग के लिए क्षमा करें, मैंने इसे अपने फोन से पोस्ट किया है, जैसे ही मैं अपने हाथों को एक पीसी पर प्राप्त करूंगा, ठीक कर दूंगा

— लियो

जब तक अन्यथा चुनौती में निर्दिष्ट नहीं किया जाता है तब तक कार्यक्रमों को समाप्त करना होगा।

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

आप ~hहालांकि एक शाब्दिक 0x7F का उपयोग करके बाइट को बचा सकते हैं ।

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

@MartinEnder ने इसे समाप्त कर दिया। मैं कोड में 0x7F सम्मिलित करने का प्रबंधन नहीं कर सका, लेकिन मुझे लगता है कि यह वैकल्पिक संशोधन वैसे भी अधिक दिलचस्प है :)

— Leo

3

जेएस (ईएस 6), 97 92 बाइट्स

c=>(a=0,y="",c.split``.map(x=>x=="#"?(a%=127,y+=String.fromCharCode(a),a=0):x==";"?a++:0),y)

शैगी के उत्तर की तुलना में एक अलग दृष्टिकोण लेने की कोशिश की । ओह अच्छा।

3

; # + , 59 बाइट्स, नॉनकंपेटिंग

इस चुनौती के बाद भाषा बनाई गई।

;;;;;~+++++++>~;~++++:>*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)

इसे ऑनलाइन आज़माएं! इनपुट को शून्य बाइट के साथ समाप्त किया जाता है।

व्याख्या

पीढ़ी मेरी पीढ़ी से समान है ; # कोड उत्तर । यहाँ एकमात्र अंतर पुनरावृति का है।

यात्रा

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   take input while != 0
  ~                                    swap
   <                                   read value from memory (;)
    :                                  move forward to the accumulator memory spot (AMS)
     -                                 flip Δ
      +                                subtract two accumulators into A
       !                               flip A (0 -> 1, else -> 0)
        (     (;))                     if A is nonzero, or, if A == ';'
         <                             read from AMS
          -;-                          increment
             >                         write to AMS
                  ::                   move to cell 0 (#)
                    <                  read value from memory (#)
                     +                 subtract two accumulators into A
                      -                flip Δ
                       ::              move to AMS
                         !(   )        if A == '#'
                           <           read from AMS
                            #          output mod 127, and clear
                             >         write to AMS
                               -:-     move back to initial cell

— कोनोर ओ ब्रायन
स्रोत

3

बैश + कोरुटिल्स, 46 39 बाइट्स

tr -dc \;#|sed 'y/;/1/;s/#/.ZC7%P/g'|dc

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

व्याख्या

(धन्यवाद गाय -7 बाइट्स के लिए बोली!)

trभाग को हटा सभी असंगत वर्णों (मैं इस डाल सकता है sedठीक उसी bytecount के लिए है, लेकिन फिर यह linefeed चरित्र सही ढंग से संभाल नहीं करता, क्योंकि sedउन में छोड़ देता है और dcकेवल के साथ पहली linefeed अप करने के लिए हो जाता है ?)

sedबाकी काम करता है और एक dcकार्यक्रम बनाता है :

के तार ;की बन तार 1(एक लंबे शाब्दिक)

#बन जाता है .ZC7%P(यदि यह एक स्ट्रिंग का अनुसरण करता है 1, .एक नो-ऑप के लिए एक दशमलव बिंदु है। लेकिन अगर यह प्रोग्राम की शुरुआत में है, या किसी अन्य का अनुसरण कर रहा है #, 0तो यह शाब्दिक है । फिर यह संख्या की लंबाई लेता है, इसे मॉड करता है, और इसी ASCII प्रिंट करता है।)

— सोफिया लेचनर
स्रोत

आप से बचने के लिए की जरूरत नहीं है ;के अंदर '...'और बस को बदल सकते हैं dc -ez?करने के लिए dc। इसके अलावा, ;स्टैक में 1 जोड़ने के बजाय , आप उन्हें एक साथ समूहित कर सकते हैं और Zइस tio.run/##S0oszvj/… तक पहुंचने के लिए उनकी लंबाई प्राप्त कर सकते हैं ।

— कृति लीथोस

@Cowsquack यह अच्छा है, धन्यवाद! (और dc -ez?कार्यक्रम शुरू करने के लिए एक अतिरिक्त शून्य की आवश्यकता का एक परिणाम था) लेकिन आपका कार्यक्रम stderrलगातार #या इनपुट के मामलों में अतिरिक्त आउटपुट जोड़ता है जो समाप्त नहीं होता है #(दोनों मामलों में, मेरा मतलब है कि बाहरी वर्ण हटा दिए जाने के बाद) । मुझे नहीं पता कि क्या कोई सहमति है, लेकिन मुझे लगता है कि अतिरिक्त आउटपुट समाधान को अमान्य कर देता है। हालांकि, मैंने आपके विचार को अनुकूलित कर दिया, और dcत्रुटियों को फेंकने के बिना आपके सुझाव से अधिक केवल एक बाइट पर घाव कर दिया !

— सोफिया लेचनर

के अनुसार इस stderr जब तक चुनौती स्पष्ट रूप से इस तरह के रूप में कहा गया है अनदेखा किया जा सकता है, ताकि डीसी के लिए बहुत आसान है। यह भी ध्यान रखें कि यह वर्तमान समाधान लगातार साथ विफल #रों क्योंकि Zकी 0है 1, तो यह बजाय 0x01 0x00 (मैं भी है कि एक ही जाल में गिर गया है, लेकिन अपने ब्राउज़र unprintables प्रदर्शित करता है के रूप में उनके hexcodes इसलिए मैं उस पकड़ा) आउटपुट।

— कृतिका लिथोस

3

सी, ६५ ६४ 60 बाइट्स

(सीटिंगकैट के लिए धन्यवाद)

c;f(char*s){for(c=0;*s;s++)c+=*s-35?*s==59:-putchar(c%127);}

— HVD
स्रोत

cफ़ंक्शन को पुन: प्रयोज्य बनाने के लिए आपको शून्य को इनिशियलाइज़ करना होगा ।

— कॉनर ओ'ब्रायन

@ ConorO'Brien फिक्स्ड। दुर्भाग्य से मैं बस में जोड़ने की तुलना में कुछ भी कम के साथ आने का प्रबंधन नहीं किया c=0, और मैं डेनिस के जवाब से कॉपी करके धोखा नहीं करना चाहता।

— hvd

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

— hvd

एक; # दुभाषिया बनाओ

उदाहरण

पायथन 3 , 69 68 बाइट्स

जावास्क्रिप्ट (ईएस 6), 76 82 80 बाइट्स

डेमो

पुनरावर्ती संस्करण, 82 77 बाइट्स

रेटिना , 336 63 67 65 66 62 59 बाइट्स

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

जाप , 18 बाइट्स

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

पायथन , 65 बाइट्स

व्याख्या

> <> , 35 बाइट्स

मुख्य घेरा

काउंटर तर्क

मुद्रण तर्क

पायथन 3, 69 बाइट्स

रोड़ा , 44 39 38 बाइट्स

रोड़ा , 20 बाइट्स

रूबी, 41 35 34 अक्षर

05AB1E , 16 15 14 बाइट्स

जेली , 13 बाइट्स

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

MS-DOS पर x86 मशीन कोड - 29 बाइट्स

05AB1E , 25 21 19 बाइट्स

रेटिना , 34 बाइट्स

आर, 97 90 86 84 बाइट्स

पायथन, 82 बाइट्स

सादा टीएक्स, 156 बाइट्स

सी (जीसीसी) , 58 बाइट्स

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

सीजेएम, 27 बाइट्स

वैकल्पिक समाधान, 18 बाइट्स

एफ #, 79 91 93 बाइट्स

Ungolfed

विकल्प

एफ #, 107 104 बाइट्स

Ungolfed

प्रसंस्करण .js (खानकैमी संस्करण), 118 बाइट्स

भूलभुलैया , 61 47 बाइट्स

व्याख्या

संतरा

बैंगनी

हरा

धूसर

MATL , 29 बाइट्स

व्याख्या

ऐलिस , 22 बाइट्स

व्याख्या

जेएस (ईएस 6), 97 92 बाइट्स

; # + , 59 बाइट्स, नॉनकंपेटिंग

व्याख्या

यात्रा

बैश + कोरुटिल्स, 46 39 बाइट्स

व्याख्या

सी, ६५ ६४ 60 बाइट्स