Rutger , 310 bajtów
n=e=$Input;
a=0;
w=While[{m=Modulo[$e];Not[m[1]];}];
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
Do[$w];
Wypróbuj online!
Najwyższy czas ponownie użyć Rutgera. Niestety, może to nie być najlepszy język dla tego zadania, ponieważ nie ma żadnej formy eval, zmuszając mnie do użycia czterech instrukcji if
Jak to działa
Jak działa Rutger
Krótkie przedmowa o tym, jak działa język: wszystko jest albo przypisaniem, albo funkcją, a każda funkcja wymaga dokładnie jednego argumentu. W przypadku operacji wymagających więcej niż jednego argumentu (np. Mnożenie) pierwsze wywołanie zwraca funkcję częściową , która po ponownym wywołaniu z drugim argumentem zwraca oczekiwany wynik. Na przykład:
left = Times[5];
Print[left[6]];
wydrukuje 30: Wypróbuj online!. Chociaż zwykle jest to dłuższa niż zwykła alternatywa, może czasami oszczędzać bajty, jeśli funkcja jest wywoływana wielokrotnie z jednym stałym argumentem i jednym zmieniającym się argumentem, na przykład podczas drukowania tabel czasów.
Ta reguła jednego argumentu ma zastosowanie do wszystkiego, co nie jest stałą ani zmienną, w tym pętli i warunków warunkowych. Jednak pętli i instrukcji warunkowych ( For, Each, While, DoWhile, Ifi IfElse) są wykonalne , co oznacza, że aby właściwie prowadzonym nich, Dofunkcja musi być wywołana (patrz ostatni wiersz w odpowiedzi). Ponownie może to zaoszczędzić bajty przy wielokrotnym uruchamianiu tej samej pętli lub pozwolić na uruchomienie dowolnego kodu między definicją a uruchomieniem pętli.
Wreszcie istnieją trzy sposoby odwoływania się do zmiennych, z których wszystkie są używane w tym programie. Pierwszym z nich jest bezpośrednie odwołanie , w którym nazwa zmiennej poprzedzona jest $symbolem. Uzyskuje to bezpośredni dostęp do wartości zmiennej i zwraca ją. Drugim jest odwołanie funkcjonalne , które nie ma znaku prefiksu. Umożliwia to kodowi rozróżnienie między (potencjalnie częściowymi) funkcjami przypisanymi do zmiennych a rzeczywistymi zmiennymi zawierającymi określoną wartość. Wreszcie pośrednie odwołanie , poprzedzone @symbolem, tworzy zmienną (jeśli jeszcze nie istnieje) i zwraca obiekt zmiennej w danym zakresie. Umożliwia to utworzenie zmiennej pętli (np. iWfor i in range(...) ).
Jak działa rzeczywiste rozwiązanie
Oto nielepszy kod:
n = elem = $Input;
var = 0;
while = While[{
mod = Modulo[$elem];
Not[mod[1]];
}];
while = while[{
for = For[4];
for = for[@index];
for = for[{
Print[$elem];
equal = Equal[$index];
if = If[{ equal[1]; }];
if = if[{ func = Times[$elem]; }];
Do[$if];
if = If[{ equal[2];}];
if = if[{ func = Add[$elem];}];
Do[$if];
if = If[{ equal[3];}];
if = if[{ func = Subtract[$elem];}];
Do[$if];
if=If[{ equal[4];}];
if=if[{ func = Divide[$elem];}];
Do[$if];
elem = func[var = Increment[$var]];
}];
Do[$for];
}];
Do[$while];
Wypróbuj online!
Jak widać, zaczyna przypisując trzy zmienne n, ei a, które stanowią wkład, zmieniający się element w sekwencji i numer modyfikacji dla każdego nowego elementu odpowiednio. Następnie tworzymy pętlę while:
w=While[{m=Modulo[$e];Not[m[1]];}];
{}me % m100 → 1n → 0 , n ≠ 0 .
Następnie dochodzimy do absolutnej potworności składającej się z ciała pętli while:
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
4x
Print[$e];
q=Equal[$x];
i=If[{q[1];}];i=i[{k=Times[$e] ;}];Do[$i];
i=If[{q[2];}];i=i[{k=Add[$e] ;}];Do[$i];
i=If[{q[3];}];i=i[{k=Subtract[$e] ;}];Do[$i];
i=If[{q[4];}];i=i[{k=Divide[$e] ;}];Do[$i];
e=k[a=Increment[$a]];
Pierwsza instrukcja wypisuje każdą iterację sekwencji przed jej modyfikacją. Następnie tworzymy funkcję częściową w celu sprawdzenia równości ze zmienną pętli xi napotykamy cztery instrukcje if. Każdy sprawdza komunikat, jeśli xma wartość 1, 2, 3 lub 4, odpowiednio, a następnie przydziela się kdo każdej funkcji *, +, -i /, następnie wprowadza się do funkcji z częściowym ejako argument. Wreszcie możemy przypisać edo kuruchomienia z ajako drugi argument i przyrostu a.
