से संबंधित: एक बनाओ! # दुभाषिया और उत्पन्न; # कोड

`;#` - एक बवंडर गाइड

यह एक सरल भाषा है जिसमें दो कमांड हैं। इसकी एकमात्र डेटा संरचना एक संचायक है, जिसे 0 से प्रारंभ किया जाता है।

; संचायक में वृद्धि
#संचायक modulo 127 के मान की गणना करें, और संबंधित ASCII वर्ण प्रिंट करें। फिर, संचायक को 0 पर रीसेट करें।

स्रोत कोड में अतिरिक्त वर्ण (मुद्रण योग्य ASCII + व्हाट्सएप) हो सकते हैं, लेकिन इन्हें टिप्पणियों के रूप में माना जाता है और कार्यक्रम के निष्पादन पर कोई प्रभाव नहीं पड़ता है।

चुनौती

चूंकि अधिकांश कंप्यूटर ;#प्रीइंस्टॉल्ड के साथ नहीं आते हैं , इसलिए एक उपकरण होना बहुत उपयोगी होगा जो ;#कोड को एक अलग भाषा में बदल सकता है । इस चुनौती में, आप इसे पूरा करने के लिए एक कार्यक्रम लिखेंगे।

इनपुट

कुछ ;#स्रोत कोड, तर्क या STDIN के माध्यम से लिया जाता है। इस स्रोत कोड में (के अलावा) वर्ण ( ;या ) हो सकते हैं #।

उत्पादन

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

एक चीज़ देखने के लिए बचना है, जैसे कि कोड, जो बैकस्लैश या प्रिंट उद्धरण चिह्नों को प्रिंट करता है। ;#उस कोड के लिए भी देखें जिसमें आपकी भाषा में कीवर्ड या कमांड जैसी चीजें हो सकती हैं।

अतिरिक्त प्रतिबंध

सभी कार्यक्रमों को समाप्त करना चाहिए (मैं आमतौर पर इसे डिफ़ॉल्ट मानता हूं, लेकिन किसी ने इसके बारे में पूछा तो मैं इसे यहां बता रहा हूं)।

उदाहरण

input: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
output (python): print(";#")
input: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
output (element): \'`

code-golf

— PhiNotPi
स्रोत

34

मेरा कंप्यूटर ;#प्रीइंस्टॉल्ड के साथ आया ...

— प्रोग्रामर

1

और एक? क्यूं कर?

— caird coinheringaahing

क्या कार्यक्रम को निष्पादन रोकना है? इसके अलावा, क्या यह वास्तविक कोड के बाद असीम रूप से प्रिंट कर सकता है?

— totallyhuman

2

@totallyhuman मैं यह कहने वाला हूं कि सभी कार्यक्रमों को आखिरकार रोकना चाहिए।

— फीनोटपी

1

कृपया हमें एक परीक्षण मामला मिल सकता है जहां इनपुट में एक चरित्र (या वर्ण) हैं जो ;या नहीं हैं #?

— स्ट्रीटस्टर

7

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

कोड

इनपुट उद्धरण से घिरा हुआ है।

for y in input('print').split("#")[:-1]:print`chr(y.count(";")%127)`,

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

व्याख्या

आउटपुट का पहला भाग अनिवार्य रूप से इनपुट द्वारा उपयोग किया जाता है input('print')। हम हैशटैग पर इनपुट को विभाजित करते हैं और अंतिम तत्व को छोड़ देते हैं। हम ऑर्ड (y% 127) के प्रतिनिधित्व को प्रिंट करते हैं , जहां y अर्धविराम की घटनाओं की संख्या है। हम ,यह सुनिश्चित करने के लिए प्रिंट के अंत में संलग्न करते हैं कि यह एक नई रूपरेखा नहीं प्रिंट करता है।

यह Hello, World!-प्रोग्राम के लिए निम्नलिखित पायथन कोड देगा :

print'H' 'e' 'l' 'l' 'o' ',' ' ' 'W' 'o' 'r' 'l' 'd' '!'

जिसे ऑनलाइन ट्राय किया जा सकता है ।

— अदनान
स्रोत

5

ब्रेनफक , 126 बाइट्स

+++[->+++++<]>[->++++>+++<<],[+<++++++[-<++++>>------<]>[<]<<[>>>>>[--<--.++>]<+.-<.<<<<]>[->>-<<]>>[[-]<]>[>>++++[-->]<[<]],]

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

आउटपुट प्रोग्राम TIO कार्यान्वयन में विफल हो जाएगा यदि ;#आउटपुट 65536 वर्णों से अधिक हो। मैंने 130-बाइट संस्करण भी बनाया , जो इस समस्या से बचने के [+]बजाय आउटपुट देता <है:

++[------>++>+<<]>+++++<,[+<++++++[-<++++>>------<]>[<]<<[>>>>>[--<.>]<+++.---<.>.<++.--<<<<]>[->>-<<]>>[[-]<]>[>>++++[-->]<[<]],]

व्याख्या

+++[->+++++<]>[->++++>+++<<]        initialize tape with 60 and 45
,[                                  for each input byte:
  +<++++++[-<++++>>------<]         subtract 35 (#) from byte
  >[<]<<[                           if byte was #
         >>>>>[--<--.++>]           output + (43) a number of times equal to accumulator
         <+.-<.<<<<                 output . (46) and < (60)
  ]
  >[->>-<<]>>                       subtract 24 from what's left of byte
  [[-]<]                            check difference and clear if nonzero
  >[                                if byte was originally 59 (;)
   >>++++[-->]<[<]                  add 4 to accumulator cell, then subtract 2 if nonzero. Since BF cells are mod 256, this creates an accumulator mod 127.
  ]
,]

— Nitrodon
स्रोत

5

व्हॉट्सएप, 291 बाइट्स

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

स्पेस को S से बदलें, T को टैब से और N को न्यूलाइन द्वारा।

व्हॉट्सएप में व्हॉट्सएप बनाना दुनिया की सबसे कारगर चीज नहीं है। किसी भी प्रकार के डायनामिक कोड को बनाने के लिए महत्वपूर्ण बिट-ट्विडलिंग की आवश्यकता होती है, जो बिना किसी बिटवाइज़ ऑपरेशंस के भाषा में कोड साइज़ को विस्फोट करने का कारण बनेगा। इसलिए, यह कार्यक्रम कुछ स्मार्ट करने का प्रयास नहीं करता है, इसके बजाय केवल स्रोत कार्यक्रम को एक से एक अनुवाद करने का विकल्प चुनने के लिए। यह निम्नलिखित के समान है:

early:
    call S
    call S
    call N
start:
    push  0
    dup
    ichr
    get
    push  35
    sub
    dup
    jz    hash
    push  24
    sub
    jz    semi
    jmp   start
hash:
    pop
    call SSS
    call TTT
    call TTT
    call T
    call N
    call T
    call S
    call TTT
    call N
    call S
    call S
    jmp   early
semi:
    call SSS
    call T
    call N
    call T
    call SSS
    jmp   start
N:
    push 10
    pchr
    ret
SSS:
    call S
    call S
S:
    push 32
    pchr
    ret
TTT:
    call T
    call T
T:
    push 9
    pchr
    ret

प्रोग्राम द्वारा उत्पन्न कोड इस तरह दिखता है:

push  0
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  127
mod
pchr
push  0
push  1
add
...

— CensoredUsername
स्रोत

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

— aschepler

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

— CensoredUsername

4

वी , 19 20 28 बाइट्स

बगफिक्स, नहीं होने पर टूट गया # अंत पर

बगफिक्स, कार्यान्वित mod 127

Í;û127}
éiA0Í#/0
ò/;
x

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

जनरेट कोड का प्रयास करें

स्पष्टीकरण:

Í;û127}                            ' Delete runs of 127 `;`s (mod 127)
éi                                 ' Insert an `i` in front of input
  A<C-v><esc>0<esc>                ' Append <esc>0 to input
                   Í#/<C-v><C-v>0  ' Replace all `#` with `<C-v>0`
ò                                  ' Recursively
 /;                                ' Go to the next `;`
<C-a>                              ' Increment the next number come across

V में, इन्सर्ट मोड में, कोई भी ASCII कैरेक्टर का उपयोग करके कोड द्वारा डाला जा सकता है <C-v><Code>। वी कोड सभी #को बदल देता है <C-v>0, जहां शून्य एक छद्म संचायक प्रति है #। प्रत्येक #संचयकर्ता को 0 पर रीसेट करता है, इसलिए प्रति एक ठीक काम करता है। फिर कोड पाया गया प्रत्येक अर्धविराम के लिए एक वृद्धि करता है, जो कि अगली संख्या को बढ़ाता है जो इसे पाता है, जो अगले संचयकर्ता होगा। 0अंत में जोड़ा ताकि शिक्षा के लिए विफल नहीं हुआ है ;एक के बाद बिना #।

Hexdump:

00000000: e969 4116 1b30 1bcd 232f 1616 300a f22f  .iA..0..#/..0../
00000010: 3b0a 7801                                ;.x.

— nmjcman101
स्रोत

3

05AB1E , 20 19 18 16 बाइट्स

-1 अदनान को धन्यवाद
-2 कारुसोकोम्पुटिंग को
धन्यवाद -2 केविन क्रूज़सेन को धन्यवाद

'#¡¨vy';¢ƵQ%„çJJ

इसे ऑनलाइन आज़माएं! (निष्पादित 05AB1E कोड का आउटपुट शामिल है)

'#¡              # Split on #
   ¨             # remove the last element
    vy           # For each...
      ';¢        #   count the number of ;s
         ƵQ%     #   Mod by 127
            „çJ  #   Push çJ („çJ should work, but it doesn't for some reason)
               J # Join stack and output implicitly

— रिले
स्रोत

';¢हो सकता है g, žy128 को धक्का दे, किसी तरह से काम कर सकता है और सिर्फ पूरा शब्द क्यों नहीं लिख सकता है और इसे उद्धरण द्वारा घेर सकता है?

— मैजिक ऑक्टोपस Urn

1

मुझे उपयोग करने की आवश्यकता है इसके ';¢अलावा अन्य वर्ण हैं ;। žy<के रूप में ही है 127। यदि वर्णों में से कोई एक उद्धरण है, तो उद्धरणों से घिरे शब्द को प्रिंट करना टूट जाएगा।

— रिले

@carusocomputing मैं आपको पिंग करना भूल गया ...

— रिले

1

@carusocomputing और रिले: 127ƵQ का एक संकुचित संस्करण है ।

— अदनान

@ अदनान क्यों / कैसे?

— मैजिक ऑक्टोपस Urn

2

पायथन 2 , 75 बाइट्स

lambda s:"print"+`''.join(chr(x.count(';')%127)for x in s.split('#')[:-1])`

इसे ऑनलाइन आज़माएं! (शामिल पायथन कोड निष्पादित करने से आउटपुट शामिल है)

कई बाइट्स के लिए ovs का धन्यवाद!

व्याख्या

इस कार्यक्रम में # ट्रांसपाइल्स; #s ( s.split('#')[:-1]) पर विभाजित करके कोड , प्रत्येक chunk mod 127 ( x.count(';')%127for x in ...) में अर्धविरामों की संख्या की गिनती , और संबंधित ASCII वर्ण ( chr(...)) में परिवर्तित करना । फिर उस सूची को संक्षिप्त ( ''.join(...)), स्ट्रिंग (बैकटिक्स) के पायथन प्रतिनिधित्व में परिवर्तित किया जाता है और प्रिंटिंग स्ट्रिंग्स ( "print"+...) के लिए एक कंकाल पायथन कार्यक्रम में डाला जाता है ।

— मै जाऊं
स्रोत

2

जेली , 25 24 16 बाइट्स

ṣ”#Ṗċ€”;%127;€”Ọ

एक पूरा प्रोग्राम प्रिंटिंग जेली कोड के बराबर (एक मानद लिंक के रूप में यह मिश्रित प्रकारों की सूची की सूची देता है)।

पहला उदाहरण इसे ऑनलाइन आज़माएं! जो इस कार्यक्रम की पैदावार करता है ।

कैसे?

प्रत्येक मॉडुलो 127 के ;बीच प्रत्येक रन में s को गिनता है #और Ọप्रत्येक के बाद क्रमिक निर्देश, मोनोडिक परमाणु के लिए कलाकारों को जोड़ देता है ।

जेली स्पष्ट रूप से STDOUT के लिए प्रत्येक मूल्य को पाइप करता है क्योंकि यह उस तरह के कार्यक्रम के माध्यम से चलता है जैसे कि 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọप्रिंट होता है Hello, world!।

ṣ”#Ṗċ€”;%127;€”Ọ - Main link: list of characters
 ”#              - literal '#'
ṣ                - split the result at #s
   Ṗ             - pop (remove the last result, list of trailing non-# characters)
      ”;         - literal ';'
    ċ€           - count for €ach
        %127     - modulo 127 (vectorises)
              ”Ọ - literal 'Ọ' (Jelly's cast to ordinal monadic atom)
            ;€   - concatenate for €ach - making a list of lists like [[72,'Ọ],[101,'Ọ'],...]
                 - implicit print (this smashes, printing something like: 72Ọ101Ọ...)

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

— जोनाथन एलन
स्रोत

2

मूल रूप से , 138 137 बाइट्स

+1/1+54@6:5+1/1+5@6/1+52@6:4/1+5@6:1/1+54@6:4/1+5@6:5+2/1+4@6(~-61/1=7&6+5/1+51=7?6{+3/1+5@6}:5+3/1+3=7?6{+52@6:5+1@6-1@6+1@6:5+2/1+4@6})

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

नोट: आप बदलना पड़ सकता है &6के साथ?6& यह TIO पर काम करने के लिए। &6हालांकि, भाषा की युक्ति में है।

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

+1/1+54@6        Output 'R'
:5+1/1+5@6       Output '3'
/1+52@6          Output 'D'
:4/1+5@6         Output '1'
:1/1+54@6        Output 'R'
:4/1+5@6         Output '1'
:5+2/1+4@6       Output '+'
(                Loop indefinitely
  ~                Get next character
  -61/1=7&6        If input is -1 (EOF), exit program
  +5/1+51=7?6{     If input is `;`
    +3/1+5@6         Output '0'
  }                End if
  :5+3/1+3=7?6{   If input is '#'
    +52@6            Output '@'
    :5+1@6           Output '6'
    -1@6             Output '-'
    +1@6             Output '6'
    :5+2/1+4@6       Output '+'
  }                End if
)                End loop

आउटपुट प्रोग्राम:

R3D1R1           Set top face to 1
+00...           Add top face to notepad, aka increment notepad
@6               Output notepad as character
-6               Set notepad to 0
...

— TehPers
स्रोत

तर्कों को हटाने से बहुत से बाइट्स बचाएं@6 , %6और -6। कमांड्स जो पहले कुछ भी नहीं करते थे जब कहा जाता है कि अब नोटपैड का उपयोग किया जाता है। तो @एक ही है के रूप में @6, %के रूप में ही है %6, आदि

— एमडी XF

1

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

s=>`_=>'${s.replace(/[^#;]/g,``)}'.replace(/;*(#|$)/g,(l,c)=>c&&String.fromCharCode(~-l.length%127))`

इनपुट स्ट्रिंग को देखते हुए, सभी अनावश्यक वर्णों को हटा दिया जाता है, फिर निम्न फ़ंक्शन का स्रोत लौटाता है:

_=>'...'.replace(/;*(#|$)/g,(l,c)=>c&&String.fromCharCode(~-l.length%127))

जहां ...साफ किए गए ;#स्रोत का प्रतिनिधित्व करता है ।

— नील
स्रोत

1

सी, 98 96 99 98 97 बाइट्स

^{+3 बाइट्स क्योंकि मैं भूल गया सी व्याख्या नहीं की है :(}

c,a;f(){printf("f(){puts(\"");for(;~c;c=getchar())c==59?a++:c==35?a=!printf(&a):a;puts("\");}");}

साथ चल रहा है:

echo ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#" | ./a.out

प्रिंट होगा:

f(){puts("Hello, World!");}

— एमडी एक्सएफ
स्रोत

2

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#उत्पन्न करता है f(){puts(""");}, जो अमान्य है। चुनौती विशेष रूप से कहती है, "एक चीज़ देखने के लिए बची हुई सीक्वेंस है, जैसे कि कोड जो कि बैकस्लैश या प्रिंट को प्रिंट करता है।"

— hvd

@hvd फिक्सिंग ....

— एमडी एक्सएफ

1

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

”‘x
f”;L%127Ç;“Ọø”
ṣ”#Ç€ṙ-

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

और उस जेली कोड को यहाँ आज़माएं!

ṣ”#Ç€ṙ-      Main link, input is a string of ";;;;;;#lala;;;;;;;;;#"
ṣ”#          Split input on char #
   Ç€        Call helper link 1 for each segment
     ṙ-      Rotate returns 1 to the right (SPLIT introduces an empty element which is moved up front)

f”;L%127Ç;“Ọø”  Helper link 1, determines the number of increments
f”;             Throw out all but semicolons
   L%127        Take the count mod 127
        Ç       Call helper 2
         ;“Ọø”  Add a Jelly link that prints characters and splits print statements

”‘x             Helper 2, receives the count of ;'s
”‘              Return the character ‘ (Jelly's increment command
  x             Once for each ; in the input

जेली आउटपुट कोड की तरह हो जाता है Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, जो chr (13) + chr (10) प्रिंट करता है

— steenbergh
स्रोत

उपयोग करने के लिए अजीब उदाहरण (केवल सफेद स्थान की छपाई) जिसने मुझे भ्रमित किया।

— जोनाथन एलन

1

@JonathanAllan ने TIO के लिंक के साथ उदाहरण जोड़े।

— स्टाइनबर्ग

1

PHP, 72 बाइट्स

for(;~$c=$argn[$i++];)echo[Z=>'$n++;',B=>'echo~$n=~chr($n%127);'][a^$c];

— user63956
स्रोत

1

> <>, 106 81 77 बाइट्स

यह मेरा पहला गोल्फ> <> (मछली) है! एक बहुत ही दिलचस्प भाषा मुझे कहनी है। बहुत मजा!

0n01.
>i:1+?!v:";"=?v"#"=?v
^ ;o";"<   .37<
^oo"1+"
^oooooooo'"~"1+%o0' <

— पीटर लेनकेफी
स्रोत

तालाब में आपका स्वागत है! आप को छोटा कर सकते i:1+?!में i:0(?है, और मैं भी आप कुछ बाइट्स बचा सकता है, जैसा कि आप ढेर पर परिणाम का निर्माण किया है और यह उत्पादन के लिए इनपुट के अंत के लिए इंतजार कर रहे थे लग रहा है। मेरा मतलब है, यह बहुत है o;)

— हारून

1

सी # 169 बाइट्स

golfed:

class P{static int Main(string[] args){var r="Console.Write(";foreach(var y in args[0].Split('#')){r+=(char)(-1+y.Split(';').Length%127);}System.Console.Write(r+");");}}

मानव पठनीय संस्करण:

class P
{
    static int Main(string[] args)
    {
        var r="Console.Write(\"";
        foreach (var y in args[0].Split('#'))
        {
            r +=(char)(-1+y.Split(';').Length% 127);
        }
        System.Console.Write(r+"\");");
    }
}

— ऐप-डेवोन
स्रोत

1

हास्केल , 106 102 बाइट्स

';'!(x:a)=x+1:a;'#'!a=0:a;_!a=a;h s="main=putStr"++(show$""++(toEnum.(`mod`127)<$>init(foldr(!)[0]s)))

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

Ungolfed

step ';' (x:acc) = x+1:acc
step '#' acc = 0:acc
step _ acc = acc;

semicolonHash s = toEnum . (`mod` 127) <$> init (foldr step [0] s)

toHaskell s = "main = putStr " ++ (show $ "" ++ semicolonHash s)

— sudee
स्रोत

1

ब्रेकीलॉग , 33 बाइट्स

{";"∧"+₁"|"#"∧"%₁₂₇g~ạw0"}ˢ;"0"↔c

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

इस समय इसे समझाने में थोड़ी थकान महसूस हो रही है, अगर कोई भी इसे देखता है और सोचता है कि यह कैसे काम करता है यह मुझे याद दिलाने के लिए एक टिप्पणी छोड़ देता है।

— असंबंधित स्ट्रिंग
स्रोत

1

मैथॉल्फ , 17 बाइट्स

⌡(¶{gÉ'8=£♣(%$''\

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

व्याख्या

⌡                      decrement twice
 (                     decrement
                       this transforms ";;;#;;#" -> "888 88 "
  ¶                    split string on spaces
   {                   foreach...
    gÉ                 filter using next 3 characters
      '8               push single character "8"
        =              pop(a, b), push(a==b)
                       this filters out all non-";"
         £             length of array/string with pop
          ♣            push 128
           (           decrement
            %          modulo
             $         pop(a), push ord(a) or char(a) (gets character with code)
              ''       push single character "'"
                \      swap top elements

चूँकि किसी भी वर्ण का उपयोग करके स्टैक (और इस प्रकार आउटपुट) पर रखा जा सकता है '<char>, यह इस तरह के कोड ब्लॉक का एक क्रम आउटपुट करेगा।

— maxb
स्रोत

चैट बनाना भूल गए .. वैसे भी, `` (स्टैक के शीर्ष को छोड़कर सब कुछ छोड़ दें) वर्तमान में बग़ल में है। यह Python FileNotFoundError देता है।

— केविन क्रूज़सेन

@ केविनक्रूजसेन README की जाँच करें! मैंने उस कोड को कोड पृष्ठ में बदल दिया, ताकि दो स्थान वर्ण होने से बचा जा सके। नया चरित्र है Þ।

— अधिकतम

हाँ, @ जोकिंग ने कहा कि वास्तव में इसे बदल दिया गया था Þ। ( डॉक्स मैं अभी भी पुराने मूल्य का उपयोग करता हूं। )

— केविन क्रूज़सेन

1

@ केविनक्रूजसेन ओह, कि डॉक्टर को अद्यतन करने की आवश्यकता है, अनुस्मारक के लिए धन्यवाद! मैं उन दोनों को अद्यतन रखने के लिए एक स्क्रिप्ट लिखने की कोशिश करूँगा। मुझे लगता है कि जब तक मुझे वह जगह नहीं मिल जाती, मैं इसका उपयोग करने का सुझाव दूंगा।

— 13

1

MATL , 32 28 बाइट्स

35lF4$Yb"@g59=z]xv127\!&D99h

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

strsplitएक ऑटोमेटन-प्रकार कार्यक्रम के बजाय पूरी तरह से अलग दृष्टिकोण ।

      Yb % strsplit
    4$   %  with 4 inputs, namely:
35       %   Split on '#'
  lF     %   Do not (F) collapse delimiters (l).
         %   And of course the implicit program input.

"@g    ] % Loop over strings, convert each to a normal char array
   59=z  % How many equal to 59 ';'?

xv!127\  % Delete last element, concatenate and flip to horizontal, mod 127
&D       % Convert to MATL representation
  99h    % Append a 'c' to output ASCII.

— सांची
स्रोत

0

दरअसल , 25 बाइट्स

'#@s⌠';@c7╙D@%⌡MdX$"♂cΣ"o

इसे ऑनलाइन आज़माएं!(ट्रांसप्लड एक्चुअली कोड को निष्पादित करने से आउटपुट शामिल है)

स्पष्टीकरण:

'#@s⌠';@c7╙D@%⌡MdX$"♂cΣ"o
'#@s                       split on "#"
    ⌠';@c7╙D@%⌡M           for each chunk:
     ';@c                    count ";"s
         7╙D@%               mod by 127 (2**7-1)
                dX         discard last value
                  $        stringify
                   "♂cΣ"o  append "♂cΣ":
                    ♂c       convert each value to an ASCII character
                      Σ      concatenate

— मै जाऊं
स्रोत

0

शॉर्टसी , 48 बाइट्स

c,a;AR"AP\"");O;~c;c=G)c==59?a++:c==35?a=!R&a):a

— एमडी एक्सएफ
स्रोत

क्या आप विस्तारित रूप जोड़ सकते हैं?

— कैलक्यूलेटरफल

@CalculatorFeline पहले ही कर चुका है ।

— एमडी एक्सएफ

0

फूरियर, 32 बाइट्स

$(I~S{59}{`^`}S{35}{`%127a0`}&i)

यह चार वीडियो पर कोशिश करो!

यह काफी आसान चुनौती थी क्योंकि फूरियर मूल रूप से एक सुपरसेट है; #:

;# command > Fourier equivalent
; > ^ (Increment the accumulator)
# > %127a0 (Modulo accumulator by 127, output corresponding code point and set accumulator to zero)

— बीटा डिके
स्रोत

0

CJam, 14 बाइट्स

q'#/);';fe=:c`

स्पष्टीकरण:

q               e# Read input
 '#/            e# Split on '#'
    );          e# Delete last element
      ';fe=     e# Count occurrences of ';' in each
           :c   e# Convert each to character (code point)
             `  e# Escape

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

0

एपीएल, 31 बाइट्स

{⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽

आउटपुट:

      ({⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽) ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#'
⎕UCS 59 35
      ⍝ evaluate the output
      ⍎({⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽) ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#'
;#

स्पष्टीकरण:

⌽: इनपुट उल्टा करें
{...} : इसे इस समारोह में पास करें:
- ⍵⊂⍨'#'=⍵: प्रत्येक में विभाजन # स्ट्रिंग में (शुरुआत से, यही वजह है कि इसे पहले उलट करना पड़ा)
- +/¨';'=: ;प्रत्येक विभाजन में एस गिनें
- 127|: मोडुलो 127
- ⌽: इसे फिर से उल्टा करें
- '⎕UCS',: स्ट्रिंग को रोकें ⎕UCS , जो कि यूनिकोड फ़ंक्शन है।
- ⍕: स्ट्रिंग प्रतिनिधित्व

— मारीनस
स्रोत

आप ⍕वास्तविक आउटपुट को हटा सकते हैं जैसे कि STDOUT समान है।

— एडम

0

रूबी , 47 + 1 = 48 बाइट्स

$_=gsub(/.*?#/){"$><<#{$&.count(?;)%127}.chr;"}

के लिए +1 बाइट -p ।

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

-30 बाइट्स @manatwork की बदौलत !

— पावेल
स्रोत

दुर्भाग्य से यह "स्रोत कोड में (टिप्पणी) वर्णों के अलावा ;या #आवश्यकता के अनुसार" अच्छा हो सकता है ।

— मैनेटवर्क

@manatwork फिक्स्ड, बाद में गोल्फर बनेगा।

— पावेल

नियमित अभिव्यक्ति /;+#/→ /.*?#/और कोड ब्लॉक s.length-1→ को बदलने के लिए पर्याप्त था s.count(?;)। बीटीडब्ल्यू, आपका गणित भी गलत है, क्योंकि %इसकी तुलना में उच्च प्राथमिकता है -, इसलिए होना चाहिए (s.length-1)%127। और में .gsubकी कोड ब्लॉक आप के साथ कब्जा कर लिया समूहों का उपयोग कर सकते $&, $1... इसलिए |s|कोड ब्लॉक पैरामीटर आमतौर पर संभव नहीं है। और स्ट्रिंग प्रक्षेप स्ट्रिंग {"$><<#{$&.count(?;)%127}.chr;"}:। इसे ऑनलाइन आज़माएं!

— मैनेटवर्क

@manatwork बहुत बहुत धन्यवाद! मुझे लगता है कि आपकी टिप्पणी ने मेरे रूखे ज्ञान को दोगुना कर दिया है।

— पावेल

देर हो चुकी है, लेकिन कोड चुनौती खुद को हाल ही में संशोधित जवाब से टकरा गई थी जो भी हो। सीधे gsubसंशोधित करता $_है, जिसका अर्थ है कि आपको इसे फिर से असाइन करने की आवश्यकता नहीं है। फिर भी, अगर आपके पास अपने अंतिम के बाद टिप्पणी करने वाले अक्षर हैं, तो आपके पास #... यहाँ देखें

— मूल्य इंक

0

पायथ, 25 23 24 बाइट्स

j\\+"jk["mC%/d\;127Pcw\#

+1 बाइट्स @FryAmTheEggman को धन्यवाद

कोशिश करो!

केवल 1-चार-स्ट्रिंग्स का उपयोग करके उन वर्णों को संभालता है जिन्हें बचना है।

नमूना आउटपुट:

jk[\"

jk[\H\e\l\l\o\,\ \W\o\r\l\d\!

मेरा उपयोग करता है ; # दुभाषिया ।

— KarlKastor
स्रोत

यह काम नहीं करता है यदि #इनपुट में नहीं हैं , क्योंकि यह प्रिंट होगा 0। आप jkइसके बजाय इसे ठीक कर सकते हैं s।

— FryAmTheEggman

0

सी, 150 बाइट्स

#include<stdio.h>
c;n=0;main(){puts("#include<stdio.h>\nmain(){");while(~(c=getchar()))c-35?c-59?:n++:(printf("putchar(%d);",n%127)&(n=0));puts("}");}

विस्तारित:

#include<stdio.h>
c;
n=0;
main(){
        puts("#include<stdio.h>\nmain(){");
        while( ~(
            c=getchar()
        ))
                c-35?
                        c-59?
                                :
                                n++
                        :
                        ( printf("putchar(%d);",n%127)
                        &(n=0))
                ;
        puts("}");
}

यह एक पूर्ण कार्यक्रम है जिसे (को) समाप्त करना चाहिए, टिप्पणियों को अनदेखा करना चाहिए और हमेशा सही आउटपुट कोड का उत्पादन करना चाहिए। मैं ईओएफ = -1 मान रहा हूं

SystemResque-Cd 4.9.6 पर परीक्षण किया गया, जो कि 4.9.4 के साथ संकलित है

— epimatech
स्रोत

0

ब्रेकिंग , 40 बाइट्स

,[35-z["[127-s[127+.>]]<0*".]24-z[43.],]

कहना होगा, यह आश्चर्यजनक रूप से छोटा है।

,[                                    ,]     Read a byte until end of input
  35-                                          Subtract 35.
     z[                     ]                  If the result is zero,
       "[127-s[127+.>]]<0*".                     print the code for `#`.
                             24-               Subtract 24.
                                z[   ]         If the result is zero,
                                  43.            print the code for `;`

के लिए उत्पन्न कोड ;है a+ , जो वर्तमान सेल को बढ़ाता है।

जनरेट किए गए कोड #में एक akward, मैनुअल मोडुलो ऑपरेशन होता है

[127-s[127+.>]]<0*
[             ]       While current cell is not zero
 127-                   Subtract 127
     s[      ]          If result is negative
       127+.              Add 127 again and print current cell
            >             Step to next cell to break the loop
               <0*      Step back to first cell and clear it

— daniero
स्रोत

0

ब्रिंगोल्फ , 55 बाइट्स

V#0VR&,l1-MvMR[R.#;e"+1"MM|.##e"@%+1~#"MMMMMM|$_vv]Rv&@

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

मूल रूप से बदल देता ;है 1+, के #साथ #~1+%@और पूर्व की 0वजह से पूरी चीज को एक विमुद्रीकृत करता है+ ऑपरेटर अभी टूट गया है।

1+ स्टैक में अंतिम आइटम में 1 जोड़ता है।

#~1+%@ के मूल्य को बढ़ाता है ~(126) , 1 को जोड़ने के लिए 127 बनाता है, स्टैक पर अन्य आइटम के साथ मापांक, फिर पॉप और प्रिंट के रूप में चार।

व्याख्या

V#0VR&,l1-MvMR                         Implicit input of each char to stack
[R.#;e"+1"MM|.##e"@%+1~#"MMMMMM|$_vv]
Rv&@

V#0                                    Create stack2, push char value of 0
   VR                                  Create stack3, return to stack1
     &,                                Reverse stack
       l1-                             Push length of stack - 1
          MvMR                         Move length to stack2, switch to stack 2
                                       Move length to stack3, switch back to stack1
[R................................vv]  Do-While loop, will run l times
                                       where l is length of input
  .#;                                  Duplicate last item and push char value of semicolon
     e                                 Pop last 2 items, if they are equal..
      "+1"                             ..Push char values of +1 in that order
          MM                           ..Move last 2 items to stack2
            |                          endif
             .##                       Duplicate last item and push char value of hash
                e                      Pop last 2 items, if they are equal..
                 "@%+1~#"              ..Push char values of @%+1~# in that order
                         MMMMMM        ..Move last 6 chars to stack2
                               |       endif
                                $_     Silently pop last item
Rv                                     Switch to stack2
  &@                                   Greedy char print, print every item in stack as char

— Skidsdev
स्रोत

0

क्यू / केडीबी +, ४२ बाइट्स

समाधान:

{-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}

उदाहरण:

ध्यान दें कि ,एक सूची (बनाम परमाणु) को इंगित करने के लिए उपयोग किया जाता है जैसा कि परमाणु के "\""बजाय एक तत्व की एक सूची है।

q){-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"
";#"
q){-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"
,"\""

स्पष्टीकरण:

इनपुट स्ट्रिंग, निकालें कुछ भी है कि नहीं है एक ले लो #या एक ;, पर सूचियों में विभाजित #, प्रत्येक सूची में तत्वों की संख्या गिनती, परिणाम और एक स्ट्रिंग के लिए कलाकारों पर आधुनिक 127 करते हैं:

{-1_"c"$mod[;127]count each"#"vs x inter"#;"} / ungolfed
{                                           } / lambda function
                                 x inter"#;"  / intersection of input and ';#' to clear out any 'comments'
                           "#"vs              / split string on hash
                 count each                   / length of each sub-list
        mod[;127]                             / 127 modulo result (vectorised)
    "c"$                                      / cast back to string
 -1_                                          / drop last character (assuming terminated string)

टिप्पणियाँ:

मान लेता है कि इनपुट को समाप्त कर दिया गया है #, अन्यथा अंतिम चंक को गलत तरीके से हटा दिया जाएगा-1_ ।
यदि इनपुट केवल शामिल होने की गारंटी है तो 10 बाइट्स कम हो सकते हैं ;#।

— streetster
स्रोत

0

पर्ल 5 , 78 बाइट्स

say"say''",map{$_=chr y/;//%127;$_.=$_ if/\\|'/;",'$_'"}(join$",<>)=~/[^#]*#/g

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

— Xcali
स्रोत

Transpile; # अपनी भाषा में

;# - एक बवंडर गाइड

चुनौती

इनपुट

उत्पादन

टिप्पणियाँ

अतिरिक्त प्रतिबंध

उदाहरण

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

कोड

व्याख्या

ब्रेनफक , 126 बाइट्स

व्याख्या

व्हॉट्सएप, 291 बाइट्स

वी , 19 20 28 बाइट्स

05AB1E , 20 19 18 16 बाइट्स

पायथन 2 , 75 बाइट्स

व्याख्या

जेली , 25 24 16 बाइट्स

कैसे?

मूल रूप से , 138 137 बाइट्स

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

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

सी, 98 96 99 98 97 बाइट्स

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

PHP, 72 बाइट्स

> <>, 106 81 77 बाइट्स

सी # 169 बाइट्स

हास्केल , 106 102 बाइट्स

ब्रेकीलॉग , 33 बाइट्स

मैथॉल्फ , 17 बाइट्स

व्याख्या

MATL , 32 28 बाइट्स

दरअसल , 25 बाइट्स

शॉर्टसी , 48 बाइट्स

फूरियर, 32 बाइट्स

CJam, 14 बाइट्स

एपीएल, 31 बाइट्स

रूबी , 47 + 1 = 48 बाइट्स

पायथ, 25 23 24 बाइट्स

सी, 150 बाइट्स

ब्रेकिंग , 40 बाइट्स

ब्रिंगोल्फ , 55 बाइट्स

व्याख्या

क्यू / केडीबी +, ४२ बाइट्स

पर्ल 5 , 78 बाइट्स

`;#` - एक बवंडर गाइड