Ihr Chef hat Ihnen gerade eine Liste mit 12 Programmieraufgaben per E-Mail geschickt, die er so schnell wie möglich erledigen muss. Die Aufgaben sind einfach genug, aber Ihr Chef, ein junger Softwaremagnat, der von sozialen Netzwerken begeistert ist, besteht darauf, dass Ihre Lösungen in einen einzelnen Twitter- Tweet passen .

Das bedeutet, dass Sie nur Code im Wert von 140 Byte haben, um alle Aufgaben zu lösen, durchschnittlich 11,67 Byte pro Aufgabe. (Ja, Twitter zählt die Zeichen, aber Ihr Chef hat speziell die Bytes gesagt.)

Sie erkennen, dass es keine Möglichkeit gibt, alle 12 Aufgaben in 140 Byte zu lösen, aber Sie vermuten, dass Ihr Chef nicht alle Ihre Lösungen tatsächlich testet. Sie lösen so viele Aufgaben wie möglich und überspringen einige davon vollständig. Ihre Einstellung ist, dass es nicht darauf ankommt, welche Teilmenge der Aufgaben Sie erledigen, sondern nur darauf, dass die Teilmenge so groß wie möglich ist .

Wie viele Aufgaben kannst du erledigen?

Herausforderung

Schreiben Sie bis zu 12 verschiedene Programme, von denen jedes genau eine der 12 unten aufgeführten Aufgaben löst. Die kumulative Summe der Längen dieser Programme darf 140 Byte nicht überschreiten

Alternativ können Sie ein einzelnes Programm mit einer Länge von maximal 140 Byte schreiben, das eine Ganzzahl von 1 bis 12 benötigt und (idealerweise) mit der Lösung der entsprechenden Aufgabe fortfährt, wobei bei Bedarf weitere Eingaben erforderlich sind. Nicht alle Aufgaben müssen funktionieren, sondern nur diejenigen, die für Ihre Punktzahl zählen. Aufgaben, die nicht funktionieren, dürfen fehlerhaft sein oder etwas anderes tun.

In beiden Fällen kann ein "Programm" tatsächlich eine Funktion sein, die die Eingabe als Argumente verwendet oder dazu auffordert und die Ausgabe ausgibt oder zurückgibt. So könnten Sie beispielsweise eine 140-Byte-Funktion schreiben, die aussieht f(taskNumber, taskInput), oder Sie könnten separate Codeausschnitte für jede Aufgabe schreiben, einige als Funktionen und andere als vollwertige Programme.

Andere Details:

• Der gesamte Code muss in derselben Sprache geschrieben sein.

• Wie üblich sollte die Eingabe von stdin, der Befehlszeile, einem Funktionsargument oder was auch immer für Ihre Sprache üblich ist, kommen. Die Ausgabe wird auf stdout oder die nächstgelegene Alternative Ihrer Sprache gedruckt oder in einem geeigneten Typ zurückgegeben.

• Ein angemessenes Maß an Eingabeformatierung ist in Ordnung. zB Anführungszeichen um Zeichenfolgen oder \nanstelle von tatsächlichen Zeilenumbrüchen.

• Die Ausgabe sollte genau das sein, was erforderlich ist, ohne überflüssige Formatierungen oder Leerzeichen. Die Ausnahme ist eine optionale einfache nachgestellte Zeile.

• Code, der nur in einer REPL- Umgebung ausgeführt wird, ist kein Programm oder keine Funktion.

• Sie dürfen nicht mehrere Programme schreiben, die mehrere Aufgaben lösen. Es ist entweder ein Programm, das (idealerweise) alle Aufgaben löst, oder (idealerweise) 12 Programme, die jeweils eine einzelne Aufgabe lösen.

• Das Posten einer Aufgabenlösung, die Sie nicht oder nur geringfügig geändert haben, ist nicht gestattet, ohne dass der ursprüngliche Autor angegeben wurde, und im Idealfall auch, um Erlaubnis zu erhalten. Wenn Ihre Antwort in erster Linie die kürzesten Lösungen aus allen anderen Antworten zusammensetzt, sollte es sich um ein Community-Wiki handeln.

Wertung

Der Beitrag, der die meisten Aufgaben erledigt, ist der Gewinner. Stimmen zwei Einsendungen überein, gewinnt der mit den wenigsten Bytes. Wenn die Anzahl der Bytes gleich ist, gewinnt die frühere Übermittlung. Community-Wiki-Antworten dürfen nicht gewinnen.

Teilen Sie uns unbedingt mit, welche Aufgaben Sie gelöst haben, nicht nur wie viele!

Handicap für Nichtgolfer:

Es ist wahrscheinlich, dass diese Herausforderung von Golfsprachen dominiert wird . Viele Sprachen haben möglicherweise Probleme, auch nur eine oder zwei Aufgaben innerhalb von 140 Byte zu lösen. Aus diesem Grund können Sie eine nicht konkurrierende Antwort einreichen , wenn das Limit 3 Tweets, dh 420 Bytes, beträgt. Alle anderen Regeln bleiben gleich.

Aufgaben

Aufgabe 1 - Können drei Zahlen ein Dreieck bilden?

Nehmen Sie drei positive ganze Zahlen auf und geben Sie einen Wahrheits- / Falschwert aus , der angibt, ob drei Linien mit diesen Längen ein Dreieck bilden könnten oder nicht . Sie können nicht davon ausgehen, dass die Nummern in einer bestimmten Reihenfolge vorliegen.

Wahrheitsbeispiele (eines pro Zeile):

20 82 63
1 1 1
2 3 4
1 2 2

Falsche Beispiele:

6 4 10
171 5 4
1 1 2
1 2 3

---

Aufgabe 2 - Einer Million am nächsten

Ordnen Sie sie bei einer Zeichenfolge mit genau 7 Dezimalstellen (0-9) neu an, um eine Zahl zu erhalten, die einer Million möglichst nahe kommt. Das heißt, abs(1000000 - rearrangedNumber)sollte minimiert werden.

Geben Sie die resultierende Zahl als Ganzzahl und nicht als Zeichenfolge aus oder geben Sie sie zurück (es sollten also keine führenden Nullen vorhanden sein, es sei denn, dies ist die Norm für Ihre Sprache).

zB sollte eine Eingabe von 9034318zu 984331(und nicht 1033489) führen.

2893984sollte werden 2348899.

0001000sollte werden 1000000.

0000020sollte werden 200000.

---

Aufgabe 3 - Einfacher Tastatursimulator

Nehmen Sie eine Reihe von Kleinbuchstaben (az), Leerzeichen und spitzen Klammern auf <>. Von links nach rechts gelesen, stellt diese Zeichenfolge die Tasten dar, die auf einer Standardtastatur gedrückt wurden, während ein ursprünglich leerer Texteditor geöffnet war. Die Buchstaben und Leerzeichen entsprechen den normalen Tasten, <entsprechen jedoch den Pfeiltasten nach links und >nach rechts, die beide den Cursor bewegen, wenn sie gedrückt werden.

<Bewegt den Cursor um ein Zeichen nach links oder tut nichts, wenn sich der Cursor am Anfang der Zeichenfolge befindet.
>Bewegt den Cursor um ein Zeichen nach rechts oder tut nichts, wenn sich der Cursor am Ende der Zeichenfolge befindet.

Geben Sie die Zeichenfolge aus, die sich im Texteditor befinden würde, wenn alle Tasten in der Eingabezeichenfolge gedrückt wurden. Die Ausgabe von Escape-Codes zum Bewegen des Cursors ist nicht zulässig.

In der Eingabe ist immer mindestens ein Zeichen enthalten, das keine Pfeiltaste ist.

zB sollte der Input ui<<q>>ck <<<<<<the<<<<>>> >>>>>>>>brown x<o<fnachgeben the quick brown fox.

op<<l>>t<<<lam>>>>>>imi<<<><>>>zer<<<<<<<<<<<<<<<<<<>>><>msollte geben llammoptimizer.

e< <c<b<asollte geben abc e.

<<<>><><<><toast>><<>><><<>><sollte geben toast.

---

Aufgabe 4 - Briefe filtern

In vielen Schriftarten, 6 der Groß englischen Alphabet Buchstaben bestehen vollständig aus horizontalen und vertikalen Linien: E, F, H, I, L, und T. Wir werden diese die FILTHE-Buchstaben nennen.

Nehmen Sie eine Folge von Großbuchstaben (AZ) und zählen Sie die Anzahl der Zeilen in den FILTHE-Buchstaben, wobei Sie die resultierende Ganzzahl ausgeben.

E, F, H, I, L, Und That 4, 3, 3, 3, 2 und 2 Zeilen auf.

zB GEOBITShat 4 + 3 + 2 = 9 Zeilen einen Teil der FILTHE-Buchstaben (für .E..IT.), so sollte die Ausgabe sein 9.

ABCDEFGHIJKLMNOPQRSTUVWXYZsollte ausgeben 17.

ABCDGJKMNOPQRSUVWXYZsollte ausgeben 0.

FILTHYLINESINLETTERSsollte ausgeben 39.

---

Aufgabe 5 - Alex Recursive A.

Unser Moderator Alex A. hat eine ziemlich mysteriöse Initiale "A".

Jetzt bin ich mir nicht sicher, aber ich denke das A.steht für .A xelA. Und ich bin mir auch ziemlich sicher, dass das .Ada schleichend für steht Alex A..

Um also Alex 'vollen Namen zu erhalten, müssen wir das A.' s und .A's erweitern:

Alex A. -> Alex [A.] -> Alex [.A xelA] -> Alex .A xelA -> Alex [.A] xelA -> Alex [Alex A.] xelA -> Alex Alex A. xelA -> etc.

Lassen Sie Ihr Programm eine nicht negative Ganzzahl aufnehmen und Alex A.diese so oft erweitern, bis die resultierende Zeichenfolge ausgegeben wird.

So
0wird Alex A.,
1wird Alex .A xelA,
2wird Alex Alex A. xelA,
3wird Alex Alex .A xelA xelA,
4wird Alex Alex Alex A. xelA xelA,
5wird Alex Alex Alex .A xelA xelA xelA,
und so weiter.

^{(Ich habe das gemacht, weil ich mich schlecht gefühlt habe, weil ich Alex versehentlich aus meiner Mod Tribute Challenge ausgeschlossen habe .: P)}

---

Aufgabe 6 - Numpad-Rotation

Geben Sie eine ganze Zahl von 1 bis einschließlich 9 ein (Sie können sie auch als Zeichenfolge verwenden). Geben Sie das 3 × 3-stellige Quadrat aus

789
456
123

in 90 ° -Schritten gedreht, so dass die eingegebene Ziffer an einer beliebigen Stelle in der oberen Reihe erscheint. Wenn 5eingegeben wird, ist jede Drehung eine gültige Ausgabe, da sie 5nicht nach oben gedreht werden kann.

zB wenn 3eingegeben wird, beides

963
852
741

und

321
654
987

sind gültige Ausgaben.

4Nur zur Eingabe

147
258
369

ist gültige Ausgabe.

---

Aufgabe 7 - Aufteilen von Ziffern in Zehner

Nehmen Sie eine nicht leere Folge von Dezimalstellen (0-9) und geben Sie einen Wahrheitswert aus, wenn diese in zusammenhängende Abschnitte unterteilt werden kann, wobei alle Stellen in jedem Abschnitt genau 10 ergeben. Wenn dies nicht möglich ist, geben Sie einen falschen Wert aus.

zB 19306128können 19|3061|28die Abschnitte wie folgt aufgeteilt werden: Alle werden zu 10 summiert (1 + 9, 3 + 0 + 6 + 1, 2 + 8), daher sollte ein wahrer Wert ausgegeben werden.

Wahrheitsbeispiele (eines pro Zeile):

19306128
073
730
0028115111043021333109010
2222255

Falsche Beispiele:

6810410
9218
12341
5222225
000

---

Aufgabe 8 - Quadratische Uhr

Nehmen Sie eine gleich große mehrzeilige Saite auf.

Ausgabe, 12wenn die Eingabe ist

 _ _
| | |
|_ _|

Ausgabe, 3wenn die Eingabe ist

 _ _
| |_|
|_ _|

Ausgabe, 6wenn die Eingabe ist

 _ _
| | |
|_|_|

Ausgabe, 9wenn die Eingabe ist

 _ _
|_| |
|_ _|

Es gibt keine anderen Eingabefälle.

---

Schritt 9 - Halterung Art.-Nr.

Nehmen Sie in einem 4 - Byte - String eine von jedem der linken Klammern enthält (, [, {, und <in beliebiger Reihenfolge.

Fügen Sie die entsprechenden rechten Klammern hinzu, damit die Zeichenfolge 8 Byte lang ist und eine vertikale Symmetrielinie aufweist. zB [<({wird [<({})>].

Kehren Sie dann jede Klammer in dieser Zeichenfolge um. zB [<({})>]wird ]>)}{(<[.

Geben Sie die ursprüngliche 8-Byte-Klammer mit der umgekehrten Version oben und unten in separaten Zeilen aus.

Die endgültige Ausgabe für die Eingabe [<({wäre also

]>)}{(<[
[<({})>]
]>)}{(<[

Ebenso sollte die Ausgabe für <({[sein

>)}][{(<
<({[]})>
>)}][{(<

Die Eingabe (<<[ist ungültig, da die {fehlt und es ein Extra gibt <.

---

Aufgabe 10 - Perimiterize

Nehmen Sie ein rechteckiges Textraster (mindestens 1 × 1) auf ., das aus leeren Feldern und Xdurchgezogenen Feldern besteht. Zellen außerhalb der Gittergrenzen werden als leer betrachtet. Sie können davon ausgehen, dass jede der 4 Gitterkantenzeilen und -spalten mindestens eine enthält X.

zB eine gültige Eingabe könnte sein:

XXX.....X.....
X..X...X.X....
XXX.....X....X

Geben Sie ein weiteres rechteckiges Textgitter aus, in dem jede leere Zelle, die Xorthogonal oder diagonal benachbart ist , einschließlich derjenigen außerhalb des Eingabegitters , zu wird o. Im Wesentlichen wird ein Perimiter von o's um alle Teile von Volltonkacheln gezogen. Das neue Gitter sollte nicht größer sein als es sein muss.

Die Ausgabe des obigen Beispiels wäre also:

ooooo...ooo.....
oXXXoo.ooXoo....
oXooXo.oXoXo.ooo
oXXXoo.ooXoo.oXo
ooooo...ooo..ooo

Ebenso sollte die Ausgabe der Eingabe XXX..X.Xsein

oooooooooo
oXXXooXoXo
oooooooooo

und ausgeben

oooooooooo.
oXXXooXoXo.
oooooooooo.

wäre ungültig, da die leere Spalte ganz rechts nicht erforderlich ist.

Sie können alle 3 verschiedene verwenden druckbaren ASCII - Zeichen anstelle von ., X, und o.

---

Aufgabe 11 - Sator Square

Ausgabe des Satorquadrats :

SATOR
AREPO
TENET
OPERA
ROTAS

Jeder der Buchstaben kann in Klein- oder Großbuchstaben geschrieben werden

SatOR
aRePO
tenet
OPERa
RoTaS

ist auch eine gültige Ausgabe.

Es erfolgt keine Eingabe.

---

Aufgabe 12 - Prime Tweet

Nehmen Sie keine Eingabe vor, sondern geben Sie eine druckbare 140-Byte- ASCII- Zeichenfolge aus, die mindestens eines der 95 druckbaren ASCII-Zeichen enthält. (45 Zeichen werden also dupliziert.)

Die Summe der Zeichencodes aller 140 Bytes in dieser Zeichenfolge muss eine Sophie Germain-Primzahl sein , dh eine Primzahl p, 2p+1die auch eine Primzahl ist. Der Zeichencode für Leerzeichen ist 32, 33 für !, 34 für "und so weiter bis zu 126 für ~. Die Summe könnte in Python als berechnet werden sum(map(ord, myString)).

Eine Beispielausgabe ist:

! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

Die Zeichencodesumme ist die Primzahl 12203, deren entsprechende sichere Primzahl 24407 ist.

Pyth, 9 Aufgaben in 136 Bytes

Aufgabe 1: 7 Bytes

<-F_SQ0

Demonstration

In absteigender Reihenfolge sortieren ( _SQ), Subtraktion darüber falten ( a-b-c), prüfen, ob das Ergebnis negativ ist.

Aufgabe 2: 14 Bytes

sho.a-sN^T6.pz

Demonstration

Bilden Sie alle Zeichenfolgenpermutationen ( .pz) und sortieren Sie sie ( o) basierend auf dem absoluten Wert der Differenz ( .a-) zwischen der Zahl ( sN) und einer Million ( ^T6).

Nehmen Sie den ersten solchen String ( h) und konvertieren Sie ihn in eine Zahl. ( s).

Aufgabe 4: 19 Bytes

s/L+\EPP*3"EFHILT"z

Demonstration

Replizieren Sie "EFHILT"dreimal ( *3), entfernen Sie das nachfolgende LT( PP) und fügen Sie ein E( +\E) hinzu. Ordnen Sie jeden Buchstaben in der Eingabe der Anzahl seiner Erscheinungsbilder in dieser Zeichenfolge zu. ( /L ... z). Summe. ( s).

Aufgabe 5: 16 Bytes

u+"Alex "_GhQ".A

Demonstration

Beginnen Sie mit "A.", kehren Sie um und fügen Sie ein hinzu, und geben Sie "Alex "+ 1-mal ein.

Aufgabe 7: 13 Bytes

}Y-RTsMM./sMz

Konvertieren Sie die Eingabezeichenfolge in eine Liste mit 1-stelligen Zahlen ( sMz). Bilden Sie alle Partitionen ( ./). Summiere jedes Element jeder Partition ( sMM). Entfernen Sie alle 10er aus jeder Unterliste ( -RT). Überprüfen Sie, ob dadurch eine der Unterlisten geleert wurde, indem Sie prüfen, ob die leere Liste in der Gesamtliste enthalten ist ( }Y).

Aufgabe 8: 11 Bytes

*3h%%CQC\Ç4

Demonstration

Modulo Magie. Wandle in Zahl ( CQ) um, nimm Mod 199 ( C\Ç= 199) und nimm diesen Mod 4. Addiere dann 1 und multipliziere mit 3.

Schritt 9: 21 Bytes

J+Xz"<{[()]}>")_zJ_JJ

Demonstration

Zuerst generieren wir die erste Zeile, die aus der Eingabe besteht, die in die Spiegelzeichen ( Xz"<{[()]}>")) übersetzt wurde, gefolgt von der umgekehrten Eingabe ( + ... _z), und speichern sie in J. Drucken Sie dann diese Zeile, ihre Rückseite und diese Zeile erneut aus ( J_JJ).

Aufgabe 11: 22 Bytes

+J"SATOR
AREPO
TEN"t_J

Demonstration

Drucken Sie einfach eine Zeichenfolge und ihre Umkehrung aus, aber duplizieren Sie nicht die Mitte N.

Aufgabe 12: 13 Bytes

++G*19\3srd\

Demonstration

Am Ende des Codes befindet sich ein invisble DEL( 7F) -Zeichen.

Dies wird gedruckt

abcdefghijklmnopqrstuvwxyz3333333333333333333 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

das hat Zeichensumme 11321. Es besteht aus Gdem Alphabet, 19 3s und allen druckbaren ASCII-Zeichen.

CJam, 8 9 Aufgaben in 140 Bytes

Hier ist zunächst ein Skript, mit dem Sie Ihre Lösungen sortieren und Ihnen mitteilen können, welche in den Tweet passen:

{\s\Se[oSo}:F;
qN/ee{W=,}${)_,_T+:T140>X*_{0:X;}*'=@11+*N+*o\~)YF_,ZFTZFoNo}/

Fügen Sie einfach Ihre 12 Lösungen in die Eingabe ein, eine in jeder Zeile. Führen Sie es hier aus. Die erste Spalte ist die Aufgabennummer, die zweite die Größe (in Zeichen - Sie müssen dies selbst korrigieren, wenn sich dies von der Byteanzahl unterscheidet), die dritte die kumulative Größe. Die Programme, die in den Tweet passen, sind durch eine Zeile von getrennt=== .

Für mich sieht die Ausgabe so aus:

 1   7   7 q~$~\->
 8  10  17 qDbJ%5/)3*
12  12  29 ',32>_51>'d
 7  13  42 Aq{~-Ace|}/N&
 2  15  57 qe!{~1e6-z}$0=~
 4  19  76 q"FIHEELT"3*H<fe=:+
 5  20  96 ".A"q~){" xelA"+W%}*
 9  22 118 q_{_')>+)}%W%+_W%N@N3$
11  22 140 "SATOR\AREPO\TEN"_W%1>
====================================
 6  25 165 9,:)s3/zq~))3mdg*{W%z}*N*
 3  43 208 LLq{_'=-z({+}{'=>_)$\[{)@+\}{\(@\+}]=&}?}/\
10  45 253 0XW]_m*qN/{'.f+W%z}4*f{\~@m>fm>N*}(\{8f^.e>}/

Hier sind also die Aufgaben, die ich derzeit in den Tweet einbauen kann.

Aufgabe 1 - Können drei Zahlen ein Dreieck bilden? - 8 7 Bytes

Danke an jimmy23013 für das Speichern von 1 Byte.

q~$~\->

Testsuite.

Es wird erwartet, dass die Eingabe eine CJam-artige Liste ist.

Dies ist ziemlich einfach: Prüfen Sie, ob die größte Seite kürzer ist als die Summe der beiden anderen. Oder stellen Sie gleichermaßen sicher, dass die kürzeste Seite länger ist als die Differenz der beiden anderen:

q~  e# Read and eval input.
$~  e# Sort the values and dump them on the stack.
\-  e# Subtract the middle value from largest.
>   e# Check if the smallest value is greater than that.

Aufgabe 2 - Am nächsten an einer Million - 15 Bytes

qe!{~1e6-z}$0=~

Testsuite.

Einfache rohe Gewalt:

q        e# Read input.
e!       e# Get all permutations.
{        e# Sort by...
  ~      e#   Evaluate the permutation to get its numerical value X.
  1e6-z  e#   abs(X - 1,000,000)
}$
0=       e# Pick the first element (which minimises the difference)
~        e# Evaluate it to get rid of the leading zeroes.

Aufgabe 4 - FILTHE Letters - 21 19 Bytes

Danke an jimmy23013 für das Speichern von 2 Bytes.

q"FIHEELT"3*H<fe=:+

Testsuite.

Die Idee ist, eine Zeichenfolge zu erstellen, die jeden der FILTHE-Buchstaben einmal für jede ihrer orthogonalen Linien enthält. Dies geschieht über eine lustige String-Manipulation:

q          e# Read the input.
"FIHEELT"  e# Push this string. It first contains the 3-line letters, then the 2-line 
           e# letters, where we include 'E' twice to make it count for 4.
3*         e# Repeat 3 times: "FIHEELTFIHEELTFIHEELT"
H<         e# Truncate to 17 characters: "FIHEELTFIHEELTFIH". This is chosen such that
           e# it discards the third repetition of the 2-line letters.
fe=        e# For each character in the input, count its occurrences in this new string.
:+         e# Sum them all up.

Aufgabe 5 - Alex Recursive A. - 27 20 Bytes

".A"q~){" xelA"+W%}*

Testsuite.

Das Implementieren der Substitution von A.und .Adirekt ist viel zu teuer. Stattdessen stellen wir fest, dass wir nur einen Fall behandeln müssen, wenn wir die Zeichenfolge jedes Mal umkehren. Darüber hinaus entspricht das Voranstellen Alex(und jedes Leerzeichen) dem Erweitern der Initiale. Wir können ein weiteres Byte speichern, indem wir die Umkehrung anfügen, bevor wir die Zeichenfolge umkehren:

".A"        e# Start with ".A" (the -1st iteration if you like).
q~)         e# Read input, eval, increment (so the following block is run at least once.)
{           e# Repeat this block that many times...
  " xelA"+  e#   Append " xelA".
  W%        e#   Reverse the string.
}*

Aufgabe 7 - Aufteilen von Ziffern in Zehner - 18 16 13 Bytes

Aq{~-Ace|}/N&

Testsuite. (Mit Klammern um jeden Ausgang.)

Nicht gerade benutzerfreundlich: Der Wahrheitswert ist eine einzelne neue Zeile, der falsche Wert ist die leere Zeichenfolge.

Die Grundidee ist einfach: Addiere die Ziffern zu einer laufenden Summe, die wir zurücksetzen, wenn sie genau 10 ergibt. Die Summe muss am Ende der Eingabe Null sein. Zunächst stellt sich heraus, dass es kürzer ist als die Summe bei 10, und subtrahiert die Ziffern, wobei die Summe zurückgesetzt wird, wenn wir 0 drücken. Wir müssen jedoch sicherstellen, dass wir nichts Wahres zurückgeben, wenn die Eingabe nur Nullen enthält. Der kürzeste Weg, den ich gefunden habe, bestand darin, die Summe auf das Zeichen mit dem Codepunkt 10 (den Zeilenvorschub) zurückzusetzen und dann am Ende zu überprüfen, ob das Zeichen tatsächlich auf dem Stapel und nicht auf der Zahl 10 liegt. weil sowohl die ganze Zahl Null als auch das Zeichen Null (das Null-Byte) falsch sind:

A     e# Push a 10, the initial running total.
q{    e# For each character in the input...
  ~-  e#   Evaluate the character to get the digit and subtract it from the total.
  Ac  e#   Push a linefeed character.
  e|  e#   Logical OR of the running total and the linefeed character (using
      e#   short-circuiting).
}/
N&    e# Take the set intersection with the string containing a linefeed character.
      e# If the total is still a number of any character other than the linefeed,
      e# this will yield an empty string. Otherwise, the string will remain unchanged
      e# and the linefeed will be printed.

Aufgabe 8 - Quadratische Uhr - 10 Bytes

qDbJ%5/)3*

Testsuite.

Dies ist nur eine ziemlich zufällige Modulo-Magie für die Zeichencodes, die zufällig auf die richtigen Werte gehasht werden. Ich bin ziemlich davon überzeugt, dass etwas kürzeres möglich ist, aber es ist das kürzeste, das ich (programmatisch) für diese Art von Struktur gefunden habe:

q   e# Read the input.
Db  e# Treat the character codes of the string as digits in base 13. This maps the
    e# four inputs to the values: 2023940117708546863
    e#                            2023940113755405840
    e#                            2023940781838850791
    e#                            2023940113755390292
J%  e# Take the result modulo 19. This gives [2, 5, 12, 18], respectively.
5/  e# Divide by 5 (rounding down). [0, 1, 2, 3], respectively.
)   e# Increment. [1, 2, 3, 4], respectively.
3*  e# Multiply by 3. [3, 6, 9, 12], respectively.

Task 9 - Bracket Art - 23 22 Bytes

Vielen Dank an Sp3000 für das Speichern von 1 Byte.

q_{_')>+)}%W%+_W%N@N3$

Testsuite.

Ziemliech direkt. Die Zuordnung zwischen der linken und der rechten Klammer erfolgt durch Hinzufügen von 2 (oder 1 für Klammern):

q_      e# Read input and duplicate.
{       e# Map this block onto each character...
  _')>  e#   Duplicate and check if it's not a parenthesis.
  +     e#   Add the result, leaving parentheses unchanged and incrementing the
        e#   other bracket types.
  )     e#   Increment again.
}%
W%+     e# Reverse and add to the original, giving the middle line.
_W%     e# Duplicate and reverse, giving the first line.
N@      e# Push a linefeed, pull up the middle line.
N3$     e# Push another linefeed, copy the first line.

Aufgabe 11 - Sator Square - 22 Bytes

"SATOR
AREPO
TEN"_W%1>

Teste es hier.

Wahrscheinlich die langweiligste Lösung von allen. Es drückt die erste Hälfte der Zeichenkette und kehrt sie dann um:

"SATOR
AREPO
TEN"    e# Push everything up to the centre of the square.
_W%     e# Duplicate and reverse.
1>      e# Discard the "N", because we don't want that twice.

Aufgabe 12 - Prime Tweet - 13 12 Bytes

',32>_51>'d

Teste es hier. (Mit Diagnoseausgabe für das Ergebnis.)

Danach 'gibt es den nicht druckbaren <DEL>(0x7F), den SE ausstreift . Verwenden Sie zum Kopieren und Einfügen stattdessen diese Version:

'~),32>_51>'d

Die gedruckte Zeichenfolge ist

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

Das heißt, es enthält einen Durchlauf aller Zeichen, gefolgt von einem weiteren Durchlauf von Sbis ~, gefolgt von einem einzelnen d. Die Summe der Zeichencodes ist 12203. Ich habe dies durch ein bisschen Versuch und Irrtum herausgefunden.

'~),32>  e# Push a string with all printable characters.
_51>     e# Duplicate this and discard the first 51 of them.
'd       e# Push a "d".

Pyth, 9 Aufgaben in 138 Bytes

Das hat eine ganze Weile gedauert.

Ich denke, 9 Aufgaben sind die Grenze für Pyth. Einschließlich des nächstkürzeren Programms (Sator Square) ergeben sich 160 Bytes. Das Golfen von 20 Bytes ist ziemlich unwahrscheinlich. Es gibt 2 oder 3 Aufgaben, die ein bisschen hässlich sind und möglicherweise gekürzt werden können, aber insgesamt bin ich mit den Lösungen sehr zufrieden.

Aufgabe 1 - Können drei Zahlen ein Dreieck bilden ?, 8 Bytes

>FsMc2SQ

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 2 - Am nächsten an einer Million, 14 Bytes

ho.a-^T6NsM.pz

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 4 - FILTHE Buchstaben, 20 Bytes

s*Vtsmmdd5/Lz"TLIHFE

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 5 - Alex Recursive A., 16 Bytes

u+"Alex "_GhQ".A

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 6 - Numpad-Drehung, 20 Bytes

jeo}zhN.uC_N3_c3jkS9

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 7 - Aufteilen von Ziffern in Zehner, 15 Bytes

qTu+WnGTvHG-zZZ

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 8 - Quadratische Uhr, 12 Bytes

*3%%Cz1978 5

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 9 - Bracket Art, 20 Bytes

V3_WtN+z_Xz"[<({})>]

Probieren Sie es online aus: Regular Input oder Test Suite

Aufgabe 12 - Prime Tweet, 13 Bytes

++*d44srd\\&

Probieren Sie es online aus: Regelmäßige Eingabe

TI-BASIC, 11 12 Aufgaben in 728 830 Bytes

Aufgabe 1 in 7 Bytes

:2max(Ans)`<`sum(Ans

Eingabe ist eine Liste in Ans.

Aufgabe 2 in 92 110 Bytes

:seq(expr(sub(Ans,I,1)),I,1,7→L₁
:SortA(L₁
:min(7,1+sum(not(L₁
:{L₁(1)+sum(seq(L₁(I))₁₀^(I-8),I,2,7)),L₁(Ans)+sum(seq((I`>`Ans)L₁(I)₁₀^(1-I),I,2,7
:ᴇ6Ans(1+(0`>`min(ΔList(abs(1-Ans

Fordert zur Eingabe einer Ziffernliste auf Eingabe ist eine Zeichenfolge in Ans.

Aufgabe 3 in 119 Bytes

:Input Str1
:"  →Str2
:For(I,1,length(Str1
:sub(Str1,I,1→Str3
:inString("`<>`",Ans
:If Ans:Then
:max(0,min(L,C+2Ans-3→C
:Else
:C+1→C
:L+1→L
:sub(Str2,1,C)+Str3+sub(Str2,C+1,L-C+1→Str2
:End
:End
:sub(Str2,2,L

Fordert zur Eingabe einer Zeichenfolge auf. Angenommen, C und L sind entweder undefiniert oder 0.

Aufgabe 4 in 35 Bytes

:sum(int(2seq(inString("TLIHFE",sub(Ans,I,1))^.4,I,1,length(Ans

Eingabe ist ein String in Ans.

Aufgabe 5 in 63 Bytes

:Ans/2→C
:sub("A.A",1+2fPart(C),2
:For(I,0,C
 :"Alex "+Ans
 :If I≠C
  :Ans+" xelA
:End
:Ans

Eingabe ist eine Zahl in Ans.

Aufgabe 6 in 66 Bytes

: 𝑖 ^ ((Ans <7) (Ans-3 (Ans >3: Für (Y, ⁻1,1: Disp sum (seq ((5-real (AnsX + Ans𝑖Y) -3imag (AnsX + Ans𝑖Y))) ₁₀ ^ ( X + 1), X, ~ 1,1: Ende

Eingabe ist eine Zahl in Ans.

Aufgabe 7 in 36 43 Bytes

:Input <strike>L₁</strike>Str1
:.5
:For(I,1,<strike>dim(L₁</strike>length(Str1
 :Ans+<strike>L₁(I</strike>expr(sub(Str1,I,1
 :If 10=int(Ans
  :0
:End
:not(Ans

Fordert zur Eingabe einer Liste mit Ziffern auf .

Task 8 in 29 Bytes

:18fPart(sum(seq(I(sub(Ans,I,1)=" ")/6,I,1,15

Eingabe ist ein String in Ans.

Aufgabe 9 in 83 Bytes

:For(I,1,16,2
 :If I<8
  :Ans+sub("`)}]>`",inString("`({[<`",sub(Ans,4,1)),1
 :sub(Ans,I,1)+Ans
:End
:For(I,⁻1,1
 :Disp sub(Ans,9-8abs(I),8
:End

Eingabe ist ein String in Ans.

Aufgabe 10 in 159 Bytes

:1→X
:Input Str1
:2+length(Str1→L
:"X
:While 2+L`>`length(Ans
 :Ans+Ans→Str2
:End
:Ans→Str3
:While 1
 :"XX
 :Ans+Str1+Ans→Str1
 :For(I,1,L
  :Ans+sub("0X.",2expr(sub(Str2,I+1,1))+not(expr(sub(Ans,I,3)+sub(Str2,I,3)+sub(Str3,I,3))),1
 :End
 :Disp sub(Ans,L+3,L
 :Str2→Str3
 :Str1→Str2
 :Input Str1
:End

Verwendet X0.statt .Xojeweils (sorry nichts passt). Fordert zur zeilenweisen Eingabe auf. Sie müssen zwei Zeilen von eingebenX s , um die gesamte Ausgabe zu sehen, und dann 2nd + Quit, um die Ausgabe zu beenden.

Aufgabe 11 in 39 Bytes

:Disp "SATOR
:Disp "AREPO
:Disp "TENET
:Disp "OPERA
:Disp "ROTAS

Task 12 in 77 Bytes

: Ans + "tvm_I% LinReg (ax + b) DS <(getKeyconj (1-PropZTest (dayOfWk (Manuelle Anpassung C / YANOVA (* row (HorizRegEQUnarchive [J]! # $ &'', .234567890:; = >? @GBQX \^ _`qw {|} ~

Oder als Hex:

72702ABB21FFDBADBB25BB3EEF06EF16
6331BB5917746201BB695C092DBBD2BB
D3BBD4AEAE2B3A323334353637383930
3EBBD66A6CAFBBD147425158BBD7F0BB
D9BBD5BBC1BBC708BBD809BBCF

Die Eingabe ist eine Zeichenfolge, die "in enthältAns .

Dies ist in TI-BASIC eigentlich unmöglich. Es ist möglich, ein Basisprogramm hexadezimal zu bearbeiten und bestimmte 2-Byte-Token zu verwenden, um alle druckbaren ASCII-Zeichen in den Quellcode zu bekommen, aber das ist nicht das Problem. Das Problem ist, dass es keine Möglichkeit gibt, ein "Zeichen in einer Zeichenfolge in pure basic auf einem sauberen Rechner ohne Programmeingabe zu speichern (dasselbe gilt für das →Zeichen, aber das ist kein druckbarer ASCII-Code). Es ist jedoch möglich, "eine Gleichung außerhalb von basic zu erstellen. Anschließend können Sie basic verwenden, um die Gleichung in eine Zeichenfolge zu konvertieren und diese Zeichenfolge anzuzeigen. Darüber hinaus ist auf dem Bildschirm ohnehin nur Platz für 128 Zeichen.

Perl, 4 Aufgaben in 117 Bytes

Lass uns eine echte Sprache ausprobieren ;)

Noch nicht aufgegeben, kann möglicherweise sogar 5 Tasks in 140 Byte komprimieren, obwohl dies unwahrscheinlich ist!

* Aufgabe 1: 30 + 1 = 31 Bytes

@F=sort@F;say$F[0]+$F[1]>$F[2]

Verwendungszweck: perl -aM5.010 entry.pl input.txt

* Aufgabe 4: 32 + 1 = 33 Bytes

y/ELTFHI/4223/;s/./+$&/g;$_=eval

Verwendungszweck: perl -p entry.pl input.txt

Aufgabe 5: 54 Bytes

say"Alex "x($_/2+1).qw(A. .A)[$_%2]." xelA"x(--$_/2+1)

-2b danke an Dom Hastings

Verwendungszweck: echo 4 | perl -M5.010 entry.pl

Aufgabe 7: 37 + 2 = 39 Bytes

($i+=$_)>10&&exit,$i%=10for@F;$_=!$i;

Verwendungszweck: perl -pF entry.pl input.txt

* Aufgabe 8: 21 + 2 = 23 Bytes

$_=y/|_ 
/14/dr/64%14

Das ist ein bisschen knifflig. Angefangen von jedem Ersetzen |mit xund jeder _mit ydann ersetzt Räumen eine eindeutige zwei Ziffernfolge für jedes Raster zu erzeugen (yyxxyxxyyx , yyxxyxxyyxyyxxxxyxyx, yyxxxxyxyxyyxyxxxyyx, yyxyxxxyyxyyxxxxyyx, yyxxxxyyx). Als nächstes habe ich ein Programm geschrieben, um Werte für xund yund mathematische Operationen zu erzwingen, die mit den nach dem Ersetzen erzeugten Zahlen durchgeführt werden können, xund yfür jede Zahl eine Ausgabe von 3,6,9,12 zu erhalten. Am Ende x=1, y=4und war die magische Operation /64%14.

Verwendungszweck: perl -0p entry.pl input.txt

Aufgabe 11: 34 Bytes

say"SATOR
AREPO
TENET
OPERA
ROTAS"

Verwendungszweck: perl -M5.010 entry.pl

* Aufgabe 12: 30 Bytes

say d.pack"C*",32..126,83..126

Verwendungszweck: perl -M5.010 entry.pl

Haftungsausschluss: -M5.010 gilt als "kostenlos"

Ruby, 4 Aufgaben in 280 Bytes (nicht wettbewerbsfähig)

Dies ist nur ein Versuch, ich werde später weitere Aufgaben ausführen (und hoffentlich die vorhandenen Golf spielen).

Aufgabe 1

a=gets.split.map &:to_i;p a.all?{|e|e<a.inject(:+)-e}

Aufgabe 2

p gets.chars.permutation.map{|a|a.join.to_i}.min_by{|x|(x-1e6).abs}

Aufgabe 4

n,b='EFHILT',0;gets.chars.map{|c|b+=n[c]==p ? 0:[4,3,3,3,2,2][n.index c]};p b

Aufgabe 5

a='Alex A.';gets.to_i.times{|i|i%2<1 ? a.sub!('A.','.A xelA'):a.sub!('.A',a)};$><<a

TI-BASIC, 12 Aufgaben in 994 Bytes

Alles als TI-Gruppendatei herunterladen ( .8xg )

(Spoiler-Tags auf Anfrage hinzugefügt.)

Aufgabe 1 - Können drei Zahlen ein Dreieck bilden? - 7 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:2max(Ans)<sum(Ans

Aufgabe 2 - Am nächsten an einer Million - 114 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:int(10fPart(Ans\10^(\-cumSum(binomcdf(6,0→X
:"sum(\L\X\10^(\cumSum(not(binompdf(6,0→\Y1\
:SortD(\L\X
:\Y1\→X
:sum(not(\L\X
:If Ans
:Then
:If max(\L\X=1
:X+\E\6-\10^(\6-Ans→X
:SortA(\L\X
:augment(ΔList(cumSum(\L\X)),{0→X
:End
:{X,\Y1\
:Ans(1+(0>min(ΔList(abs(\E\6-Ans

Aufgabe 3 - Einfacher Tastatursimulator - 131 127 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:Input Str1
:DelVar X1→Y
:"..→Str2
:For(Z,1,length(Str1
:sub(Str1,Z,1→Str3
:(Ans=">")-(Ans="<
:If Ans
:Then
:max(1,min(Y+Ans,X+1→Y
:Else
:sub(Str2,1,Y)+Str3+sub(Str2,Y+1,X-Y+2→Str2
:X+1→X
:Y+1→Y
:End
:End
:sub(Str2,2,X

Aufgabe 4 - FILTHE Letters - 34 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:sum(int(\³√(\12seq(inString("TLIHFE",sub(Ans,X,1)),X,1,length(Ans

Aufgabe 5 - Alex Recursive A. - 107 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:Input X
:".A..
:For(X,0,X
:Ans→Str1
:5int(.5X+.5
:sub(Str1,1,Ans+1)+sub(".A xelAlex A.",6gcd(X,2)-5,7)+sub(Str1,Ans+4,5X-Ans+1
:End
:sub(Ans,2,5X+2

Task 6 - Numpad-Drehung - 86 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:.3Ans+2(Ans=6→X
:[[9,6,3][8,5,2][7,4,1
:For(X,0,X
:rowSwap(Ans\^T\),1,3
:End
:Ans
:*row+(10,*row+(10,Ans\^T\,1,2),2,3
:For(X,1,3
:Disp Ans(3,X
:End

Aufgabe 7 - Aufteilen von Ziffern in Zehner - 77 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:Ans+"0
:seq(expr(sub(Ans,X,1)),X,1,length(Ans
:augment(Ans,{10not(not(max(Ans→X
:1→X
:Repeat Ans≥dim(\L\X
:Ans+1
:If 10=sum(\L\X,X,Ans
:Ans+1→X
:End
:X=Ans

Aufgabe 8 - Quadratische Uhr - 35 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:12-3max(seq(X(sub(Ans,6gcd(X,2)+X,1)≠" "),X,1,3

Task 9 - Bracket Art - 86 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:Input Str1
:For(X,1,4
:For(Y,0,1
:abs(X-9not(Y→Z
:"()[]{}<>
:sub(Ans,inString(Ans,sub(Str1,X,1))+Y,1
:Output(1,Z,Ans
:Output(2,9-Z,Ans
:Output(3,Z,Ans
:End
:End

Task 10 - Perimiterize - 218 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:".
:For(A,0,\E\9
:Input Str1
:Ans+Str1→Str2
:If Str1≠".
:End
:length(Ans→X
:round(A\^-1\(Ans-2→B
:seq(expr(sub(Str2,A,1)),A,2,X-1→B
:πAns→C
:"augment(Ans,augment(Ans,\L\B))+augment(Ans,augment(\L\C,Ans))+augment(\L\B,augment(Ans,Ans→X
:seq(0,A,1,B
:\L\X→A
:For(C,0,A+1
:seq(\L\A(A+BC),A,1,B→C
:int(Ans→B
:{0
:1+not(\L\X)+not(fPart(\L\X→B
:".
:For(X,1,B+2
:Ans+sub("120",\L\B(X),1
:End
:Disp sub(Ans,2,B+2
:End

Diese Ersetzungen wurden vorgenommen: 0= ., 1= X, 2=o

Geben Sie für die Eingabe (nachdem das Programm gestartet wurde) jeweils eine Zeile ein und drücken Sie bei jedem Zeilenumbruch die Eingabetaste, bis die letzte Zeile ausgeschrieben ist. Drücken Sie dann die Eingabetaste, geben Sie einen Punkt ein und drücken Sie erneut die Eingabetaste, um die gesamte Zeichenfolge zu übermitteln.

Aufgabe 11 - Sator Square - 38 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:Disp "SATOR","AREPO","TENET","OPERA
:"ROTAS

Aufgabe 12 - Prime Tweet - 151 Bytes

Als TI-83 + -Programmdatei herunterladen ( .8xp )

:Ans+"!#$%&'()*+,-./01234567889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
:For(X,1,45
:Ans+" 
:End
:Ans

Anssollte ein doppeltes Anführungszeichen enthalten, das ausgeführt wird, indem eines direkt \Y1\vom Gleichungseditor aus eingegeben und Equ►String(\Y1\,Str1:Str1vom Startbildschirm aus ausgeführt wird.

Die Ausgabelänge beträgt 140. 8 wird zweimal angezeigt, und 45 Leerzeichen sowie die anderen ASCII-Zeichen werden jeweils einmal angezeigt. Dies ergibt (33 + 34 + ... + 126) + 56 + 32 × 45 = 8969, eine Sophie-Germain-Primzahl.

Python 3, 1 Task, 268 Bytes, nicht wettbewerbsfähig

Ich habe Task # 2 in Python 3.5.2 ausprobiert. Ich bin neu im Codieren von Golf und Python

import itertools
def f2(l):
    n=1000000
    l=list(itertools.permutations(l))
    j = len(l)
    m=[None]*j
    while j>0:
        j -= 1
        m[j]= int(''.join(str(i) for i in l[j]))
        l[j]=abs(n-m[j])
    l.sort()
    k=n-l[0]
    return(n+l[0],k)[k in m]