Neden 6 7'den korkuyordu? Çünkü 7 8 9!

Bir dize verilen aşağıdaki dönüşümleri uygulayın:

• 7'nin yanında 6 varsa 6'yı çıkarın (6 7'den korkar)
• "789" sekansı belirirse 8 ve 9'u kaldırın (7 9)

(Eğer yanılmıyorsam, dönüşümleri hangi sırayla yaptığınız önemli değildir)

Artık bu işlemi yapamayana kadar bu dönüşümleri uygulamaya devam edin.

Örnek:

78966

İlk önce "789" u görüyoruz, böylece ip "766" oluyor. Sonra "76" yı görüyoruz, böylece 6'yı çıkarıyoruz ve string "76" oluyor. Sonra tekrar "76" görüyoruz, böylece "7" ile kalıyoruz.

Test Durumları:

• 987=> 987(Doğru sırada değil. Hiçbir şey yapmaz.)
• 6 7=> 6 7(Boşluk, 6 ile 7 arasında bir tampon görevi görür. Hiçbir şey olmuyor)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Retina , 12

Sed cevabının çevirisi:

6*7(6|89)*
7

Çevrimiçi deneyin

Javascript ES6, 29 bayt

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

Ölçek:

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])

Java, 126 81 66 58 bayt

Bu kodun lambda sürümünü sağladığı için @GamrCorps'a teşekkürler!

Bir otomatik boks hilesi işaret için @ user902383 için teşekkürler!

...Evet.

Aslında beklediğimden daha uzun - Java dizeleri içindeki öğeleri replaceAll()değiştirmeyi durdurana kadar art arda değil, eşleşme başına bir kez değiştiriyor. Bu yüzden döngü için bir fantezi kullanmak zorunda kaldı.

Lambda formu:

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

İşlev formu:

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

Test Edilebilen Ungolfed Kodu:

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;}
}

GNU Sed, 17

Puan -rseçeneği için +1 içerir .

s/6*7(6|89)*/7/g

Perl 6 , 19  18 bayt

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

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

(Not [6|89]olmayan yakalama versiyonu (6|89)olarak yazıldığından olan (?:6|89)Perl 5. <[6|89]>Eğer olarak yazıldığından ne yazardı nasıl [6|89]Perl 5)

kullanımı:

$ 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

Pyth, 17 bayt

u:G"67|76|789"\7z

Burada dene.

Sızdıran Rahibe, bu yorumları bir bayt tarafından aşmıştır.

Perl 5 , 17 bayt

perl -pe 's/6*7(6|89)*/7/g' # 16 + 1

kullanımı:

$ perl -pe 's/6*7(6|89)*/7/g' <<< '
987
6 7
6676689
7896789
7689
abcd
68978966897896
'

987
6 7
7
77
7
abcd
68977

Mathematica, 52 bayt

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

Açıklama:

                                                   &   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.

Pas, 96 bayt

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

Umutsuzca uzun, her zamanki gibi Rust için ...

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
}

Emacs Lisp, 59 bayt

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

Boşluklarla biraz daha netleşir:

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

Ruby, 27 bayt

Bu çözüm yorumlardan, Brad Gilbert b2gills’e teşekkür eder .

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

Ruby, 37 bayt

(eski çözüm)

Bu çözüm, dizedeki karakterlerden daha fazla kez değiştirmeniz gerekmeyeceği gerçeğini kullanır.

->s{s.chars{s.sub! /67|76|789/,?7};s}

Japt , 15 bayt

Ur"6*7(89|6)*"7

Basit RegEx çözümü

Çevrimiçi deneyin

PowerShell, 27 bayt

$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

Faydalanmak:

• başkasının regex düzeni
• yol -replace, PowerShell'de varsayılan olarak global bir değiştirme yapar
• Döngüyü açma, -regexişleci diziye $argstüm öğelere ayrı ayrı uygulayarak diziye uygulayacağı ve burada yalnızca bir öğe olduğundan, yalnızca bir komut dosyası parametresi olduğundan, Tamam çalıştığından ve öğeyi dizine eklemekten kaçınabileceğiz [0].

Yenilik, küresel bir değişimin gerçekleştirilmesinden önceki girişimi yapardı; 74 bayt, dize çarpımını kullanarak, dizenin uzunluğu kadar çok sayıda dize çarpımı kullanarak bir "-replace -replace -replace" zinciri oluşturdu, ardından değerlendirdi:

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

(Yer değiştirme sayısını kısaltmak için bir miktar dize yerine).

CJam, 70 64 bayt

Kesim {"789":I}{"76:":I}?için @Peter Taylor'a teşekkürler"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

Bunun muhtemelen daha fazla golf oynayabileceğini ve yardımınızın çok takdir edileceğini biliyorum, ama açıkçası cevabı almayı başardığım için mutluyum. Bu CJam'ı yazmaya ilk girişimdi.

Açıklama:

"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

MATL , 17 bayt

jt"'789|76'55cYX]

Örnek

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

EDIT : Çevrimiçi deneyin!

açıklama

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

Bu , orijinal dizedeki karakterlerde olduğu kadar çok kez düzenli ifade değiştirme uygulayarak çalışır . Bu yeterli, çünkü her oyuncu değişikliği karakter sayısını azaltır.

Cidden, 29 bayt

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

Girdiyi çift tırnaklı dize gibi alır "6789". Çevrimiçi deneyin (girişi el ile alıntı yapmanız gerekecek).

Açıklama:

,;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"

Salı , 26 bayt

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

takip eden bir newline dahil.

Giriş başlamadan önce programa eklenir.
Bir Turing makinesine benzer şekilde, sonlandırıldığında, program durumu çıkıştan okunur.
(Thue yapar bir çıkış akışı var, ancak doğru kullanmak zordur, bu yüzden bu kabul edilebilir bir çıkış yöntemi olup olmadığından emin değilim)

Bash, 102 82 67 (+7)? bayt

extglob sürümü

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

Bu bir dosyaya koymak ve örneğin ile çağrılmak içindir bash -O extglob 789.sh 6567678989689789656. (+7)? bayt, extglob seçeneği baytlara göre sayılırsa.

Extglob özelliklerini gösteren @BinaryZebra için teşekkürler!

Eklenti olmayan sürüm (82 bytes)

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

Bu bir dosyaya koymak ve örneğin ile çağrılmak içindir ./789.sh 65678989656.

Döngü içinde aramak ve değiştirmek için parametre genişletmeyi kullanır. Genişlemeyi daha etkili bir şekilde zincirlemenin bir yolunun farkında olmadığımdan, değiştirmeyi yapmak için bir dizi genişletmeye katıldım.

R, 35 bayt

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

gsubBu şekilde kullanabileceğimi bilmiyordum , buradaki her cevap için yeni bir şeyler öğrenmeme neden olan çok teşekkür ederim.

PHP 51 karakter

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

Uzun el ile yazılmış sınav davası

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

Bu dize karşılaştırması yapar ve dize her ikisi de koşulda yerine geçer. Koşul yerine getirilirse, sonuçla karşılaştırmanın sol tarafını günceller. Herhangi bir gelişmeyi bana bildirin.

Jolf , 15 bayt

Burada dene! Gerçekten açıklamak zorunda mıyım?

pi"6*7(6|89)*"7
p               replace any entity in
 i               the input
  "6*7(6|89)*"   that matches this regex
              7  with 7
                implicit output

PHP, 36 bayt

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

Regex çözümü, $ dizge alır ve ifade ile değiştirir.

Clojure, 71 bayt

Clojure, ayrıntılı yapısı nedeniyle golf oynamak için idealden daha azdır - ancak yine de ilginç bir egzersizdir:

Java birlikte çalışmayı kullanan golf sürümü:

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

Java birlikte çalışmayı kullanan, golf oynamayan sürüm:

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

Un golfed "saf Clojure" versiyonu:

(defn six-fears-seven [s]
  (let [x (clojure.string/replace s #"67|76|789" "7")]
    (if (= s x)
      s
      (recur x))))

/// , 19 bayt (rekabet etmeyen)

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

Aslında bu dilde giriş sağlayamazsınız, bu nedenle sözde giriş kodun sağına gider.

Python 3, 46 bayt

import re
lambda s:re.sub(r'6*7(6|89)*','7',s)

Japt v2.0a0, 12 bayt

e/6?7(6|89/7

Çevrimiçi deneyin!

Nasıl çalışır

String.eözyinelemeli değiştirme işlevidir. Japt 2'de yeni bir regex sözdizimi ve regex içindeki parantezlerin otomatik tamamlanması var. (Japt 1.x'te regex'lerin yerine dizeleri geçmek zorundaydık, ki bu biraz garipti.)

Dyalog APL , 17 bayt

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

'6*herhangi bir sayıda altılı,
7 ardından yedi
(… )*' ardından sıfır veya daha fazla dizi…
 6|89 altı veya sekiz-dokuz

⎕R R bunun yerine

'7' yedi

05AB1E , 12 bayt

Δ67‚7:789¬:

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

Δ               # 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)