Зворотні позитивні прогони


22

Вхідні дані

Ваша інформація - це список одноцифрових чисел у будь-якому розумному форматі, включаючи рядок цифр. Вхід не буде порожнім.

Вихідні дані

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

Приклад

Розглянемо вхідні дані

95883007414830
<--->  <---->

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

38859003841470

Правила та оцінка

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

Це завдання пов'язане, але набагато складніше, оскільки включає додаткову обробку рядків.

Тестові кейси

4 -> 4
00 -> 00
123 -> 321
0010 -> 0010
12000345 -> 21000543
18161604 -> 61618104
95883007414830 -> 38859003841470
010230456078912 -> 010320654021987
357509902003550 -> 575309902005530
2492882377675046 -> 5767732882942064
03026302053000357099 -> 03036202035000753099

Таблиця лідерів

Ось фрагмент стека для створення таблиць лідерів та списку переможців за мовою. Щоб відповідь з’явилася, почніть її із заголовка форми

## Language, N bytes

Ви можете зберегти старі бали у заголовку, використовуючи перекреслені теги: <s>57</s>з'явиться як 57 .

Відповіді:



8

IPOS , 5 байт

'0!r%

%розбиває рядок введення на нулі, застосовує команду r(зворотний) до кожної підрядки і приєднує результат назад до нулів.


7

Сітківка , 15 байт

S`0
O%^$`.

¶
0

Спробуйте в Інтернеті! (Трохи модифікований для запуску всіх тестових випадків одночасно.)

Пояснення

S`0

Розділіть вхід навколо 0 s, тобто поставте кожен (можливо, порожній) запуск ненульових цифр у свій власний рядок.

O%^$`.

Це обертає кожен рядок на:

  • Застосування етапу до кожного рядка окремо % .
  • Зіставлення кожного символу окремо з . .
  • Сортування його за результатами заміни ($ ) порожнім рядком (порожній другий рядок). Тобто це зовсім не сортується, оскільки всі значення сортування однакові.
  • Потім повертає порядок відсортованих символів.

Нарешті:

¶
0

Поверніть канали ліній назад у 0s.



5

Джулія, 30 байт

s->replace(s,r"[^0]+",reverse)

Це анонімна функція, яка приймає рядок і повертає рядок. Щоб викликати його, призначте його змінній.

replaceФункція забезпечує можливість заміни матчів регулярного виразу з результатом функції стосовно до кожної гри. У цьому випадку ми можемо отримати нульові знаки, використовуючи [^0]+та замінивши ті запуски результатом reverseфункції, застосованої до відповідного тексту.

Перевірте всі тестові справи онлайн!


4

Сітківка, 25 24

O^$#`[^0](?=(.*?0)*)
$#1

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

Збережено 1 байт завдяки Мартіну!

Сортуйте ненульові цифри за кількістю нулів, що слідують за цифрою, у зворотному порядку.

Дивіться рішення Мартіна про розумне використання режиму в рядку, щоб скоротити програму!


4

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

RΜGi0λ_0

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

Пояснення

RΜGi0λ_0
  Gi0     split input on zeroes
 Μ   λ_   map over reversal as a lambda
R      0  join by zeroes

Пояснення коду схоже на лямбда, якщо ти косиш.

Еквівалентна 8-байтна відповідь:

RΜGi0΅O0

Те саме, але він використовує ΅O(string lambda) натомість.


Я б сказав, що він більше схожий на якийсь текст у кумедній формі, коли я косити його. Можливо, я мав би відкласти цей телескоп.
кіт

1
@cat Ні, ні, тримай, але дивись на лямбда, коли ти це робиш.
Conor O'Brien


3

Python, 58 50 байт

lambda x:"0".join([n[::-1] for n in x.split("0")])

Бере в рядок х і розбивається на нулі і перевертає кожен елемент в розщепленні і додає нуль і повертає цей мінус останній нуль.


1
Ласкаво просимо до PPCG :) Ви маєте змогу це зробити, "0".joinа потім скинути додавання та шматочок.
FryAmTheEggman

@FryAmTheEggman дякую за пораду
1232

Немає проблем :) Ви також можете видалити пробіл між ]і for. Ви можете ознайомитись з нашою сторінкою порад щодо отримання додаткових покажчиків, якщо хочете.
FryAmTheEggman

7
lambda x:"0".join(n[::-1]for n in x.split("0"))
orlp

3

Математика, 30 байт

Join@@Reverse/@#~SplitBy~Sign&

напр. Join@@Reverse/@#~SplitBy~Sign&[{1,2,3,0,0,5,9,0}]={3, 2, 1, 0, 0, 9, 5, 0}


2

PowerShell v2 +, 45 байт

($args-split0|%{-join$_[$_.length..0]})-join0

Зловживають неявним кастингом, як ні завтра. Ймовірно, це не може бути набагато коротшим, оскільки немає вбудованого для зворотного зв'язку, який коротший, ніж цей трюк індексування.

Пояснення

Приклад того, як це працює - припустимо, 123045був вхід $args. Після -splitвключення 0трубопровід міститиме масив (123,45). Перший цикл з |%{...}має поточний елемент $_рівний 123, який потім неявно виводиться у вигляді рядка, а потім перевертається з []індексуванням. Це робить його ('3','2','1')як масив char. Цикл -joinповертає його назад у рядок "321"і залишає його на конвеєрі. Наступна (остання) ітерація циклу повертає вхід до "54". Так що тепер наш трубопровід "321", "54". Це інкапсульовано в паренах, ()тому воно реформується в масив, і знову . Що залишилося на конвеєрі, а вихід на консоль неявний.-join повертається разом із нулями, щоб отримати результуючу рядок виводу"321054"

Якщо в початковому вході є наступні нулі, масив буде заповнений нульовими елементами, тому на виході є правильна кількість нулів. Наприклад, 1230045-split0перетворюється на, (123,,45)і все продовжується як вище.



2

Фактор, 35 байт

Побої Піфона та Клуджура, буя!

[ "0"split [ reverse ] map "0"join ]

Ця анонімна функція є буквальним перекладом цієї відповіді Python .

Це досить просто, просто розділіть рядок на нулі, поверніть кожен елемент отриманого масиву і з'єднайте всі елементи (включаючи рядки нульової довжини) "0".

Ось приклад його роботи на всіх тестових випадках:

IN: scratchpad auto-use {
        "4"
        "00"
        "123"
        "0010"
        "12000345"
        "18161604"
        "95883007414830"
        "010230456078912"
        "357509902003550"
        "2492882377675046"
        "03026302053000357099"
        }
        [ 
          "0" split [ reverse ] map "0" join
        ]
        map .

{
    "4"
    "00"
    "321"
    "0010"
    "21000543"
    "61618104"
    "38859003841470"
    "010320654021987"
    "575309902005530"
    "5767732882942064"
    "03036202035000753099"
}

"00120"-> { "" "" "12" "" }-> { "" "" "21" "" }->"00210"


2

Haskell, 45 байт

r%(0:t)=r++0:[]%t
r%(h:t)=(h:r)%t
r%_=r
([]%)

Рекурсивно накопичує перевернутий шматок до цього часу r, попередньо, коли його 0буде досягнуто. Коли залишилася рядок порожній, він також розряджається r.

Перші два повторюють деякий код, але я не знайшов більш короткого способу їх поєднання (45 і 47 байт):

r%(h:t)|h<1=r++h:[]%t|1>0=(h:r)%t
r%_=r
([]%)

r%l|0:t<-l=r++0:[]%t|h:t<-l=(h:r)%t
r%_=r
([]%)

Я думаю, вам потрібна ще одна пара дужок у рядку №2:r%(h:t)=(h:r)%t
nimi


1

JavaScript (ES6), 50 49 байт

Версія рядка:

s=>s.replace(/[^0]+/g,r=>[...r].reverse().join``)

Збережено байт завдяки @Kevin Lau!

Версія масиву (60 байт):

a=>a.map((n,i)=>n?a[z-i+[...a,0].indexOf(0,i)]:(z=i,0),z=-1)

1

J, 20 18 байт

0}:@;@(<@|.;.1)@,]

Дякую Згарбу за допомогу в цьому! Приймає розділений пробілом список як правильний аргумент.

-2 байти завдяки Згарбу!


1

Clojure / ClojureScript, 44 символи

#(flatten(map reverse(partition-by pos? %)))

Таке ж рішення, як і інші, просто більш багатослівне завдяки довгим іменам функцій. Не збирався розміщувати це через це, але це б'є деякі інші відповіді, то чому б ні?

Працює на будь-якому типі послідовностей. У ClojureScript це також працює на рядках, оскільки рядки обробляються у вигляді списків символів, які є насправді просто рядками 1 довжини, які примушують до чисел подібні речі pos?.


1

Haskell, 46 байт

import Data.Lists
(reverse=<<).split(oneOf"0")

Приклад використання: (reverse=<<).split(oneOf"0") $ "0123004500678090"->"0321005400876090" .

На жаль, splitфункція вимагає дорогого імпорту. Розділіть список вводу на кожен 0, наприклад split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""], переверніть кожен фрагмент і об'єднайте в один рядок.



1

Java, 179 байт (з імпортом)

import java.util.*;static void r(String s){StringJoiner x= new StringJoiner("0");for(String a:s.split("0",s.length())){x.add(new StringBuilder(a).reverse());}System.out.print(x);}

Займає введення рядків і розбиває символи на нуль, а потім додає їх назад, викликаючи метод add у класі StringJoiner.


1

Oracle SQL 11.2, 131 123 байт

Зловживання функціями XML

SELECT LISTAGG(REVERSE(COLUMN_VALUE||''))WITHIN GROUP(ORDER BY rownum)FROM XMLTABLE(('"'||REPLACE(:1,'0','","0","')||'"'));

1

Perl, 22 байти

Включаючи +1 для -pопції:

s/[^0]+/reverse$&/eg

Це досить банальна заміна - вибачте, що так нудно. Зауважте, що якщо ваше введення завершено новим рядком (наприклад, використання perl -pe 's/[^0]+/reverse$&/eg' <<<21000543в Bash), воно буде перехоплювати новий рядок з цифрами - використовуйте echo -nабо printfуникайте цього. Крім того, для вартості додаткового байту змініть клас символів на [1-9], і ви можете надати багато входів, по одному на рядок.


1

C, 105 байт

#define x(o)for(p=s;*s&&'0'o*s;++s);for(r=s;r-->p;putchar(*r));
f(s,p,r)char*s,*p,*r;{x(^)x(==)*s&&f(s);}

Дзвінок f зі списком цифр у вигляді нульового завершення, і він надрукує правильний вихід.

Необов’язаний і пояснив:

f(s,p,r)
char*s,*p,*r; // K&R style to avoid repeating `char`
{

    // x(^)x(==) expands to...

    // Find the next zero digit
    for(p = s; *s && '0' ^ *s; ++s)
        ;

    // Print that run backwards
    for(r = s; r-- > p; putchar(*r))
        ;

    // Find the next non-zero digit
    for(p = s; *s && '0' == *s; ++s)
        ;

    // Print that run backwards (no difference, it's all zeros)
    for(r = s; r-- > p; putchar(*r))
        ;

    // If there's more string, recurse
    *s && f(s);
}

Побачити його в прямому ефірі на Коліру


0

Perl 5, 52 байти

Підпрограма:

{$_=pop;y/0/ /;map$i.=reverse,split/\b/;$i=~y/ /0/r}

-aне працює (принаймні у Strawberry), коли рядок введення закінчується 0, оскільки split/\b/включає в $/себе 0.
msh210

0

Власне, 22 байти

k"a%sa"%'0@s♂R'0j#pXdX

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

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

Пояснення:

k"a%sa"%'0@s♂R'0j#pXdX
k"a%sa"%                surround input with "a" characters
        '0@s            split on 0
            ♂R          reverse each piece
              '0j       join on 0
                 #pXdX  listify, remove first and last element (the "a"s)

0

C #, 131 байт ##

рішення хибно!

string j(string i){foreach(var s in i.Split('0'))if(s!="")i=i.Replace(s,new string(s.ToCharArray().Reverse().ToArray()));return i;}

неозорений:

string j(string input)
    {

        string[] a = input.Split('0');

        foreach (string s in a)
        {
            if (s!="")
            input=input.Replace(s, new string(s.ToCharArray().Reverse().ToArray()));
        }

        return input;
    }

1
Я вважаю, що у цього методу є помилка, коли одна рядок, яку потрібно повернути, є підмножиною іншої. Якби дано вхід 01201230, це повернеться 02102130. Це тому, що метод String.Replace замінює всі входження першого рядка на другий. Ця помилка також буде викликана, якщо одна картина з'явиться, коли її перевернути ( 0120210повернеться 0120120).
Ксинаріз

Я навіть не думав про це ..
downrep_nation

0

C #, 133 байт


Гольф

String m(String s){for(int i=0,p=i;i<s.Length;i++){if(s[i]=='0'){p=i+1;}else{s=s.Insert(p,s[i].ToString()).Remove(i+1,1);}}return s;}

Безумовно

String m( String s ) {
    // i = Index on the String
    // p = Pointer of the last '0' found
    for (int i = 0, p = i; i < s.Length; i++) {
        if (s[ i ] == '0') {
            // Move the 'p' pointer to the index after this '0'
            p = i + 1;
        } else {
            // Insert the Char at the Index location to the Pointer location 
            //    and remove the one at the Index Location + 1,
            //    since the String was incremented by one char due to the 'Insert()'.
            s = s.Insert( p, s[ i ].ToString() )
                 .Remove( i + 1, 1 );
        }
    }

    return s;
}

Повний код

using System;
using System.Collections.Generic;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            List<String> ls = new List<String>() {
                "4",
                "00",
                "123",
                "0010",
                "12000345",
                "18161604",
                "95883007414830",
                "010230456078912",
                "357509902003550",
                "2492882377675046",
                "03026302053000357099"
            };

            foreach (String s in ls) {
                String f = m( s );

                Console.WriteLine( String.Format( "{0,30}", s.Replace( "0", "0 " ) ) );
                Console.WriteLine( String.Format( "{0,30}", f.Replace( "0", "0 " ) ) );
                Console.WriteLine( "" );
            }

            Console.ReadLine();
        }

        static String m( String s ) {
            for (Int32 i = 0, p = i; i < s.Length; i++) {
                if (s[ i ] == '0') {
                    p = i + 1;
                } else {
                    s = s.Insert( p, s[ i ].ToString() ).Remove( i + 1, 1 );
                }
            }

            return s;
        }
    }
}

Щойно помітив, що @downrep_nation вже опублікував тут рішення для C #, яке б'є мій код на 2 байти ... (Це може бути більше ....)
auhmaan

0

Ява, 126

a->{String r="",t[]=a.split("0");for(String s:t){r+=new StringBuilder(s).reverse()+"0";}return r.substring(0, r.length()-1);}

Якщо ви оголошуєте sзмінну в передній частині за допомогою rі t[], чи можете ви пропустити декларацію типу sу циклі for?
Кіос

Ні, я перевірив це, для покращення циклів потрібна нещодавно оголошена змінна.
Сподіваюсь,

так. Це дивно. Ну добре
Кіос

0

Clojure, 37 байт

#(mapcat reverse(partition-by #{0}%))

Використання #{0} замість pos?(збережіть 1 байт шляхом об'єднання %) та mapcatзамість цього (flatten(map. Ще довше, ніж Фактор .

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.