Чому 6 боялися 7? Тому що 7 8 9!

Задавши рядок, застосуйте такі перетворення:

• Якщо поруч із 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

Сітківка , 12

Переклад відповіді sed:

6*7(6|89)*
7

Спробуйте в Інтернеті

Javascript ES6, 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])

Java, 126 81 66 58 байт

Дякуємо @GamrCorps за надання лямбда-версії цього коду!

Дякуємо @ user902383 за вказівку трюку автобоксингу!

...Так.

Це насправді довше, ніж я очікував - Java замінює елементи в рядках 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;}
}

GNU Sed, 17

Оцінка включає +1 за -rваріант.

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

Perl 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

Піт, 17 байт

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

Спробуйте тут.

У коментарях Leaky Nun перевершила це байтом.

Perl 5 , 17 байт

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

використання:

$ 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

Математика, 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.

Іржа, 96 байт

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

Безнадійно довго, як зазвичай у Руста ...

Безголівки:

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 байт

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

З пробілами стає ясніше:

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

Рубін, 27 байт

Це рішення - з коментарів, кредиту Бреду Гілберту b2gills .

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

Рубін, 37 байт

(старе рішення)

Це рішення використовує той факт, що вам ніколи не потрібно буде замінювати більше разів, ніж символи в рядку.

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

Japt , 15 байт

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

Просте рішення RegEx

Спробуйте в Інтернеті

PowerShell, 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].

Початкова попередня спроба перед реалізацією глобальної заміни зробила б це; 74 байти побудови ланцюжка "-замінити -замінити -замінити", використовуючи множення рядка стільки разів, скільки довжина рядка, а потім його оцінюйте:

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

(З невеликою підстановкою рядків, щоб скоротити кількість замін).

CJam, 70 64 байт

Завдяки @Peter Taylor за різання {"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

MATL , 17 байт

jt"'789|76'55cYX]

Приклад

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

EDIT : Спробуйте в Інтернеті!

Пояснення

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

Це працює, застосовуючи звичайну заміну виразів стільки разів, скільки символів у вихідному рядку . Цього достатньо, оскільки кожна заміна зменшує кількість символів.

Серйозно, 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"

Чт , 26 байт

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

включаючи зворотний новий рядок.

Введення додається до програми перед її запуском.
Вихід зчитується з програмного стану, коли він закінчується, як і машина Тьюрінга.
(Thue робить мати вихідний потік, але це важко правильно використовувати, так що я не впевнений, чи є це прийнятний метод виведення)

Баш, 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 зараховується до байтів.

Дякуємо @BinaryZebra за вказівку функцій extglob!

Неекглобійна версія (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.

Він використовує розширення параметрів для пошуку та заміни в циклі. Я задіяв низку розширень для заміни, оскільки мені не відомо про спосіб ефективнішого розширення ланцюга.

R, 35 байт

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

Я не знав, що можу скористатись gsubцим способом, велике спасибі за кожну відповідь, яка змусила мене навчитися чомусь новому.

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;

Це робить порівняння рядків і рядок замінюють обидва в режимі while. Якщо умова виконується, вона оновлює ліву руку порівняння з результатом. Повідомте мене про будь-які вдосконалення.

Джольф , 15 байт

Спробуйте тут! Чи мені справді треба пояснювати?

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 байт

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

regex рішення, бере $ рядок і замінює через вираз.

Clojure, 71 байт

Клуджур є менш ідеальним для гри в гольф через його багатослівний характер - але, тим не менш, це цікаве вправа:

Версія для гольфу, використовуючи Java interop:

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

Версія без гольфу, використовуючи Java interop:

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

Версія "чистого Clojure" без гольфу:

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

/// , 19 байт (неконкурентоспроможний)

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

Ви фактично не можете надати введення цією мовою, тому передбачуваний ввід іде праворуч від коду.

Python 3, 46 байт

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

Japt v2.0a0, 12 байт

e/6?7(6|89/7

Спробуйте в Інтернеті!

Як це працює

String.eє рекурсивна функція заміни. У Japt 2 є новий синтаксис регулярних виразів та автоматичне заповнення дужок всередині регулярного вираження, що зберігає тут один байт. (У Japt 1.x, ми повинні були пропустити рядки замість регулярних виразів, що було свого роду незграбним.)

Діалог APL , 17 байт

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

'6*будь-яку кількість шісток ,
7 супроводжувані сім
(... )*' слід нуль або більше послідовності ...
 6|89 в шість або вісім-дев'ять

⎕R R eplace , що з

'7' сім

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)