कार्य

अंकों के अंग्रेजी नामों की एक स्ट्रिंग को देखते हुए, "एक साथ ढह गए":

zeronineoneoneeighttwoseventhreesixfourtwofive

स्ट्रिंग को अंकों में विभाजित करें:

zero nine one one eight two seven three six four two five

नियम

इनपुट हमेशा एक स्ट्रिंग है। इसमें हमेशा एक या अधिक लोअरकेस अंक अंग्रेजी के होते हैं, एक साथ ढह जाते हैं, और कुछ नहीं।
- अंग्रेजी अंकों के नाम हैं zero one two three four five six seven eight nine।
आउटपुट स्ट्रिंग्स की एक सूची या एक नया स्ट्रिंग हो सकता है, जहां अंकों को गैर-वर्णनात्मक, गैर-खाली कोडिंग द्वारा सीमांकित किया जाता है। (आपके आउटपुट में वैकल्पिक रूप से शुरुआत या अंत में इस तरह के तार हो सकते हैं , और सीमांकक के संगत होने की आवश्यकता नहीं है। इसलिए भी ऐसा कुछ {{ zero0one$$two );मान्य है (यदि बेतुका है) इसका जवाब दें zeroonetwo।)
बाइट्स जीत में सबसे छोटा जवाब।

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

three -> three
eightsix -> eight six
fivefourseven -> five four seven
ninethreesixthree -> nine three six three
foursixeighttwofive -> four six eight two five
fivethreefivesixthreenineonesevenoneeight -> five three five six three nine one seven one eight
threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight -> three seven seven six nine nine nine five eight two five eight six three eight
zeroonetwothreefourfivesixseveneightnine -> zero one two three four five six seven eight nine

code-golf string

— लिन
स्रोत

28

यह एक उत्कृष्ट चुनौती है! यह कार्य समझना और सत्यापित करना बेहद आसान है, लेकिन उपयोग करने का सही तरीका बहुत स्पष्ट नहीं है। और सही दृष्टिकोण चुनने से स्कोर में भारी अंतर आ सकता है । +1 :)

— DJMcMayhem

1

यह सोचने के बाद, मुझे अराजकता गोल्फ पर एक समान, लेकिन अधिक सरल चुनौती याद आई: हाँ ! इसने कुछ आश्चर्यजनक सी उत्तर दिए। मैं जल्द ही उन में से एक को देखने की उम्मीद करता हूं :)

— लिन

मुझे नहीं लगता कि मेरा सी उत्तर इस तरह से उत्तीर्ण है, लेकिन उम्मीद है कि यह दूसरों के लिए खुद से ज्यादा हास्य की भावना के साथ एक शुरुआती बिंदु है।

— माइकल डोरगन

मुझे पूरा यकीन है कि मैंने यही चुनौती देखी है, लेकिन आप वास्तविक संख्या को प्रिंट करने वाले हैं। मुझे लगभग निश्चित है कि यह भी आप द्वारा पोस्ट किया गया था, आप, लिन; लेकिन मैं लिंक खो दिया है, मुझे इसके साथ हुक?

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

3

@MichaelDorgan (या कोई अन्य C कोडर्स), आप मेरे Befunge उत्तर में उपयोग किए गए एल्गोरिथ्म पर एक नज़र रखना चाह सकते हैं। सी के लिए सीधे रूपांतरण से मुझे 104 बाइट समाधान मिला, जो मुझे लगता है कि मौजूदा सी के सभी जवाबों को धड़कता है। मैं शर्त लगाने को तैयार हूं कि किसी के द्वारा और अधिक सी गोल्फ कौशल के साथ सुधार किया जा सकता है।

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

29

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

!`..[eox]|[tse]?....

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

— Uriel
स्रोत

17

C (gcc) , 89 80 76 75 72 71 70 69 बाइट्स

f(char*s){*s&&f(s+printf(" %.*s",""[(*s^s[2])%12],s)-1);}

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

(89) एक्सओआर हैश के लिए गैस्ट्रोपनर को श्रेय ।
(76) 1 और 3 का उपयोग करने के विचार के लिए टोबी स्पाइट को श्रेय ।
(75) माइकल डोरगन को '0'→ के लिए श्रेय 48।
(72) नियंत्रण पात्रों के साथ शाब्दिक रूप से माइकल डोरगन और लिन को श्रेय ।
(69) के लिए ऋण लिन के लिए x?y:0→x&&y

f (char *s) {        /* K&R style implicit return type. s is the input. */
    *s&&f(           /* Recurse while there is input. */
        s+printf(    /* printf returns the number of characters emitted. */
            " %.*s", /* Prefix each digit string with a space. Limit
                      * how many bytes from the string to print out. */
            ""
                     /* Magic hash table, where the value represents
                      * the length of the digit string. The string
                      * is logically equivalent to
                      * "\04\01\05\03\04\05\05\04\04\01\03\03" */
            [(*s^s[2])%12],
                     /* The XOR hash (mod 12) */
            s)       /* The current digit. */
            -1);}    /* Subtract 1 for the space. */

— jxh
स्रोत

11

अजगर 2 , 50 बाइट्स

import re
re.compile('..[eox]|[tse]?....').findall

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

-3 लिन को धन्यवाद ।
-4 यूरेल के जवाब के लिए धन्यवाद ।

— आउटग्रॉफर को एरिक
स्रोत

3

अच्छा! import re;re.compile('…').findallबाइट्स के एक जोड़े को बचाना चाहिए। मुझे उम्मीद थी कि यह रेगेक्स गोल्फ में बदल जाएगा :)

— लिन

@ Lynn रुको, रुको जब तक मैं कर रहा हूँ! :-P EDIT: यह वास्तव में 3 बाइट्स है।

— निकोलग्राफ

@ इसके अलावा, आपको इसे कोड-गोल्फ नियमित-अभिव्यक्ति के बजाय बदल देना चाहिए । ;)

— निकोलफर

मैं एक सी उत्तर के लिए पकड़ रहा हूं, जो बहुत दिलचस्प होगा!

— लिन

9

बेफुंज, 87 85 81 76 बाइट्स

<*"h"%*:"h"$_02g-v1$,*<v%*93,:_@#`0:~
"@{&ruX;\"00^ !: _>_48^>+:"yp!"*+%02p0

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

Befunge में कोई स्ट्रिंग हेरफेर निर्देश नहीं हैं, इसलिए हम जो करते हैं वह पिछले तीन वर्णों का एक प्रकार का हैश बना है, जैसा कि हम उन्हें संसाधित कर रहे हैं।

यह हैश अनिवार्य रूप से एक तीन अंक, आधार-104 नंबर है। जब भी कोई नया वर्ण पढ़ा जाता है, तो हम सबसे पुराने वर्ण से छुटकारा पाने के लिए 104 ^{2 के} साथ हैश का मॉड करते हैं, नए वर्ण के लिए स्थान बनाने के लिए इसे 104 से गुणा करते हैं, फिर नए वर्ण mod 27 के ASCII मान को जोड़ते हैं (यह सुनिश्चित करने के लिए यह अतिप्रवाह नहीं करता है)।

तुलनात्मक उद्देश्यों के लिए, हम इस वैल्यू मॉड ३ take१ take को लेते हैं, इसे मेमोरी में लिखते हैं (इस प्रकार इसे c बिट्स तक छोटा कर दिया जाता है), जिसके परिणामस्वरूप कम संख्या में होते हैं जो बीफुन्ज को संभालना आसान होता है। फिर जिस हैश की तुलना करनी है, वह है 0, 38, 59, 64, 88, 92, 114, 117, और 123। यदि यह उनमें से किसी से मेल खाता है, तो हमें पता है कि हमें एक चरित्र अनुक्रम का सामना करना पड़ा है जो एक के अंत को दर्शाता है। संख्या, इसलिए हम एक अतिरिक्त स्थान का उत्पादन करते हैं और हैश को शून्य पर रीसेट करते हैं।

यदि आप सोच रहे हैं कि बेस 104, या मॉड 3817 क्यों है, तो उन मानों को सावधानीपूर्वक चुना गया था ताकि जिन हैश सूची की तुलना करने की आवश्यकता है, उन्हें यथासंभव कम बाइट्स में प्रस्तुत किया जा सके।

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

बहुत ईमानदारी से, यह मेरे लिए bakemoji (けもじ to) जैसा दिखता है। वाह। एल्गोरिथ्म विवरण हालांकि अच्छा है और मैं इस पर विचार करूंगा।

— माइकल डोरगन

^, मुझे याद है कि इस शब्द को मोजिबेक (じばけ।) के रूप में देखा जाता है। आपने उन नंबरों (बेस 104, मॉड 3187), @JamesHolderness को कैसे पाया?

— ज़ाचरी

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

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

6

जावा (ओपनजेडके 8) , 55 46 43 बाइट्स

Forty3 / FrownyFrog के लिए 9 बाइट्स की बचत

टाइटस की बदौलत 3 बाइट्स बचाए

s->s.replaceAll("one|tw|th|f|z|s|.i"," $0")

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

संपादित करें: lambdas के स्वागत और स्पष्टीकरण के लिए धन्यवाद!

— लुका एच
स्रोत

3

नमस्ते, PPCG में आपका स्वागत है! महान पहला उत्तर, और यह वास्तव में काम करता है। यहां इसके लिए TIO लिंक दिया गया है। लंबोदर कई तरीकों से बनाया जा सकता है। यहाँ कुछ टिप्पणियों के साथ कुछ लंबो के साथ एक और TIO है ताकि आप देख सकें कि उन्हें कैसे बनाया जाए। (मेरा सुझाव है कि इसे ग्रहण करने के लिए कॉपी करें ताकि आप कोड की हाइलाइटिंग देख सकें।) इसके अलावा, जावा में गोल्फिंग के लिए टिप्स और सभी भाषाओं में गोल्फ के लिए टिप्स पढ़ने के लिए दिलचस्प हो सकते हैं। यहां रहने का आनंद! :)

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

@ केविनक्रूजसेन धन्यवाद! मुझे ईमानदारी से आश्चर्य हुआ कि जावा जावास्क्रिप्ट से छोटा है। आमतौर पर जब मैं चुनौतियां पढ़ रहा होता हूं, तो जेएस बहुत छोटा होता है।

— लुका एच

जावास्क्रिप्ट 2 बाइट्स छोटा होना चाहिए ( gregex प्रत्यय के बजाय All)।

— नील

@ अब यह यहाँ लंबा है क्योंकि यह f=(s)=>इसके बजाय उपयोग कर रहा है s->, जो 4 बाइट्स छोटा है।

— लुका एच

1

@ लुका - फ्रॉनीफ्रॉग के सुझाव के अनुसार, आप अपने दो अक्षर के तार को कुछ अक्षरों को कम कर सकते हैं: ze | f के बजाय z | f | f | si | se /

— Forty3

6

C (gcc) , 179 159 146 139 137 116 107 103 102 बाइट्स

संपादित करें 1: ( मिस्टर एक्सकोडर से जोड़े गए सुझाव - धन्यवाद! - मेरा मैक्रो संस्करण आपके जैसे ही आकार का था, लेकिन मैं आपको बेहतर पसंद करता हूं।)

संपादित 2: बदल चार व्यक्ति करने के लिए कॉल करने के लिए तुलना करता हैstrchr()

3 संपादित करें: K & R की var घोषणाएँ (Eww!)

संपादित करें 4: जब 1 मैक्रो पर्याप्त नहीं है ...

संपादित करें 5: ऊपर सुझाए गए नए एल्गोरिथ्म के साथ फिर से करें। इस महान विचार के लिए जेम्स होल्डरनेस का धन्यवाद !

संपादित करें ६: हटाए गए ० सेट, जैसा कि यह स्वतः ही वहाँ जाता है - मास्टर स्तर कोड गोल्फ तकनीक का उपयोग किया जाता है (अल्पविराम, प्रिंटफ ट्रिक, आदि) - धन्यवाद गैस्ट्रोपनर !

संपादित करें 7: जेम्स होल्डरनेस द्वारा बताए गए बग का उपयोग करें ।

संपादित करें 7: का प्रयोग करें &&को बदलने के लिए अंतिम जाँच पर ?- धन्यवाद jxh ।

c,h;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,memchr("&;@X\\ru{",h%3817,9)&&putchar(h=32);}

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

गैर-गोल्फ (जो अभी भी ईमानदारी से बहुत गोल्फ है ...)


int c;
int h;
void f(char*s)
{
    while(c=*s++)
        putchar(c),
        h=h%10816*104+c%27,
        memchr("&;@X\\ru{",h%3817,9)?putchar(h=32):1;
}

पुराना, सीधा फॉरवर्ड ग्रीप-एसकेई समाधान:

#define p putchar
#define q c=*s++
c,x;f(char*s){while(q){p(c);x=strchr("tse",c);p(q);p(q);if(!strchr("eox",c)){p(q);if(x)p(q);}p(' ');}}

पुराना, क्लीनर संस्करण।

// Above code makes a macro of putchar() call.

void f(char *s)
{
    char c;
    while(c = *s++)
    {
        putchar(c);
        int x = strchr("tse", c);

        putchar(*s++);
        putchar(c=*s++);

        if(!strchr("eox", c))
        {
            putchar(*s++);
            if(x)
            {
                putchar(*s++);
            }
        }       
        putchar(' ');
    }
}

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

— माइकल डोरगन
स्रोत

हम कुछ बाइट्स के लिए पुचर और ऐसे मैक्रो कर सकते हैं, लेकिन सामान्य तौर पर, यदि संभव हो तो एक बेहतर एल्गोरिदम के बारे में सोच रहे हैं।

— माइकल डोरगन

159 बाइट्स#define आईएनजी द्वारा putcharऔर अनावश्यक ब्रैकेट्स की एक जोड़ी को हटाकर।

— श्री Xcoder

2

थोड़ा बदसूरत, लेकिन इसके बजाय का उपयोग करके 136 बाइट्स#define p putchar( (खुले कोष्ठक पर ध्यान दें)।

— टॉम कारपेंटर

1

109 बाइट्सc,h=0;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,c=h%3817,printf(" "+!(c&&strchr("&;@X\\ru{",c)));}

— गैस्ट्रोपनर

आह, मैं एक दो कोष्ठक और ब्रेसिज़ के प्लस हटाने के नीचे प्रिंटफ ट्रिक को देखा। मास्टर स्तर कोड गोल्फ सक्षम :)

— माइकल डोरगन

5

जावास्क्रिप्ट, 66 57 52 44 41 बाइट्स

s=>s.replace(/one|t[wh]|.i|[fsz]/g," $&")

बहुत भोला, लेकिन यह काम करता है।

2 चार्ट का उपयोग करने के लिए FrownyFrog द्वारा अच्छी पकड़ .. "एक" को छोड़कर जो एक शुद्ध 2 चार चेक ज़ेरोनिन गड़बड़ कर सकता है। संपादित करें: FrownyFrog द्वारा एकल fऔर sअच्छे कैच थे जो मैंने अपने पहले दो गोल्फों को नजरअंदाज किया।

धन्यवाद, नील, एक अनाम लंबोदर के सुझाव के लिए zऔर 52 के लिए नीचे एक एकल चार्ट का उपयोग करने में सक्षम होने के लिए ।

टाइटस एक छोटे RegEx के साथ आता है। मुझे लगता है कि हम अंततः उरियल के रेक्स की ओर बढ़ रहे हैं।

— Forty3
स्रोत

यदि आप दो वर्णों का उपयोग करते हैं और अंत तक 'ऑन' पर पुश करते हैं तो क्या यह टूट जाता है?

— 23

मैं सोच रहा हूँz|tw|th|f|s|ei|ni|on

— FrownyFrog

1

@FrownyFrog ओ पहले आता है इसलिए इसे पहले पहचाना जाता है।

— यूरिल

1

on|t[wh]|.i|[fsz](-4 बाइट्स)

— टाइटस

2

@ टिट्स - दुर्भाग्य से, रेंडरिंग on|मैच होगाzeroninezer onine

— फोर्टी 3

5

रेटिना , 24 23 बाइट्स

!`..[eox]|[fnz]...|.{5}

इसे ऑनलाइन आज़माएं! संपादित करें: @FrownyFrog के लिए 1 बाइट धन्यवाद सहेजा गया।

— नील
स्रोत

1

होगा .....-> .{5}काम?

— FrownyFrog

5

सी, 103 99 बाइट्स

char*r="f.tzuonresn.xgv";f(char*s){*s&&f(s+printf("%.*s ",(strrchr(r,s[2])-strchr(r,*s))%10,s)-1);}

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

परीक्षण कार्यक्रम

#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}

— टोबी स्पाईट
स्रोत

1

कुछ बाइट्स को पुनरावर्तन का उपयोग करके बचाया जा सकता है: tio.run/##XY/…

— jxh

4

जे , 37 35 बाइट्स

rplc'twthsiseeinionzef'(;LF&,)\~_2:

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

— FrownyFrog
स्रोत

2

शांत वैकल्पिक समाधान! मैंने कोशिश की f=:[:>'..[eox]|[tse]?....'&rxallऔर यह इंटरपीटर में काम किया, लेकिन टीआईओ में काम नहीं करता है।

— गैलेन इवानोव

यह वास्तव में चतुर है, अच्छी तरह से किया

— योना

@GalenIvanov TIO की नवीनतम रिलीज़ है, यह जे में एक प्रतिगमन हो सकता है

— FrownyFrog

4

सी (जीसीसी) , 106 बाइट्स 104 बाइट्स

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

c;f(char*s){char*t=" $&=B*,29/?";while(*s)for(c=4+(strchr(t,(*s^s[1])+35)-t)/4;c--;)putchar(c?*s++:32);}

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

XOR वास्तव में हमारा सबसे बड़ा सहयोगी है।

— gastropner
स्रोत

जैसे s ++ ट्रिक। अच्छा हैश।

— माइकल डोरगन

1

s[1]छोटा हो जाएगा।

— jxh

@jxh अच्छा लगा! अपडेट किया गया।

— गैस्ट्रोपनर

3

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

t[ewh]|[zfs]|(ni|o)ne|ei
 $&

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

— OVS
स्रोत

3

पायथ , 35 27 23 बाइट्स

यूरिल के दृष्टिकोण को चित्रित करके बहुत सारे बाइट्स को बचाया ।

:Q"..[eox]|[tse]?...."1

यहाँ कोशिश करो! प्रारंभिक दृष्टिकोण।

— श्री Xcoder
स्रोत

3

पिप , 27 बाइट्स

aR`[zfs]|one|[ent][iwh]`s._

कमांड-लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

सरल रेगेक्स प्रतिस्थापन, के प्रत्येक मैच से पहले एक स्थान सम्मिलित करता है [zfs]|one|[ent][iwh]।

उरीएल के रेगेक्स की ~~चोरी करने वाले~~ बैंडबाजे पर कूदना 23 बाइट्स देता है ( -sध्वज के साथ ):

a@`..[eox]|[tse]?....`

— DLosc
स्रोत

आप छोटे रेगेक्स का उपयोग कर सकते हैं ।

— आउटगोल्फ

3

जेली , 23 21 बाइट्स

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ

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

इसे ऑनलाइन आज़माएं! (TIO आउटपुट संचित है, एक स्थानीय कार्यान्वयन लाइन द्वारा लाइन प्रिंट करेगा)

कैसे?

पात्रों की एक सूची के साथ शुरू, कार्यक्रम बार-बार:

कुछ क्रमिक गणित का उपयोग करते हुए वर्णों की सूची के पहले शब्द की लंबाई पाता है;
शब्द को प्रिंट करता है साथ ही एक लाइनफीड; तथा
वर्णों की सूची के प्रमुख से शब्द हटाता है

वर्णों की वर्तमान सूची के पहले तीन पात्रों (पहले शब्द का अनिवार्य रूप से हिस्सा) का निरीक्षण करके पहले शब्द की लंबाई तय की जाती है। कार्यक्रम उन्हें अध्यादेशों में परिवर्तित करता है, उन्हें एक साथ गुणा करता है, परिणाम को 953, modulos द्वारा सात, modulos द्वारा तीन और तीन को जोड़ता है:

word   head3  ordinals       product  %953  %7  %3  +3 (=len(word))
zero   zer    [122,101,114]  1404708   939   1   1   4
two    two    [111,110,101]  1233210    28   0   0   3
one    one    [116,119,111]  1532244   773   3   0   3
three  thr    [116,104,114]  1375296   117   5   2   5
four   fou    [102,111,117]  1324674     4   4   1   4
five   fiv    [102,105,118]  1263780   102   4   1   4
six    six    [115,105,120]  1449000   440   6   0   3
seven  sev    [115,101,118]  1370570   156   2   2   5
eight  eig    [101,105,103]  1092315   177   2   2   5
nine   nin    [110,105,110]  1270500   151   4   1   4

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ - Main link, list of characters           e.g. "fiveeight..."
ḣ3              - head to index three                                "fiv"
  O             - ordinals                                           [102,105,118]
   P            - product                                            1263780
    %953        - modulo by 953                                      102
        %7      - modulo by seven                                    4
          %3    - modulo by three                                    1
            +3  - add three                                          4

              ɓ - dyadic chain separation swapping arguments...
... ḣṄȧṫḊÇ ...
    ḣ         - head to index                                        "five"
     Ṅ        - print the result plus a line-feed and yield the result
       ṫ      - tail from index                                      "eeight..."
      ȧ       - and (non-vectorising)                                "eeight..."
        Ḋ     - dequeue                                               "eight..."
         Ç    - call the last link (Main*) as a monad with this as input
              -       * since it's the only link and link indexing is modular.

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

1

मुझे यकीन नहीं है कि क्या इसकी अनुमति है । (गंभीरता से, आप क्या करते हैं जब दो बहुत बड़े मेटा-उत्तर एक-दूसरे के विपरीत कहते हैं?)

— अर्जन जोहान्सन

ओपी स्पष्ट रूप से कहता है "आपके आउटपुट में वैकल्पिक रूप से शुरुआत या अंत में भी ऐसे तार हो सकते हैं" और यह कार्यक्रम वास्तव में प्रिंट करता है, इसलिए आउटपुट किसी भी मजबूर समाप्ति से पहले उत्पन्न होता है।

— जोनाथन एलन

यकीन है, लेकिन मुझे नहीं लगता कि ओपी को एक अनंत अंत स्ट्रिंग माना जाता है। और मेटा-प्रश्न स्पष्ट रूप से उस मामले के बारे में है जहां आउटपुट पहले मुद्रित होता है।

— अर्जन जोहान्सन

मुझे लगता है कि यह आवश्यकता की भावना को पूरा करता है (यदि यह, उदाहरण के लिए, अनंत खाली तारों को मुद्रित करता है और फिर जो शब्द मैं यह तर्क दे सकता हूं वह नहीं किया गया)

— जोनाथन एलन

इसलिए, मुझे लगता है कि मुझे मार्टिन के शिविर में डाल दिया गया है "अगर यह एक कार्यक्रम है और उचित हो सकता है ..." :)

— जोनाथन एलन

3

सी 168 ,145,144, 141 बाइट्स

संपादित करें: इस तरह से 1 के लिए 'आई' की कोशिश की

ए, बी, मुख्य (i)

प्रमुख व्हाट्सएप से छुटकारा पाने के लिए,
लेकिन यह तीन, सात या आठ से शुरू होने वाले इनपुट पर टूट जाता है

141

#define s|a%1000==
a,i;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b%32<<5*i++)if(i>4|a%100==83 s 138 s 116 s 814 s 662 s 478)a=i=0;}

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

144

a,i;main(b){for(;~(b=getchar());printf(" %c"+!!i,b),a=a*21+b-100,++i)if(i>4|a==204488|a==5062|a==7466|a==23744|a==21106|a==6740|a==95026)a=i=0;}

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

168

i,a;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4|a==1869768058|a==6647407|a==7305076|a==1920298854|a==1702259046|a==7891315|a==1701734766)a=i=0;}

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

Ungolfed

i,a;main(b){
for(;~scanf("%c",&b); // for every char of input
printf(" %c"+!!i,b), // print whitespace if i==0 , + char
a|=b<<8*i++ // add char to a for test
)
if(
i>4| // three seven eight
a==1869768058|      // zero
a==6647407|        // one
a==7305076|       // two
a==1920298854|   //four
a==1702259046|  //five
a==7891315|    //six
a==1701734766 //nine
) a=i=0; //reset i and a
}

int constants << 8 को स्थानांतरित करने से अनावश्यक बड़े हो जाते हैं,
लेकिन अगर आप किसी भी तरह तार की तुलना कर सकते हैं तो यह सबसे स्वाभाविक होना चाहिए

146 स्ट्रिंग तुलना का उपयोग करना

#define s|a==*(int*)
a,b;main(i){for(;~(b=getchar());printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4 s"zero"s"one"s"two"s"four"s"five"s"six"s"nine")a=i=0;}

स्ट्रिंग तुलना का उपयोग करना

Obfuscated

#define F(x)if(scanf(#x+B,&A)>0){printf(#x,&A);continue;}
B;A;main(i){for(;i;){B=1;F(\40e%4s)F(\40th%3s)F(\40se%3s)F(\40o%2s)B=2;F(\40tw%1s)F(\40si%1s)B=1;F(\40%4s)i=0;}}

— PrincePolka
स्रोत

2

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

Ṛ¹Ƥz⁶ZUwÐ€“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳ¤$€Ẏḟ1Ṭœṗ

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

— आउटग्रॉफर को एरिक
स्रोत

3

सॉरी यार, तुम दो बार आउटगोइंग हो चुके हो।

— 21

2

काफी लंबा है। आप इसे नीचे गोल्फ में स्वागत है।

आर , 109 बाइट्स

function(x)for(i in utf8ToInt(x)){F=F+i;cat(intToUtf8(i),if(F%in%c(322,340,346,426,444,448,529,536,545))F=0)}

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

— djhurio
स्रोत

अंकों के बजाय यूनिकोड वर्णों का उपयोग करने का कोई तरीका?

— माइकल डोरगन

का अच्छा अनुप्रयोग intToUtf8! Regexp का उपयोग करके एक अलग दृष्टिकोण का उपयोग करके 90 बाइट्स संभव होंगे:function(x,p=paste,z=p("(",p(c("zero",broman::numbers),collapse="|"),")"))gsub(z,"\\1 ",x)

— माइकल एम

2

हास्केल , 81 बाइट्स

f[c]=[c]
f(h:t)=[' '|s<-words"z one tw th f s ei ni",and$zipWith(==)s$h:t]++h:f t

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

स्पष्टीकरण:

f(h:t)=                      h:f t -- recurse over input string
   [' '|s<-               ]++      -- and add a space for each string s
      words"z one tw th f s ei ni" -- from the list ["z","one","tw","th","f","s","ei","ni"]
      ,and$zipWith(==)s$h:t        -- which is a prefix of the current string

— Laikoni
स्रोत

2

पायथन 3 (कोई रेगेक्स) , 85 बाइट्स

i=3
while i<len(s):
	if s[i-3:i]in'ineiveroneghtwoureesixven':s=s[:i]+' '+s[i:]
	i+=1

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

— एलेक्स
स्रोत

2

PPCG में आपका स्वागत है!

— लकोनी

यह अच्छा है, लेकिन एक पूर्ण कार्यक्रम में इनपुट लेने के लिए कोड शामिल होना चाहिए।

— जोनाथन एलन

तो, एक पूर्ण कार्यक्रम के रूप में 104 बाइट्स । हालाँकि आप 4 का उपयोग करके बचा सकते हैं while s[i:]और फिर आप पुनरावर्ती जमा करके 93 बाइट्स तक प्राप्त कर सकते हैं lambda(कार्यों को केवल प्रिंट करने के बजाय आउटपुट को वापस करने की आवश्यकता है)।

— जोनाथन एलन

2

एक्सेल, 181 बाइट्स

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"z"," z"),"on"," on"),"tw"," tw"),"th"," th"),"f"," f"),"s"," s"),"ei"," ei"),"ni"," ni")

के सामने एक अंतरिक्ष स्थान: z, on, tw, th, f, s, ei,ni

— Wernisch
स्रोत

2

Z80 विधानसभा, 46 45 बाइट्स

; HL is the address of a zero-terminated input string
; DE is the address of the output buffer

Match5: ldi                                 ; copy remaining characters
Match4: ldi
Match3: ld a,32 : ld (de),a : inc de        ; and add space after a matched word.

Uncollapse:

        ld a,(hl) : ldi : or a : ret z      ; copy first byte (finish if it was zero)
        ex af,af'                           ; and save its value for later.

        ldi : ld a,(hl) : ldi               ; copy second and third bytes

        cp 'e' : jr z,Match3                ; is the third letter 'e' or 'o' or 'x'?
        cp 'o' : jr z,Match3
        cp 'x' : jr z,Match3

        ex af,af'                           ; now look at the first letter

        cp 'e' : jr z,Match5                ; is it 't' or 's' or 'e'?
        sub 's' : jr z,Match5
        dec a : jr z,Match5
        jr Match4

(यह उरीएल के शांत रेगेक्स को एक रेग्ज-अनफ्रेंडली वातावरण में अनुकूलित करने के लिए मजेदार था)।

— introspec
स्रोत

1

जेली , 40 39 बाइट्स

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK

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

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

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK
“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»                 = the compressed string of the digit names
                        Ḳ                = split at spaces
                         e€€@ŒṖ          = check whether each member of each partition of the argument is a digit.
                               Ạ€        = A function that checks whether all values of an array are true, applied to each element.
                                 T       = Finds the index of each truthy element 
                                  Ḣ      = Grab the first element, since we have a singleton array
                                    ịŒṖ  = The previous command gives us the index, partition that splits the input into digits. This undoes it and gives us the partition.
                                       K = Join the array of digits with spaces

— जाकारी
स्रोत

1

क्वाड्स , 21 20 बाइट्स

..[eox]|[tse]?....
&

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

यह मेरे रेटिना उत्तर का एक बंदरगाह है ।

— Uriel
स्रोत

1

एपीएल (डायलॉग यूनिकोड) , 25 बाइट्स

'..[eox]|[tse]?....'⎕S'&'

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

— आउटग्रॉफर को एरिक
स्रोत

1

पायथन 3 , नो रेगेक्स, 83 68 65 63 बाइट्स

-15 लिन के लिए धन्यवाद (एक समारोह में रिफ्लेक्टर)
-3 लिन के लिए और अधिक धन्यवाद (अधिक अंकगणित के साथ एक सूची में अनुक्रमण से बचें)
... 2 बाइट्स की एक और बचत के लिए अग्रणी (नकारात्मक मॉड्युलोस के साथ कोष्ठक से परहेज) :)

def f(s):h=ord(s[0])*ord(s[1])%83%-7%-3+5;print(s[:h]);f(s[h:])

एक फ़ंक्शन जो नए शब्दों को अलग किए गए शब्दों को प्रिंट करता है और फिर एक उठाता है IndexError।

इसे ऑनलाइन आज़माएं! (परीक्षण-सूट के भीतर कई रन की अनुमति देने के अपवाद को दबा देता है)

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

मैं इसे बहुत बाद में फिर से पढ़ रहा हूं और यह महसूस कर रहा हूं कि यह 68 बाइट्स हो सकता है:def f(s):h=[4,5,3][ord(s[0])*ord(s[1])%83%7%3];print(s[:h]);f(s[h:])

— लिन

अरे वाह, h(s)और h(s)मैं कैसे ध्यान नहीं दिया ?! धन्यवाद लिन!

— जोनाथन एलन

मुझे यकीन नहीं है कि मैं इस सवाल पर वापस कैसे आता हूं और नई चीजों को नोटिस करता हूं, लेकिन h=(ord(s[0])*ord(s[1])%83%7+1)%3+365 बाइट्स हैं! :)

— लिन

हे, धन्यवाद लिन, कि दो और बाइट्स भी बंद गोल्फ होने की अनुमति दी!

— जोनाथन एलन

0

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

œṣj⁶;$}
W;“€ɗİẒmṫṃ¦¦ạỊɦ⁼Fḷeṭḷa»s2¤ç/

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

कलन विधि:

for x in ['ze', 'ni', 'on', 'tw', 'th', ...]:
    replace x in input by space+x

मुझे यकीन है कि हम और भी बेहतर कर सकते हैं।

— लिन
स्रोत

0

गणितज्ञ, 125 बाइट्स

(s=#;While[StringLength@s>2,t=1;a="";While[FreeQ[IntegerName/@0~Range~9,a],a=s~StringTake~t++];Print@a;s=StringDrop[s,t-1]])&

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

TIO "CountryData" के बारे में एक त्रुटि संदेश आउटपुट करता है (???)
मुझे नहीं पता कि ऐसा क्यों होता है, लेकिन अहंकार कीमिया पर ठीक काम करता है

— J42161217
स्रोत

0

पर्ल 6 , 42 30 बाइट्स

*.comb(/<{(0..9).Str.uninames.lc.words}>/)

झसे आज़माओ

{m:g/..<[eox]>||<[tse]>?..../}

इसका परीक्षण करें
(अन्य उत्तरों से अनुवादित)

— ब्रैड गिल्बर्ट b2gills
स्रोत

0

क्यू / केडीबी +, ५ ९ ५१ बाइट्स

उपाय:

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}

उदाहरण:

q){asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}"threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight"
"three"
"seven"
"seven"
"six"
"nine"
"nine"
"nine"
"five"
"eight"
"two"
"five"
"eight"
"six"
"three"
"eight"

स्पष्टीकरण:

त्वरित समाधान, शायद बेहतर और अधिक गोल्फ दृष्टिकोण।

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x} / ungolfed solution
{                                                 } / lambda with implicit x as input
                                             cut x  / cut x at indices given by left
 asc[                                       ]       / sort ascending
                string`z`one`tw`th`f`s`ei`ni        / string list ("z","one",...)
          x ss/:                                    / string-search left with each right
     raze                                           / reduce down list

टिप्पणियाँ:

कुछ सरल गोल्फ के साथ 46 बाइट्स, क्ष को k के साथ कॉल करता है, लेकिन फिर भी एक भारी समाधान है।

asc[(,/)x ss/:($)`z`one`tw`th`f`s`ei`ni]cut x:

— streetster
स्रोत

बिना अंक के अंक

कार्य

नियम

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

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

C (gcc) , 89 80 76 75 72 71 70 69 बाइट्स

अजगर 2 , 50 बाइट्स

बेफुंज, 87 85 81 76 बाइट्स

जावा (ओपनजेडके 8) , 55 46 43 बाइट्स

C (gcc) , 179 159 146 139 137 116 107 103 102 बाइट्स

जावास्क्रिप्ट, 66 57 52 44 41 बाइट्स

रेटिना , 24 23 बाइट्स

सी, 103 99 बाइट्स

परीक्षण कार्यक्रम

जे , 37 35 बाइट्स

सी (जीसीसी) , 106 बाइट्स 104 बाइट्स

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

पायथ , 35 27 23 बाइट्स

पिप , 27 बाइट्स

जेली , 23 21 बाइट्स

कैसे?

सी 168 ,145,144, 141 बाइट्स

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

आर , 109 बाइट्स

हास्केल , 81 बाइट्स

पायथन 3 (कोई रेगेक्स) , 85 बाइट्स

एक्सेल, 181 बाइट्स

Z80 विधानसभा, 46 45 बाइट्स

जेली , 40 39 बाइट्स

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

क्वाड्स , 21 20 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 25 बाइट्स

पायथन 3 , नो रेगेक्स, 83 68 65 63 बाइट्स

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

गणितज्ञ, 125 बाइट्स

पर्ल 6 , 42 30 बाइट्स

क्यू / केडीबी +, ५ ९ ५१ बाइट्स