Problem:

Ihre Aufgabe ist es, zu entscheiden, ob in einer Folge von Zahlen jede Zahl mindestens eine der Ziffern der vorangegangenen Zahl enthält.

Beispielsweise sollte Folgendes als wahr zurückgegeben werden:

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

Folgendes sollte Falschgeld zurückgeben:

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

Ihre Einreichung kann eine Funktion oder ein vollständiges Programm sein.

Eingang:

Die Eingabe kann eine beliebige sinnvolle Sequenz sein. Ein Array von Zahlen, ein Array von Zeichenfolgen, eine begrenzte Zeichenfolge von Zahlen usw.

Die Reihenfolge ist jedoch von Bedeutung. Unabhängig von der Struktur, die Sie als Eingabe akzeptieren, muss die Reihenfolge eindeutig festgelegt sein.

Die Eingabe kann über die Standardeingabe oder als Argument erfolgen.

Sie können annehmen:

• Alle Zahlen sind nicht negative ganze Zahlen

• Die Eingabe enthält immer mindestens 2 Zahlen

• Eingabenummern beginnen nicht mit einer 0

Ausgabe:

Die Ausgabe ist ein Wahrheits- oder Falschwert (wie in Ihrer Sprache definiert), der angibt, ob die oben angegebene Spezifikation erfüllt ist oder nicht.

Wahrheits- / Falschheitswerte müssen zwischen den Tests nicht konsistent sein.

Es kann entweder auf die Standardausgabe ausgegeben oder zurückgegeben werden.

Testfälle:

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)

Das ist Code-Golf, also gewinnt die geringste Anzahl von Bytes.

Gelee , 5 4 Bytes

f2\Ạ

Die Eingabe ist ein Array von Zeichenfolgen.

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Probieren Sie es online!

Drucken Sie einen leeren Satz für Falseund das letzte Element fürTrue

Netzhaut , 25 bis 20 Bytes

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

^.+$

Probieren Sie es online!

Immer wenn wir eine Ziffer finden, die auch in der nächsten Ziffer vorkommt, entfernen wir das Trennzeichen zwischen diesen Ziffern (zusammen mit den Ziffern in der vorherigen Ziffer, beginnend mit der gemeinsamen Ziffer, aber das ist irrelevant). Die Eingabe ist gültig, wenn alle Trennzeichen im Prozess entfernt wurden. Wir überprüfen, ob die Zeichenfolge als einzelne Zeile übereinstimmt.

Brachylog , 9 Bytes

{⊇ᵐ=∧?t}ˡ

Probieren Sie es online!

Beachten Sie, dass dies nicht nur mit einer Liste von ganzen Zahlen funktioniert, sondern auch mit einer Liste von Zeichenfolgen oder einer Liste von Listen.

Erläuterung

{      }ˡ       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 Byte

Ein Byte dank @Neil gespeichert

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

Übernimmt die Eingabe als Liste von Zeichenfolgen.

Testschnipsel

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])

* _{( durchgestrichen 44 ist immer noch regulär 44 )}

05AB1E , 10 Bytes

ü‚vy`Så1åP

Probieren Sie es online! oder als Testsuite

Erläuterung

ü‚          # 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 Bytes

4 Bytes gespart dank Martin Ender

l~Afb_1>.&:,:*

Probieren Sie es online!

Erläuterung

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 Bytes

-3 Bytes dank @NickHansen! Ich muss wirklich besser mit diesen Monadenoperatoren werden

-4 und -9 Bytes dank @Laikoni bzw. @nimi!

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

In dieser Version wird die Eingabe als ein Array von Zeichenfolgen interpretiert, so dass dies nicht mehr erforderlich showist. Soweit ich jedoch sehe, funktioniert dies weitgehend wie in der älteren Version:

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

(Ich bin mir ziemlich sicher, dass ich eine anonyme Funktion wie diese einreichen darf, aber ich werde es bei Bedarf beheben.)

Zuerst werden die Zahlen in Strings umgewandelt. Dann erstellt die Monadenmagie zip=<<taileine Funktion, die die Liste mit sich selbst komprimiert und jeden Eintrag mit seinen Nachbarn koppelt. Dann allordnet einen Lambda jedes Paar , dass überprüft , ob eine Zeichenfolge enthält keine Zeichen von der anderen und schließlich überprüft , dass sie alle kommen True.

Alte Version, die im Prinzip genauso funktioniert:

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

Mathematica 62 47 35 Bytes

Mit 12 Bytes dank MartinE gespart.

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

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

Falsch

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

Wahr

Ruby, 49 48 Bytes

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

Die Ausgabe ist nilfür false und eine "zufällige" Ganzzahl für true.

Java 8, 94 90 87 Bytes

Die Eingabe ist ein Array von Zeichenfolgen, die die Zahlen darstellen. Beginnend mit der zweiten Folge, führt er einen regulären Ausdruck Vergleich gegen jede vorherige Zeichenfolge zu sehen , ob es irgendwelche seiner Zeichen enthält: .*[previous string].*.

Golf gespielt:

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

}

Gelee , 6 Bytes

Dµf"ḊẠ

Probieren Sie es online!

Erläuterung

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

Es ist am offensichtlichsten, hier zu versuchen 2/, aber das führt eine unäre Funktion auf allen Slices der Größe 2 aus. Führt "Ḋeffektiv eine binäre Funktion auf allen Paaren benachbarter Elemente aus, was bedeutet, dass wir sie fdirekt verwenden können (anstatt sie in eine unäre umwandeln zu müssen) funktionieren als f/). Dies führt dazu, dass das letzte Element der Eingabe nicht geändert wird. Glücklicherweise wird jedoch nicht einmal eine Eingabe von 0 zu einer leeren Liste, wenn sie in eine Dezimalzahl konvertiert wird Ạ.

Python 3 , 48 Bytes

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

Probieren Sie es online!

Gelee , 8 Bytes

Dœ&L¥2\Ạ

Probieren Sie es online!

Wie?

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 Bytes

Code:

üÃõå_

Verwendet die CP-1252- Codierung. Probieren Sie es online! oder Überprüfen Sie alle Testfälle! .

Erläuterung:

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

PowerShell , 87 Byte

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

Probieren Sie es online!

In jeder Hinsicht nicht die kürzeste, aber ein etwas anderer Ansatz als die anderen, der die raffinierte |?{}Funktionalität demonstriert .

Dies nimmt die Eingabe als ein Array von Strings auf $nund führt dann eine Schleife von 1oben nach unten durch length-1. Mit Where-Object(the |?{...}) ziehen wir die Indizes heraus, die für eine bestimmte Bedingung zutreffend sind. Sie können sich das wie eine Kombinationsschleife formit einer ifKlausel vorstellen.

Die Klausel hier ist [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}. Das heißt, wir nehmen den aktuellen Index $_, setzen ihn auf $iund subtrahieren ihn 1und verwenden ihn, um ihn zu indizieren $n(dh wir erhalten das vorherige Element in unserem Eingabearray). Das wird dann als char-array geworfen und durch ein anderes Where-ObjectVerfahren geschickt.

Die innere Klausel $n[$i]-like"*$_*"gibt an, dass die Zeichenkette auf dem aktuellen Index $iist -likedas aktuelle Zeichen$_ aus dem vorhergehenden Index. Dadurch werden alle Zeichen ausgegeben, die zwischen den beiden Array-Elementen gemeinsam sind. Daher ist die äußere Klausel nur dann wahr, wenn ein Zeichen gemeinsam ist (da ein leeres Array in PowerShell falsch ist), und der Index wird nur dann ausgewählt, wenn Zeichen gemeinsam sind.

Danach sammeln wir alle Indizes bis dass die Kriterien abgestimmt, und verifizieren , dass die .countdavon -eqUAL der Länge des Eingangsfeldes. Dieses boolesche Ergebnis verbleibt in der Pipeline, und die Ausgabe ist implizit.

Perl 5 , 31 Bytes

Ein Hafen von Martin Enders schöner Antwort .

30 Byte Code + -pFlag.

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

Probieren Sie es online!

APL (Dyalog APL) , 9 Bytes

∧/×≢¨2∩/⎕

Probieren Sie es online!

∧/ sind alle in der Liste von

× die Zeichen

≢ der Bilanz von

¨ jeder von

2∩/ die paarweisen Schnittpunkte von

⎕ die Eingabe?

PHP, 65 68

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

iterieren Sie über alle Zahlen und entfernen Sie alle Ziffern, die in der vorherigen erschienen sind. Zählen Sie, wie oft es der Zahl selbst entspricht (keine Ziffer entfernt). Wenn mindestens einer gleich war, hatten wir keine Übereinstimmung in einem der Paare.

Ein Fehler mit triminsted von wurde behoben strtr. Danke an @ JörgHülsermann

PHP, 75 Bytes

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

Nimmt Zahlen aus Befehlszeilenargumenten. Ausgänge mit 1für falsch, mit 0für wahr.
Laufen Sie mit -roder testen Sie es online .

• beginnen mit $b = eine Zahl, die alle Ziffern enthält
• durchlaufen Sie die Argumente
  • entfernen Sie alle Ziffern von $b aus dem Argument
  • Kopieren Sie das Argument nach $b
  • Wurde keine Ziffer entfernt, mit beenden 1
• implizit: beenden mit 0

PHP, 77 Bytes

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

MATL , 14 Bytes

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

Probieren Sie es online!

Vielen Dank an @LuisMendo für das Speichern eines Bytes. Erläuterung:

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 Bytes

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

Eine anonyme Funktion, die eine Folge von Zahlen akzeptiert. Rückgabe true/ false.

Ich mag, wie es liest. Es gibt definitiv ein paar Bereiche, die hier verbessert werden können. Meine Funktion, an die übergeben wird, mapkann nicht einfach geändert werden, sodass das Funktionsmakro nicht erforderlich ist. Dies bedeutet, dass die gesamte Funktion das Makro nicht verwenden kann, das wahrscheinlich einige Bytes hinzugefügt hat. Es wäre auch schön, wenn ich einen besseren Weg finden könnte, die Werte im every?Prädikat zu entpacken.

(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 Byte

Wow, das war ein Training!

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

Dies macht "einfach" 1einen regulären Ausdruck unter Verwendung des alten Elements, der als wahrer Wert oder nichts anderes angezeigt wird.

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 Byte

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

Akzeptiert Eingaben als eine Folge von durch Zeilenumbrüche getrennten Zahlen. Basierend auf der ausgezeichneten Antwort von @ MartinEnder ♦ auf Retina, jedoch wird der gesamte Test in einem einzigen regulären Ausdruck durchgeführt, da er in JavaScript auf diese Weise kürzer ist.

Pip , 12 10 Bytes

$&B@X^_MPg

Nimmt Eingaben als eine Reihe von Befehlszeilenargumenten auf. Die Ausgabe ist eine nicht leere Liste für Wahrheiten und eine leere Liste für Falseys. Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung

         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 Bytes

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

Probieren Sie es online!

Dies ähnelt der Perl 5-Lösung, die ein Port der Retina-Lösung von Martin Ender ist. -10 Bytes dank @Neil.

Hier ist eine andere Lösung ( 73 bis 72 Bytes):

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

Es ist eine anonyme Funktion, die Zeichenfolgen aus dem Stream abruft und überprüft, ob die aufeinander folgenden Zeichenfolgen dieselben Zeichen enthalten. Erläuterung:

{
    [_/""]|    /* 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 */
}

Es könnte möglicherweise mehr Golf gespielt werden ...

Bash + Unix-Dienstprogramme, 71 bis 69 Byte

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

Probieren Sie es online!

Die Eingabe erfolgt stdin, eine Nummer pro Zeile.

Die Ausgabe erfolgt im Exit-Code: 0 für wahrheitsgemäß, 1 für falsch.

Damit kann wohl mehr golfen werden.

Damit der obige Code funktioniert, darf sich im aktuellen Verzeichnis keine Datei mit einem einstelligen Namen befinden. Wenn dies nicht akzeptabel ist, ersetzen Sie [\1]im Programm durch '[\1]'(für 2 zusätzliche Bytes).

Probelauf (letzter Testfall der Challenge):

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

(1 hier ist falsey.)

Wie es funktioniert:

Ich werde oben auf dem Probelauf demonstrieren.

Der sed-Befehl konvertiert die Eingabe in:

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

Der Befehl tr konvertiert dies dann in die Zeichenfolge:

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

Diese Zeichenfolge ist ein Shell-Befehl zum Ausführen der gewünschten Operation. Ich übergebe das an sh und bin fertig.

Q, 57 Bytes

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

1. Initialisiert globales r.
2. Konvertiert die Eingabe in ein String-Array.
3. Durchsucht das Array und überprüft, ob ein Zeichen in der letzten Zeichenfolge in der aktuellen Zeichenfolge enthalten ist.
4. Hängt jedes Ergebnis an r an.
5. Gibt 1 zurück, wenn alle Zeichenfolgen Schritt 3 erfüllen, andernfalls wird 0 zurückgegeben.

Hinweis: 0 wird an den Beginn des Eingabearrays innerhalb der Funktion angehängt. Dies geschah, damit der Vergleich des ersten Elements eingetragen erfolgen konnte. Andernfalls wird das letzte Zeichen des ersten Elements zum Vergleich abgerufen. Könnte jedoch eine Typprüfung durchführen, die 7 Bytes über die aktuelle Anzahl hinzufügt.