Складові послідовності

29

Один раз ви обробляєте картки з позначкою від 0 до 9, утворюючи стеки, які починаються з 0 і рахуються з 1.

  • Коли ви маєте справу з 0, ви кладете її на стіл, щоб почати новий стек.
  • Коли ви дістаєте будь-яку іншу карту, ви складаєте її на карту, яка рівно на одну меншу вартість, прикриваючи її. Якщо такої картки немає, колоду не можна складати.

З огляду на колоду, визначте, чи можна її складати, коли роздано у вказаному порядку. Еквівалентно, задаючи перелік цифр, вирішуйте, чи можна його розділити на нерозчленовані підряди кожної форми0,1,..,k

Приклад

Візьміть колоду 0012312425. Перші дві картки є 0, тому вони йдуть на стіл:

Stacks: 00

  Deck: 12312425

Далі ми маємо справу з a 1, що продовжується на a 0, не важливо, що:

        1
Stacks: 00

  Deck: 2312425

Тоді ми маємо справу на 2вершині щойно розміщеної 1, і 3на верхній.

        3
        2
        1
Stacks: 00

  Deck: 12425

Далі 1, 2і поміщають поверх першого стека і на 4вершині другий. 

        4
        3
        22
        11
Stacks: 00

  Deck: 25

Тепер нам потрібно розмістити 2, але на 1вершині немає жодного стека. Отже, ця колода не була складною.

Введення: Непорожній список цифр 0-9 або їх рядок. Ви не можете припустити, що 0 завжди буде на вході.

Вихід : одне з двох чітких послідовних значень, одне для послідовностей, що складаються, і одне для нестабільних

Тестові приклади:

Укладається:

0
01
01234
00011122234567890
012031
0120304511627328390

Не можна складати:

1
021
0001111
0012312425
012301210
000112223

Для зручності, як списки:

[0]
[0, 1]
[0, 1, 2, 3, 4]
[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[0, 1, 2, 0, 3, 1]
[0, 1, 2, 0, 3, 0, 4, 5, 1, 1, 6, 2, 7, 3, 2, 8, 3, 9, 0]

[1]
[0, 2, 1]
[0, 0, 0, 1, 1, 1, 1]
[0, 0, 1, 2, 3, 1, 2, 4, 2, 5]
[0, 1, 2, 3, 0, 1, 2, 1, 0]
[0, 0, 0, 1, 1, 2, 2, 2, 3]

Згруповано:

[[0], [0, 1], [0, 1, 2, 3, 4], [0, 0, 0, 1, 1, 1, 2, 2, 2, 3], [0, 1, 2, 0, 3, 1], [0, 1, 2, 0, 3, 0, 4, 5, 1, 1, 6, 2, 7, 3, 2, 8, 3, 9, 0]]
[[1], [0, 2, 1], [0, 0, 0, 1, 1, 1, 1], [0, 0, 1, 2, 3, 1, 2, 4, 2, 5]]

Табло:

Показати фрагмент коду

code-golf  sequence  decision-problem  subsequence 
— xnor
джерело
Чи можна вважати обмеженням довжини списку?
— orlp
@orlp Без явного обмеження.
— xnor
@xnor він, ймовірно, просить виправдати написання int a[99]на C
— Leaky Nun
@LuisMendo Ви можете, я кажу "непусто".
— xnor
@xnor Ах, вибачте, я цього не бачив. Чи може масив базуватися на 1? Тобто цифри від 1до10
— Луїс Мендо

Відповіді:

6

Хаскелл , 55 байт

Анонімна функція, що приймає список цілих чисел і повертає a Bool.

Використання: (all(<1).foldr(?)[]) [0,1,2,3,4].

all(<1).foldr(?)[]
m?l|(p,r)<-span(/=m+1)l=m:p++drop 1r

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

Як це працює

  • foldr(?)[]складе аргумент списку справа наліво ?, починаючи з порожнього списку. Результатом є список номерів у списку, які не вписувались у попереднє число.
  • all(<1) тестує, якщо єдині числа, що не відповідають попередньому номеру, дорівнюють нулю.
  • m?lпопередньо додає номер mдо списку lнепридатних номерів. Якщо m+1це вже є в списку, його тепер можна буде видалити, як він знаходиться вгорі m.
    • (p,r)<-span(/=m+1)lрозбиває список lна дві частини pі rв першій інстанції числа m+1. Якщо таких немає, права частина rбуде порожньою.
    • m:p++drop 1rпретендує mна розбиті частини. Якщо він rне порожній, він повинен починатися з того m+1, що видаляється drop 1.
— Ørjan Johansen
джерело
Відмінна ідея робити укладання в зворотному порядку! Я намагався розширити ваш ?рекурсивно, але отримав однакову довжину .
— xnor
54 байти зData.List.delete
— H.PWiz
5

Лушпиння , 9 байт

Λ¬ḞS:o-→ø

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

Повернення 1для колод, що складаються, і 0для колод, що не складаються.

Схоже, Шріян Йохансен у своїй відповіді Хаскелла вже придумав той самий алгоритм, але в Хуск це, очевидно, набагато більш стисло.

Пояснення

Ми вирішуємо проблему з іншого боку: перевертаємо колоду і робимо спадаючі палі. Якщо після проходження всієї колоди всі палі мають 0 у верхній частині, колоду можна складати.

Λ¬ḞS:(-→)ø
         ø    Starting with the empty list (each element of this list will be the top card
              of a stack)
  ḞS          Traverse the input from right to left. For each card:
      -→        Remove the successor of this card from our list (if present)
    :           Add this card to our list
Λ¬            At the end, check if all the cards in our list are zeroes (falsy)
— Лев
джерело
4

C (gcc), 74 73 байт

f(int*l){int s[10]={},r=1;for(;~*l;s[*l++]++)r*=!*l||s[*l-1]--;return r;}

Потрібен вхідний масив для позначення кінця -1. Приклад використання:

int main(int argc, char** argv) {
    int a[] = {0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 0, -1};
    printf("%d\n",  f(a));
    return 0;
}
— orlp
джерело
Що не так із звичайною return r?
— Leaky Nun
4

Сітківка , 42 байти

O$#`(.)(?<=(\1.*?)*)
$#2
.
$*1,
^(,|1\1)+$

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

Пояснення

O$#`(.)(?<=(\1.*?)*)
$#2

Це сортує цифри, стабільно, за тим, як часто ця цифра траплялася раніше. Фактично, це поєднує різні подальший кандидат разом. Отриманий рядок спочатку матиме перше виникнення кожної цифри, а потім друге виникнення кожної цифри тощо. У вхідному стані результат може виглядати приблизно так 0123...0123...0123..., де кожна з цих підрядків може закінчуватися в будь-якій точці.

Найпростіше визначити, чи вхід має такий тип шаблону в одинаковості.

.
$*1,

Кожну цифру n замінюємо на n 1 s, після чого комою відокремлюємо окремі цифри.

^(,|1\1)+$

Нарешті, ми використовуємо пряму посилання, щоб відповідати послідовно зростаючим пробігам цифр. Ми намагаємось зіставити весь рядок або шляхом зіставлення однієї коми (що представляє 0 , який починає новий пробіг), або шляхом зіставлення попередньої речі, перед якою передує додаткова 1, яка працює лише в тому випадку, якщо поточна цифра є наступником попередньої.

— Мартін Ендер
джерело
3

TI-Basic (83 серія), 25 байт (49 символів)

:min(seq(min(cumSum(Ans=I)≤cumSum(Ans=I-1)),I,1,9

Як це працює

Приймає введення як список у Ans. Виходи 1для вхідних даних, що складаються, 0інакше.

Для кожного I, cumSum(Ans=I)обчислює список того , скільки разів Iвідбулися в кожному початковому сегменті, так min(cumSum(Ans=I)≤cumSum(Ans=I-1))тільки 1 , якщо в будь-якому положенні, ми бачили , по I-1крайней мере , стільки раз , скільки I. Загальний вираз є, 1коли це стосується кожного I.

— Міша Лавров
джерело
3

JavaScript (ES6), 61 45 40 байт

Вводиться як список.

a=>a.every(k=>a[~k]=!k|a[-k]--&&-~a[~k])

Тестові справи

Показати фрагмент коду

Як?

Для кожного значення 0 ... 9 ми відстежуємо кількість доступних стеків з попередньою картою на вершині. Ці лічильники зберігаються в межах від [-9] до [0] , де [] - вихідний вхідний масив. Єдиний лічильник, що стикається з вхідними даними, є [0] , але нас це насправді не хвилює, оскільки 1) картки з позначкою 0 завжди дозволені і так чи інакше повинні оброблятися окремо і 2) вхідне значення a [0 ] обробляється, перш ніж вона має можливість оновитись.

a => a.every(k =>  // given the input array a, for each card k in a:
  a[~k] =          // the card is valid if:
    !k |           //   - it's a 0 or
    a[-k]-- &&     //   - there's at least one stack with the card k-1 atop
    -~a[~k]        // in which case we allow a new card k+1 and go on with the next card
)                  // otherwise, every() fails immediately
— Арнольд
джерело
Ти швидший за мене: o
— Leaky Nun
@LeakyNun Ви, мабуть, були 20 хвилин ...;)
— Арнольд
2

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

Catch[Fold[#~Join~{-1}/.{{p___,#2-1,q___}:>{p,#2,q},-1:>Throw[1<0]}&,{},#];1>0]&
— JungHwan Min
джерело
2

R , 88 байт

function(d){s={}
for(e in d)if(!e)s=c(s,0)else{k=match(e,s+1)
if(is.na(k))T=F
s[k]=e}
T}

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

Функція, яка приймає R-вектор; повертається TRUEяк FALSEдля складання, так і для нестабільних.

Пояснення:

function(d){
 s <- {}              # initialize the stacks as empty
 for(e in d){         # iterate over the deck
  if(!e)              # if e is zero
   s <- c(s,0)        # start a new stack
  else {              # otherwise
   k <- match(e,s+1)  # find where e should go in s, NA if not there
   if(is.na(k))       # if no match (unstackable)
    T <- F            # set T to F (False)
   s[k] <- e          # set s[k] to e
  }
 T                    # return the value of T, which is TRUE by default and only gets changed in the loop to F.
}
— Джузеппе
джерело
2

Нім, 133 байти

proc s(d:seq[int]):int=
 var
  t= @[0]
  r=1
 for c in d:(t.add(0);var f=0;for i,s in t.pairs:(if s==c:(t[i]=c+1;f=1;break));r*=f)
 r

1якщо це працює; 0якщо цього немає.

Довелося задіяти якусь дивну справу, щоб розібратися з незмінністю змінних у for-loops, ну добре.

— Квеклеф
джерело
1

Haskell , 77 75 байт

import Data.List
g[]=1<3
g(x:r)|s<-r\\[x-1]=g r&&(x<1||s/=r&&g s)
g.reverse

Спробуйте в Інтернеті! Використання: g.reverse $ [0,1,2]. Повертається Trueдля вхідних даних, які можна складати, Falseінакше

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

  • порожній список можна скласти.
  • не порожній список з префіксом rта останнім елементом xє стеканим, якщо він rє стеканим і або xдорівнює нулю, або в обох x-1відображаєтьсяr і rз x-1видаленими також є стеканими.
— Лайконі
джерело
1

Ява 8, 168 150 142 байт

a->{int x[]=new int[a.length],s=0,i;a:for(int n:a){if(n<1){s++;continue;}for(i=0;i<s;i++)if(x[i]==n-1){x[i]=n;continue a;}return 0;}return 1;}

Повертається 0 / 1правильно воно складати чи ні.

Пояснення:

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

a->{                         // Method with integer-array parameter and integer return-type
  int x[]=new int[a.length], //  Array for the stacks, (max) size equal to input-size
      s=0,                   //  Amount of stacks, starting at 0
      i;                     //  Index integer
  a:for(int n:a){            //  Loop (1) over the input
    if(n<1){                 //   If the current item is a zero:
      s++;                   //    Increase amount of stacks `s` by 1
      continue;}             //    And go to the next iteration
    for(i=0;i<s;i++)         //   Inner loop (2) over the stacks
      if(x[i]==n-1){         //    If a top item of a stack equals the current item - 1:
        x[i]=n;              //     Set this item in the stacks-array
        continue a;}         //     And go to the next iteration of loop (1)
    return 0;                //   If we haven't encountered a `continue`, return 0
  }                          //  End of loop (1)
  return 1;                  //  Return 1 if we were able to correctly stack everything
}                            // End of method
— Кевін Круїссен
джерело
1

C, 248 байт

Примітка. Щоб надрукувати статус повернення, введіть "echo $ status" в термінал

Стан повернення 0: Не можна скласти

Стан повернення 1: Згинання

Пояснення: Елемент масиву збільшення з індексом, еквівалентним найбільшої цифри в потоці. Потім програма перевіряє, чи є цей щойно збільшений елемент масиву більшим, ніж елемент, що передує йому. Якщо так, повертається 0. Ще, якщо програма встигає до кінця масиву повертає 1.

 main(int argc, char ** argv)
{
    static int stack[10];

    while ( *++argv != 0x0 )
    {
        stack[**argv - 0x30]++;

        if ( **argv - 0x30 > 0 )
        {
            if ( stack[**argv - 0x30] > stack[**argv - 0x30 - 1] )
            {
                return 0;
            }

        }

    }   

    return 1;
}
— Т. Салім
джерело
3
Ласкаво просимо в Code Golf! Ваш код і ваш номер рахунку повинні збігатися, тому обов'язково надайте повністю кодову версію свого коду. Необов’язана версія є необов'язковою.
— Стівен
0

Желе , 15 байт

œp@ŒQẎµ0rṀ⁼Qµ¿Ẹ

Монадічне посилання, що містить список невід’ємних цілих чисел і повертається, 0якщо їх можна скласти або 1якщо не можна скласти.

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

Як?

œp@ŒQẎµ0rṀ⁼Qµ¿Ẹ - Link: list
             ¿  - while loop:
      µ     µ   - ...condition chain:
       0        -      literal zero
         Ṁ      -      maximum of current list
        r       -      inclusive range = [0,1,2,...,max(list)]
           Q    -      de-duplicate list (unique values in order of appearance)
          ⁼     -      equal?
                - ...do:
   ŒQ           -      distinct sieve (1s at first occurrences 0s elsewhere)
  @             -      use swapped arguments:
œp              -        partition (the list) at truthy values (of the distinct sieve)
     Ẏ          -      tighten (makes the list flat again ready for the next loop)
              Ẹ - any truthy? 1 if the resulting list has any non-zero integers remaining
                -           - effectively isNotEmpty for our purposes since a list of only
                -             zeros gets reduced to an empty list via the loop.
— Джонатан Аллан
джерело
Ваш хід: P: P
— Leaky Nun
Хе, ну я сумніваюся, що бив 11 (або 10 ?!) і повинен спати: D
— Джонатан Аллан
0

Japt , 16 байт

£=k_¥T©°T}T=0ÃUd

Перевірте це в Інтернеті! Виходи falseдля складання, trueдля нестабільності.

Пояснення

 £   = k_  ¥ T© ° T}T=0Ã Ud
UmX{U=UkZ{Z==T&&++T}T=0} Ud    Ungolfed
                               Implicit: U = input array
UmX{                   }       For each item X in the array:
                    T=0          Set T to 0.
      UkZ{         }             Remove the items Z where
          Z==T&&++T              Z == T (and if so, increment T).
                                 This has the effect of removing the largest stack.
    U=                           Reset U to the result.
                               This process is repeated U.length times, which is
                               evidently enough to handle any U.
                         Ud    Return whether there are any truthy items in U.
                               Any items not part of a stack are non-zero/truthy,
                               so this works for every possible case.
— ETHproductions
джерело
0

05AB1E , 25 байт

ηε[DõQ#ZƒDNåiNõ.;Dëˆ#]¯OĀ

Це завдання виглядає не так вже й складно, але це досить важко в 05AB1E (принаймні для мене ..)

Виходи, 0якщо їх можна скласти, а 1якщо не скласти.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

η             # Prefixes of the (implicit) input
              #  i.e. '012031' → ['0','01','012','0120','01203','012031']
              #  i.e. `021` → ['0','02','021']
 ε            # Map each to:
  [           # Start an infinite inner loop
   D          # Duplicate the current value
    õQ#       # If it's an empty String, stop the infinite loop
   Z          # Get the maximum (without popping)
              #  i.e. '01203' → 3
              #  i.e. '02' → 2
    ƒ         # Inner loop `N` in the range [0,max]
     D        # Duplicate the current value
      Nåi     # If it contains the current digit `N`
              #  i.e. '01203' and 1 → 1 (truthy)
              #  i.e. '02' and 1 → 0 (falsey)
         Nõ.; # Remove the first one (by replacing the first `N` with an empty string)
              #  i.e. '1203' and 1 → '203'
         D    # And duplicate it again for the next iteration of the inner loop
      ë       # Else (does not contain the digit `N`):
       ˆ      # Push `N` to the global stack
        #     # And break the infinite loop
 ]            # Close the if-else, inner loop, infinite loop, and mapping (short for `}}}}`)
  ¯           # Push the global stack
   O          # Take the sum
              #  i.e. [] → 0
              #  i.e. ['2'] → 2
    Ā         # And get the trutified value of that (which we implicitly output as result)
              #  i.e. 0 → 0
              #  i.e. 2 → 1
— Кевін Круїссен
джерело
0

Java 8, 87 байт

Замість того, щоб будувати стеки, я просто обчислюю, чи є елемент нестабільним на попередніх елементах, і повертаю 0, коли виникає нестабільний елемент. Якщо я дойду до кінця, весь рядок є стеканим і 1 повертається:

s->{int l[]=new int[10];for(int n:s)if(n!=0&&l[n]>=l[n-1]||l[n]++<0)return 0;return 1;}

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

Пояснення:

s->{
  int l[]=new int[10];                # initialise the counts of each digit encountered prefix of element, all initialised to 0
  for(int n:s)                        # Iterate over all entries in input
    if(n!=0&&l[n]>=l[n-1]||++l[n]<0)  # Check if the element is stackable on the previous elements. Last check is always evaluated and false, but the sideeffect is to add the element to the handled, prefixed element og the next element.  
      return 0;                       # Unstackable
  return 1;                           # No unstackable elements, so the result is stackable
}
— tfantonsen
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.