मैं! N! रों! ई! R! टी! ! N! ख! ई! टी! डब्ल्यू! ई! ई! N!

24

यहाँ से पोस्ट किया ।

यह चुनौती इस प्रश्न से अत्यधिक "आसुत" है । @ अकाबाबा को विशेष धन्यवाद!

इस कार्य में, आपको स्ट्रिंग की शुरुआत में और प्रत्येक वर्ण के बाद एक विस्मयादिबोधक चिह्न सम्मिलित करना चाहिए।

नियम

  • हमेशा एक गैर-खाली स्ट्रिंग इनपुट होगा। इनपुट में टैब भी नहीं होंगे। आप यह मान सकते हैं कि इनपुट में केवल गैर-विस्तारित एएससीआईआई प्रिंट करने योग्य वर्ण और नए अंक हैं।
  • जब तक आपकी भाषा एक नई रेखा का पता नहीं लगा सकती है तब तक इनपुट में नई सीमाएँ नहीं होंगी।
  • यह एक कोड-गोल्फ प्रतियोगिता है; सबसे छोटा जवाब जीतना चाहिए।

उदाहरण

  • 4 न्यूलाइन में 5 न्यूलाइन-सीमांकित विस्मयादिबोधक चिह्न हैं। इसे मार्कडाउन टेक्स्ट के रूप में रखना बहुत कठिन है, इसलिए इसके बजाय यह कहा गया है।
1 2 3 4 5 6
129591 129012 129127 129582

0

आउटपुट

! 1! ! 2! ! 3! ! 4! ! 5! ! 6!
! 1! 2! 9! 5! 9! 1! ! 1! 2! 9! 0! 1! 2! ! 1! 2! 9! 1! 2! 7! ! 1! 2! 9! 5! 8! 2!
!
! 0!

asd afjoK ak: ई
kPrLd
    fOJOE;
    KFO
कफपजगप सगपज फज

आउटपुट

! एक! रों! D! ! एक! च! J! ओ! कश्मीर! ! एक k:! ई!
! K! पी! R! एल! D!
! ! ! ! ! च हे जे ओ ई!!!!!
! ! ! ! ! कश्मीर! एफ! हे!
! कश्मीर! एफ! K! ई! पी! J! जी! ओ! पी! ! रों! जी! पी! एक! ओ! J! ! ! ! च! एक! J!

केवल एक चरित्र के साथ आधार परीक्षण का मामला:

ए

आउटपुट

!ए!

(स्वतः पूर्णता! बस मजाक करना, ऐसी कोई बात नहीं है।) विस्मयादिबोधक चिह्न शामिल हैं:

!!
!!
!!
!!
!!

आउटपुट:

!!!!!
!!!!!
!!!!!
!!!!!
!!!!!
code-golf  string 
— ए
स्रोत
6
— Giuseppe
7
मैं वास्तव में नीचा नहीं समझता - यह एक स्पष्ट और अच्छी तरह से लिखित चुनौती है। पुन: एक डुप्लिकेट होने के नाते - यह (पूर्ववर्ती नहीं है! 'एक बड़े अंतर के लिए बनाता है), और मुझे विश्वास नहीं होता कि किसी ने भी ऐसा सुझाव दिया है (कोई करीबी वोट नहीं)।
— जोनाथन एलन
1
अगर एक भाषा के बीच अंतर नहीं बता सकता a\nऔर a, हम चाहते हैं कर सकते हैं कोई अनुगामी नई-पंक्तियों देखते हैं कि?
— Giuseppe
13
डाउनवोट्स को हर अपवोट के बीच डाला जाता है, ठीक वैसे ही जैसे कि क्लॉलेज बताता है।
— एक
2
यह मर चुका है।
— वी। कोर्टोइस

जवाबों:

12

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

lambda s:f"!{'!'.join(s)}!"

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

ईमानदारी से, मुझे आशा है कि कोई मुझे एक छोटे बाइट की गिनती के साथ ऐसा करने का एक अच्छा तरीका दिखा सकता है।

— मोनिका को बहाल करो
स्रोत
यह खाली लाइन मामले को सही ढंग से नहीं संभालता है
— गुच्छे
@flakes क्या मतलब है आपका? यदि आपका मतलब एक खाली स्ट्रिंग है: हमें एक खाली स्ट्रिंग को संभालने की आवश्यकता नहीं है (और इस !!मामले में इस आउटपुट की परवाह किए बिना , जो कि मेरे लिए समझ में आता है)। यदि आप स्ट्रिंग का मतलब है \n: यह करता है, क्योंकि सही आउटपुट है !\n!।
— जोनाथन एलन
3
@ जद जहां तक ​​मैं देख सकता हूं, इसके उदाहरणों में एक खाली स्ट्रिंग नहीं है। इतना ही नहीं, लेकिन पहला नियम शाब्दिक रूप से कहता है "हमेशा एक गैर-रिक्त स्ट्रिंग इनपुट होगा।"
— मोनिका
1
आह मैं गलत था। पहला उदाहरण इनपुट के बीच में एक खाली रेखा है। लेकिन यह उत्तर विस्मयादिबोधक बिंदु को उस के बीच में रखने से निपटेगा !\n!\n!। अच्छा काम।
— फ्लेक्स
1
codegolf.stackexchange.com/questions/190223/insert-nbetween/... आप एक छोटा रास्ता दिखाने के लिए कह रहे थे के रूप में
— U10-फॉरवर्ड - को पुनः स्थापित मोनिका
10

रेटिना 0.8.2 , 2 बाइट्स


!

इसे ऑनलाइन आज़माएं! अंत में, एक चुनौती जहां रेटिना में एक अंतर्निहित है!

— नील
स्रोत
1
वास्तव में, मैंने इस रेटिना में निर्मित इस चुनौती के आधार पर बनाया।
— A̲̲
— एडम
QuadR में -1 बाइट्स।
— एक
2
@A__ राइट, मैं उस सुविधा के बारे में भूल गया ( यदि केवल एक गैर-फ़ंक्शन लाइन है ... )। आप अपने चेक-मार्क पर फिर से विचार करना चाह सकते हैं ।
— 19
8

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

वर्णों के एक सरणी के रूप में इनपुट लेता है।

s=>`!${s.join`!`}!`

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

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

3 बाइट्स को @ShieruAsakoto को धन्यवाद दिया

एक स्ट्रिंग के रूप में इनपुट लेता है।

s=>[,...s,,].join`!`

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

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

@Tjjfvi द्वारा सुझाया गया

एक स्ट्रिंग के रूप में इनपुट लेता है।

s=>s.replace(/|/g,"!")

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

— Arnauld
स्रोत
3
— tjjfvi
@tjjfvi निफ्टी एक!
— अरनौलड
5
मुझे आपके 23 के लिए एक 20 मिला है:s=>[,...s,,].join`!`
— शायरु असाकोतो
7

आर , 25 बाइट्स

function(x)gsub("","!",x)

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

एक चरित्र वेक्टर को स्वीकार करने और वापस करने का एक फ़ंक्शन।

— निक केनेडी
स्रोत
करने के लिए फंक्शन फॉर्म स्विचन द्वारा 3 बाइट्स दाढ़ी कर सकते हैं scan(,''), तो जैसे tio.run/##K/r/P724NElDSUlHSVFJpzg5MU9DR11dU/O/...
— Sumner18
@ Sumner18 धन्यवाद। मैंने इसके साथ शुरुआत की थी लेकिन यह रिक्त स्थान पर इनपुट को विभाजित करता है।
— निक कैनेडी
1
@ Sumner18 चुनौती नई कहानियों के साथ इनपुट को संभालने के लिए कहती है, जो कि नहीं किया जा सकता scan(लेकिन निक का समाधान जो संभालता है, कम से कम यदि आप आउटपुट को प्रदर्शित करते हैं cat।)
— रॉबिन राइडर
7

8086 मशीन कोड, .COM प्रारूप (MS-DOS 2+), 32 बाइट्स

(-1 एमुलेटर पर निर्भर करता है: नीचे देखें)

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

यह प्रोग्राम वास्तविक MS-DOS इम्यूलेशन (जैसे PCjs) में ठीक व्यवहार करता है, लेकिन DOSBox को Ctrl + Z EOF (असेंबली लिस्टिंग में टिप्पणियां देखें) के साथ समस्या थी, इसलिए DOSBox में कंसोल का उपयोग करके इनपुट दर्ज करने का प्रयास न करें जब तक कि आप अतिरिक्त जांच जोड़ें!

BB 01 00 53 59 BA 0B 01 B4 40 CD 21 4A 4B B4 3F CD 21 85 C0 74 09 B4 40 43 41 CD 21 49 EB EE C3

कुछ दिलचस्प बिट्स:

  • मैं (याद है कि पहले से ही मार डाला गया था पुन: उपयोग से कुछ डेटा अंतरिक्ष बचाया 21Hमें INT 21Hहोने वाला !)

  • मैं था लगभग एक दिलचस्प चाल है कि मैं पृष्ठ पर पाया उपयोग करने में सक्षम "की बीसीडी निर्देश छिपे हुए पावर" जो मुझे इस्तेमाल करने की अनुमति देगा AAAएक मानक के बजाय TESTतुलना करने के लिए AL0 करने के लिए, एक बाइट की बचत। दुर्भाग्य से, यह पूरी तरह से प्रलेखित नहीं है, इसलिए मैं इस पर भरोसा नहीं कर सकता: उदाहरण के लिए, पीसीजे कुछ भी नहीं ले जाता है, लेकिन कैरी और सहायक कैरी झंडे। :-(

विधानसभा कोड (TASM आदर्श मोड):

IDEAL
MODEL   TINY

CODESEG
ORG 100H

;; DOSBox (tested with 0.74-2) didn't seem to handle Ctrl-Z as EOF
;; so uncomment the ";;" lines to run it there.
MAIN:
    MOV     BX,1
    PUSH    BX
    POP     CX
    MOV     DX,OFFSET MAIN_1+1  ; The 21H in INT 21H
    MOV     AH,40H
MAIN_1:
    INT     21H
    DEC     DX
    ;;PUSH  DX
    ;;POP   SI
IO_LOOP:
    DEC     BX
    MOV     AH,3FH
    INT     21H
    ;;; This should work on an non-emulated PC. 
    ;;;AAA      ; AL=0?
    TEST    AX,AX
    JZ      DONE
    ;;CMP   [BYTE PTR SI],1AH
    ;;JZ    DONE
    MOV     AH,40H
    INC     BX
    INC     CX
    INT     21H
    DEC     CX
    JMP     IO_LOOP
DONE:
    RET
ENDS
END MAIN
— ErikF
स्रोत
7

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

-2 बाइट्स जोकिंग के लिए धन्यवाद।

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

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

— क्रेज़सटेस्टो ज़्वेज़्स्की
स्रोत
@JoKing धन्यवाद, मैंने अपना उत्तर अपडेट कर दिया है।
— Krzysztof Szewczyk
अरे, यह बदमाश है
— क्रंचर
6

पेपे , 47 बाइट्स

REREEeRErEErREeeEeeeeEREEeeREEeereeREEEEeeEReee

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

स्पष्टीकरण:

REREEeRE # Push 0,then input (str),then 0 -> (R)
         # The zeroes are pushed to correct the inserting
rEE # Begin loop labelled 0 -> (r)
  rREeeEeeeeE # Push "!" -> (R)
              # r flag inserts it instead of pushing
  REEeeREEee # Move pointer pos 2 steps forward -> (R)
ree # Loop while (R) != 0
REEEEeeE # Remove characters of (R) that are in stack of (r)
         # Removes the 0 in (R)
Reee # Output (R)
— u_ndefined
स्रोत
आप इस कोड को कैसे लिखते हैं? क्या कुछ कोड कनवर्टर है जो आप उपयोग करते हैं? यह कोशिश करने और लिखने के लिए पागल लगता है
— क्रंचर
1
@ क्रंचर 1) मैं इसे अपने मार्गदर्शक के रूप में उपयोग करता हूं। 2) नहीं, मैं एक कोड कनवर्टर का उपयोग नहीं करता, मैं सिर्फ कोड लिखने के लिए गाइड का उपयोग करता हूं।
— u_ndefined 12
6

भूलभुलैया ,  19 11 10  9 बाइट्स

33
..
",@

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

कैसे?

हम शीर्ष पर बाईं ओर भूलभुलैया में प्रवेश करते हैं जो शून्य के अनंत ढेर के साथ दाईं ओर है ...

                         I / O    stack
                                  0,0,0,...
3 - pop * 10 + 3                  3,0,0,0,...
  - 2 neighbours, forward
3 - pop * 10 + 3                  33,0,0,0,...
  - 2 neighbours, forward
. - pop & print chr          !    0,0,0,...
  - T junction from the side
  -   TOS==0, forward
, - read chr or -1       L        76,0,0,0,...   or   -1,0,0,0
  - T junction from the base
  -   if TOS > 0 right:
" -     no-op                     76,0,0,0,...
  -     2 neighbours, forward
. -     pop & print chr      L    0,0,0,...
  -     T junction from the side
  -       TOS==0, forward
3 -       ...back to the start
  -   elif TOS == -1 left:
@ -     exit                                          we're out!


  * right, but on the first occasion (from above) we hit the wall and turn
    around, so that's like a left

सौभाग्य से हमें अन-प्रिंटेबल्स को संभालने की आवश्यकता नहीं है, अन्यथा पहले शून्य-बाइट हमें चारों ओर ,घुमाएगी और कहर बरपाएगी।

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

sed , 12 बाइट्स

s/\b\|\B/!/g

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

-3 बाइट्स गायों के लिए धन्यवाद

— जोनाह
स्रोत
वास्तव में Sed कोड वहां सिर्फ 15 अक्षर है: इसे ऑनलाइन आज़माएं! ।
— मैनटवर्क
बहुत बहुत धन्यवाद। मैं स्पष्ट नहीं था कि यह कैसे काम किया ...
— योना
1
s/\b\|\B/!/g12 बाइट्स के लिए भी काम करता है
— क्रिति लिथोस
@ सहवास धन्यवाद। अपडेट किया गया।
— जोनाह
4

Zsh , 32 बाइट्स

for c ('' ${(s::)1})echo -nE $c!

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

(s::)वर्णों में विभाजित हो जाता है, ''प्रारंभ में एक खाली तत्व जोड़ता है, और फिर echo -nE $c!प्रत्येक एक के बाद गूँजता है !।

— GammaFunction
स्रोत
4

पर्ल 5 -p0, 17 6 बाइट्स

s,,!,g

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

मेरी मूल जवाब था -pऔर $_='!'.s,.,$&!,gr। 11 बाइट्स काटने और -p0टिप के लिए @Grimy @Nahuel Fouilleul को धन्यवाद ।

— केजेटिल एस।
स्रोत
2
— नाहुएल फौइलुल
1
@NahuelFouilleul परीक्षण मामले के -lpलिए गलत आउटपुट देता है \n\n\n\n( !निर्दिष्ट 5 के बजाय 4 नई-अलग-अलग रिटर्न देता है )। -p0सही ढंग से काम करता है।
— ग्रिम्मी
4

6502, 12 बाइट्स (13 बाइट्स अगर Apple II)

6502

मशीन कोड मानता है कि शून्य पृष्ठ स्थानों की एक जोड़ी चरित्र इनपुट ($ FE) और आउटपुट (FF) हार्डवेयर से जुड़ी है। कई 6502-आधारित सिस्टम इस तरह से I / O की सुविधा देते हैं, यद्यपि I / O पता आमतौर पर शून्य पृष्ठ पर नहीं होता है।

सादगी के लिए, मैंने इस्तेमाल किया Py65 में लिखे 6502 माइक्रो कंप्यूटर सिस्टम सिम्युलेटर Py65 का ।

यहाँ Py65 से एक मेमोरी डंप है। आप निम्नलिखित कोड को शून्य पृष्ठ में कहीं भी लोड कर सकते हैं जैसे कि यह $ FE और $ FF को ओवरलैप नहीं करता है।

       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.mem 0:b
0000:  a9  21  85  ff  a5  fe  f0  fc  85  ff  d0  f4

विंडोज कमांड विंडो में चल रहा है, आप (Ctrl + V) अपनी इच्छा के अनुसार किसी भी पाठ को पेस्ट कर सकते हैं, या आप बस टाइप कर सकते हैं। यदि टाइप करते हैं, तो एक नईलाइन (उसी ASCII चार) के लिए Ctrl + J दबाएं। प्रोसेसर को बाधित करने और Py65 कमांड प्रॉम्प्ट पर लौटने के लिए Ctrl + C दबाएं।

स्वाभाविक रूप से, विधानसभा कोड पढ़ना आसान है।

       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.d 00:0b
$0000  a9 21     LDA #$21
$0002  85 ff     STA $ff
$0004  a5 fe     LDA $fe
$0006  f0 fc     BEQ $0004
$0008  85 ff     STA $ff
$000a  d0 f4     BNE $0000

स्पष्टता के लिए, यहां CBA65 प्रारूप में विधानसभा कोड है ।

; ASSEMBLE:
; cba65 bangit
;
; LOAD/RUN
; python3 py65/monitor.py -i 00fe -o 00ff -l bangit.bin
; goto 0000

        .FILES  BIN=256

; I/O LOCATIONS
GETC    .EQU    $FE             ; (1) MOVING PY65'S GETC TO ZP SHAVES 1 BYTE
PUTC    .EQU    $FF             ; (1) MOVING PY65'S PUTC TO ZP SHAVES 2 BYTES

        .ORG    $0000

VROOM   LDA     #'!'
        STA     PUTC
VROOM2  LDA     GETC
        BEQ     VROOM2
        STA     PUTC
        BNE     VROOM

        .END

Apple II

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

तुलना के लिए, Apple I और Apple II कीबोर्ड I / O पते के बिट 7 को सेट करके एक नए वर्ण की उपलब्धता का संकेत देता है, जिसे तब वर्ण प्राप्त करने के बाद साफ़ करने की आवश्यकता होती है। उन प्रणालियों पर, चरित्र I / O आमतौर पर सीधे हार्डवेयर तक पहुंचने के बजाय सिस्टम मॉनिटर रूटीन को कॉल करके किया जाता है।

RDKEY ($ FD0C) और COUT ($ FDED) को कॉल करके, ऊपर दिए गए Apple II को 13 बाइट्स में कोडित किया जा सकता है, और RAM में कहीं भी चलाया जा सकता है। यहाँ एक कोड है जिसे मैंने Apple // e emulator, a2ix में Android 9 पर चलाया था।

दबाने पर रिटर्न का न्यूलाइन के समान प्रभाव पड़ता है।

*300L

0300-   A9 A1       LDA   #$A1
0302-   20 ED FD    JSR   $FDED
0305-   20 0C FD    JSR   $FD0C
0308-   20 ED FD    JSR   $FDED
030B-   F0 F3       BEQ   $0300

क्या आपने देखा कि विस्मयादिबोधक बिंदु के लिए सामान्य ASCII मूल्य # $ 21 के बजाय # $ A1 का उपयोग किया जाता है? ऐसा इसलिए है क्योंकि COUT में मानक ASCII मान भेजने से उन्हें "उलटा मोड", सफेद पर काला दिखाई देता है। काले रंग पर सामान्य सफेद में ASCII प्रदर्शित करने के लिए COUT को कॉल करने से पहले संचायक में वर्ण मान में # $ 80 जोड़ने की आवश्यकता होती है। क्योंकि RDKEY उच्च-बिट सेट के साथ वर्ण लौटाता है, इसलिए असेंबली प्रोग्राम ने आमतौर पर इसका उपयोग करके ASCII मान प्राप्त करने के लिए चरित्र के बिट को मंजूरी दे दी।

— ली
स्रोत
1
साइट पर आपका स्वागत है! :)
— राहुल भारद्वाज
धन्यवाद, @Rahul!
— ली
4

बैश , 36 बाइट्स

while read -n1 c;do printf \!$c;done

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

यह अंतिम के लिए इनपुट को समाप्त करने वाली न्यूलाइन पर मायने रखता है! निशान।

— spuck
स्रोत
स्वागत हे! कृपया व्याख्याकार या किसी व्याख्याकार या किसी चीज़ से लिंक जोड़ने पर विचार करें, क्योंकि कोड-ही उत्तरों को स्वचालित रूप से निम्न-गुणवत्ता के रूप में चिह्नित किया जाता है।
— mbomb007
@ mbomb007, सूचक के लिए धन्यवाद।
— 23
1
दुर्भाग्य से यह !इनपुट के अंत में नहीं जुड़ता है।
— कृति लिथोस
@Cowsquack: मेरे टर्मिनल पर, इनपुट को समाप्त करने वाली नई लाइन मिलती है! जोड़ा। Tio.run पर, इनपुट को गाड़ी वापसी के साथ समाप्त करने की आवश्यकता होती है। मैंने इसे दर्शाने के लिए ऑनलाइन इसे आज़माने के लिए लिंक अपडेट किया है।
— 16
4

मारियोलेन , 95 94 90 89 69 बाइट्स

++++++
======< >)
>+++++++",+[
=======<.==<
>+++++++!(.-
========#===

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

पहली बार मारियोलेन्ग की कोशिश करना, यह बहुत मजेदार था!

-20 बाइट्स के लिए जो किंग को धन्यवाद

स्पष्टीकरण:

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

मारियो (निर्देश सूचक) हमेशा कार्यक्रम के शीर्ष बाएं सेल में शुरू होता है, गति के अपने इच्छित दिशा के साथ दाईं ओर सेट होता है। यदि मारियो के पास उसके (=, ", या #) नीचे फर्श जैसी वस्तु नहीं है, तो वह तब तक गिरता रहेगा जब तक कि वह एक मंजिल जैसी वस्तु तक नहीं पहुंच जाता। यदि मारियो कार्यक्रम को छोड़ देता है, तो गेम खत्म होने के कारण कार्यक्रम समाप्त हो जाता है :(

यह विशिष्ट कार्यक्रम मूल रूप से दो हिस्सों में विभाजित किया जा सकता है: सेटअप, और लूप।

   Setup                          Loop
-----------------------------------------------
                       |
++++++                 |          
======<                |          >)
>+++++++               |          ",+[
=======<               |          .==<
>+++++++               |          !(.-
========               |          #===

सेटअप अनुभाग में, हम पहली मेमोरी सेल को बढ़ा रहे हैं, जब तक कि हम 33 तक नहीं पहुँच जाते हैं - "!" के लिए ASCII मान। काफी आसान; अगर यह गोल्फ हो सकता है, तो यह विशुद्ध रूप से आकार की बात है। मारियो शीर्ष बाएं से शुरू होता है, 10 सिक्के उठाता है, 11 वीं उठाते समय गिरने लगता है, दिशाओं को बदलता है, फिर दोहराता है। वह निर्देशों को स्विच किए बिना अंतिम 11 सिक्कों को उठाता है; वह नीचे-दाईं ओर "+" सेटअप अनुभाग को समाप्त करता है।

लूप सेक्शन में, मारियो एक एलेवेटर पर पहुंचकर शुरू होता है। "!" ऑपरेटर उसे गति से रोक देता है, ताकि वह लिफ्ट पर बने रहे। रास्ते में, यह वर्तमान ASCII चरित्र को वर्तमान मेमोरी सेल के मूल्य में प्रिंट करता है (यह हमेशा 33 है, "!"), फिर मेमोरी में अगले सेल पर स्विच करता है। मारियो शीर्ष पर पहुँच जाता है और दाईं ओर अपनी दिशा निर्धारित करता है। वह गिरता है, और इनपुट से एक चरित्र को उसके ASCII मान (या -1 यदि कोई वर्ण नहीं) के रूप में पढ़ता है। हम वृद्धि करते हैं क्योंकि मारियोलैंग में नियंत्रण का एकमात्र उपाय एक निर्देश को छोड़ना है यदि वर्तमान मेमोरी सेल का मान 0. है। यदि यह होता है, तो हम मारियो की दिशा को बदलना छोड़ देते हैं, इसलिए वह अगली मंजिल से दाईं ओर चलना होगा। यदि ऐसा नहीं होता है, तो हम बाईं ओर दिशा निर्धारित करते हैं; नीचे की मंजिल से बाईं ओर चलना वर्तमान सेल को उसके पिछले मूल्य में वापस घटाता है,

पिछला संस्करण (89 बाइट्स):

+++++++++++>,
==========@"+
+++++++++++)[
@==========.==<
+++++++++++!(.-
===========#===
— मोनिका को बहाल करो
स्रोत
एक काउंटर के बजाय एक गुणा लूप का उपयोग करके 62 बाइट्स
— जो राजा
ठीक है अब यह अच्छा है। जैसे ही मेरे पास स्पष्टीकरण को फिर से करने का समय होगा, धन्यवाद एक गुच्छा!
— मोनिका
1
अहा! 8 * 4 + 1 के बजाय 5 * 6 + 3 को गुणा करके 60 बाइट्स
— जो राजा
यार, मुझे पता है कि यह आपकी पहली रोडियो नहीं है, लेकिन यह वास्तव में प्रभावशाली है। xD
— मोनिका
वास्तव में, यह मेरी पहली बार की गई मारियोलिंग है। मेरे पास दिमाग के साथ-साथ अन्य 2 डी भाषाओं के साथ कुछ अनुभव है
— जो किंग
4

पर्ल 6 , 16 11 बाइट्स

{S:g/<(/!/}

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

विस्मयादिबोधक चिह्न के साथ सभी शून्य चौड़ाई के मैचों की जगह। नल रीगेक्स की अनुमति नहीं है, इसलिए हम इसके बजाय कुछ भी नहीं पकड़ने के लिए कैप्चर मार्कर का उपयोग करते हैं

— मजाक कर रहा है
स्रोत
3

त्रिकोणीय , 15 13 बाइट्स

B\3;#*~.,</@<

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

-2 बाइट्स यह याद रखने के बाद कि त्रिकोणीय में एक सशर्त हॉल्ट ऑपरेटर है।

मेरा मानना ​​है कि यह इस पर जितना कम हो उतना कम है। त्रिकोणीय करता सशर्त दिशा-परिवर्तन ऑपरेटरों है, लेकिन वे दुर्भाग्य से अन्य सशर्त, की तुलना में अलग तरह से काम। जबकि अन्य सभी अगर ToS <= 0 की जाँच करते हैं, तो दिशा बदलने वाली स्थितियाँ ToS की जाँच करती हैं! = 0. यदि ऐसा नहीं होता, तो हमारे पास 10 बाइट्स होते Bq3~#*/@<<।

Ungolfed:

    B
   \ 3
  ; # *
 ~ . , <
/ @ <
----------------------------------------------------
B3*              - Push 11 and 3, then pop both and push their product.
    <,<          - Change directions 3 times (to save 2 bytes on last line)
        @/       - Print Top of Stack value as a character, do not pop
          ~;\    - Push a character from input to ToS. Halt if ToS <= 0. Change Direction.
              #  - Print ToS as a character and pop

पिछला संस्करण (15 बाइट्स):

B.3\.*#).(/?~@<
— मोनिका को बहाल करो
स्रोत
3

SimpleTemplate , 23 बाइट्स

यह एक भाषा है जिसे मैंने लिखा था, और यह टेम्पलेट के लिए होना चाहिए था, लेकिन अच्छी तरह से।

!{@eachargv.0}{@echo_}!

अप्राकृतिक कोड देखने के बाद, लगभग स्व-व्याख्यात्मक होना चाहिए:

!{@each argv.0 as char} {@echo char}!{@/}

और एक स्पष्टीकरण:

  • !- शाब्दिक !चरित्र को प्रिंट करता है
  • {@each argv.0 as char}- चर के लिए सेट मूल्य के साथ हर वर्ण के माध्यम से लूप, char( वैकल्पिक , डिफ़ॉल्ट चर है _)। कंपाइलर
    argv.0की render()विधि के लिए दिया गया पहला पैरामीटर है ।
  • {@echo char}!- charचर और एक शाब्दिक !चरित्र आउटपुट ।
    गोल्फ संस्करण के लिए, डिफ़ॉल्ट चर_ इसके बजाय का उपयोग किया जाता है।
  • {@/}- लूप बंद करता है ( वैकल्पिक )

शुद्ध SimpleTemplate समाधान:

{@fn x}!{@eachargv.0}{@echo_}!{@/}{@/}

एक फ़ंक्शन बनाता है x जो समान परिणाम देता है।

आप इसे इस तरह से उपयोग कर सकते हैं:

{@call x "this is an example"}

आप इस सब पर कोशिश कर सकते हैं: http://sandbox.onlinephpfunctions.com/code/f6baff8d411fc8227ece81eccf05b6e7d3586bfa

लाइन 908 पर, आप चर का उपयोग कर सकते हैं $golfed, $ungolfedऔर $fnसभी संस्करणों का परीक्षण कर सकते हैं ।

हालाँकि, यदि इसे किसी वर्ण सरणी का उपयोग करने की अनुमति है, तो कोड सरल (20 बाइट्स) है:

!{@echoj"!" argv.0}!

और अपुष्ट:

!{@echo separator "!" argv.0}!

मूल रूप से, सरणी में सभी वस्तुओं को आउटपुट करता है "!", जो शाब्दिक रूप से घिरा हुआ है !।
संकलक वर्ग में सीमाओं के कारण, स्थान अनिवार्य है (गोल्फ संस्करण में)।

यह कोड शुद्ध SimpleTemplate (उदाहरण के रूप में फ़ंक्शन का उपयोग करके) में उपयोग करने के लिए भी कठिन है :

{@fn x}!{@echoj"!" argv.0}!{@/}

{@// alternative: @call str_split into a "a char array"}
{@set a "a", " ", "c", "h", "a", "r", " ", "a", "r", "r", "a", "y"}

{@call x a}

@callएक समारोह है कि PHP में मौजूद है, जिसका अर्थ है कि यह एक शुद्ध नहीं है कॉल कर सकते हैं SimpleTemplate समाधान।

— इस्माइल मिगुएल
स्रोत
2

गामा , 11 वर्ण

\A=\!
?=?\!

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

नमूना रन:

bash-5.0$ echo -ne '1 2 3 4 5 6\n129591 129012 129127 129582\n\n0' | gema '\A=\!;?=?\!'
!1! !2! !3! !4! !5! !6!
!1!2!9!5!9!1! !1!2!9!0!1!2! !1!2!9!1!2!7! !1!2!9!5!8!2!
!
!0!

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

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

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

Ż”!ṁż

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

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

कैसे?

Ż”!ṁż - Main Link: list of characters, s   e.g. "abc"
 ”!   - character '!'                           '!'
   ṁ  - mould like:
Ż     -   s with a zero prepended              "!!!!"
    ż - zip together with s                    ["!a","!b","!c",'!']
      - implicit (smashing) print              !a!b!c!
— जोनाथन एलन
स्रोत
2

जाप , 4 बाइट्स

rP'!

कोशिश करो

जाप -P , 7 बाइट्स

दुर्भाग्य !से एक आरक्षित चरित्र है, उद्धरण चिह्नों की आवश्यकता है।

ï'! i'!

कोशिश करो

समझाने के लिए बहुत कुछ नहीं: ïकार्टेशियन उत्पाद है और iप्रीपेंड करता है।

— झबरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.