こちらの問題です。
ACが不可能であるTextを除いた全ての言語について、ACが確認出来ました。
><>
0i:48*=?v4c*-$a*+!
v 0:~<
>i:a=?v'0'-+a*
-&,n; >,r~1-:r:&%
AWK
{print int(($1-1)/$2)}
Ada
with Ada.Integer_Text_IO;
procedure Main is
A, T : Integer;
begin
Ada.Integer_Text_IO.Get(A);
Ada.Integer_Text_IO.Get(T);
Ada.Integer_Text_IO.Put((A - 1)/T,0);
end Main;
Assembly x64
section .data
int_in_format db "%d", 0
int_out_format db "%d", 10, 0
section .bss
a resb 4
b resb 4
section .text
global main
extern scanf, printf
main:
sub rsp, 8
lea rdi, [rel int_in_format]
lea rsi, [rel a]
call scanf WRT ..plt
lea rdi, [rel int_in_format]
lea rsi, [rel b]
call scanf WRT ..plt
mov eax, [rel a]
sub eax, 1
mov ecx, [rel b]
div ecx
lea rdi, [rel int_out_format]
lea rsi, [eax]
call printf WRT ..plt
done:
add rsp, 8
mov rax, 0
ret
bash
read A T
echo $(((A-1)/T))
Brainfuck
[-]>>>>>>>[<<<<<<<+>>>>>>>>+<-]>[-]+<<<<<<<[-]>>>>>>>[<<<<<<<+>>>>>>+>-]<[-]<<<<<[-]>>>>>[<<<<<+>>>>>>+<-]>[-]<<<<<<[>>>>>>+<+<<<<<-]>>>>>[<<<<<+>>>>>-]++++>[-<[>>+>+<<<-]>>>[<<<+>>>-]+<[<<->>>-<[-]]>[<<[-]>>-]<<]<[>+<[-]]>[<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]+<<[>>-<<-]+>>[<<->>[-]]+<<[>>>>,<<<<<<<<[-]>>>>>>>>[<<<<<<<<+>>>>>>>>>+<-]>[-]<<<<<<<<<[>>>>>>>>>+<+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>>++++++[<<++++++++>>-]<[-<[>>+>+<<<-]>>>[<<<+>>>-]+<[<<->>>-<[-]]>[<<[-]>>-]<<]<[>+<[-]]>>+++++++[<<++++++++>>-]<<+<<<<<<<<[>>>>>>>>>>+>+<<<<<<<<<<<-]>>>>>>>>>>>[<<<<<<<<<<<+>>>>>>>>>>>-]<<<[->>[>+>+<<-]>>[<<+>>-]+<[<->>-<[-]]>[<<<<[-]>>>>-]<<<<]>>[<<+>>[-]]<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]+<<[<<<<<<<<<<[-]>>>>>>>>>>>>>[<<<<<<<<<<<<<+>>>>>>>>>>>>>>+<-]>[<<<+>>>-]<<-<<[-]]>>[<<<<<<<<<<<<<[>>>>>>>>>>>+>>>>+<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]++++++++++<<<<[>>>>[<+>>+<-]>[<+>-]<<<<<-]>>>>[-]<[<<<+>>>-]<<<<<<<<<<<[>>>>>>>>>>>>+<+<<<<<<<<<<<-]>>>>>>>>>>>[<<<<<<<<<<<+>>>>>>>>>>>-]>[<<<<+>>>>-]<++++++[>++++++++<-]>[<<<<->>>>-]<<<<<<<<<<<<<<<[-]>>>>>>>>>>>[<<<<<<<<<<<+>>>>>>>>>>>>>>>+<<<<-]>>>>[<<<+>>>-]<<-]<[<<+>>-]<<<-<<[-]]>>[-]>[-]<<<<<<<<+[>>>>>>>>+<+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]<<[-]<<<<<<[>>>>>>>>+<+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]++++>[-<[<<+>>>>>+<<<-]>>>[<<<+>>>-]+<<<<<[>>->>>-<<<<<[-]]>>>>>[<<[-]>>-]<<]<[>+<[-]]>[<<+>>-]<<]<<<<[-]>>>>[<<<<+>>>>>>+<<-]>>[-]+<<<<<[-]>>>>>[<<<<<+>>>+>>-]<<[-]<<<<<<[-]>>>>>>[<<<<<<+>>>>>>>>+<<-]>>[-]<<<<<<<<[>>>>>>>>+<<+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]++++>>[-<<[>+<<+>-]<[>+<-]+>>[<-<->>[-]]<<[>>>[-]<<<-]>>>]<<[>>+<<[-]]>>[<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]+<[>-<-]+>[<->[-]]+<[>>>>,<<<<<<<<<[-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>>+<-]>[-]<<<<<<<<<<[>>>>>>>>>>+<+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]>>>++++++[<<<++++++++>>>-]<<[-<[>>>+<<<<+>-]<[>+<-]+>>>>[<<<-<->>>>[-]]<<<<[>>[-]<<-]>>]<[>+<[-]]>>>+++++++[<<<++++++++>>>-]<<<+<<<<<<<<<[>>>>>>>>>>>>+<<<<+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[->>>[<<<<+>>>+>-]<[>+<-]+<<<[>>>>-<-<<<[-]]>>>[<<[-]>>-]<<]>>>[<<<+>>>[-]]<<[>>+<<[-]]<[>>>+<<<[-]]>>>[<<<+>>>[-]]+<<<[<<<<<<<[-]>>>>>>[<<<<<<+>>>>>>>>>+<<<-]>>>[<+>-]>-<<<[-]]>>>[<<<<<<<<<<<[>>>>>>>>+>>+<<<<<<<<<<-]>>>>>>>>>>[<<<<<<<<<<+>>>>>>>>>>-]++++++++++<<[>>[<<<+>>>>>+<<-]>>[<<+>>-]<<<<-]>>[-]<<<[>+<-]<<<<<<<<[>>>>>>>>>>>+<<<+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>>>[<<+>>-]<<<++++++[>>>++++++++<<<-]>>>[<<->>-]<<<<<<<<<<[-]>>>>>>>>[<<<<<<<<+>>>>>>>>>>+<<-]>>[<+>-]>-]<<[<<<<<<+>>>>>>-]<<<<-<[-]]>[-]<<[-]<<<<<+[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<[-]>>>[-]<<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]++++<<[->>[<+>>>>>+<<<<-]>>>>[<<<<+>>>>-]+<<<<<[>->>>>-<<<<<[-]]>>>>>[<<<<<<[-]>>>>>>-]<<<<<<]>>[<<+>>[-]]<<[>>>+<<<-]>>>]<<<<<<<<<<[>>>>>>>>>>+<<<+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]+[>>>-<<<-]<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]>[<+>-]<[<<[>+>>>>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<<<[>>>>>+<<<<-[>>>>[-]>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<[<<<<<-[>>-<<[-]]+>>>>>-]<<<<<-]>>+<]<<[-]<[-]>>>>[<<<<+>+>>>-]<<<[-]<[>+>>>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<<<[->>>-<+>[<<+>>>>>+<<<-]>>>[<<<+>>>-]+<<<<<[>>>>>-<<<<<[-]]>>>>>[<<<<[>+<-]>>>>>>+<<-]<<<<<<]>>[>>>+<<<-]>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[-]++++++++++<<<[->>>-<+>[<<+>>>>>+<<<-]>>>[<<<+>>>-]+<<<<<[>>>>>-<<<<<[-]]>>>>>[<<<<[>+<-]>>>>>>+<<-]<<<<<<]>>[>>>>>+<<<<<-]>>>>>>[++++++++++++++++++++++++++++++++++++++++++++++++.<<+>+>[-]]<[<[>-<-]>++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<[-]
C
#include <stdio.h>
int main(){
int A,T;
scanf("%d %d",&A,&T);
printf("%d\n",(A-1)/T);
}
C#
using System;
class Program
{
static void Main(string[] args)
{
string[] input = Console.ReadLine().Split(' ');
int A = int.Parse(input[0]);
int T = int.Parse(input[1]);
Console.WriteLine((A-1)/T);
}
}
C++
#include <iostream>
int main(){
int A,T;
std::cin>>A>>T;
std::cout<<(A-1)/T<<std::endl;
}
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. Main.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 INP PIC X(10).
01 A PIC 9(03).
01 T PIC 9(03).
01 G PIC ZZZ9.
*>
PROCEDURE DIVISION.
ACCEPT INP.
UNSTRING INP DELIMITED BY ' '
INTO A T.
*>
COMPUTE G = (A - 1)/T.
DISPLAY FUNCTION TRIM(G).
*>
STOP RUN.
Carp
(use IO)
(use String)
(use Int)
(use Array)
(defn getnum []
(let [ss (get-line)
s (chomp &ss)]
(Maybe.unsafe-from (from-string &s))
)
)
(defn getnums []
(let [ss (get-line)
s (words &ss)
nums (copy-map &Int.from-string &s)]
nums
)
)
(defn solve [a b]
(let [ am (Maybe.unsafe-from a)
bm (Maybe.unsafe-from b)
aa (Maybe.unsafe-from am)
bb (Maybe.unsafe-from bm) ]
(/ (- aa 1) bb)
)
)
(defn main []
(let [
tmp (getnums)
AT (solve (first &tmp) (last &tmp))
]
(do
(print &(Int.str AT))
)
)
)
Clojure
(prn (quot (- (read) 1) (read)))
Common Lisp
(format t "~D" (floor (- (read) 1) (read)))
Crystal
a,t=gets.not_nil!.split.map &.to_i
puts (a-1)//t
Cyber
tmp = getInput().utf8().split(' ')
A = number(tmp[0])
T = number(tmp[1])
print int((A-1)/T)
D
import std.stdio;
import std.string;
import std.conv;
void main()
{
string[] input = split(readln());
int A = to!int(input[0]);
int T = to!int(input[1]);
writefln("%d", (A-1)/T);
}
Dart
import 'dart:io';
void main() {
String tmp = stdin.readLineSync()!;
int A = int.parse(tmp.split(" ")[0]);
int T = int.parse(tmp.split(" ")[1]);
print("${(A-1)~/T}");
}
ECLiPSe
:- lib(ic).
main :-
read_num(A),
read_num(T),
Ans #= (A-1) // T,
printf("%d%n", [Ans]).
read_str(S) :-
read_string(user_input, " \n", "", _, S).
read_num(N) :-
read_str(S),
number_string(N, S).
Elixir
defmodule Main do
def main do
[a,t] = IO.read(:line) |> String.trim() |> String.split(" ") |> Enum.map(&String.to_integer/1)
div(a-1, t) |> IO.puts()
end
end
Emacs Lisp
(set-buffer (get-buffer-create "*stdin*"))
(while (ignore-errors (insert (read-string "") "\n") t))
(goto-char (point-min))
(setq standard-input (get-buffer "*stdin*"))
(princ (format "%s" (floor (- (read) 1) (read))))
Erlang
-module('Main').
-export([main/1]).
main(_) ->
{ok, [A, T]} = io:fread("", "~d~d"),
io:format("~B ~n", [(A - 1) div T]),
halt().
F#
let a,t = stdin.ReadLine().Split(" ") |> fun x ->int x[0],int x[1]
printfn "%i" ((a-1)/t)
Factor
USING: kernel io sequences splitting math math.parser ;
readln
" "
split
[ string>number ] map
first2
swap
1
-
swap
/i
number>string
print
Forth
: read-all begin key drop key dup 4 <> tuck if ( emit ) else drop then invert until ; ( read until EOF )
: read-number 0 0 begin swap 10 * + key 48 - dup 0 < until drop ;
: to-bin begin 2 /mod swap 1+ swap dup 0= until drop ; ( convert number to bin array )
: write-pure ( d -- ) dup 0<> if dup 0< if ." -" negate then -1 swap begin dup 0 <> while 10 /mod repeat drop begin dup -1 <> while 48 + emit repeat drop else ." 0" then ;
: write-cr ( d -- ) write-pure cr ;
read-number read-number
swap 1 - swap /
write-cr
Fortran
program main
implicit none
integer :: A,T
read(*,*) A,T
print '(i0)', (A-1)/T
end program main
Go
package main
import (
"fmt"
)
func main() {
var A, T int
fmt.Scanf("%d %d", &A, &T)
fmt.Printf("%d\n", (A-1)/T)
}
Haskell
main :: IO ()
main = do
[a, t] <- map read . words <$> getLine
putStrLn $ show ((a - 1) `div` t)
Haxe
using Std;
class Main {
static function main() {
var args=Sys.stdin().readLine().split(" ").map(v -> v.parseInt());
var A=args[0],T=args[1];
Sys.println(Math.floor((A-1)/T));
}
}
Java
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int A = sc.nextInt();
int T = sc.nextInt();
System.out.println((A-1)/T);
}
}
JavaScript
function Main(input) {
input = input.split("\n");
tmp = input[0].split(" ");
var A = BigInt(tmp[0]);
var T = BigInt(tmp[1]);
console.log(((A - 1n) / T).toString());
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
Julia
A,T=parse.(Int,split(readline()))
print((A-1)÷T)
Koka
import std/os/readline
fun main()
val [a, t] = readline().split(" ").map(fn(s) { s.parse-int.unjust })
println((a - 1) / t)
Kotlin
fun main(args: Array<String>) {
val (A,T) = readln().split(' ').map { c -> c.toInt() }
println(String.format("%d", (A-1)/T))
}
LLVM IR
@.str = private unnamed_addr constant [6 x i8] c"%d %d\00", align 1
@.str.1 = private unnamed_addr constant [3 x i8] c"%d\00", align 1
define dso_local i32 @main() #0 {
%1 = alloca i32, align 4
%2 = alloca i32, align 4
%3 = call i32 (i8*, ...) @__isoc99_scanf(i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* noundef %1, i32* noundef %2)
%4 = load i32, i32* %1, align 4
%5 = sub nsw i32 %4, 1
%6 = load i32, i32* %2, align 4
%7 = sdiv i32 %5, %6
%8 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 noundef %7)
ret i32 0
}
declare i32 @__isoc99_scanf(i8* noundef, ...)
declare i32 @printf(i8* noundef, ...)
Lua
A, T = io.read("*n", "*n")
print((A - 1) // T)
Mercury
:- module main.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module int, list, string.
main(!IO) :-
io.read_line_as_string(Result, !IO),
( if
Result = ok(Line),
[AStr, TStr] = string.words(Line),
string.to_int(AStr, A), string.to_int(TStr, T)
then
io.format("%d\n", [i((A - 1)/T)], !IO)
else
true
).
Nibbles
/-$1;$
Nim
import strutils, sequtils
var
tmp=readLine(stdin).split().map(parseInt)
A=tmp[0]
T=tmp[1]
echo (A-1) div T
OCalm
let () =
let a, t = Scanf.scanf " %d %d" (fun i j -> (i, j)) in
let res = (a - 1)/t in
Printf.printf "%d\n" res
Octave
[A T] = scanf("%d %d", 'C');
printf("%d\n", floor((A-1)/T))
PHP
<?php
fscanf(STDIN, "%d %d", $A, $T);
echo intdiv($A-1,$T)."\n";
?>
Pascal
var
A, T : integer;
begin
read(A);
readln(T);
writeln((A-1) div T);
end.
Perl
my $input = <STDIN>;
chomp $input;
my ($A, $T) = split / /, $input;
$ret = int(($A - 1)/$T);
print "$ret\n";
PowerShell
$A,$T= ([Console]::ReadLine()) -split ' '
[int][Math]::Floor(($A - 1) / $T)
Prolog
main :-
read_num(A),
read_num(T),
Res is (A - 1) // T,
write(Res),
nl.
read_str(S) :-
read_string(current_input, ' \n', '', _, S).
read_num(N) :-
read_str(S),
number_string(N, S).
Python
A,T = map(int, input().split())
print((A-1)//T)
R
library(magrittr)
s <- readLines("stdin", n=1) %>% strsplit(" ") %>% unlist %>% as.integer
A <- s[1]
T <- s[2]
cat((A - 1) %/% T)
Raku
$/=words>>.Int;say ($0-1) div $1
ReasonML
let inp = read_line();
let res = Scanf.sscanf(inp,"%d %d", ((a, t) => (a-1)/t));
print_endline(string_of_int(res));
Ruby
A,T=gets.chomp.split(" ").map(&:to_i);
print("#{(A-1)/T}\n")
Rust
use proconio::input;
fn main(){
input!{
A: i32,
T: i32
}
println!("{}",(A-1)/T);
}
SageMath
A,T = map(int, input().split())
print((A-1)//T)
Scala
import scala.io.StdIn.*
object Main extends App {
var tmp = readLine.split(" ")
var A = tmp(0).toInt
var T = tmp(1).toInt
println((A-1)/T);
}
Scheme
(define (main args)
(let* ([a (read)]
[t (read)])
(print (quotient (- a 1) t)))
0)
Sed
s/^\(.*\) \(.*\)$/echo $(((\1-1)\/\2))/e
Seed7
$ include "seed7_05.s7i";
const proc: main is func
local
var integer: A is 0;
var integer: T is 0;
begin
read(A);
read(T);
writeln((A - 1) div T);
end func;
Swift
let tmp = readLine()!.split(separator: " ").map { Int($0)! }
let A = tmp[0]
let T = tmp[1]
print("\((A - 1)/T)")
Text
TypeScript
import * as fs from 'fs';
let tmp = fs.readFileSync('/dev/stdin', 'utf8').split(' ');
let A = BigInt(tmp[0]);
let T = BigInt(tmp[1]);
console.log(((A - 1n) / T).toString());
Unison
get_int : '{IO, Exception} Int
get_int = do
line = !readLine
Optional.getOrBug "Invalid Input" (Int.fromText line)
get_ints : '{IO, Exception} List(Int)
get_ints = do
line = !readLine
w = words line
v = List.map Int.fromText w
List.map (Optional.getOrBug "Invalid Input") v
main : '{IO, Exception} ()
main = do
tmp = get_ints()
a = List.unsafeAt 0 tmp
t = List.unsafeAt 1 tmp
printLine (Int.toText ((a Int.- +1) Int./ t)
V
import os
fn main() {
tmp := os.get_line().split(' ').map(it.int())
a := tmp[0]
t := tmp[1]
println("${(a - 1) / t}")
}
Vim
dw:let a = @"
dw:let t = @"
:put! = (a - 1) / t
ZZ
Visual Basic
module A
sub Main(ByVal args() as String)
Dim line(10) as String
Dim A as Integer
Dim T as Integer
line=Console.ReadLine().Split()
A = int(line(0))
T = int(line(1))
Console.WriteLine((A-1)\T)
end sub
end module
Whitespace
おそらくコピペしてもACがとれないので、提出リンクを貼っておきます。
https://atcoder.jp/contests/oupc2023-day1/submissions/49183555
Zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const stdin = std.io.getStdIn().reader();
var buff: [100]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buff);
const alloc = fba.allocator();
pub fn main() !void {
const line = if (try stdin.readUntilDelimiterOrEofAlloc(alloc, '\n', 100)) |str| str else "0 0";
const index = std.mem.indexOfScalar(u8, line, ' ').?;
const a = try std.fmt.parseInt(i32, line[0..index], 10);
const t = try std.fmt.parseInt(i32, line[index + 1..], 10);
try stdout.print("{}", .{@divTrunc(a-1,t)});
}
Zsh
read A T
echo $(((A-1)/T))
bc
scale=0
(read()-1)/read()
dc
?r1-r/p
jq
split(" ")|map(tonumber)as$tmp|($tmp[0]-1)/$tmp[1]|floor
なでしこ
tmp=「」と尋ねて「 」で区切る。
Aは「{tmp[0]}n」をJS実行。
Tは「{tmp[1]}n」をJS実行。
(A-1n)/Tを表示。
プロデル
【tmp：整数の配列】は、コンソールから受け取ったものを「 」で区切ったもの。
【A：整数】は、tmp(1)。
【T：整数】は、tmp(2)。
(A-1)\Tを表示。
あとがき
並べてみると、ほとんどの言語では小数除算に/が採用されている反面、整数除算は各言語の工夫が見られますね。
追記
littlegirl112さんにいくつかコードをいただきました。ありがとうございます。
KowerKointさんにいくつかコードをいただきました。ありがとうございます。