Größer als kleiner als größer als etwas Fischartiges

45

Bei einer Länge von N Zeichenfolgen mit Vorzeichen kleiner als und größer als ( <, >) fügen Sie die Ganzzahlen 0 bis N am Anfang und am Ende sowie zwischen die einzelnen Zeichenpaare ein, sodass alle Ungleichungen erfüllt sind. Die resultierende Zeichenfolge ausgeben. Wenn es mehrere gültige Ausgaben gibt, geben Sie eine (und nur eine) davon aus.

Zum Beispiel

<<><><<

Hat 7 Zeichen, daher müssen alle Zahlen von 0 bis einschließlich 7 eingegeben werden. Eine gültige Ausgabe ist

2<3<4>1<5>0<6<7

weil alle Ungleichungen eines nach dem anderen genommen

2<3
3<4
4>1
1<5
5>0
0<6
6<7

sind wahr.

Falls gewünscht, kann die Ausgabe Leerzeichen aufweisen, die die Zeichen umgeben, z 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

Der kürzeste Code in Bytes gewinnt.

Testfälle

Die erste Zeile nach einer Leerzeile ist die Eingabe und die nächste (n) Zeile (n) sind jeweils gültige Ausgabebeispiele.

[empty string]
0

<
0<1

>
1>0

<<
0<1<2

<>
1<2>0

><
1>0<2
2>0<1

>>
2>1>0

<<<
0<1<2<3

><>
1>0<3>2

>><
3>2>0<1
3>1>0<2
2>1>0<3

>>>
3>2>1>0

>>><<<
3>2>1>0<4<5<6
6>3>1>0<2<4<5
4>2>1>0<3<5<6
4>3>1>0<2<5<6

<<><><<
2<3<4>1<5>0<6<7

>><><>>
7>6>0<5>1<4>3>2

<<<<<<<<<<<<<<
0<1<2<3<4<5<6<7<8<9<10<11<12<13<14

>><<<<><>><><<
6>5>4<7<8<9<10>3<11>2>1<12>0<13<14
14>5>4<7<8<9<10>3<11>2>1<12>0<13<6
Calvins Hobbys
quelle
4
Wird es immer eine gültige Ausgabe geben?
mbomb007
3
@ mbomb007 Ja. Es gibt immer mindestens einen.
Calvins Hobbys
23
Ich möchte, dass jemand dies in> <> programmiert! Das wäre großartig (und ironisch, denke ich?)
Soren
Das war ein wirklich Spaß , aber einfach Herausforderung dank op
Shaun Wilder

Antworten:

29

Netzhaut , 20 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.


$.'
S`>
%O#`\d+
¶
>

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

Eine einfache Möglichkeit, eine gültige Permutation zu finden, besteht darin, zunächst die Zahlen von 0bis Nin der richtigen Reihenfolge einzufügen und dann die Zahlen umzukehren, die die einzelnen Unterzeichenfolgen von >s umgeben. Nehmen Sie <><<>>><<als Beispiel:

0<1>2<3<4>5>6>7<8<9
  ---   -------      these sections are wrong, so we reverse them
0<2>1<3<7>6>5>4<8<9

Beide Aufgaben sind in Retina relativ einfach, obwohl wir nur mit Strings arbeiten können. Wir können ein zusätzliches Byte sparen, indem wir die Zahlen von Nunten nach unten einfügen 0und <stattdessen die umgebenden Abschnitte umkehren , aber das Prinzip ist dasselbe.

Stufe 1: Substitution


$.'

Wir beginnen damit, die Länge von $'(das Suffix, dh alles nach dem Match) in jede mögliche Position in der Eingabe einzufügen. Dies fügt die Zahlen von Nunten bis ein 0.

Stufe 2: Split

S`>

Wir teilen die Eingabe >in separate Zeilen auf, sodass jede Zeile entweder eine einzelne Zahl oder eine Liste von Zahlen ist, mit denen sie verbunden ist <.

Stufe 3: Sortieren

%O#`\d+

Innerhalb jeder Zeile ( %) sortieren ( ) wir Odie Zahlen ( \d#) nach ihrem numerischen Wert ( #). Da wir die Nummer in umgekehrter numerischer Reihenfolge eingegeben haben, werden sie dadurch umgekehrt.

Stufe 4: Substitution

¶
>

Wir verwandeln die Zeilenvorschübe >wieder in, um alles wieder zu einer einzigen Zeile zusammenzufügen. Das ist es.

Als Randnotiz wollte ich eine Möglichkeit hinzufügen %, andere Trennzeichen als Zeilenvorschübe zu verwenden. Hätte ich das schon getan, hätte diese Übermittlung 14 Bytes betragen, denn dann wären die letzten drei Stufen auf eine einzige reduziert worden:

%'>O#`\d+
Martin Ender
quelle
Wie ist das für ein Achtel meiner Größe? Gute Arbeit.
ThreeFx
@ThreeFx Weil ich keine rohe Gewalt benutze. ;) Erklärung kommt in einer Minute.
Martin Ender
22

> <> , 46 43 35 + 4 für  -s== 39 Bytes

0&l?!v:3%?\&:n1+$o!
+nf0.>&n; >l&:@

Dies ist eine Implementierung von xnors Algorithmus in> <>.

Es nimmt die Eingabezeichenfolge auf dem Stapel ( -sFlag mit dem Standardinterpreter).

Sie können es mit dem Online-Dolmetscher ausprobieren .

Aaron
quelle
2
> <> scheint eine passende Sprache für diese Herausforderung zu sein.
Anaximander
21

> <> , 26 + 4 = 30 Bytes

l22pirv
1+$2po>:3%::2g:n$-

Probieren Sie es online! +4 Bytes für das -s=Flag - Wenn dies nur -sin Ordnung ist (dies würde bedeuten, dass das Flag für leere Eingaben vollständig gelöscht werden müsste), wäre dies stattdessen +3.

Es wird davon ausgegangen, dass die STDIN-Eingabe leer ist, sodass i-1 erzeugt wird (was bei EOF der Fall ist). Das Programm versucht, -1 als Zeichen auszugeben.

Verwendet den Max-of-Num-bisher >-für-Min-of-Num-bisher-für- <Ansatz.

[Setup]
l22p         Place (length of stack) = (length of input) into position (2, 2) of
             the codebox. Codebox values are initialised to 0, so (0, 2) will
             contain the other value we need.
i            Push -1 due to EOF so that we error out later
r            Reverse the stack
v            Move down to the next line
>            Change IP direction to rightward

[Loop]
:3%          Take code point of '<' or '>' mod 3, giving 0 or 2 respectively
             (call this value c)
:            Duplicate
:2g          Fetch the value v at (c, 2)
:n           Output it as a number
$-1+         Calculate v-c+1 to update v
$2p          Place the updated value into (c, 2)
o            Output the '<' or '>' as a char (or error out here outputting -1)

Ein Programm, das sauber beendet wird und die Annahme über STDIN nicht trifft, besteht aus 4 zusätzlichen Bytes:

l22p0rv
p:?!;o>:3%::2g:n$-1+$2
Sp3000
quelle
12

CJam , 16 Bytes

l_,),.\'</Wf%'<*

Probieren Sie es online!

Ein Port meiner Retina-Antwort .

Erläuterung

l    e# Read input.
_,   e# Duplicate, get length N.
),   e# Get range [0 1 2 ... N].
.\   e# Riffle input string into this range.
'</  e# Split around '<'.
Wf%  e# Reverse each chunk.
'<*  e# Join with '<'.
Martin Ender
quelle
11

Perl, 29 Bytes

Beinhaltet +2 für -lp

Mit Eingabe auf STDIN ausführen, z

order.pl <<< "<<><><<"

Ausgabe:

0<1<7>2<6>3<4<5

order.pl:

#!/usr/bin/perl -lp
s%%/\G</?$a++:y///c-$b++%eg

Erläuterung

Haben Sie zwei Zähler, max beginnend mit der Zeichenkettenlänge, min beginnend mit 0. Dann an jeder Grenze (einschließlich Anfang und Ende der Zeichenkette), wenn es gerade vor a ist, <setzen Sie das Minimum dort und erhöhen Sie um 1, sonst setzen Sie das Maximum dort und verringern Sie um 1 (am Ende der Zeichenkette spielt es keine Rolle, welchen Zähler Sie nehmen, da beide gleich sind)

Tonne Hospel
quelle
s{}{/\G/...}Ich habe das noch nie gesehen, es ist brillant.
Primo
10

Python 2, 67 Bytes

f=lambda s,i=0:s and`i+len(s)*(s>'=')`+s[0]+f(s[1:],i+(s<'>'))or`i`

Eine rekursive Funktion. Befriedigt jeden Bediener, indem er den kleinsten unbenutzten Wert xfür x<und den größten für einsetzt x>. Der kleinste nicht verwendete Wert wird gespeichert iund aktualisiert, und der größte nicht verwendete Wert wird aus ider verbleibenden Länge abgeleitet.

xnor
quelle
1
Ich denke, Sie könnten tun, (s>'=')anstatt (s>='>')ein Byte zu speichern?
Mathmandan
@mathmandan Danke! Es ist komisch , dass <und >nicht aufeinander folgen Codepoints.
Donnerstag,
Einverstanden! Aber ich schätze, ich kann sehen, wie sinnvoll es wäre, =zwischen <und zu haben >.
Mathmandan
8

Python 2, 163 137 Bytes

from random import*
def f(v):l=len(v)+1;N=''.join(sum(zip(sample(map(str,range(l)),l),v+' '),()));return N if eval(N)or len(v)<1else f(v)

Mischt die Zahlen, bis die Aussage zu ausgewertet wird True.

Versuch es.

Atlasologe
quelle
Dies ist eindeutig die vernünftigste aller Antworten.
Moopet
7

APL, 33 Bytes

⍞←(S,⊂''),.,⍨-1-⍋⍋+\0,1-2×'>'=S←⍞

⍋⍋ ist ungewöhnlich nützlich.

Erläuterung

⍞←(S,⊂''),.,⍨-1-⍋⍋+\0,1-2×'>'=S←⍞
                                   ⍞ read a string from stdin      '<<><><<'
                                 S←   store it in variable S
                             '>'=     test each character for eq.   0 0 1 0 1 0 0
                         1-2×         1-2×0 = 1, 1-2×1 = ¯1         1 1 ¯1 1 ¯1 1 1
                                      (thus, 1 if < else ¯1)
                       0,             concatenate 0 to the vector   0 1 1 ¯1 1 ¯1 1 1
                     +\               calculate its running sum     0 1 2 1 2 1 2 3
                   ⍋                 create a vector of indices    1 2 4 6 3 5 7 8
                                      that sort the vector in
                                      ascending order
                 ⍋                   do it again: the compound ⍋⍋ 1 2 5 3 6 4 7 8
                                      maps a vector V to another
                                      vector V', one permutation of
                                      the set of the indices of V,
                                      such that
                                            V > V  => V' > V'.
                                             i   j     i    j
                                      due to this property, V and V'
                                      get sorted in the same way:
                                          ⍋V = ⍋V' = ⍋⍋⍋V.
              -1-                     decrement by one              0 1 4 2 5 3 6 7
      ⊂''                            void character vector         ⊂''
    S,                                concatenate input string     '<<><><<' ⊂''
   (     ),.,⍨                       first concatenate each        0 '<' 1 '<' 4 '>' 2 \
                                     element of the result vector  '<' 5 '>' 3 '<' 6 '<' \
                                     with the cordisponding        7 ⊂''
                                     element in the input string,
                                     then concatenate each result
⍞←                                  write to stdout
Oberon
quelle
3
Was machen die Weihnachtsbäume ( ⍋⍋)?
Conor O'Brien
ist eine Note höher, die Angaben in sortierter Reihenfolge zurückgibt. Wenn Sie es zweimal machen, erhalten Sie, 1wo die kleinste Zahl war, 2wo die nächstkleinere Zahl war, ect.
Zwei
@ ConorO'Brien bearbeitet mit einer kurzen Erklärung.
Oberon
Ja, sehr kurz.
Conor O'Brien
7

JavaScript (ES6), 74 56 Byte

s=>s.replace(/./g,c=>(c<'>'?j++:l--)+c,j=0,l=s.length)+j

Beginnt mit der Menge der Zahlen 0...N. In jeder Phase wird einfach die größte ( l) oder die kleinste ( j) der verbleibenden Zahlen genommen. Die nächste Zahl muss per definitionem kleiner oder größer sein. Bearbeiten: Dank @Arnauld wurden massive 18 Bytes gespeichert.

Neil
quelle
3
Kannst du verwenden replace? Vielleichts=>s.replace(/./g,c=>(c<'>'?j++:l--)+c,j=0,l=s.length)+j
Arnauld
@Arnauld ... und ich dachte, ich könnte meinen ersten Versuch (der nicht durch ersetzt werden konnte replace) auf 74 Bytes reduzieren ...
Neil,
5

Pyth - 19 Bytes

Ein Hoch auf die Vergleichsverkettung!

!QZhv#ms.idQ.p`Mhl

Funktioniert aus Sicherheitsgründen nicht online.

Maltysen
quelle
4

2sable , 20 Bytes

gUvy'<Qi¾¼ëXD<U}y}XJ

Erläuterung

gU                     # store input length in variable X
  v              }     # for each char in input
   y'<Qi               # if current char is "<"
        ¾¼             # push counter (initialized as 0), increase counter
          ëXD<U}       # else, push X and decrease value in variable X
                y      # push current char
                  XJ   # push the final number and join the stack

Probieren Sie es online!

Für N <10 könnte dies 14 Bytes gewesen sein:

ÎvyN>}J'<¡í'<ý
Emigna
quelle
4

C # 102 99 Bytes

string f(string s){int i=0,j=s.Length;var r="";foreach(var c in s)r=r+(c<61?i++:j--)+c;return r+i;}

Ungolfed:

string f(string s)
{
    int i = 0, j = s.Length;    // Used to track the lowest and highest unused number.
    var r = "";                 // Start with the empty string.

    foreach (var c in s)        // For each character in the input string:
        r = r +                 // Append to the result:
            (c < 61             // If the current character is '<':
                ? i++           // Insert the lowest unused number,
                : j--)          // otherwise, insert the highest unused number.
            + c;                // And append the current character.

    return r + i;               // Return the result with the last unused number appended.
}
Scepheo
quelle
Ich bin müde, also könnte mir etwas fehlen, aber würde ich das r = r +Teil nicht in eine zusammengesetzte Zuweisung ändern, um ein paar Bytes zu sparen?
Carcigenicate
2
Nein - der r+Teil auf der rechten Seite teilt dem Compiler mit, dass das Ganze ein String ist, daher wird die String-Darstellung von cverwendet. Wenn ich das verwende r+=, würde das ?:Teil zu einem ausgewertet int, der Ordnungswert von cwürde dazu addiert und nur dann würde es in seine Zeichenfolgendarstellung konvertiert.
Scepheo
4

Java 8, 126 125 Bytes

s->{int t=s.replaceAll("<","").length(),y=t-1;String r=t+++"";for(char c:s.toCharArray())r+=(c+"")+(c<61?t++:y--);return r;};

Ich glaube nicht, dass das funktioniert, hehe

Ungolfed Testprogramm

public static void main(String[] args) {
    Function<String, String> function = s -> {
        int t = s.replaceAll("<", "").length(), y = t - 1;
        String r = t++ + "";
        for (char c : s.toCharArray()) {
            r += (c + "") + (c < 61 ? t++ : y--);
        }
        return r;
    };

    System.out.println(function.apply("<<><><<"));
    System.out.println(function.apply(">>><<<"));
    System.out.println(function.apply(">>>"));
    System.out.println(function.apply("<<<"));
    System.out.println(function.apply(">><><>>"));
}
Shaun Wild
quelle
Sie können das ändern .replaceAllzu .replaceund die Klammer entfernen um (c+"")5 Bytes zu speichern.
Kevin Cruijssen
@ KevinCruijssen Nicht etwa 5 Bytes hahah arsed.
Shaun Wild
Bei Verwendung einer geeigneten Golfsprache sind 5 Byte der Unterschied zwischen dem 5. und dem 2. Platz. Mit Java ist es der Unterschied zwischen dem letzten Platz bei weitem und dem letzten Platz.
Shaun Wild
Java wird bei Code-Golf-Herausforderungen fast immer das letzte sein, aber der Grund, warum wir Java-Antworten veröffentlichen, ist, es so kurz wie möglich zu halten. Ich persönlich bin schon froh, wenn mein Java-Code byteweise von 500 auf 499 geht. ; P
Kevin Cruijssen
Wir ignorieren grundsätzlich alle Mitbewerber und konkurrieren nur mit oder Java / C # -Einreichungen usw.
Shaun Wild
4

Jelly , 27 14 12 Bytes

Port von @Martin Enders CJam Lösung
-2 Bytes dank @Dennis

żJ0;µFṣ”<Uj”<

Testen Sie es bei TryItOnline

Wie?

żJ0;Fṣ”<Uj”< - main link takes an argument, the string, e.g. ><>
 J           - range(length(input)), e.g. [1,2,3]
  0          - literal 0
   ;         - concatenate, e.g. [0,1,2,3]
ż            - zip with input, e.g. [[0],">1","<2",">3"]
    F        - flatten, list, e.g. "0>1<2>3"
      ”<  ”< - the character '<'
     ṣ       - split, e.g. ["0>1","2>3"]
        U    - upend (reverse) (implicit vectorization), e.g. ["1>0","3>2"]
         j   - join, e.g. "1>0<3>2"

Vorherige Methode war mathematisch interessant, aber nicht so golfen ...

=”>U
LR!×ÇĖP€S‘
L‘ḶŒ!ị@ÇðżF

Hierbei wird das faktorielle Basissystem verwendet, um einen Index der Permutationen von [0, N] zu finden, der die Gleichung erfüllt.

Jonathan Allan
quelle
1
Uvektorisiert, so dass Sie nicht brauchen . żJ0;speichert ein weiteres Byte.
Dennis
4

Clojure, 152 132 126 Bytes

(defn f[s](loop[l 0 h(count s)[c & r]s a""](if c(case c\<(recur(inc l)h r(str a l c))(recur l(dec h)r(str a h c)))(str a l))))

Habe eine ganze Menge Bytes gespart, indem ich so viel Leerzeichen wie möglich entfernt habe. Ich habe festgestellt, dass Leerzeichen nicht erforderlich sind, um eine Klammer von einem anderen Zeichen zu trennen.

Grundsätzlich eine Clojure-Portierung von @ Scepheos Antwort. Arbeitet identisch.

Diese recurAnrufe sind Killer! Ich nehme an, ich hätte Atome verwenden können, um es zu säubern. Die swap!Aufrufe, die erforderlich sind, um zur Anzahl hinzugefügte Atome zu verwenden: /

Vielen Dank an @amalloy, dass du mir ein paar Bytes gespart hast.

Ungolfed:

(defn comp-chain [chain-str]
  (loop [l 0 ; Lowest number
         h (count chain-str) ; Highest number
         [c & cr] chain-str ; Deconstruct the remaining list
         a ""] ; Accumulator
    (if c ; If there's any <>'s left
      (if (= c \<) ; If current char is a <...
        (recur (inc l) h cr (str a l c)) ; Add l to a, and inc l
        (recur l (dec h) cr (str a h c))) ; Add h to a, and dec h
      (str a l)))) ; Add on the remaining lowest number, and return
Karzigenat
quelle
Willkommen auf der Seite!
DJMcMayhem
@ DJMcMayhem Danke. Hoffentlich kann ich beim nächsten Mal meine eigene Lösung finden, anstatt nur eine andere Antwort zu portieren.
Carcigenicate
Sie können zwei weitere Leerzeichen in der loopBindung davor sund danach speichern a. Sie könnten auch ein bisschen durch den Austausch des rasieren ifBaum mit ein case: (case c \< (recur ...) nil (str ...) (recur ...)). Und natürlich crkönnte ein kürzerer Name sein.
Amalloy
@amalloy Gute Punkte, danke. Ich aktualisiere, wenn ich auf meinem Laptop bin.
Carcigenicate
3

Haskell, 162 Bytes

import Data.List
(a:b)%(c:d)=show c++a:b%d
_%[x]=show x
f l=map(l%).filter(l#)$permutations[0..length l]
(e:f)#(x:y:z)=(e!x)y&&f#(y:z)
_#_=0<1
'>'!x=(>)x
_!x=(<)x

Das ist verdammt lang.

ThreeFx
quelle
3

Perl (107 + 1 für -p) 108

for$c(split''){$s.=$i++.$c;}
for$b(split'<',$s.$i){$h[$j]=join'>',reverse split'>',$b;$j++;}
$_=join'<',@h;

Algorithmus aus Martin Enders Antwort gestohlen

Riley
quelle
2

Ruby, 135 Bytes

g=gets
puts g.nil?? 0:[*0..s=g.size].permutation.map{|a|a.zip(g.chars)*""if s.times.map{|i|eval"%s"*3%[a[i],g[i],a[i+1]]}.all?}.compact

Hinweis: Die zeitliche Komplexität ist groß (O (n!)).

cia_rana
quelle
2

Python 2, 176 172 Bytes

Es ist nicht sehr kurz im Vergleich zu den anderen, aber ich bin froh, dass ich es so schnell gelöst habe.

from itertools import*
def f(s):
 for p in permutations(range(len(s)+1)):
    n=list(s);p=list(p);t=[p.pop()]+list(chain(*zip(n,p)));r="".join(map(str,t))
    if eval(r):return r

Probieren Sie es online aus

Ungolfed:

from itertools import*
def f(s):
    n=list(s);R=range(len(s)+1)
    for p in permutations(R):
        p=list(p)
        r=[p.pop()]
        t=n+p
        t[::2]=n
        t[1::2]=p
        r="".join(map(str,r+t))
        if eval(r):return r

Probieren Sie es online aus

mbomb007
quelle
Der Interlace-Teil kann viel kürzer gemacht werdenzip
Maltysen
@Maltysen Keine Tonne kürzer, weil die Listen nicht gleich lang sind (muss ich noch pop), aber es ist ein bisschen kürzer. Wenn N<10ja, könnte ich die Bespannung kürzer machen.
mbomb007
1

PHP, 190 Bytes

Zufälliges Mischen, bis eine gültige Lösung vorliegt

$x=range(0,$l=strlen($q=$argv[1]));while(!$b){$b=1;$t="";shuffle($x);for($i=0;$i<$l;){$t.=$x[$i].$q[$i];if(($q[$i]==">"&$x[$i]<$x[$i+1])|($q[$i]=="<"&$x[$i]>$x[1+$i++]))$b=0;}}echo$t.$x[$i];

381 Bytes erhalten alle Lösungen und wählen eine aus

<?php $d=range(0,strlen($q=$argv[1]));echo $q."\n";$e=[];function f($t=""){global$e,$d,$q;foreach($d as$z){preg_match_all("#\d+#",$t,$y);if(in_array($z,$y[0]))continue;$p=preg_match_all("#[<>]#",$t);$g="";if(preg_match("#\d+$#",$t,$x)){if(($q[$p]==">"&$x[0]<$z)|($q[$p]=="<"&$x[0]>$z))continue;$g=$q[$p];}strlen($q)==$p+1|!$q?$e[]=$t.$g.$z:f($t.$g.$z);}}f();echo$e[array_rand($e)];
Jörg Hülsermann
quelle