Sorun:

Göreviniz, bir sayı sırasına göre, her sayının kendisinden önceki sayının en az bir basamağını içerip içermediğine karar vermektir.

Örneğin, aşağıdakiler gerçeği döndürmelidir:

[1, 12, 203, 0, 30]
             ^   ^ Contains a 0
        ^ Contains a 2
    ^ Contains a 1

Aşağıdaki falsey döndürmelidir:

[1, 32, 23, 34]
    ^ Doesn't contain a 1, therefore false

Gönderiniz bir işlev veya tam program olabilir.

Giriş:

Giriş, herhangi bir makul türde sıralama olabilir. Sayı dizisi, dizge dizisi, sınırlandırılmış sayı dizisi vb.

Ancak, sipariş önemlidir, bu nedenle girdi olarak kabul etmeyi seçtiğiniz her hangi bir yapının kesin bir siparişi olması gerekir.

Giriş, stdin yoluyla veya bir argüman olarak alınabilir.

Şöyle kabul edebilirsiniz:

• tüm sayılar negatif olmayan tam sayılar olur

• giriş her zaman en az 2 sayı içerecek

• giriş numaraları 0 ile başlamayacak

Çıktı:

Çıktı, yukarıdaki şartnamenin karşılanıp karşılanmadığını temsil eden (diliniz tarafından tanımlandığı gibi) bir ya da yanlış değer olacaktır.

Truthy / falsey değerlerinin testler arasında tutarlı olması gerekmez.

Stdout'a çıktı veya döndürülebilir.

Test Durumları:

True cases:
[1, 1, 1, 11, 111, 11, 1]
[12, 23, 34, 45, 56]
[65, 54, 43, 32, 21]
[123, 29, 9, 59, 55, 52, 2017, 2]
[1234567890, 19, 95, 5012, 23]

False cases:
[1, 2, 3, 4, 5, 1, 11] (2 doesn't contain a 1)
[12, 23, 33, 45] (45 doesn't contain a 3)
[98, 87, 76, 11, 12, 23] (11 doesn't contain a 7 or 6)

Bu kod golf, yani en az bayt sayısı kazanır.

Jöle , 5 4 bayt

f2\Ạ

Giriş bir dizi dizisidir.

Çevrimiçi deneyin!

Nasıl çalışır

f2\Ạ  Main link. Argument: A (array of strings)

 2\   Pairwise reduce by:
f       Filter, yielding all chars in the left string that appear in the right one.
   Ạ  All; yield 1 if all strings are non-empty, 0 if not.

Python 2,48 bayt

lambda x:reduce(lambda a,b:set(a)&set(b)and b,x)

Çevrimiçi deneyin!

İçin boş bir küme Falseve son öğe için yazdırın .True

Retina , 25 20 bayt

(.).*¶(?=.*\1)

^.+$

Çevrimiçi deneyin!

Ne zaman bir sonraki sayıda ortaya çıkacak bir rakam bulduğumuzda, bu sayılar arasındaki ayırıcıyı kaldırırız (önceki sayının rakamları ile birlikte, paylaşılandan başlayarak, ama bu alakasızdır). İşlem sırasında tüm ayırıcılar kaldırılmışsa, dize tek bir satırla eşleştirilebileceğinden emin olarak kontrol ettiğimiz giriş geçerlidir.

Brachylog , 9 bayt

{⊇ᵐ=∧?t}ˡ

Çevrimiçi deneyin!

Bunun yalnızca bir tamsayı listesiyle değil, bir dize listesiyle veya bir liste listesiyle de çalıştığını unutmayın.

açıklama

{      }ˡ       Left fold on the input:
 ⊇ᵐ=              It is possible to find a number which is a subset of both input numbers
    ∧             (and)
     ?t           The output is the second number (to continue the fold)

JavaScript (ES6), 47 44 ^_* 43 bayt

@Neil sayesinde bir bayt kaydedildi

x=>x.every(y=>y.match(`[${p}]`,p=y),p=1/19)

Dizelerin bir listesi olarak girdi alır.

Test pasajı

let f =
x=>x.every(y=>y.match(`[${p}]`,p=y),p=1/19)

let g = x => console.log("f([%s]): %s", x.join(", "), f(x.map(String)))

g([1, 1, 1, 11, 111, 11, 1])
g([12, 23, 34, 45, 56])
g([65, 54, 43, 32, 21])
g([123, 29, 9, 59, 55, 52, 2017, 2])
g([123456789, 19, 95, 5012, 23])

g([1, 2, 3, 4, 5, 1, 11])
g([12, 23, 33, 45])
g([98, 87, 76, 11, 12, 23])

* _{( 44'ü çarpı hala 44 )}

05AB1E , 10 bayt

ü‚vy`Så1åP

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

ü‚          # map pairing over each pair in input
  v         # for each pair
   y`       # push as 2 separate elements on stack
     Så     # check each digit in 2nd number for membership in first
       1å   # check if any 1 exists in the resulting list
         P  # product of stack

CJam , 18 15 14 bayt

Martin Ender sayesinde 4 bayt kaydedildi

l~Afb_1>.&:,:*

Çevrimiçi deneyin!

açıklama

l~              e# Read and eval the input
  Afb           e# Convert each number to a list of digits
     _          e# Duplicate the array
      1>        e# Slice it after the first element
        .&      e# Vectorized set intersection; take the set intersection of corresponding 
                e#  elements of the two arrays
          :,    e# Get the length of each intersection
            :*  e# Take the product of the whole array. 
                e#  Will be 0 if any intersection was empty.

Haskell, 51 48 35 Bayt

@NickHansen sayesinde -3 bayt! Bu monad operatörleri ile gerçekten daha iyi olmam gerekiyor

Sırasıyla @Likonik ve @nimi sayesinde -4 ve -9 bayt!

and.(zipWith(any.flip elem)=<<tail)

Bu sürüm girdiyi bir dizi dizge olarak alır, ihtiyacını ortadan kaldırır showancak görebildiğim kadarıyla eski sürümle aynı şekilde çalışır:

all(\(x,y)->any(`elem`x)y).(zip=<<tail).map show

(Bunun gibi adsız bir işlev göndermeme izin verdiğimden eminim, ancak gerekirse düzelteceğim)

İlk önce sayılar dizgelere dönüştürülür. Ardından monad büyüsü zip=<<tail, listeyi kendi başına komşuları ile eşleştiren bir işlev oluşturur. Daha sonra all, bir telin diğerinden herhangi bir karakter içerip içermediğini kontrol eden ve her birinin çıkıp çıkmadığını kontrol eden her çifte bir lambda eşler True.

Temelde aynı şekilde çalışan eski sürüm:

f a=and$zipWith(\b->any(`elem`show b).show)a$tail a

Mathematica 62 47 35 bayt

MartinE sayesinde 12 bayt kurtarıldı.

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&[{{1},{1,2},{2,0,3},{0},{3,1}}]

Yanlış

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&[{{1},{1,2},{2,0,3},{0},{3,0}}]

Doğru

Yakut, 49 48 bayt

->x{x.each_cons(2){|z|x&&=z*' '=~/(.).* .*\1/};x}

Çıktı, nilyanlış ve doğru için "rastgele" bir tamsayıdır.

Java 8, 94 90 87 bayt

Giriş, sayıları temsil eden bir dizge dizisidir. İkinci dize ile başlayarak, onun herhangi bir karakter içerip içermediğini görmek için her geçen dize karşı düzenli ifade karşılaştırma gerçekleştirir: .*[previous string].*.

golfed:

a->{int r=1,i=0;while(++i<a.length)r*=a[i].matches(".*["+a[i-1]+"].*")?1:0;return r>0;}

Ungolfed:

public class NumberChainingPredicate {

  public static void main(String[] args) {
    System.out.println("Expect true:");
    for (String[] input : new String[][] { { "1", "1", "1", "11", "111", "11", "1" }, { "12", "23", "34", "45", "56" },
        { "65", "54", "43", "32", "21" }, { "123", "29", "9", "59", "55", "52", "2017", "2" },
        { "1234567890", "19", "95", "5012", "23" } }) {
      System.out.println(java.util.Arrays.toString(input) + " = " + exec(f(), input));
    }

    System.out.println();
    System.out.println("Expect false:");
    for (String[] input : new String[][] { { "1", "2", "3", "4", "5", "1", "11" }, { "12", "23", "33", "45" },
        { "98", "87", "76", "11", "12", "23" } }) {
      System.out.println(java.util.Arrays.toString(input) + " = " + exec(f(), input));
    }
  }

  private static java.util.function.Function<String[], Boolean> f() {
    return a -> {
      int r = 1, i = 0;
      while (++i < a.length) {
        r *= a[i].matches(".*[" + a[i - 1] + "].*") ? 1 : 0;
      }
      return r > 0;
    };
  }

  private static boolean exec(java.util.function.Function<String[], Boolean> function, String[] input) {
    return function.apply(input);
  }

}

Jöle , 6 bayt

Dµf"ḊẠ

Çevrimiçi deneyin!

açıklama

Dµf"ḊẠ
Dµ        Treat the first (i.e. only) input as a list of decimal digits
   "      For each pair of corresponding elements in {the input digits} and
    Ḋ     {the input digits} with the first element removed
  f       take all elements common to both sides
     Ạ    then return true if the result has no empty lists, false otherwise

Kullanımı denemek için en belirgin var 2/burada, ama bu boyutta 2. tüm dilimler üzerinde bir tek terimli fonksiyonunu çalıştırır "Ḋetkili bir şekilde çalışır ikili kullanabileceğimiz anlamına bitişik elemanların tümü çiftleri üzerinde fonksiyonunu fyerine tekli dönüştürmek gerek daha (doğrudan işlevi olarak f/). Bu, girişin son elemanını yerinde bırakarak sona erer, ancak neyse ki 0'a bir giriş bile ondalık basamağa dönüştürüldüğünde boş bir liste haline gelmez, bu nedenle üzerinde etkisi yoktur Ạ.

Python 3 , 48 bayt

f=lambda x:x==x[:1]or{*x[0]}&{*x[1]}and f(x[1:])

Çevrimiçi deneyin!

Jöle , 8 bayt

Dœ&L¥2\Ạ

Çevrimiçi deneyin!

Nasıl?

Dœ&L¥2\Ạ - Main link: the list of integers            e.g. [3, 13, 351, 73, 82]
D        - convert all the integers to decimal lists       [[3],[1,3],[3,5,1],[7,3],[8,2]]
     2\  - 2-slice cumulative reduce with:
    ¥    -     last two links as a dyad:
 œ&      -         multiset intersection                   [[3],[1,3],[3],[]]
         -         length                                  [1,2,1,0]
       Ạ - all truthy?                                     0

05AB1E , 5 bayt

Kod:

üÃõå_

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! veya Tüm test durumlarını doğrulayın! .

Açıklama:

üà         # Intersection on each pair
  õå       # Check if the empty string exists
    _      # Boolean negate

PowerShell , 87 bayt

param($n)(1..($a=$n.length-1)|?{[char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}}).count-eq$a

Çevrimiçi deneyin!

Herhangi bir önlemle en kısa olanı değil, diğerlerinden biraz daha farklı bir yaklaşım kullanıyor ve şık |?{}işlevselliği gösteriyor.

Bu girdiyi bir dizi dizisi olarak alır $n, ardından yukarıdan 1yukarıya doğru döngüler length-1. Belli bir durum için gerçeğe yakın olan endeksleri çıkarmak için Where-Object(the |?{...}) kullanıyoruz . Bunu bir kombinasyon fordöngüsü gibi düşünebilirsiniz.if cümle .

Buradaki fıkra [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}. Yani, şu anki dizini alıyoruz $_, ayarlıyoruz $ive çıkarıyoruz 1ve onu indekslemek için kullanıyoruz $n(yani, önceki diziyi giriş dizimizde alıyoruz). Bu daha sonra bir chardizi olarak döküm ve başka bir Where-Objectprosedür aracılığıyla gönderilir .

İç hükmü $n[$i]-like"*$_*"geçerli dizinde dize olduğunu belirtir $iolduğunu -likeakım karakteri$_ önceki dizinden. Bu nedenle, iki dizi elemanı arasında ortak olan karakterleri çıkartacaktır. Bu nedenle, dış cümle yalnızca ortak bir karakter varsa truthy olacaktır (PowerShell'de boş bir dizi falsey olduğundan) ve bu nedenle dizin yalnızca ortak karakterler varsa seçilecektir.

Daha sonra, kriterleri karşılayan tüm indeksleri toplar ve .countbunun -eqgirdi dizisinin uzunluğuna eşit olduğunu doğrularız . Bu Boolean sonucu boru hattında bırakılır ve çıktı kesindir.

Perl 5 , 31 bayt

Martin Ender'in güzel cevabının limanı .

30 bayt kodu + -pbayrak.

s/(\S)\S* (?=\S*\1)//g;$_=!/ /

Çevrimiçi deneyin!

APL (Dyalog APL) , 9 bayt

∧/×≢¨2∩/⎕

Çevrimiçi deneyin!

∧/ listesindeki herkes

× işaretler

≢ taksitli

¨ her biri

2∩/ çiftli kesişme noktalarında

⎕ girdi?

PHP, 65 68

for(;null!==$a=$argv[++$i+1];)$r+=$a==strtr($a,$argv[$i],_);echo!$r;

Tüm sayılar üzerinde yineleyin ve öncekilerdeki tüm sayıları kaldırın. Sayının kendisine ne kadar sıklıkla denk geldiğini sayın (rakam silinmez). En az bir tane eşitse, çiftlerden birinde bir eşleşme olmazdı.

trimİnsted kullanarak bir hata düzeltildi strtr. @ JörgHülsermann 'a teşekkürler

PHP, 75 bayt

for($b=3**39;--$argc;)preg_replace("#[$b]#","",$b=$argv[$argc])<$b?:die(1);

komut satırı argümanlarından sayıları alır; 1sahtekarlıkla, sahtekarlıkla çıkar 0. Çevrimiçi olarak
çalıştırın -rveya test edin .

• ile başla $b= tüm basamakları içeren bir sayı
• bağımsız değişkenler arasında döngü
  • $bargümanındaki tüm basamakları kaldır
  • argümanı kopyala $b
  • eğer bir rakam çıkarılmadıysa, 1
• üstü kapalı: ile çık 0

PHP, 77 Bayt

for($i=$t=1;++$i<$argc;)$t*=preg_match("#[{$argv[$i-1]}]#",$argv[$i]);echo$t;

MATL , 14 bayt

1&)"V@VX&nv@]x

Çevrimiçi deneyin!

Bayt kaydettiğiniz için teşekkürler @LuisMendo. Açıklama:

1&)            % 'Pop' the first item from the input and push it on the stack.
   "       ]   % Main 'for' loop, to loop over the rest of the input.
    V            % Stringify previous (or first) iten from the input.
     @V          % Push current number, convert to string
       X&        % Intersect with stringified number already on the stack.
         nv      % Count the size of the intersection, and add it to the existing list of sizes.
           @     % Push the current number again for the intersection in the next loop. 
             x % Remove the number pushed by the last loop.
               % Else the program would end with the result on the second instead of the first position in the stack

Clojure, 71 bayt

(fn[n](every?(fn[[q w]](some q w))(partition 2 1(map #(set(str %))n))))

Sayı dizisini kabul eden adsız bir işlev. Döndürür true/ false.

Nasıl okunduğunu seviyorum. Burada geliştirilebilecek kesinlikle birkaç alan var. Fonksiyonumun mapkolayca değiştirilememesi nedeniyle fonksiyon makrosu gerektirmez, yani tüm fonksiyon makroyu kullanamaz, bu da bazı baytlar ekler. Aynı zamanda, every?yüklem değerlerini açmak için daha iyi bir yol bulabilirsem iyi olurdu .

(defn number-chain? [nums]
  (let [; Turn each number into a set of characters
        set-nums (map #(set (str %)) nums)

        ; Partition the sets into lists of neighbors
        ; [1 2 3 4] -> [[1 2] [2 3] [3 4]]
        partitioned (partition 2 1 set-nums)]

    ; Does every second neighbor contain some element of the first?
    (every?
      (fn [[l1 l2]]
        (some l1 l2))
      partitioned)))

SimpleTemplate, 124 bayt

Vay, bu bir antrenmandı!

{@eachargv asA keyK}{@ifK}{@setR"/[",O,"]/"}{@calljoin intoR"",R}{@ifA is notmatchesR}{@return}{@/}{@/}{@setO A}{@/}{@echo1}

Bu "basitçe", eski öğeyi kullanarak, 1sıra dışı bir değer olarak gösterilen veya başka hiçbir şey göstermeyen bir regex yapar .

Ungolfed:

{@each argv as number key K}
    {@if K}
        {@set regex "/[", old, "]/"}
        {@call join into regex "", regex}
        {@if number is not matches regex}
            {@return false}
        {@/}
    {@/}
    {@set old number}
{@/}
{@echo 1}

JavaScript (ES6), 37 bayt

s=>/^(.*(.).*\n(?=.*\2))+.+$/.test(s)

Girdiyi yeni satır ayrılmış sayılar dizisi olarak kabul eder. @ MartinEnder'in mükemmel Retina cevabına dayanarak, ancak testin tamamını tek bir regexp ile yapıyoruz çünkü JavaScript bu şekilde daha kısa.

Pip , 12 10 bayt

$&B@X^_MPg

Bir dizi komut satırı argümanı olarak girdi alır. Çıktı gerçeğe uygun olmayan bir liste ve falsey için boş bir listedir. Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

açıklama

         g  List of all cmdline args
       MP   Map this function to consecutive pairs of items from that list:
     ^_      Split 1st item of pair into list of characters
    X        Convert to regex that matches any of those characters
  B@         Find all matches in 2nd item of pair
$&          Fold on logical AND--truthy if all items are truthy, falsey if one is falsey
            Print (implicit)

Röda , 45 35 bayt

{[_=~`(\S*(\S)\S* (?=\S*\2))+\S+`]}

Çevrimiçi deneyin!

Bu, Martin Ender'in Retina çözümünün limanı olan Perl 5 çözümüne benzer. @Neil sayesinde -10 bayt.

İşte farklı bir çözüm ( 73 72 bayt):

{[_/""]|{|x|{x|[0]()unless[not(_ in y)]else[1]}if tryPeek y}_|sum|[_=0]}

Dizeleri akıştan çeken ve ardışık dizelerin aynı karakterleri içerdiğini kontrol eden adsız bir işlevdir. Açıklama:

{
    [_/""]|    /* split strings -> creates arrays of characters */
    {|x|       /* begin for loop over character arrays */
        {      /* begin if tryPeek(y) -> peeks the second item from the stream */
               /* x and y are now two consecutive character arrays */
            x| /* push characters in x to the stream */
            [0]()unless[not(_ in y)]else[1] /* pushes 0 to the stream */
                                            /* if y contains the character */
                                            /* in the stream, otherwise 1 */
        }if tryPeek y
    }_|        /* end for loop */
    sum|       /* sum all numbers in the stream */
    [_=0]      /* return true if the sum is zero */
}

Muhtemelen daha çok golf oynayabilirdi ...

Bash + Unix yardımcı programları, 71 69 bayt

sed "s/\(.*\)/<<<\1 \&\&grepx[\1]/;1s/.*g/g/;\$s/ .*//"|tr 'x
' \ |sh

Çevrimiçi deneyin!

Girdi, satır başına bir sayı olan stdin'dedir.

Çıkış, çıkış kodunda: truthy için 0, falsey için 1.

Bu muhtemelen daha çok golf oynayabilir.

Yukarıdaki kodun çalışması için, geçerli dizinde adı tek bir rakam olan hiçbir dosya olamaz. Eğer bu kabul edilebilir değilse [\1], programdakilerle değiştirin '[\1]'(2 ek byte ile).

Örnek çalıştırma (mücadelede verilen son sınav durumu):

$ echo '98
> 87
> 76
> 11
> 12
> 23' | ./digittest > /dev/null; echo $?
1

(1 burada falsey.)

Nasıl çalışır:

Yukarıdaki örnek çalışmayı göstereceğim.

Sed komutu girişi şu değere dönüştürür:

grepx[98]
<<<87 &&grepx[87]
<<<76 &&grepx[76]
<<<11 &&grepx[11]
<<<12 &&grepx[12]
<<<23

Tr komutu daha sonra bunu dizeye dönüştürür:

grep [98] <<<87 &&grep [87] <<<76 &&grep [76] <<<11 &&grep [11] <<<12 &&grep [12] <<<23

Bu dize istenen işlemi yapmak için bir kabuk komutudur, bu yüzden onu sh içine alıp bitirdim.

Q, 57 bayt

{r::();({r,::any(last x)in y;x,enlist y}\)($)0,x;all 1_r}

1. Global r başlatır.
2. Girdiyi dizgelerin dizisine dönüştürür.
3. Dizideki son karakterin bazı karakterlerinin geçerli dizgide olduğunu kontrol ederek diziyi tarar.
4. Her sonucu r'ye ekler.
5. Tüm dizeler adım 3'ü karşılarsa 1, aksi takdirde 0 döndürür.

Not: 0, fonksiyon içindeki giriş dizisinin başlangıcına eklenir. Bu, ilk elemanın karşılaştırmasının kaydedilmesi için yapıldı. Aksi takdirde, ilk elemanın son karakteri karşılaştırma için tutulur. Ancak, geçerli sayıma 7 bayt ekleyen bir tür denetimi yapabilir.