Ihre ganz eigene "für" Anweisung

Angenommen, Sie haben die folgenden Eingaben: a, b, c, d

Die Eingabe kann einzeilig erfolgen, wobei jedes Format ("a / b / c / d" oder "a, b, c, d" usw.) verwendet wird.

Sie können auch 4 Eingänge haben.

Sie müssen das folgende Verhalten codieren (hier Pseudocode):

var i = <a>
while (i <b> <c>)
    print i
    i = i + <d>
    print "\n"

Hier sind einige Testfälle:

input : 1,<,10,1
output :
1
2
3
4
5
6
7
8
9

Einer noch :

input : 20,>,10,1
output :
20
21
22
23
24
25
26
27
...
infinite loop / program crashes

• aist eine ganze Zahl , der Anfangswert von i.

• bIst ein String oder ein Zeichen , kann es nicht etwas anderes sein, der Komparator, der in der Endbedingung der forSchleife verwendet wird.

  bkann und muss eine der folgenden Zeichenketten sein:

  - ">"
  - "<"
  

• cist eine Ganzzahl , die Zahl, die in der Endbedingung der for Schleife verwendet wird.

• dist eine Ganzzahl , die bei jeder Schleife zu i hinzugefügt wird.

Das ist Code-Golf, die kürzeste Antwort gewinnt!

JavaScript (ES6),  44  43 56 Bytes

Dank ETHproductions 1 Byte gespart Edit: Korrigiert
, um die Ausgabeanforderungen zu erfüllen

(a,b,c,d)=>{for(s='';eval(a+b+c);a+=d)s+=a+`
`;alert(s)}

Prüfung

let f =

(a,b,c,d)=>{for(s='';eval(a+b+c);a+=d)s+=a+`
`;alert(s)}

f(1,'<',7,2)

Javascript (ES6), 47 42 48 Bytes

Wollte die for-Version machen, aber jemand war schneller, also hier ist die rekursive Version.

(b,c,d)=>F=a=>eval(a+b+c)&&console.log(a)|F(a+d)

Du musst f=vorher hinzufügen und es so nennen f(b,c,d)(a).

Vielen Dank an Arnauld für das tolle Golfen.

alertgeändert zu console.logaufgrund der Ausgabespezifikation

Pure Bash, 35

Ich gehe davon aus, dass es in Ordnung ist, nur die Parameter in die Standard-for-Schleife einzufügen:

for((i=$1;i$2$3;i+=$4));{ echo $i;}

Probieren Sie es online aus .

Gelee , 12 Bytes

Ṅ+⁶µ⁴;⁵¹vµ¿t

Probieren Sie es online!

Jelly hat viele Möglichkeiten, Iterationen zu wiederholen, Bereiche zu erstellen usw. Das genaue Spiegeln des C ++ - Verhaltens ist jedoch ziemlich schwierig, da Sonderfälle wie das Inkrement 0 sind und die Schleife vor dem Start endet (da die Ungleichung umgekehrt ist) ) und das Inkrement in die falsche Richtung (was bedeutet, dass die Ausgangsbedingung der Schleife nicht auf natürliche Weise erfüllt werden kann). Als solche ist diese Lösung im Grunde genommen eine direkte Übersetzung von C ++, auch wenn sie dadurch weniger umfangreich ist als ein Jelly-Programm normalerweise. Glücklicherweise hat C ++ ein undefiniertes Verhalten beim Überlauf von Ganzzahlen mit Vorzeichen (wird von der Frage verwendet int), was bedeutet, dass ein Programm in diesem Fall alles tun kann und daher nicht versucht werden muss, das Überlaufverhalten nachzuahmen.

Erläuterung

Ṅ+⁶µ⁴;⁵¹vµ¿t
   µ     µ¿   While loop; while ((⁴;⁵¹v) counter) do (counter = (Ṅ+⁶)counter).
    ⁴;⁵       Second input (b) appended to third input (c), e.g. "<10"
        v     Evaluate, e.g. if the counter is 5, "<10" of the counter is true
       ¹      No-op, resolves a parser ambiguity
Ṅ             Output the counter, plus a newline
 +⁶           Add the fourth input (d)
           t  Crashes the program (because the counter is not a list)

Das Programm zum Absturz zu bringen, ist die schnellste Möglichkeit, Jellys implizite Ausgabe zu deaktivieren (andernfalls würde der Endwert des Zählers ausgegeben). es erzeugt eine Reihe von Fehlermeldungen auf stderr, aber wir betrachten dies normalerweise als zulässig.

Im Übrigen wird der Schleifenzähler vor dem Start der Schleife mit dem aktuellen Wert initialisiert. Da die Schleife beim Start des Programms erscheint, ist dies die erste Eingabe.

Python 2 , 50 Bytes

a,b,c,d=input()
while eval(`a`+b+`c`):print a;a+=d

Probieren Sie es online!

R, 63 Bytes

function(a,b,c,d)while(do.call(b,list(a,c))){cat(a,"\n");a=a+d}

Java, 58 Bytes

(a,b,c,d)->{for(;b>61?a>c:a<c;a+=d)System.out.println(a);}

05AB1E , 22 20 Bytes

[D²`'>Q"‹›"è.V_#D,³+

Probieren Sie es online!

Erläuterung

[                       # start loop
 D                      # copy top of stack (current value of a)
  ²`                    # push b,c to stack
    '>Q                 # compare b to ">" for equality
       "‹›"             # push this string
           è            # index into the string with this result of the equality check
            .V          # execute this command comparing a with c
              _#        # if the condition is false, exit loop (and program)
                D,      # print a copy of the top of the stack (current value of a)
                  ³+    # increment top of stack (a) by d

SmileBASIC, 53 Bytes

INPUT A,B$,C,D
S=ASC(B$)-61WHILE S*A>S*C?A
A=A+D
WEND

Erläuterung:

INPUT A,B$,C,D
IF B$=="<" THEN S=-1 ELSE S=1 'get comparison direction
I=A
WHILE S*I>S*C 'loop while I is less than/greater than the end
 PRINT I
 INC I,D
WEND

Dies nutzt die Tatsache, dass X<Ydas gleiche ist wie-X>-Y

Gestapelt , 34 Bytes

@d@c@b[show d+][:c b tofunc!]while

Probieren Sie es online! (Testen eingeschlossen.) Dies ist eine Funktion, die erwartet, dass der Stapel wie folgt aussieht:

a b c d

Beispielsweise:

1 '<' 10 2
@d@c@b[show d+][:c b tofunc!]while

Erläuterung

@d@c@b[show d+][:c b tofunc!]while
@d@c@b                               assign variables
               [............]while   while:
                :c                   duplicate "i" and push c
                   b tofunc!         convert b to a function and execute it
      [.......]                      do:
       show                          output "i" without popping
            d+                       and add the step to it

C ++, 80

Hoppla, das ist C++nicht so C. War ein bisschen verwirrt von der Frage.

void f(int a,char b,int c,int d){for(;b==62?a>c:a<c;a+=d)cout<<a<<endl;}

C 52 51 Bytes

-1 Byte dank H Walters

f(a,b,c,d){for(;b&2?a>c:a<c;a+=d)printf("%d\n",a);}

Probieren Sie es online!

Python 3, 52 Bytes

def f(a,b,c,d):
 while[a>c,a<c][b<'>']:print(a);a+=d

repl.it

Pip , 14 Bytes

W Va.b.ca:d+Pa

Übernimmt vier Befehlszeilenargumente. Unterstützt negative und Gleitkommazahlen sowie Vergleichsoperatoren < > = <= >= !=. Probieren Sie es online!

                a,b,c,d are cmdline args
W               While loop with the following condition:
  Va.b.c          Concatenate a,b,c and eval
            Pa  Print a with newline (expression also returns value of a)
        a:d+    Add d to that and assign back to a

Gelee , 8 Bytes

ḢṄ+⁹;µV¿

Dies ist eine dyadische Verknüpfung, die a, b, c als linkes und d als rechtes Argument verwendet . Die Ausgabe kann unendlich sein und geht zu STDOUT.

Probieren Sie es online!

Wie es funktioniert

ḢṄ+⁹;µV¿  Dyadic link.
          Left argument:  a,b,c (integer, character, integer)
          Right argument: d     (integer)

       ¿  While...
      V     the eval atom applied to a,b,c returns 1:
     µ       Combine the links to the left into a chain and apply it to a,b,c.
Ḣ              Head; pop and yield a from a,b,c.
 Ṅ             Print a, followed by a linefeed.
  +⁹           Add a and the right argument (d) of the dyadic link.
    ;          Concatenate the result and the popped argument of the chain,
               yielding a+d,b,c.

Python 2 , 45 Bytes

exec"i=%d\nwhile i%c%d:print i;i+=%d"%input()

Probieren Sie es online!

Eine sehr wörtliche Umsetzung der Spezifikation. Übernimmt die Codevorlage, ersetzt die Eingaben durch Zeichenfolgenformatierung und führt sie aus.

Normaler TeX, 88 Bytes

\newcount\i\def\for#1 #2 #3 #4 {\i#1\loop\the\i\endgraf\advance\i#4\ifnum\i#2#3\repeat} 

Der Befehl \forstellt die angeforderte Funktion bereit. Speichern Sie dies als for.texund führen Sie es dann aus und geben Sie die Variablenwerte in der Befehlszeile ein: pdftex '\input for \for 1 < 5 1 \bye'Die Variablenwerte müssen durch Leerzeichen getrennt werden.

Python 3, 61 Bytes

Einzeiler:

e=input;exec(f'i={e()}\nwhile i{e()}{e()}:print(i);i+={e()}')

Haskell , 66 64 Bytes

f a b c d|last$(a<c):[a>c|b>"<"]=print a>>f(a+d)b c d|1<3=pure()

Probieren Sie es online! Verwendung:

Prelude> f 0 "<" 9 2
0
2
4
6
8

Bash (+ Unix Tools), 29 Bytes

Golf gespielt

bc<<<"for(x=$1;x$2$3;x+=$4)x"

Prüfung

./forloop 1 '<' 10 1
1
2
3
4
5
6
7
8
9

Ruby, 43 41 Bytes

->a,*i,d{a=d+p(a)while eval"%s"*3%[a,*i]}

Wenn anstelle eines Strings bein Ruby-Symbol verwendet werden kann, erhalten Sie 38 Bytes :

->a,b,c,d{a=d+p(a)while[a,c].reduce b}

Probieren Sie eine der beiden Lösungen online aus!

Gemeines Lisp, 82 80 79 73 64 Bytes

(defmacro f(a b c d)`(do((i,a(+ i,d)))((not(,b i,c)))(print i)))

Prüfung

(f 1 < 10 1)

1 
2 
3 
4 
5 
6 
7 
8 
9 
NIL
CL-USER> 

-9 Bytes dank PrzemysławP.

PHP, 69 65 Bytes

for(list(,$i,$b,$c,$d)=$argv);$b<"="?$i<$c:$i>$c;$i+=$d)echo"$i
";

Führen Sie mit '-r' aus; Geben Sie Befehlszeilenargumente als Eingabe ein.

Für nur ein Byte mehr 4 weitere Bytes kann ich jeden Operator nehmen:

for(list(,$i,$b,$c,$d)=$argv;eval("return $i$b$c;");$i+=$d)echo"$i
";

Ja, böse Eval. Wussten Sie, dass es etwas zurückgeben kann?

Durch die Destrukturierung in Kurzform [,$i,$b,$c,$d]=$argv;würden 4 weitere Bytes eingespart.
aber PHP 7.1 datiert die Herausforderung nach.

Perl 6 , 44 Bytes

{.say for $^a,*+$^d...^*cmp$^c!= $^b.ord-61}

Wie es funktioniert

{                                          }  # A lambda.
          $^a                                 # Argument a.
             ,*+$^d                           # Iteratively add d,
                   ...^                       # until (but not including the endpoint)
                       *cmp$^c                # the current value compared to c
                                              # (less=-1, same=0, more=1)
                              != $^b.ord-61.  # isn't the codepoint of the b minus 61.
 .say for                                     # Print each number followed by a newline.

Wenn es in Ordnung ist, eine (möglicherweise unendliche) Folge von Zahlen als Wert vom Typ zurückzugeben Seq, anstatt die Zahlen auf stdout zu drucken, kann der .say forTeil entfernt und auf 35 Byte reduziert werden.

Clojure, 66 63 Bytes

#(when((if(= %2"<")< >)% %3)(println %)(recur(+ % %4)%2 %3 %4))

-3 Bytes durch Ausklammern der loop. Ich "missbrauche" den init-Parameter, um als laufender Akku zu fungieren.

Rekursive Lösung (mit TCO). Siehe Kommentare in vorprogrammiertem Code. Ich habe eine nicht-TCO-rekursive Lösung ausprobiert, die 67 Byte umfasste.

Ich würde diesen Beat gerne in Clojure sehen! Ich denke das ist das kleinste was ich bekommen kann.

(defn my-for [init-num com-str com-num inc-num]
  (let [op (if (= com-str "<") < >)] ; Figure out which operator to use
    (when (op init-num com-num) ; When the condition is true, print and recur
      (println init-num)
      (recur (+ init-num inc-num) com-str com-num inc-num))))
    ; Else, terminate (implicit) 

Groovy, 51 Bytes

{a,b,c,d->while(Eval.me("$a$b$c")){println a;a+=d}}

Dies ist eine namenlose Schließung. Probieren Sie es online!

Achtung - Wenn Sie dies mit testen möchten groovy console, stellen Sie sicher, dass Sie den gesamten Prozess abbrechen, wenn die Eingabe eine Endlosschleife verursacht. Ich bemerkte dies, nachdem es ~ 5 GB RAM verbraucht hatte.

QBIC , 51 bis 40 Bytes

:;::{?a┘a=a+c~A=@<`|~a>=b|_X]\~a<=b|_X

Und drei Minuten nach dem Posten wurde mir klar, dass ich die Terminatorlogik vereinfachen könnte ...

:;::      Consecutively read a, A$, b and c from the command line
{?a┘      Start an infinite loop; print a, add a newline to the source
a=a+c     increment a
~A=@<`|   If we are in LESS THAN mode
  ~a>=b   and IF we are no longer LESS
    |_X]  THEN QUIT, end if.
  \       ELSE (we're in GREATER THAN mode)
    ~a<=b IF we are no longer GREATER
    |_X   THEN QUIT
          The last IF and the loop are auto-closed

Batch, 94 Bytes

@set i=%1
@set o=gtr
@if "%~2"=="<" set o=lss
:g
@if %i% %o% %3 echo %i%&set/ai+=%4&goto g

Wenn das Verhalten des zweiten Parameters nicht gegeben wäre, könnte dies in 53 Bytes erfolgen:

@for /l %%i in (%1,%4,%n%)do @if not %%i==%3 echo %%i

Das macht einfach nichts, wenn der Schritt das falsche Vorzeichen hat. Der zusätzliche Test besteht darin, dass die forSchleife von Batch ermöglicht, dass die Schleifenvariable dem Endwert entspricht.

Clojure, 66 Bytes

#(loop[i %](if(({">">"<"<}%2)i %3)(do(println i)(recur(+ i %4)))))

Dies könnten 55 Bytes gewesen sein <und >sind Funktionen in Clojure:

(def f #(loop[i %](if(%2 i %3)(do(println i)(recur(+ i %4))))))
(f 1 < 10 1)

TI-Basic, 41 34 Bytes

Prompt A,Str2,Str3,D
While expr("A"+Str2+Str3
Disp A
A+D->A
End