Почему 6 боялись 7? Потому что 7 8 9!

Для заданной строки примените следующие преобразования:

• Если есть 6 рядом с 7, удалите 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])

Ява, 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;}

Тестируемый код Ungolfed:

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

ГНУ Сед, 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

Pyth, 17 байт

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

Попробуй это здесь.

Дрянная Монахиня обошла это байтом в комментариях.

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

Mathematica, 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}

Безнадежно долго, как обычно для Rust ...

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

(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 байта для построения цепочки «-replace -replace -replace» с использованием умножения строки, столько раз, сколько длина строки, а затем eval () с ее помощью:

"'$($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

РЕДАКТИРОВАТЬ : попробуйте это онлайн!

объяснение

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 за указание на особенности экстглоба!

Версия без экстглоба (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);

Решение регулярных выражений, принимает $ строку и заменяет через выражение.

Clojure, 71 байт

Clojure менее чем идеален для игры в гольф из-за своей многословной природы, но, тем не менее, это интересное упражнение:

Гольф версия, с использованием взаимодействия Java:

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

Версия без игры в гольф, использующая взаимодействие с Java:

(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 нам пришлось передавать строки вместо регулярных выражений, что было довольно неуклюже.)

Дьялог АПЛ , 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)