६ को 7 का डर क्यों था?

61

६ को 7 का डर क्यों था? क्योंकि Because 7 ९!

एक स्ट्रिंग को देखते हुए निम्नलिखित परिवर्तनों को लागू करें:

  • यदि 7 को हटाने पर 6 के आगे 6 है (6 को 7 से डर लगता है)
  • यदि अनुक्रम "789" प्रतीत होता है 8 और 9 को हटा दें (7 खाया 9)

(अगर मैं गलत नहीं हूँ तो इससे कोई फर्क नहीं पड़ता कि आप किस क्रम में परिवर्तन करते हैं)

इन परिवर्तनों को तब तक लागू करते रहें, जब तक आप अब नहीं कर सकते।

उदाहरण:

78966

पहले हम "789" देखते हैं, इसलिए स्ट्रिंग "766" बन जाती है। फिर हम "76" देखते हैं, इसलिए हम 6 निकालते हैं, और स्ट्रिंग "76" बन जाती है। फिर हम "76" को फिर से देखते हैं, इसलिए हमें "7" के साथ छोड़ दिया जाता है।

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

  • 987=> 987(सही क्रम में नहीं। कुछ नहीं करता।)
  • 6 7=> 6 7(व्हाट्सएप 6 और 7 के बीच बफर के रूप में कार्य करता है। कुछ भी नहीं होता है)
  • 676 => 7
  • 7896789 => 77
  • 7689 => 7
  • abcd => abcd
code-golf  string 
— geokavel
स्रोत
130
विस्टा 7 से क्यों डरता था? क्योंकि 7 8 10.
— lirtosiast
2
एक अन्य परीक्षण मामला 68978966897896=>68977
— ब्रैड गिल्बर्ट b2gills
19
@ThomasKwa ओह, मैं इसे प्राप्त करता हूं: माइक्रोसॉफ्ट ने विंडोज 9 को छोड़ दिया क्योंकि वे पहेली के साथ जा रहे थे। ;)
— यूटीप्रोडक्शन
43
सात का डर पाँच क्यों था? क्योंकि छह सात आठ। --योडा
— जकूजी
2
छह को सात का डर था क्योंकि सात की ठंडी, मृत आँखें थीं।
— कॉनर ओ'ब्रायन

जवाबों:

12

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

s=>s.replace(/6*7(89|6)*/g,7)

परीक्षा:

f=s=>s.replace(/6*7(89|6)*/g,7)
;`987 -> 987
6 7 -> 6 7
676 -> 7
7896789 -> 77
7689 -> 7
abcd -> abcd`
.split`\n`.every(t=>(t=t.split` -> `)&&f(t[0])==t[1])
— Qwertiy
स्रोत
12
महान, और चूंकि 9 खाया जाता है, आपके पास केवल 2 बाइट्स हैं और इस उत्तर के साथ जीतें: पी
— पियरे अरलाउड
12

जावा, 126 81 66 58 बाइट्स

इस कोड का लंबो वर्जन उपलब्ध कराने के लिए @GamrCorps को धन्यवाद!

ऑटोबॉक्सिंग ट्रिक बताने के लिए @ user902383 को धन्यवाद!

...हाँ।

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

लंबोदर रूप:

x->{for(;x!=(x=x.replaceAll("67|76|789","7")););return x;}

फंक्शन फॉर्म:

String s(String x){for(;x!=(x=x.replaceAll("67|76|789","7")););return x;}

परीक्षण योग्य अघोषित कोड:

class B{
    public static void main(String[]a){
        System.out.print(new B().s(a[0]));
    }
    String s(String x){for(;x!=(x=x.replaceAll("67|76|789","7")););return x;}
}
— एडिसन क्रम्प
स्रोत
2
मेमने के साथ क्यों नहीं जाते? कम से कम 15 बाइट
— बचाएगी
@GamrCorps वाक्यांश का उपयोग कैसे करें - यह कभी नहीं जानते कि कार्यों का उपयोग न करें।
— एडिसन क्रम्प
1
इंटरफ़ेस की बात क्या है और वर्ग नहीं?
— आईस
3
@ आईस इंटरफ़ेस मुख्य को सार्वजनिक घोषित करने की आवश्यकता को हटाता है, जो थोड़ा सा लाभ देता है। देखें: codegolf.stackexchange.com/a/64713/44713
— एडिसन क्रम्प
1
@ user902383 आप जो कमी कर रहे हैं वह बदलकर .equalsहै !=, जो एक ही काम नहीं करता है। ==(या !=) ऑब्जेक्ट हेक्स स्थान से तुलना करता है, मूल्य से नहीं। यह समान लंबाई है अन्यथा। while()7 बाइट्स है, for(;;)7 बाइट्स है।
— एडिसन क्रम्प
9

जीएनयू सैड, 17

-rविकल्प के लिए स्कोर में +1 शामिल है ।

s/6*7(6|89)*/7/g
— डिजिटल आघात
स्रोत
के लिए काम नहीं करना 67789चाहिए, 77लेकिन इसे वापस लौटना चाहिए677
— ब्रैड गिल्बर्ट b2gills
1
आप s/67|7(6|89)/7/इसके बजाय का उपयोग कर सकते हैं s/6?7(6|89)/7/
— ब्रैड गिल्बर्ट b2gills 19
1
जी, मुझे आश्चर्य है कि लैरी किसके विचार के साथ आया था s///g?
— ब्रैड गिलबर्ट b2gills
8

पर्ल 6 , 19  18 बाइट्स

{S:g/6*7[6|89]*/7/} # 19 bytes

$ perl6 -pe 's:g/6*7[6|89]*/7/' # 17 + 1 = 18 bytes

(ध्यान दें कि [6|89]जो गैर-कैप्चरिंग संस्करण है, (6|89)जिसे (?:6|89)Perl 5 में लिखा गया है। <[6|89]>आप कैसे लिखेंगे कि [6|89]Perl 5 में क्या लिखा गया है)

उपयोग: 

$ perl6 -pe 's:g/6*7[6|89]*/7/' <<< '
987
6 7
6676689
7896789
7689
abcd
68978966897896
79|689
'
987
6 7
7
77
7
abcd
68977
79|689
— ब्रैड गिल्बर्ट b2gills
स्रोत
मैं पर्ल 6 को नहीं जानता, लेकिन मुझे लगता है कि यह एक दोहराया प्रतिस्थापन है। यदि 6*और [6|89]*कुछ भी मेल नहीं खाता है, तो विज्ञापन के 7लिए प्रतिस्थापित होने वाले स्टॉप को क्या कहा जाता है 7?
— डिजिटल ट्रामा
2
@DigitalTrauma इसके 7साथ स्वैप 7होता है फिर अगली स्थिति में फिर से शुरू होता है, अंत तक अपना काम करता है। नहीं के :gलिए छोटा है । :globalrepeat until it doesn't match anymore
— ब्रैड गिल्बर्ट b2gills
1
@DigitalTrauma s/67|76|789/7/पर काम करने के लिए 667मुझे इसके प्रभाव के रूप में कुछ लिखना होगा: while s/67|76|789/7/ {}यदि आप इसे वैसा while s/6*7[6|89]*/7/ {}ही लिखेंगे जैसा आपने अपेक्षा की थी, तो कभी नहीं रुकेगा । इसके अलावा, पिछली टिप्पणी के अंत के रूप में आ सकता है उत्साही, कि यह कैसे inteded था नहीं है
— ब्रैड गिल्बर्ट b2gills
1
नहीं []बदला जाना चाहिए ()? आप पाइपों का मिलान नहीं करना चाहते या 79999।
— jwodder
1
@jwodder नहीं []पर्ल 6 गैर-कैप्चरिंग संस्करण है (), जिसे आप सोच रहे हैं कि पर्ल 6 में क्या लिखा गया <[6|89]>है
— ब्रैड गिल्बर्ट b2gills
4

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

StringReplace[#,"67"|"76"|"789"->"7"]&~FixedPoint~#&

व्याख्या:

                                                   &   A function returning
                                     &                   a function returning
              #                                            its first argument
StringReplace[ ,                    ]                     with
                "67"                                        "67"
                    |                                      or
                     "76"                                   "76"
                         |                                 or
                          "789"                             "789"
                               ->                         replaced with
                                 "7"                       "7"
                                    ~FixedPoint~        applied to
                                                #        its first argument
                                                        until it no longer changes.
— LegionMammal978
स्रोत
8
गोल्फ कोड स्पष्टीकरण कोड की तुलना में स्पष्ट है .. :)
— Rob
@ रोब व्यवस्थित दृष्टिकोण के लिए जाने से पहले कई स्पष्टीकरण नहीं दिया गया है।
— लीजनमोनमाल 978
मैं बस चिढ़ा रहा था, दोस्त :)
— रोब
3

जंग, 96 बाइट्स

fn f(mut s:String)->String{for _ in 0..s.len(){for r in&["67","76","789"]{s=s.replace(r,"7")}}s}

आमतौर पर लंबे समय तक, जंग के लिए हमेशा की तरह ...

Ungolfed:

fn seven_ate_nine(mut str: String) -> String {
    for _ in 0..str.len() {
        for to_replace in &["67","76","789"] {
            str = str.replace(to_replace, "7");
        }
    }
    s
}
— Doorknob
स्रोत
कम से कम यह जावा नहीं है
3

एमएसीएस लिस्प, 59 बाइट्स

(lambda(s)(replace-regexp-in-string"6*7\\(6\\|89\\)*""7"s))

यह रिक्त स्थान के साथ थोड़ा स्पष्ट हो जाता है:

(lambda (s) (replace-regexp-in-string "6*7\\(6\\|89\\)*" "7" s))
— भगवान युमा
स्रोत
3

रूबी, 27 बाइट्स

यह समाधान ब्रैड गिल्बर्ट b2gills के लिए टिप्पणियों, क्रेडिट से है ।

->s{s.gsub /6*7(6|89)*/,?7}

रूबी, 37 बाइट्स

(पुराना समाधान)

यह समाधान इस तथ्य का उपयोग करता है कि आपको स्ट्रिंग में वर्णों की तुलना में अधिक बार प्रतिस्थापित करने की आवश्यकता नहीं होगी।

->s{s.chars{s.sub! /67|76|789/,?7};s}
— MegaTom
स्रोत
आप कुछ बाइट्स को बचाने के charsबजाय उपयोग कर सकते हैं size.times।
— दरवाज़े
क्या रूबी के पास रेगेक्स प्रतिस्थापन के लिए वैश्विक ध्वज नहीं है, या यह सक्षम करने के लिए अधिक बाइट्स लेगा?
— ब्रैड गिल्बर्ट b2gills
@ ब्रैडीगिल्बर्ब २ गल्स, रूबी में ऑक की तरह है: पहले या सभी को बदलने के लिए अलग-अलग sub()और gsub()तरीके हैं। इसलिए वैश्विक अब केवल एक चरित्र है।
— मैनेटवर्क
1
@ मैनटवर्क तब मैं इसे कुछ इस तरह लिखूंगा: ->s{s.gsub /6*7(6|89)*/,'7'}और gsubसभी काम करने देंगे ।
— ब्रैड गिल्बर्ट b2gills
यदि मैं कमांड लाइन के झंडे के नियमों को सही ढंग से समझता हूं, तो आप -p कमांड लाइन फ्लैग (+1) का उपयोग करके 16 बाइट्स बचा सकते हैं, जो कुल 20 + 1 बाइट्स के gsub /6*7(6|89)*/,?7उपयोग ruby -pe "gsub /6*7(6|89)*/,?7"के साथ बना रहे हैं
— एलेक्सिस एंडरसन
2

पॉवरशेल, 27 बाइट्स

$args-replace'6*7(89|6)*',7

e.g.
PS C:\temp> .\ate.ps1 "7689"
7

PS C:\temp> .\ate.ps1 "abcd"
abcd

PS C:\temp> .\ate.ps1 "68978966897896"
68977

काम लेना:

  • किसी और का रेगेक्स पैटर्न
  • जिस तरह -replaceसे PowerShell में एक वैश्विक डिफ़ॉल्ट रूप से प्रतिस्थापित करता है
  • लूप अनरोलिंग, जहां यह -regexऑपरेटर को सरणी $argsमें व्यक्तिगत रूप से सभी तत्वों को लागू करने के लिए लागू करेगा, और यहां केवल एक तत्व है क्योंकि केवल एक स्क्रिप्ट पैरामीटर है, इसलिए यह ठीक काम करता है और हम सूचकांक तत्व होने से बच सकते हैं [0]।

वैश्विक प्रतिस्थापन को महसूस करने से पहले नवीनता का पिछला प्रयास यह करेगा; स्ट्रिंग के गुणन का उपयोग करके "-replace -replace -replace" की एक श्रृंखला बनाने के 74 बाइट्स, स्ट्रिंग की लंबाई के रूप में कई बार, फिर eval () आईएनजी:

"'$($args)'"+("{0}6|6(?=7)'{0}89'"-f"-replace'(?<=7)")*$args[0].Length|iex

(जगह की संख्या को कम करने के लिए स्ट्रिंग प्रतिस्थापन के एक बिट के साथ)।

— TessellatingHeckler
स्रोत
2

CJam, 70 64 बाइट्स

धन्यवाद काटने के लिए टेलर @Peter करने {"789":I}{"76:":I}?के लिए"789""76"?:I

"67":Iq:A{AI#:B){AB<7+A{BI,+}~>+s:A];}{"76"I={"789":I}{"76":I}?];}?}/A

"67":Iq:A{AI#:B){AB<7+A{BI,+}~>+s:A];}{"76"I="789""76"?:I];}?}/A

मुझे पता है कि यह शायद बहुत आगे बढ़ाया जा सकता है और आपकी मदद की बहुत सराहना की जाएगी, लेकिन स्पष्ट रूप से मैं खुश हूं कि मैं जवाब पाने में कामयाब रहा। CJam लिखने का यह मेरा पहला प्रयास था।

व्याख्या:

"67":I                e# Assign the value of 67 to I
q:A                   e# Read the input and assign to A
{                     e# Opening brackets for loop
    AI#:B)            e# Get the index of I inside A and assign to B. The increment value by 1 to use for if condition (do not want to process if the index was -1)
    {                 e# Open brackets for true result of if statement
        AB<           e# Slice A to get everything before index B
        7+            e# Append 7 to slice
        A{BI,+}~>     e# Slice A to get everything after index B plus the length of string I (this will remove I entirely)
        +s:A          e# Append both slices, convert to string, and assign back to A
        ];            e# Clear the stack
    }                 e# Closing brackets for the if condition
    {                 e# Open brackets for false result of if statement
        "76"I=        e# Check if I is equal to 76
        "789"         e# If I is 76, make I 789
        "76"?:I       e# If I is not 76, make I 76
        ];            e# Clear the stack if I does not exist inside A
    }?                e# Closing brackets for false result of if statement
}/                    e# Loop
A                     e# Output A
— कॉनराड बक्से
स्रोत
मैंने स्वयं इस प्रश्न का प्रयास नहीं किया है, इसलिए मुझे यकीन नहीं है कि यह सबसे अच्छा तरीका है, लेकिन यदि आप विभाजन करना और जुड़ना चाहते हैं तो एक नज़र डालें /और *। यह भी ध्यान दें कि जब आप सी जैसी भाषाओं के लिए उपयोग किए जाते हैं तो स्टैक के संदर्भ में सोच कुछ अनुकूलन लेती है। जैसे {"789":I}{"76":I}?बनने के लिए असाइनमेंट को बाहर निकाल सकते हैं "789""76"?:I, जिसे आगे बढ़ाया जा सकता है 78976`3/?:I।
— पीटर टेलर
धन्यवाद! हालांकि मैं आपके दूसरे सुझाव का उपयोग करने के तरीके को काफी समझ नहीं पाया।
— कॉनरैड क्रेट
माफ कीजिएगा यह मेरी गलती है। 78976`3/एक सरणी देता है ["789" "76"]; तब उपयोग करने के बजाय ?आपको =इंडेक्स का उपयोग करने की आवश्यकता होगी ; लेकिन यह बैक-टू-फ्रंट है, इसलिए लाभ को खोने के लिए सूचकांक की आवश्यकता होगी।
— पीटर टेलर
2

MATL , 17 बाइट्स

jt"'789|76'55cYX]

उदाहरण

>> matl
 > jt"'789|76'55cYX]
 > 
> 7896789
77

संपादित करें : इसे ऑनलाइन आज़माएं!

व्याख्या

j                   % input string
t                   % duplicate
"                   % for each character. Iterates as many times as the string length
    '789|76'        % regular expression for replacement
    55c             % string to insert instead: character '7'
    YX              % regexprep
]                   % end for

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

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

गंभीरता से, 29 बाइट्स

,;l`'7;;"67"(Æ"76"(Æ"789"(Æ`n

इनपुट को दोहरे-उद्धृत स्ट्रिंग के रूप में लेता है, जैसे "6789"। इसे ऑनलाइन आज़माएं (आपको इनपुट को मैन्युअल रूप से उद्धृत करना होगा)।

व्याख्या:

,;l`'7;;"67"(Æ"76"(Æ"789"(Æ`n
,;l                            get input and push its length (we'll call it n)
   `                       `n  call the following function n times:
    '7;;"67"(Æ                   replace all occurrences of "67" with "7"
              "76"(Æ             replace all occurrences of "76" with "7"
                    "789"(Æ      replace all occurrences of "789" with "7"
— मेगो
स्रोत
1

थू , 26 बाइट्स

67::=7
76::=7
789::=7
::=

एक अनुगामी न्यूलाइन भी शामिल है।

इसे शुरू करने से पहले कार्यक्रम में इनपुट जोड़ा जाता है।
जब यह समाप्त हो जाता है, तो ट्यूरिंग मशीन के समान आउटपुट प्रोग्राम को पढ़ा जाता है।
(Thue करता है एक निर्गम धारा है, लेकिन इसे सही ढंग से उपयोग करने के लिए मुश्किल है, तो मुझे यकीन है कि यह एक स्वीकार्य उत्पादन विधि है कि क्या नहीं कर रहा हूँ)

— user253751
स्रोत
मुझे ऐसा नहीं लगता। यदि आपके पास STDOUT के लिए एक रास्ता है, तो आपको करना होगा। माफ़ करना!
हां, मेटा पोस्ट के अनुसार इसकी अनुमति है।
— जियोकॉवेल
1

बैश, 102 82 67 (+7)? बाइट्स

extglob संस्करण

x=$1
while v=${x/@(76|67|789)/7};[ $v != $x ];do x=$v;done
echo $v

यह एक फ़ाइल में रखा जाना है और उदाहरण के लिए कहा जाता है bash -O extglob 789.sh 6567678989689789656। (+7)? बाइट्स के लिए है अगर extglob विकल्प बाइट्स की ओर गिना जाता है।

Extglob सुविधाओं को इंगित करने के लिए @BinaryZebra के लिए धन्यवाद!

नॉन-एक्सग्लोब संस्करण (82 बाइट्स)

x=$1
while v=${x/76/7};v=${v/67/7};v=${v/789/7};[ $v != $x ];do x=$v;done
echo $v

यह एक फ़ाइल में रखा जाना है और उदाहरण के लिए कहा जाता है ./789.sh 65678989656।

यह लूप में खोजने और बदलने के लिए पैरामीटर विस्तार का उपयोग करता है। मैं प्रतिस्थापन की एक श्रृंखला को शामिल करने के लिए जगह ले रहा हूं क्योंकि मैं अधिक प्रभावी ढंग से श्रृंखला विस्तार के तरीके से अवगत नहीं हूं।

— pooping
स्रोत
PPCG में आपका स्वागत है!
— Mego
@BinaryZebra आह, @()वाक्य रचना के लिए धन्यवाद । मुझे पता था कि उन को मिलाने का एक तरीका होना चाहिए। और @ मेगो, स्वागत के लिए धन्यवाद!
— पोपिंग
1

आर, 35 बाइट्स

cat(gsub("6*7(6|89)*",7,scan(,"")))

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

— Mutador
स्रोत
0

PHP 51 अक्षर

while($s!=$r=str_replace([789,67,76],7,$s)){$s=$r;}

टेस्ट केस लंबे हाथ में लिखा गया

$s = '78966';
while ($s != $r = str_replace([789, 67, 76], 7, $s) )
{
    $s = $r;
}
echo $s; // 7;

यह स्ट्रिंग की तुलना करता है और स्ट्रिंग को दोनों ही स्थिति में बदल देता है। यदि शर्त पूरी होती है, तो यह परिणाम के साथ तुलना के बाएं हाथ को अद्यतन करता है। मुझे किसी भी सुधार के बारे में बताएं।

— बत्तख
स्रोत
0

PHP, 36 बाइट्स

preg_replace('/6*7(6|89)*/','7',$a);

रेगेक्स समाधान, $ स्ट्रिंग लेता है और अभिव्यक्ति के माध्यम से बदलता है।

— daraeman
स्रोत
GET पैरामीटर PHP में एक इनपुट विधि के रूप में स्वीकार्य नहीं हैं । आपको इसे एक फ़ंक्शन बनाने और इनपुट को फ़ंक्शन पैरामीटर के रूप में पास करने की आवश्यकता होगी, $argvया एसटीडीआईएन से इनपुट प्राप्त करना होगा ।
— Mego
@Mego आप जिस पद से जुड़े हैं उस पर कोई सर्वसम्मति नहीं प्रतीत होती है।
— user253751
@ मिनीबिस करेक्ट। I / O विधि को स्वीकार्य बनाने के लिए आम सहमति आवश्यक है। एक की कमी का मतलब यह स्वीकार्य नहीं है।
— Mego
यदि आप कोडगुल्फ़ के लिए PHP का उपयोग करते हैं, तो टीआर; डीआर आपको गंभीर नुकसान है।
— हमजा
0

क्लोजर, 71 बाइट्स

क्लोबर अपने क्रिया प्रकृति के कारण गोल्फ के लिए कम से कम आदर्श है - लेकिन फिर भी यह एक दिलचस्प व्यायाम है:

जावा इंटरॉप का उपयोग करके गोल्फ संस्करण:

(defn f[s](let[x(.replaceAll s "67|76|789" "7")](if(= s x)s(recur x))))

जावा इंटरॉप का उपयोग कर अन-गोल्‍डेड संस्‍करण:

(defn six-fears-seven [s]
  (let [x (.replaceAll s "67|76|789" "7")]
    (if (= s x)
      s
      (recur x))))

अन-गोल्‍ड "शुद्ध क्लोजर" संस्‍करण:

(defn six-fears-seven [s]
  (let [x (clojure.string/replace s #"67|76|789" "7")]
    (if (= s x)
      s
      (recur x))))
— बॉब जार्विस
स्रोत
0

/// , 19 बाइट्स (गैर-प्रतिस्पर्धात्मक)

/67/7//76/7//789/7/

आप वास्तव में इस भाषा में इनपुट प्रदान नहीं कर सकते हैं, इसलिए माना गया इनपुट कोड के दाईं ओर जाता है।

— आउटगोल्फर को एरिक करें
स्रोत
ध्यान दें कि Itflabtijtslwi स्लैश है लेकिन इनपुट के साथ।
— FryAmTheEggman 15
@FryAmTheEggman हालांकि एक इनपुट पात्रों , तार नहीं है ।
— आउटगोल्फर
आपका लिंक एक स्लैश याद आ रहा है।
— डिलीट
0

जाप v2.0a0, 12 बाइट्स

e/6?7(6|89/7

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

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

String.eफ़ंक्शन का पुनरावर्ती है। जेएपीटी 2 में रेगेक्स के अंदर एक नया रेगेक्स सिंटैक्स और ऑटो-कोष्ठक पूरा होता है, जो यहां एक बाइट बचाता है। (जैप 1.x में, हमें रेगीज़ के स्थान पर स्ट्रिंग्स पास करना था, जो थोड़े क्लंकी था।)

— bubbler
स्रोत
0

डायलॉग एपीएल , 17 बाइट्स

'6*7(6|89)*'⎕R'7'

'6*किसी भी छक्के की संख्या
7 सात के  बाद
(… )*'शून्य या उससे अधिक के अनुक्रमों के बाद…
 6|89 एक छह या आठ-नौ

⎕R के साथ कि eplace

'7' जैसे समान

— एडम
स्रोत
0

05AB1E , 12 बाइट्स

Δ67‚7:789¬:

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या:

Δ               # Continue doing the following until it no longer changes:
 67             #  Push 67 to the stack
   Â            #  Bifurcate (short for Duplicate & Reverse); which pushes 76 to the stack
    ‚           #  Pair them up
     7:         #  Replace all occurrences of 67 or 76 with 7 in the (implicit) input
                #   i.e. 17893762 → 1789372
       789      #  Push 789 to the stack
          ¬     #  Take the head (without popping); which pushes 7 to the stack
           :    #  Replace all 789 with 7
                #   i.e. 1789372 → 17372
                # (And implicitly output the result after the loop)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.